standardize responses from luna modules

1 files changed, 72 insertions, 93 deletions

diff --git a/main.go b/main.go
index 993c7bb..dd5e7fe 100644
--- a/main.go
+++ b/main.go
@@ -54,12 +54,10 @@ func main() {
 	routeModule := make(map[string]any)
 	routeModule["route"] = func (l *Lua) int {
 		var route string
-		var fn LuaRef 
+		var fn LuaRef
 		err := l.Scan(&route, &fn)
 		if err != nil {
-			fmt.Println("error:", err)
-			// FIXME: handle
-			return 0
+			return luaErr(l, err)
 		}
 		// find corresponding worker for the lua context
 		var wrk *Worker
@@ -70,13 +68,13 @@ func main() {
 			}
 		}
 		if wrk == nil {
-			return 0
+			return luaOk(l, nil)
 		}
 		// check if route is already registered. otherwise
 		// mux.HandleFunc will panic
 		_, ok := routes[route]
 		if ok {
-			return 0
+			return luaOk(l, nil)
 		}
 		routes[route] = true
 		mux.HandleFunc(
@@ -99,28 +97,26 @@ func main() {
 				)
 			},
 		)
-		return 0
+		return luaOk(l, nil)
 	}
 	routeModule["static"] = func (l *Lua) int {
 		var route, dir string
 		err := l.Scan(&route, &dir)
 		if err != nil {
-			fmt.Println("error:", err)
-			// FIXME: handle
-			return 0
+			return luaErr(l, err)
 		}
 		// check if route is already registered. otherwise
 		// mux.HandleFunc will panic
 		_, ok := routes[route]
 		if ok {
-			return 0
+			return luaOk(l, nil)
 		}
 		routes[route] = true
 		mux.Handle(
 			route,
 			http.StripPrefix("/static/", http.FileServer(http.Dir(dir))),
 		)
-		return 0
+		return luaOk(l, nil)
 	}
 
 	// define luna.http module
@@ -130,39 +126,35 @@ func main() {
 		headers := make(map[string]string)
 		err := l.Scan(&method, &url, &headers, &body)
 		if err != nil {
-			// FIXME: handle
-			fmt.Println("error:", err)
-			return 0
+			return luaErr(l, err)
 		}
 
 		req, err := http.NewRequest(method, url, strings.NewReader(body))
 		if err != nil {
-			// FIXME: return error
-			return 0
+			return luaErr(l, err)
 		}
 		for k, v := range headers {
 			req.Header.Add(k, v)
 		}
 		resp, err := httpClient.Do(req)
 		if err != nil {
-			// FIXME: return error
-			return 0
+			return luaErr(l, err)
 		}
 		defer resp.Body.Close()
 		respBody, err := io.ReadAll(resp.Body)
 		if err != nil {
-			// FIXME: return error
-			return 0
+			return luaErr(l, err)
 		}
 		respHeaders := make(map[string]any)
 		for k := range resp.Header {
 			respHeaders[k] = resp.Header.Get(k)
 		}
 
-		l.PushNumber(resp.StatusCode)
-		l.PushObject(respHeaders)
-		l.PushString(string(respBody))
-		return 3
+		res := make(map[string]any)
+		res["status"] = resp.StatusCode
+		res["headers"] = respHeaders
+		res["body"] = string(respBody)
+		return luaOk(l, res)
 	}
 
 	// define luna.db module
