Merge branch 'main' into dev

Dev

.gitignore

@@ -5,6 +5,8 @@ tmp/
 .meta/
 db/
 
+com/test.lua
+
 .vscode
 Taskfile.yml
 config.yaml

com/DB/Put.lua

@@ -0,0 +1,66 @@
+---@diagnostic disable: redefined-local
+local db = require("internal.database-sqlite").connect("db/test.db", {log = true})
+local log = require("internal.log")
+local session = require("internal.session")
+
+if not (session.request.params.name and session.request.params.email) then
+  session.response.error = {
+    code = -32602,
+    message = "Name and email are required"
+  }
+  return
+end
+
+local existing, err = db:query("SELECT 1 FROM users WHERE email = ? LIMIT 1", {
+  session.request.params.email
+})
+if err ~= nil then
+  session.response.error = {
+    code = -32603,
+    message = "Database check failed: "..tostring(err)
+  }
+  log.error("Email check failed: "..tostring(err))
+  return
+end
+
+if existing and #existing > 0 then
+  session.response.error = {
+    code = -32604,
+    message = "Email already exists"
+  }
+  return
+end
+
+local ctx, err = db:exec(
+  "INSERT INTO users (name, email) VALUES (?, ?)", 
+  {
+    session.request.params.name,
+    session.request.params.email
+  }
+)
+if err ~= nil then
+  session.response.error = {
+    code = -32605,
+    message = "Insert failed: "..tostring(err)
+  }
+  log.error("Insert failed: "..tostring(err))
+  return
+end
+
+local res, err = ctx:wait()
+if err ~= nil then
+  session.response.error = {
+    code = -32606,
+    message = "Insert confirmation failed: "..tostring(err)
+  }
+  log.error("Insert confirmation failed: "..tostring(err))
+  return
+end
+
+session.response.result = {
+  success = true,
+  rows_affected = res,
+  message = "User created successfully"
+}
+
+db:close()

com/List.lua

@@ -1,7 +1,9 @@
 -- com/List.lua
 