@@ -171,69 +163,59 @@ func main() {
 		var file string
 		err := l.Scan(&file)
 		if err != nil {
-			// FIXME: handle.
-			return 0
+			return luaErr(l, err)
 		}
 		db, err := sql.Open("sqlite3", file)
 		if err != nil {
-			// FIXME: handle.
-			return 0
+			return luaErr(l, err)
 		}
 		dbmu.Lock()
 		dbs = append(dbs, db)
 		dbmu.Unlock()
 		h := cgo.NewHandle(db)
-		l.PushNumber(int(h))
-		return 1
+		return luaOk(l, int(h))
 	}
 	dbModule["begin"] = func (l *Lua) int {
 		var handle cgo.Handle
 		err := l.Scan(&handle)
 		if err != nil {
-			// FIXME: handle.
-			return 0
+			return luaErr(l, err)
 		}
 		db := handle.Value().(*sql.DB)
 		tx, err := db.Begin()
 		if err != nil {
-			// FIXME: handle.
-			return 0
+			return luaErr(l, err)
 		}
 		txh := cgo.NewHandle(tx)
-		l.PushNumber(int(txh))
-		return 1
+		return luaOk(l, int(txh))
 	}
 	dbModule["commit"] = func (l *Lua) int {
 		var handle cgo.Handle
 		err := l.Scan(&handle)
 		if err != nil {
-			// FIXME: handle.
-			return 0
+			return luaErr(l, err)
 		}
 		tx := handle.Value().(*sql.Tx)
 		err = tx.Commit()
 		if err != nil {
-			// FIXME: handle.
-			return 0
+			return luaErr(l, err)
 		}
 		handle.Delete()
-		return 0
+		return luaOk(l, nil)
 	}
 	dbModule["rollback"] = func (l *Lua) int {
 		var handle cgo.Handle
 		err := l.Scan(&handle)
 		if err != nil {
-			// FIXME: handle.
-			return 0
+			return luaErr(l, err)
 		}
 		tx := handle.Value().(*sql.Tx)
 		err = tx.Rollback()
 		if err != nil {
-			// FIXME: handle.
-			return 0
+			return luaErr(l, err)
 		}
 		handle.Delete()
-		return 0
+		return luaOk(l, nil)
 	}
 	dbModule["exec-tx"] = func (l *Lua) int {
 		var handle cgo.Handle
@@ -241,18 +223,14 @@ func main() {
 		var params []any
 		err := l.Scan(&handle, &query, &params)
 		if err != nil {
-			fmt.Println(err)
-			// FIXME: handle.
-			return 0
+			return luaErr(l, err)
 		}
 		tx := handle.Value().(*sql.Tx)
 		_, err = tx.Exec(query, params...)
 		if err != nil {
-			fmt.Println(err)
-			// FIXME: handle.
-			return 0
+			return luaErr(l, err)
 		}
-		return 0
+		return luaOk(l, nil)
 	}
 	dbModule["exec"] = func (l *Lua) int {
 		var handle cgo.Handle
@@ -260,18 +238,14 @@ func main() {
 		var params []any
 		err := l.Scan(&handle, &query, &params)
 		if err != nil {
-			fmt.Println(err)
-			// FIXME: handle.
-			return 0
+			return luaErr(l, err)
 		}
 		db := handle.Value().(*sql.DB)
 		_, err = db.Exec(query, params...)
 		if err != nil {
-			fmt.Println(err)
-			// FIXME: handle.
-			return 0
+			return luaErr(l, err)
 		}
-		return 0
+		return luaOk(l, nil)
 	}
 	dbModule["query"] = func (l *Lua) int {
 		var handle cgo.Handle
@@ -279,15 +253,12 @@ func main() {
 		var params []any
 		err := l.Scan(&handle, &query, &params)
 		if err != nil {
-			fmt.Println(err)
-			// FIXME: handle.
-			return 0
+			return luaErr(l, err)
 		}
 		db := handle.Value().(*sql.DB)
 		rows, err := db.Query(query, params...)
 		if err != nil {
-			// FIXME: handle.
-			return 0
+			return luaErr(l, err)
 		}
 		var res [][]any
 		cols, _ := rows.Columns()
@@ -309,11 +280,9 @@ func main() {
 		}
 		err = l.PushArray(ares)
 		if err != nil {
-			fmt.Println(err)
-			// FIXME: handle
-			return 0
+			return luaErr(l, err)
 		}
-		return 1
+		return luaOk(l, ares)
 	}
 	dbModule["query*"] = func (l *Lua) int {
 		var handle cgo.Handle
@@ -321,14 +290,12 @@ func main() {
 		var params []any
 		err := l.Scan(&handle, &query, &params)
 		if err != nil {
-			// FIXME: handle.
-			return 0
+			return luaErr(l, err)
 		}
 		db := handle.Value().(*sql.DB)
 		rows, err := db.Query(query, params...)
 		if err != nil {
-			// FIXME: handle.
-			return 0
+			return luaErr(l, err)
 		}
 		var res []map[string]any
 		cols, _ := rows.Columns()
@@ -348,25 +315,18 @@ func main() {
 		for _, v := range res {
 			ares = append(ares, v)
 		}
-		err = l.PushArray(ares)
-		if err != nil {
-			// FIXME: handle
-			return 0
-		}
-		return 1
+		return luaOk(l, ares)
 	}
 	dbModule["close"] = func (l *Lua) int {
 		var handle cgo.Handle
 		err := l.Scan(&handle)
 		if err != nil {
-			// FIXME: handle.
-			return 0
+			return luaErr(l, err)
 		}
 		db := handle.Value().(*sql.DB)
 		err = db.Close()
 		if err != nil {
-			// FIXME: handle.
-			return 0
+			return luaErr(l, err)
 		}
 		dbmu.Lock()
 		for k, _db := range dbs {
@@ -377,31 +337,35 @@ func main() {
 		}
 		dbmu.Unlock()
 		handle.Delete()
-		return 0
+		return luaOk(l, nil)
 	}
 
 	// define luna.utf module
 	utfModule := make(map[string]any)
+	utfModule["len"] = func (l *Lua) int {
+		var str string
+		err := l.Scan(&str)
+		if err != nil {
+			return luaErr(l, err)
+		}
+		return luaOk(l, len(str))
+	}
 	utfModule["lower"] = func (l *Lua) int {
 		var str string
 		err := l.Scan(&str)
 		if err != nil {
-			// FIXME: handle.
-			return 0
+			return luaErr(l, err)
 		}
-		l.PushString(strings.ToLower(str))
-		return 1
+		return luaOk(l, strings.ToLower(str))
 	}
 	utfModule["sub"] = func (l *Lua) int {
 		var str string
 		var start, length int
 		err := l.Scan(&str, &start, &length)
 		if err != nil {
-			// FIXME: handle.
-			return 0
+			return luaErr(l, err)
 		}
-		l.PushString(str[start-1:length])
-		return 1
+		return luaOk(l, str[start-1:start-1+length])
 	}
 
 	module := make(map[string]any)
@@ -466,3 +430,18 @@ func mustExist(file string) {
 		os.Exit(1)
 	}
 }
+
+func luaErr(l *Lua, err error) int {
+	l.PushBoolean(false)
+	l.PushString(err.Error())
+	return 2
+}
+
+func luaOk(l *Lua, res any) int {
+	l.PushBoolean(true)
+	err := l.PushAny(res)
+	if err != nil {
+		return luaErr(l, fmt.Errorf("luaOk: %s", err))
+	}
+	return 2
+}