-if In.Params and In.Params.about then
-  Out.Result = {
+local session = require("internal.session")
+
+if session.request and session.request.params and session.request.params.about then
+  session.response.result = {
     description = "Returns a list of available methods",
     params = {
       layer = "select which layer list to display"
@@ -46,8 +48,8 @@ local function scanDirectory(basePath, targetPath)
 end
 
 local basePath = "com"
-local layer = In.Params and In.Params.layer and In.Params.layer:gsub(">", "/") or nil
+local layer = session.request and session.request.params.layer and session.request.params.layer:gsub(">", "/") or nil
 
-Out.Result = {
+session.response.result = {
   answer = layer and scanDirectory(basePath, layer) or scanDirectory(basePath, "")
 }

com/Net/GetExpl.lua

@@ -1,26 +1,29 @@
+local session = require("internal.session")
+local net = require("internal.net")
+
 local reqAddr
 local logReq = true
 
-if In.Params and In.Params.url then
-  reqAddr = In.Params.url
+if session.request.params and session.request.params.url then
+  reqAddr = session.request.params.url
 else
-  Out.Error = {
+  session.response.error = {
     code = -32602,
     message = "no url provided"
   }
   return
 end
 
-local resp = Net.Http.Get(logReq, reqAddr)
+local resp = net.http.get_request(logReq, reqAddr)
 if resp then
-  Out.Result.answer = {
+  session.response.result.answer = {
     status = resp.status,
     body = resp.body
   }
   return
 end
 
-Out.Result.answer = {
-  status = resp.status
+session.response.error = {
+  data = "error while requesting"
 }
 

com/Net/PostExpl.lua

@@ -1,27 +1,35 @@
+local session = require("internal.session")
+local net = require("internal.net")
+local log = require("internal.log")
+
 local reqAddr
 local logReq = true
 local payload
 
-if not In.Params and In.Params.url or not In.Params.payload then
-  Out.Error = {
+log.debug(session.request.params)
+
+if not (session.request.params and session.request.params.url) then
+  session.response.error = {
     code = -32602,
     message = "no url or payload provided"
   }
   return
 end
 
-reqAddr = In.Params.url
-payload = In.Params.payload
 
-local resp = Net.Http.Post(logReq, reqAddr, "application/json", payload)
+
+reqAddr = session.request.params.url
+payload = session.request.params.payload
+
+local resp = net.http.post_request(logReq, reqAddr, "application/json", payload)
 if resp then
-  Out.Result.answer = {
+  session.response.result.answer = {
     status = resp.status,
     body = resp.body
   }
   return
 end
 
-Out.Result.answer = {
-  status = resp.status
+session.response.error = {
+  data = "error while requesting"
 }

com/_globals.lua

@@ -1,59 +1,54 @@
----@diagnostic disable: missing-fields, missing-return
----@alias AnyTable table<string, any>
+--@diagnostic disable: missing-fields, missing-return
 
----@type AnyTable
-In = {
-	Params = {},
-}
+---@alias Any any
+---@alias AnyTable table<string, Any>
 
----@type AnyTable
-Out = {
-	Result = {},
-}
+--- Global session module interface
+---@class SessionIn
+---@field params AnyTable Request parameters
 
----@class Log
----@field Info fun(msg: string)
----@field Debug fun(msg: string)
----@field Error fun(msg: string)
----@field Warn fun(msg: string)
----@field Event fun(msg: string)
----@field EventError fun(msg: string)
----@field EventWarn fun(msg: string)
+---@class SessionOut
+---@field result Any|string? Result payload (table or primitive)
+---@field error { code: integer, message: string, data: Any }? Optional error info
 
----@type Log
-Log = {}
+---@class SessionModule
+---@field request SessionIn Input context (read-only)
+---@field response SessionOut Output context (write results/errors)
 
+--- Global log module interface
+---@class LogModule
+---@field info fun(msg: string) Log informational message
+---@field debug fun(msg: string) Log debug message
+---@field error fun(msg: string) Log error message
+---@field warn fun(msg: string) Log warning message
+---@field event fun(msg: string) Log event (generic)
+---@field event_error fun(msg: string) Log event error
+---@field event_warn fun(msg: string) Log event warning
+
+--- Global net module interface
 ---@class HttpResponse
 ---@field status integer HTTP status code
 ---@field status_text string HTTP status text
 ---@field body string Response body
 ---@field content_length integer Content length
----@field headers table<string, string|string[]> Response headers
+---@field headers AnyTable Map of headers
 
----@class Http
----@field Get fun(log: boolean, url: string): HttpResponse, string? Makes HTTP GET request
----@field Post fun(log: boolean, url: string, content_type: string, payload: string): HttpResponse, string? Makes HTTP POST request
+---@class HttpModule
+---@field get fun(log: boolean, url: string): HttpResponse, string? Perform GET
+---@field post fun(log: boolean, url: string, content_type: string, payload: string): HttpResponse, string? Perform POST
 
----@class Net
----@field Http Http HTTP client methods
+---@class NetModule
+---@field http HttpModule HTTP client functions
 
----@type Net
-Net = {
-    Http = {
-        ---Makes HTTP GET request
-        ---@param log boolean Whether to log the request
-        ---@param url string URL to request
-        ---@return HttpResponse response
-        ---@return string? error
-        Get = function(log, url) end,
+--- Global variables declaration
+---@global
+---@type SessionModule
+_G.session = session or {}
 
-        ---Makes HTTP POST request
-        ---@param log boolean Whether to log the request
-        ---@param url string URL to request
-        ---@param content_type string Content-Type header
-        ---@param payload string Request body
-        ---@return HttpResponse response
-        ---@return string? error
-        Post = function(log, url, content_type, payload) end
-    }
-}
+---@global
+---@type LogModule
+_G.log = log or {}
+
+---@global
+---@type NetModule
+_G.net = net or {}

config-example.yaml

@@ -1,21 +1,30 @@
-mode: "prod"
+node:
+  mode: dev
+  name: "My gosally node"
+  show_config: true
+  com_dir: "%path%/com"
 
 http_server:
-  address: "0.0.0.0:8080"
-  api:
-    latest-version: v1
-    layers:
-      - b1
-      - s2
+  address: "0.0.0.0"
+  port: "8080"
+  session_ttl: 5s
+  timeout: 3s
+  idle_timeout: 30s
 
 tls:
-  enabled: false
-  cert_file: "./cert/fullchain.pem"
-  key_file: "./cert/privkey.pem"
-
-com_dir: "com/"
+  enabled: true
+  cert_file: "%path%/cert/fullchain.pem"
+  key_file: "%path%/cert/privkey.pem"
 
 updates:
-  enabled: true
+  enabled: false
   check-interval: 1h
   repository_url: "https://repo.serve.lv/raw/go-sally"
+
+log:
+  json_format: false
+  level: "debug"
+
+disable_warnings:
+  - --WNonStdTmpDir
+  - --WUndefLogLevel

hooks/initial.go

@@ -193,8 +193,10 @@ func InitConfigReplHook(_ context.Context, cs *corestate.CoreState, x *app.AppX)
 	replacements := map[string]any{
 		"%tmp%":    filepath.Clean(run_manager.RuntimeDir()),
 		"%path%":   *x.Config.Env.NodePath,
-		"%stdout%": os.Stdout,
-		"%stderr%": os.Stderr,
+		"%stdout%": "_1STDout",
+		"%stderr%": "_2STDerr",
+		"%1%":      "_1STDout",
+		"%2%":      "_2STDerr",
 	}
 
 	processConfig(&x.Config.Conf, replacements)
@@ -301,10 +303,32 @@ func processConfig(conf any, replacements map[string]any) error {
 
 	case reflect.Ptr:
 		if !val.IsNil() {
-			return processConfig(val.Interface(), replacements)
+			elem := val.Elem()
+			if elem.Kind() == reflect.String {
+				str := elem.String()
+				if replacement, exists := replacements[str]; exists {
+					strVal, err := toString(replacement)
+					if err != nil {
+						return fmt.Errorf("cannot convert replacement to string: %v", err)
+					}
+					elem.SetString(strVal)
+				} else {
+					for placeholder, replacement := range replacements {
+						if strings.Contains(str, placeholder) {
+							replacementStr, err := toString(replacement)
+							if err != nil {
+								return fmt.Errorf("invalid replacement for %q: %v", placeholder, err)
+							}
+							newStr := strings.ReplaceAll(str, placeholder, replacementStr)
+							elem.SetString(newStr)
+						}
+					}
+				}
+			} else {
+				return processConfig(elem.Addr().Interface(), replacements)
+			}
 		}
 	}
-
 	return nil
 }
 

hooks/run.go

@@ -75,8 +75,8 @@ func RunHook(ctx context.Context, cs *corestate.CoreState, x *app.AppX) error {
 	r := chi.NewRouter()
 	r.Use(cors.Handler(cors.Options{
 		AllowedOrigins:   []string{"*"},
-		AllowedMethods:   []string{"GET", "POST", "OPTIONS"},
-		AllowedHeaders:   []string{"Accept", "Authorization", "Content-Type", "X-CSRF-Token"},
+		AllowedMethods:   []string{"POST"},
+		AllowedHeaders:   []string{"Accept", "Authorization", "Content-Type", "X-CSRF-Token", "X-Session-UUID"},
 		AllowCredentials: true,
 		MaxAge:           300,
 	}))

internal/engine/config/compositor.go

@@ -58,8 +58,9 @@ func (c *Compositor) LoadConf(path string) error {
 	v.SetDefault("updates.enabled", false)
 	v.SetDefault("updates.check_interval", "2h")
 	v.SetDefault("updates.wanted_version", "latest-stable")
+	v.SetDefault("log.json_format", "false")
 	v.SetDefault("log.level", "info")
-	v.SetDefault("log.output", "%stdout%")
+	v.SetDefault("log.output", "%2%")
 
 	if err := v.ReadInConfig(); err != nil {
 		return fmt.Errorf("error reading config: %w", err)

internal/engine/config/config.go

@@ -55,8 +55,9 @@ type Updates struct {
 }
 
 type Log struct {
+	JSON    *bool   `mapstructure:"json_format"`
 	Level   *string `mapstructure:"level"`
-	OutPath any     `mapstructure:"output"`
+	OutPath *string `mapstructure:"output"`
 }
 
 // ConfigEnv structure for environment variables

internal/engine/logs/logger.go

@@ -6,7 +6,6 @@ package logs
 import (
 	"bytes"
 	"context"
-	"fmt"
 	"io"
 	"log/slog"
 	"os"
@@ -58,30 +57,14 @@ func SetupLogger(o *config.Log) (*slog.Logger, error) {
 		handlerOpts.Level = slog.LevelInfo
 	}
 
-	switch o.OutPath {
-	case 1:
+	switch *o.OutPath {
+	case "_1STDout":
 		writer = os.Stdout
-	case 2:
-		writer = os.Stderr
-	case os.Stdout:
-		writer = os.Stdout
-	case os.Stderr:
+	case "_2STDerr":
 		writer = os.Stderr
 	default:
-		var path string
-		switch v := o.OutPath.(type) {
-		case string:
-			path = v
-		case int, int64, float64:
-			path = fmt.Sprint(v)
-		case fmt.Stringer:
-			path = v.String()
-		default:
-			path = fmt.Sprint(v)
-		}
-
 		logFile := &lumberjack.Logger{
-			Filename:   filepath.Join(path, "event.log"),
+			Filename:   filepath.Join(*o.OutPath, "event.log"),
 			MaxSize:    10,
 			MaxBackups: 5,
 			MaxAge:     28,
@@ -90,6 +73,13 @@ func SetupLogger(o *config.Log) (*slog.Logger, error) {
 		writer = logFile
 	}
 
-	log := slog.New(slog.NewJSONHandler(writer, &handlerOpts))
+	var handler slog.Handler
+
+	if *o.JSON {
+		handler = slog.NewJSONHandler(writer, &handlerOpts)
+	} else {
+		handler = slog.NewTextHandler(writer, &handlerOpts)
+	}
+	log := slog.New(handler)
 	return log, nil
 }

internal/server/gateway/route.go

@@ -21,9 +21,11 @@ func (gs *GatewayServer) Handle(w http.ResponseWriter, r *http.Request) {
 	if sessionUUID == "" {
 		sessionUUID = uuid.New().String()
 	}
+	gs.x.SLog.Debug("new request", slog.String("session-uuid", sessionUUID), slog.Group("connection", slog.String("ip", r.RemoteAddr)))
 
 	w.Header().Set("X-Session-UUID", sessionUUID)
 	if !gs.sm.Add(sessionUUID) {
+		gs.x.SLog.Debug("session is busy", slog.String("session-uuid", sessionUUID))
 		rpc.WriteError(w, &rpc.RPCResponse{
 			Error: map[string]any{
 				"code":    rpc.ErrSessionIsBusy,
@@ -36,6 +38,7 @@ func (gs *GatewayServer) Handle(w http.ResponseWriter, r *http.Request) {
 
 	body, err := io.ReadAll(r.Body)
 	if err != nil {
+		gs.x.SLog.Debug("failed to read body", slog.String("err", err.Error()))
 		w.WriteHeader(http.StatusBadRequest)
 		rpc.WriteError(w, &rpc.RPCResponse{
 			JSONRPC: rpc.JSONRPCVersion,
@@ -55,6 +58,7 @@ func (gs *GatewayServer) Handle(w http.ResponseWriter, r *http.Request) {
 	var single rpc.RPCRequest
 	if batch == nil {
 		if err := json.Unmarshal(body, &single); err != nil {
+			gs.x.SLog.Debug("failed to parse json", slog.String("err", err.Error()))
 			w.WriteHeader(http.StatusBadRequest)
 			rpc.WriteError(w, &rpc.RPCResponse{
 				JSONRPC: rpc.JSONRPCVersion,
@@ -106,17 +110,17 @@ func (gs *GatewayServer) Handle(w http.ResponseWriter, r *http.Request) {
 func (gs *GatewayServer) Route(ctx context.Context, sid string, r *http.Request, req *rpc.RPCRequest) (resp *rpc.RPCResponse) {
 	defer utils.CatchPanicWithFallback(func(rec any) {
 		gs.x.SLog.Error("panic caught in handler", slog.Any("error", rec))
-		resp = rpc.NewError(rpc.ErrInternalError, "Internal server error (panic)", req.ID)
+		resp = rpc.NewError(rpc.ErrInternalError, "Internal server error (panic)", nil, req.ID)
 	})
 	if req.JSONRPC != rpc.JSONRPCVersion {
 		gs.x.SLog.Info("invalid request received", slog.String("issue", rpc.ErrInvalidRequestS), slog.String("requested-version", req.JSONRPC))
-		return rpc.NewError(rpc.ErrInvalidRequest, rpc.ErrInvalidRequestS, req.ID)
+		return rpc.NewError(rpc.ErrInvalidRequest, rpc.ErrInvalidRequestS, nil, req.ID)
 	}
 
 	server, ok := gs.servers[serversApiVer(req.ContextVersion)]
 	if !ok {
 		gs.x.SLog.Info("invalid request received", slog.String("issue", rpc.ErrContextVersionS), slog.String("requested-version", req.ContextVersion))
-		return rpc.NewError(rpc.ErrContextVersion, rpc.ErrContextVersionS, req.ID)
+		return rpc.NewError(rpc.ErrContextVersion, rpc.ErrContextVersionS, nil, req.ID)
 	}
 
 	// checks if request is notification

internal/server/rpc/responsers.go

@@ -2,7 +2,18 @@ package rpc
 
 import "encoding/json"
 
-func NewError(code int, message string, id *json.RawMessage) *RPCResponse {
+func NewError(code int, message string, data any, id *json.RawMessage) *RPCResponse {
+	if data != nil {
+		return &RPCResponse{
+			JSONRPC: JSONRPCVersion,
+			ID:      id,
+			Error: map[string]any{
+				"code":    code,
+				"message": message,
+				"data":    data,
+			},
+		}
+	}
 	return &RPCResponse{
 		JSONRPC: JSONRPCVersion,
 		ID:      id,

internal/server/sv1/handle.go

@@ -11,17 +11,17 @@ import (
 func (h *HandlerV1) Handle(_ context.Context, sid string, r *http.Request, req *rpc.RPCRequest) *rpc.RPCResponse {
 	if req.Method == "" {
 		h.x.SLog.Info("invalid request received", slog.String("issue", rpc.ErrMethodNotFoundS), slog.String("requested-method", req.Method))
-		return rpc.NewError(rpc.ErrMethodIsMissing, rpc.ErrMethodIsMissingS, req.ID)
+		return rpc.NewError(rpc.ErrMethodIsMissing, rpc.ErrMethodIsMissingS, nil, req.ID)
 	}
 
 	method, err := h.resolveMethodPath(req.Method)
 	if err != nil {
 		if err.Error() == rpc.ErrInvalidMethodFormatS {
 			h.x.SLog.Info("invalid request received", slog.String("issue", rpc.ErrInvalidMethodFormatS), slog.String("requested-method", req.Method))
-			return rpc.NewError(rpc.ErrInvalidMethodFormat, rpc.ErrInvalidMethodFormatS, req.ID)
+			return rpc.NewError(rpc.ErrInvalidMethodFormat, rpc.ErrInvalidMethodFormatS, nil, req.ID)
 		} else if err.Error() == rpc.ErrMethodNotFoundS {
 			h.x.SLog.Info("invalid request received", slog.String("issue", rpc.ErrMethodNotFoundS), slog.String("requested-method", req.Method))
-			return rpc.NewError(rpc.ErrMethodNotFound, rpc.ErrMethodNotFoundS, req.ID)
+			return rpc.NewError(rpc.ErrMethodNotFound, rpc.ErrMethodNotFoundS, nil, req.ID)
 		}
 	}
 

internal/server/sv1/lua_handler.go

@@ -3,20 +3,332 @@ package sv1
 // TODO: make a lua state pool using sync.Pool
 
 import (
+	"database/sql"
 	"fmt"
 	"io"
 	"log/slog"
+	"math/rand/v2"
 	"net/http"
 	"os"
 	"path/filepath"
 	"strconv"
 	"strings"
+	"sync"
 
 	"github.com/akyaiy/GoSally-mvp/internal/colors"
 	"github.com/akyaiy/GoSally-mvp/internal/server/rpc"
 	lua "github.com/yuin/gopher-lua"
+	_ "modernc.org/sqlite"
 )
 
+type DBConnection struct {
+	dbPath    string
+	log       bool
+	logger    *slog.Logger
+	writeChan chan *dbWriteRequest
+	closeChan chan struct{}
+}
+
+type dbWriteRequest struct {
+	query string
+	args  []interface{}
+	resCh chan *dbWriteResult
+}
+
+type dbWriteResult struct {
+	rowsAffected int64
+	err          error
+}
+
+var dbMutexMap = make(map[string]*sync.RWMutex)
+var dbGlobalMutex sync.Mutex
+
+func getDBMutex(dbPath string) *sync.RWMutex {
+	dbGlobalMutex.Lock()
+	defer dbGlobalMutex.Unlock()
+
+	if mtx, ok := dbMutexMap[dbPath]; ok {
+		return mtx
+	}
+
+	mtx := &sync.RWMutex{}
+	dbMutexMap[dbPath] = mtx
+	return mtx
+}
+
+func loadDBMod(llog *slog.Logger) func(*lua.LState) int {
+	llog.Debug("import module db-sqlite")
+	return func(L *lua.LState) int {
+		dbMod := L.NewTable()
+
+		L.SetField(dbMod, "connect", L.NewFunction(func(L *lua.LState) int {
+			dbPath := L.CheckString(1)
+
+			logQueries := false
+			if L.GetTop() >= 2 {
+				opts := L.CheckTable(2)
+				if val := opts.RawGetString("log"); val != lua.LNil {
+					logQueries = lua.LVAsBool(val)
+				}
+			}
+
+			conn := &DBConnection{
+				dbPath:    dbPath,
+				log:       logQueries,
+				logger:    llog,
+				writeChan: make(chan *dbWriteRequest, 100),
+				closeChan: make(chan struct{}),
+			}
+
+			go conn.processWrites()
+
+			ud := L.NewUserData()
+			ud.Value = conn
+			L.SetMetatable(ud, L.GetTypeMetatable("gosally_db"))
+
+			L.Push(ud)
+			return 1
+		}))
+
+		mt := L.NewTypeMetatable("gosally_db")
+		L.SetField(mt, "__index", L.SetFuncs(L.NewTable(), map[string]lua.LGFunction{
+			"exec":  dbExec,
+			"query": dbQuery,
+			"close": dbClose,
+		}))
+
+		L.SetField(dbMod, "__gosally_internal", lua.LString("0"))
+		L.Push(dbMod)
+		return 1
+	}
+}
+
+func (conn *DBConnection) processWrites() {
+	for {
+		select {
+		case req := <-conn.writeChan:
+			mtx := getDBMutex(conn.dbPath)
+			mtx.Lock()
+
+			db, err := sql.Open("sqlite", conn.dbPath+"?_busy_timeout=5000&_journal_mode=WAL&_sync=NORMAL&_cache_size=-10000")
+			if err == nil {
+				_, err = db.Exec("PRAGMA journal_mode=WAL;")
+				if err == nil {
+					res, execErr := db.Exec(req.query, req.args...)
+					if execErr == nil {
+						rows, _ := res.RowsAffected()
+						req.resCh <- &dbWriteResult{rowsAffected: rows}
+					} else {
+						req.resCh <- &dbWriteResult{err: execErr}
+					}
+				}
+				db.Close()
+			}
+
+			if err != nil {
+				req.resCh <- &dbWriteResult{err: err}
+			}
+
+			mtx.Unlock()
+		case <-conn.closeChan:
+			return
+		}
+	}
+}
+
+func dbExec(L *lua.LState) int {
+	ud := L.CheckUserData(1)
+	conn, ok := ud.Value.(*DBConnection)
+	if !ok {
+		L.Push(lua.LNil)
+		L.Push(lua.LString("invalid database connection"))
+		return 2
+	}
+
+	query := L.CheckString(2)
+	
+	var args []any
+	if L.GetTop() >= 3 {
+		params := L.CheckTable(3)
+		params.ForEach(func(k lua.LValue, v lua.LValue) {
+			args = append(args, ConvertLuaTypesToGolang(v))
+		})
+	}
+
+	if conn.log {
+		conn.logger.Info("DB Exec",
+			slog.String("query", query),
+			slog.Any("params", args))
+	}
+
+	resCh := make(chan *dbWriteResult, 1)
+	conn.writeChan <- &dbWriteRequest{
+		query: query,
+		args:  args,
+		resCh: resCh,
+	}
+
+	ctx := L.NewTable()
+	L.SetField(ctx, "done", lua.LBool(false))
+	
+	var result lua.LValue = lua.LNil
+	var errorMsg lua.LValue = lua.LNil
+
+	L.SetField(ctx, "wait", L.NewFunction(func(lL *lua.LState) int {
+		res := <-resCh
+		L.SetField(ctx, "done", lua.LBool(true))
+		
+		if res.err != nil {
+			errorMsg = lua.LString(res.err.Error())
+			result = lua.LNil
+		} else {
+			result = lua.LNumber(res.rowsAffected)
+			errorMsg = lua.LNil
+		}
+		
+		if res.err != nil {
+			lL.Push(lua.LNil)
+			lL.Push(lua.LString(res.err.Error()))
+			return 2
+		}
+		lL.Push(lua.LNumber(res.rowsAffected))
+		lL.Push(lua.LNil)
+		return 2
+	}))
+
+	L.SetField(ctx, "check", L.NewFunction(func(lL *lua.LState) int {
+		select {
+		case res := <-resCh:
+			lL.SetField(ctx, "done", lua.LBool(true))
+			if res.err != nil {
+				errorMsg = lua.LString(res.err.Error())
+				result = lua.LNil
+				lL.Push(lua.LNil)
+				lL.Push(lua.LString(res.err.Error()))
+				return 2
+			} else {
+				result = lua.LNumber(res.rowsAffected)
+				errorMsg = lua.LNil
+				lL.Push(lua.LNumber(res.rowsAffected))
+				lL.Push(lua.LNil)
+				return 2
+			}
+		default:
+			lL.Push(result)
+			lL.Push(errorMsg)
+			return 2
+		}
+	}))
+
+	L.Push(ctx)
+	L.Push(lua.LNil)
+	return 2
+}
+
+func dbQuery(L *lua.LState) int {
+	ud := L.CheckUserData(1)
+	conn, ok := ud.Value.(*DBConnection)
+	if !ok {
+		L.Push(lua.LNil)
+		L.Push(lua.LString("invalid database connection"))
+		return 2
+	}
+
+	query := L.CheckString(2)
+
+	var args []any
+	if L.GetTop() >= 3 {
+		params := L.CheckTable(3)
+		params.ForEach(func(k lua.LValue, v lua.LValue) {
+			args = append(args, ConvertLuaTypesToGolang(v))
+		})
+	}
+
+	if conn.log {
+		conn.logger.Info("DB Query",
+			slog.String("query", query),
+			slog.Any("params", args))
+	}
+
+	mtx := getDBMutex(conn.dbPath)
+	mtx.RLock()
+	defer mtx.RUnlock()
+
+	db, err := sql.Open("sqlite", conn.dbPath+"?_busy_timeout=5000&_journal_mode=WAL&_sync=NORMAL&_cache_size=-10000")
+	if err != nil {
+		L.Push(lua.LNil)
+		L.Push(lua.LString(err.Error()))
+		return 2
+	}
+	defer db.Close()
+
+	rows, err := db.Query(query, args...)
+	if err != nil {
+		L.Push(lua.LNil)
+		L.Push(lua.LString(fmt.Sprintf("query failed: %v", err)))
+		return 2
+	}
+	defer rows.Close()
+
+	columns, err := rows.Columns()
+	if err != nil {
+		L.Push(lua.LNil)
+		L.Push(lua.LString(fmt.Sprintf("get columns failed: %v", err)))
+		return 2
+	}
+
+	result := L.NewTable()
+	colCount := len(columns)
+	values := make([]any, colCount)
+	valuePtrs := make([]any, colCount)
+
+	for rows.Next() {
+		for i := range columns {
+			valuePtrs[i] = &values[i]
+		}
+
+		if err := rows.Scan(valuePtrs...); err != nil {
+			L.Push(lua.LNil)
+			L.Push(lua.LString(fmt.Sprintf("scan failed: %v", err)))
+			return 2
+		}
+
+		rowTable := L.NewTable()
+		for i, col := range columns {
+			val := values[i]
+			if val == nil {
+				L.SetField(rowTable, col, lua.LNil)
+			} else {
+				L.SetField(rowTable, col, ConvertGolangTypesToLua(L, val))
+			}
+		}
+		result.Append(rowTable)
+	}
+
+	if err := rows.Err(); err != nil {
+		L.Push(lua.LNil)
+		L.Push(lua.LString(fmt.Sprintf("rows iteration failed: %v", err)))
+		return 2
+	}
+
+	L.Push(result)
+	return 1
+}
+
+func dbClose(L *lua.LState) int {
+	ud := L.CheckUserData(1)
+	conn, ok := ud.Value.(*DBConnection)
+	if !ok {
+		L.Push(lua.LFalse)
+		L.Push(lua.LString("invalid database connection"))
+		return 2
+	}
+
+	close(conn.closeChan)
+	L.Push(lua.LTrue)
+	return 1
+}
+
 func addInitiatorHeaders(sid string, req *http.Request, headers http.Header) {
 	clientIP := req.RemoteAddr
 	if forwardedFor := req.Header.Get("X-Forwarded-For"); forwardedFor != "" {
@@ -37,72 +349,100 @@ func addInitiatorHeaders(sid string, req *http.Request, headers http.Header) {
 // I will be only glad.
 // TODO: make this huge function more harmonious by dividing responsibilities
 func (h *HandlerV1) handleLUA(sid string, r *http.Request, req *rpc.RPCRequest, path string) *rpc.RPCResponse {
+	llog := h.x.SLog.With(slog.String("session-id", sid))
+	llog.Debug("handling LUA")
 	L := lua.NewState()
 	defer L.Close()
 
-	inTable := L.NewTable()
-	paramsTable := L.NewTable()
+	seed := rand.Int()
+
+	loadSessionMod := func(lL *lua.LState) int {
+		llog.Debug("import module session", slog.String("script", path))
+		sessionMod := lL.NewTable()
+		inTable := lL.NewTable()
+		paramsTable := lL.NewTable()
 		if fetchedParams, ok := req.Params.(map[string]any); ok {
 			for k, v := range fetchedParams {
-			L.SetField(paramsTable, k, ConvertGolangTypesToLua(L, v))
+				lL.SetField(paramsTable, k, ConvertGolangTypesToLua(lL, v))
 			}
 		}
-	L.SetField(inTable, "Params", paramsTable)
-	L.SetGlobal("In", inTable)
+		lL.SetField(inTable, "params", paramsTable)
 
-	outTable := L.NewTable()
-	resultTable := L.NewTable()
-	L.SetField(outTable, "Result", resultTable)
-	L.SetGlobal("Out", outTable)
+		outTable := lL.NewTable()
+		resultTable := lL.NewTable()
+		lL.SetField(outTable, "result", resultTable)
 
-	logTable := L.NewTable()
+		lL.SetField(inTable, "address", lua.LString(r.RemoteAddr))
+		lL.SetField(sessionMod, "request", inTable)
+		lL.SetField(sessionMod, "response", outTable)
+
+		lL.SetField(sessionMod, "id", lua.LString(sid))
+
+		lL.SetField(sessionMod, "__gosally_internal", lua.LString(fmt.Sprint(seed)))
+		lL.Push(sessionMod)
+		return 1
+	}
+
+	loadLogMod := func(lL *lua.LState) int {
+		llog.Debug("import module log", slog.String("script", path))
+		logMod := lL.NewTable()
 
 		logFuncs := map[string]func(string, ...any){
-		"Info":  h.x.SLog.Info,
-		"Debug": h.x.SLog.Debug,
-		"Error": h.x.SLog.Error,
-		"Warn":  h.x.SLog.Warn,
+			"info":  llog.Info,
+			"debug": llog.Debug,
+			"error": llog.Error,
+			"warn":  llog.Warn,
 		}
 
 		for name, logFunc := range logFuncs {
-		L.SetField(logTable, name, L.NewFunction(func(L *lua.LState) int {
-			msg := L.ToString(1)
-			logFunc(fmt.Sprintf("the script says: %s", msg), slog.String("script", path))
+			fun := logFunc
+			lL.SetField(logMod, name, lL.NewFunction(func(lL *lua.LState) int {
+				msg := lL.Get(1)
+				converted := ConvertLuaTypesToGolang(msg)
+				fun(fmt.Sprintf("the script says: %s", converted), slog.String("script", path))
 				return 0
 			}))
 		}
 
-	L.SetField(logTable, "Event", L.NewFunction(func(L *lua.LState) int {
-		msg := L.ToString(1)
-		h.x.Log.Printf("%s: %s", path, msg)
+		for _, fn := range []struct {
+			field string
+			pfunc func(string, ...any)
+			color func() string
+		}{
+			{"event", h.x.Log.Printf, nil},
+			{"event_error", h.x.Log.Printf, colors.PrintError},
+			{"event_warn", h.x.Log.Printf, colors.PrintWarn},
+		} {
+			lL.SetField(logMod, fn.field, lL.NewFunction(func(lL *lua.LState) int {
+				msg := lL.Get(1)
+				converted := ConvertLuaTypesToGolang(msg)
+				if fn.color != nil {
+					h.x.Log.Printf("%s: %s: %s", fn.color(), path, converted)
+				} else {
+					h.x.Log.Printf("%s: %s", path, converted)
+				}
 				return 0
 			}))
+		}
 
-	L.SetField(logTable, "EventError", L.NewFunction(func(L *lua.LState) int {
-		msg := L.ToString(1)
-		h.x.Log.Printf("%s: %s: %s", colors.PrintError(), path, msg)
-		return 0
-	}))
+		lL.SetField(logMod, "__gosally_internal", lua.LString(fmt.Sprint(seed)))
+		lL.Push(logMod)
+		return 1
+	}
 
-	L.SetField(logTable, "EventWarn", L.NewFunction(func(L *lua.LState) int {
-		msg := L.ToString(1)
-		h.x.Log.Printf("%s: %s: %s", colors.PrintWarn(), path, msg)
-		return 0
-	}))
+	loadNetMod := func(lL *lua.LState) int {
+		llog.Debug("import module net", slog.String("script", path))
+		netMod := lL.NewTable()
+		netModhttp := lL.NewTable()
 
-	L.SetGlobal("Log", logTable)
-
-	net := L.NewTable()
-	netHttp := L.NewTable()
-
-	L.SetField(netHttp, "Get", L.NewFunction(func(L *lua.LState) int {
-		logRequest := L.ToBool(1)
-		url := L.ToString(2)
+		lL.SetField(netModhttp, "get_request", lL.NewFunction(func(lL *lua.LState) int {
+			logRequest := lL.ToBool(1)
+			url := lL.ToString(2)
 
 			req, err := http.NewRequest("GET", url, nil)
 			if err != nil {
-			L.Push(lua.LNil)
-			L.Push(lua.LString(err.Error()))
+				lL.Push(lua.LNil)
+				lL.Push(lua.LString(err.Error()))
 				return 2
 			}
 
@@ -111,21 +451,21 @@ func (h *HandlerV1) handleLUA(sid string, r *http.Request, req *rpc.RPCRequest,
 			client := &http.Client{}
 			resp, err := client.Do(req)
 			if err != nil {
-			L.Push(lua.LNil)
-			L.Push(lua.LString(err.Error()))
+				lL.Push(lua.LNil)
+				lL.Push(lua.LString(err.Error()))
 				return 2
 			}
 			defer resp.Body.Close()
 
 			body, err := io.ReadAll(resp.Body)
 			if err != nil {
-			L.Push(lua.LNil)
-			L.Push(lua.LString(err.Error()))
+				lL.Push(lua.LNil)
+				lL.Push(lua.LString(err.Error()))
 				return 2
 			}
 
 			if logRequest {
-			h.x.SLog.Info("HTTP GET request",
+				llog.Info("HTTP GET request",
 					slog.String("script", path),
 					slog.String("url", url),
 					slog.Int("status", resp.StatusCode),
@@ -134,34 +474,34 @@ func (h *HandlerV1) handleLUA(sid string, r *http.Request, req *rpc.RPCRequest,
 				)
 			}
 
-		result := L.NewTable()
-		L.SetField(result, "status", lua.LNumber(resp.StatusCode))
-		L.SetField(result, "status_text", lua.LString(resp.Status))
-		L.SetField(result, "body", lua.LString(body))
-		L.SetField(result, "content_length", lua.LNumber(resp.ContentLength))
+			result := lL.NewTable()
+			lL.SetField(result, "status", lua.LNumber(resp.StatusCode))
+			lL.SetField(result, "status_text", lua.LString(resp.Status))
+			lL.SetField(result, "body", lua.LString(body))
+			lL.SetField(result, "content_length", lua.LNumber(resp.ContentLength))
 
-		headers := L.NewTable()
+			headers := lL.NewTable()
 			for k, v := range resp.Header {
-			L.SetField(headers, k, ConvertGolangTypesToLua(L, v))
+				lL.SetField(headers, k, ConvertGolangTypesToLua(lL, v))
 			}
-		L.SetField(result, "headers", headers)
+			lL.SetField(result, "headers", headers)
 
-		L.Push(result)
+			lL.Push(result)
 			return 1
 		}))
 
-	L.SetField(netHttp, "Post", L.NewFunction(func(L *lua.LState) int {
-		logRequest := L.ToBool(1)
-		url := L.ToString(2)
-		contentType := L.ToString(3)
-		payload := L.ToString(4)
+		lL.SetField(netModhttp, "post_request", lL.NewFunction(func(lL *lua.LState) int {
+			logRequest := lL.ToBool(1)
+			url := lL.ToString(2)
+			contentType := lL.ToString(3)
+			payload := lL.ToString(4)
 
 			body := strings.NewReader(payload)
 
 			req, err := http.NewRequest("POST", url, body)
 			if err != nil {
-			L.Push(lua.LNil)
-			L.Push(lua.LString(err.Error()))
+				lL.Push(lua.LNil)
+				lL.Push(lua.LString(err.Error()))
 				return 2
 			}
 
@@ -172,21 +512,21 @@ func (h *HandlerV1) handleLUA(sid string, r *http.Request, req *rpc.RPCRequest,
 			client := &http.Client{}
 			resp, err := client.Do(req)
 			if err != nil {
-			L.Push(lua.LNil)
-			L.Push(lua.LString(err.Error()))
+				lL.Push(lua.LNil)
+				lL.Push(lua.LString(err.Error()))
 				return 2
 			}
 			defer resp.Body.Close()
 
 			respBody, err := io.ReadAll(resp.Body)
 			if err != nil {
-			L.Push(lua.LNil)
-			L.Push(lua.LString(err.Error()))
+				lL.Push(lua.LNil)
+				lL.Push(lua.LString(err.Error()))
 				return 2
 			}
 
 			if logRequest {
-			h.x.SLog.Info("HTTP POST request",
+				llog.Info("HTTP POST request",
 					slog.String("script", path),
 					slog.String("url", url),
 					slog.String("content_type", contentType),
@@ -196,70 +536,118 @@ func (h *HandlerV1) handleLUA(sid string, r *http.Request, req *rpc.RPCRequest,
 				)
 			}
 
-		result := L.NewTable()
-		L.SetField(result, "status", lua.LNumber(resp.StatusCode))
-		L.SetField(result, "status_text", lua.LString(resp.Status))
-		L.SetField(result, "body", lua.LString(respBody))
-		L.SetField(result, "content_length", lua.LNumber(resp.ContentLength))
+			result := lL.NewTable()
+			lL.SetField(result, "status", lua.LNumber(resp.StatusCode))
+			lL.SetField(result, "status_text", lua.LString(resp.Status))
+			lL.SetField(result, "body", lua.LString(respBody))
+			lL.SetField(result, "content_length", lua.LNumber(resp.ContentLength))
 
-		headers := L.NewTable()
+			headers := lL.NewTable()
 			for k, v := range resp.Header {
-			L.SetField(headers, k, ConvertGolangTypesToLua(L, v))
+				lL.SetField(headers, k, ConvertGolangTypesToLua(lL, v))
 			}
-		L.SetField(result, "headers", headers)
+			lL.SetField(result, "headers", headers)
 
-		L.Push(result)
+			lL.Push(result)
 			return 1
 		}))
 
-	L.SetField(net, "Http", netHttp)
-	L.SetGlobal("Net", net)
+		lL.SetField(netMod, "http", netModhttp)
 
+		lL.SetField(netMod, "__gosally_internal", lua.LString(fmt.Sprint(seed)))
+		lL.Push(netMod)
+		return 1
+	}
+
+	L.PreloadModule("internal.session", loadSessionMod)
+	L.PreloadModule("internal.log", loadLogMod)
+	L.PreloadModule("internal.net", loadNetMod)
+	L.PreloadModule("internal.database-sqlite", loadDBMod(llog))
+
+	llog.Debug("preparing environment")
 	prep := filepath.Join(*h.x.Config.Conf.Node.ComDir, "_prepare.lua")
 	if _, err := os.Stat(prep); err == nil {
 		if err := L.DoFile(prep); err != nil {
-			return rpc.NewError(rpc.ErrInternalError, err.Error(), req.ID)
+			llog.Error("script error", slog.String("script", path), slog.String("error", err.Error()))
+			return rpc.NewError(rpc.ErrInternalError, rpc.ErrInternalErrorS, nil, req.ID)
 		}
 	}
+	llog.Debug("executing script", slog.String("script", path))
 	if err := L.DoFile(path); err != nil {
-		return rpc.NewError(rpc.ErrInternalError, err.Error(), req.ID)
+		llog.Error("script error", slog.String("script", path), slog.String("error", err.Error()))
+		return rpc.NewError(rpc.ErrInternalError, rpc.ErrInternalErrorS, nil, req.ID)
 	}
 
-	lv := L.GetGlobal("Out")
-	outTbl, ok := lv.(*lua.LTable)
+	pkg := L.GetGlobal("package")
+	pkgTbl, ok := pkg.(*lua.LTable)
 	if !ok {
-		return rpc.NewError(rpc.ErrInternalError, "Out is not a table", req.ID)
+		llog.Error("script error", slog.String("script", path), slog.String("error", "package not found"))
+		return rpc.NewError(rpc.ErrInternalError, rpc.ErrInternalErrorS, nil, req.ID)
 	}
 
-	// Check if Out.Error exists
-	if errVal := outTbl.RawGetString("Error"); errVal != lua.LNil {
+	loaded := pkgTbl.RawGetString("loaded")
+	loadedTbl, ok := loaded.(*lua.LTable)
+	if !ok {
+		llog.Error("script error", slog.String("script", path), slog.String("error", "package.loaded not found"))
+		return rpc.NewError(rpc.ErrInternalError, rpc.ErrInternalErrorS, nil, req.ID)
+	}
+
+	sessionVal := loadedTbl.RawGetString("internal.session")
+	sessionTbl, ok := sessionVal.(*lua.LTable)
+	if !ok {
+		return rpc.NewResponse(map[string]any{
+			"responsible-node": h.cs.UUID32,
+		}, req.ID)
+	}
+
+	tag := sessionTbl.RawGetString("__gosally_internal")
+	if tag.Type() != lua.LTString || tag.String() != fmt.Sprint(seed) {
+		llog.Debug("stock session module is not imported: wrong seed", slog.String("script", path))
+		return rpc.NewResponse(map[string]any{
+			"responsible-node": h.cs.UUID32,
+		}, req.ID)
+	}
+
+	outVal := sessionTbl.RawGetString("response")
+	outTbl, ok := outVal.(*lua.LTable)
+	if !ok {
+		llog.Error("script error", slog.String("script", path), slog.String("error", "response is not a table"))
+		return rpc.NewError(rpc.ErrInternalError, rpc.ErrInternalErrorS, nil, req.ID)
+	}
+
+	if errVal := outTbl.RawGetString("error"); errVal != lua.LNil {
+		llog.Debug("catch error table", slog.String("script", path))
 		if errTbl, ok := errVal.(*lua.LTable); ok {
 			code := rpc.ErrInternalError
-			message := "Internal script error"
+			message := rpc.ErrInternalErrorS
+			data := make(map[string]any)
 			if c := errTbl.RawGetString("code"); c.Type() == lua.LTNumber {
 				code = int(c.(lua.LNumber))
 			}
 			if msg := errTbl.RawGetString("message"); msg.Type() == lua.LTString {
 				message = msg.String()
 			}
-			h.x.SLog.Error("the script terminated with an error", slog.String("code", strconv.Itoa(code)), slog.String("message", message))
-			return rpc.NewError(code, message, req.ID)
+			rawData := errTbl.RawGetString("data")
+
+			if tbl, ok := rawData.(*lua.LTable); ok {
+				tbl.ForEach(func(k, v lua.LValue) { data[k.String()] = ConvertLuaTypesToGolang(v) })
+			} else {
+				llog.Error("the script terminated with an error", slog.String("code", strconv.Itoa(code)), slog.String("message", message))
+				return rpc.NewError(code, message, ConvertLuaTypesToGolang(rawData), req.ID)
 			}
-		return rpc.NewError(rpc.ErrInternalError, "Out.Error is not a table", req.ID)
+			llog.Error("the script terminated with an error", slog.String("code", strconv.Itoa(code)), slog.String("message", message))
+			return rpc.NewError(code, message, data, req.ID)
+		}
+		return rpc.NewError(rpc.ErrInternalError, rpc.ErrInternalErrorS, nil, req.ID)
 	}
 
-	// Otherwise, parse Out.Result
-	resultVal := outTbl.RawGetString("Result")
-	resultTbl, ok := resultVal.(*lua.LTable)
-	if !ok {
-		return rpc.NewError(rpc.ErrInternalError, "Out.Result is not a table", req.ID)
+	resultVal := outTbl.RawGetString("result")
+	payload := make(map[string]any)
+	if tbl, ok := resultVal.(*lua.LTable); ok {
+		tbl.ForEach(func(k, v lua.LValue) { payload[k.String()] = ConvertLuaTypesToGolang(v) })
+	} else {
+		payload["message"] = ConvertLuaTypesToGolang(resultVal)
 	}
-
-	out := make(map[string]any)
-	resultTbl.ForEach(func(key lua.LValue, value lua.LValue) {
-		out[key.String()] = ConvertLuaTypesToGolang(value)
-	})
-
-	out["responsible-node"] = h.cs.UUID32
-	return rpc.NewResponse(out, req.ID)
+	payload["responsible-node"] = h.cs.UUID32
+	return rpc.NewResponse(payload, req.ID)
 }