fixed bug with form submission and function exec runtime query function

Author: dstpierre

Makefile

@@ -14,6 +14,9 @@ deploy: build
 alltest:
 	@JWT_SECRET=okdevmode go test --race --cover ./...
 
+thistest:
+	@JWT_SECRET=okdevmode go test -run "$2" --race --cover
+
 test-pg:
 	@JWT_SECRET=okdevmode go test --race --cover ./database/postgresql
 
@@ -29,12 +32,12 @@ docker: build
 pkg: build
 	@rm -rf dist/*
 	@echo "building linux binaries"
-	@CGO_ENABLED=0 GOARCH=amd64 GOOS=linux go build -o dist/binary-for-linux-64-bit
-	@CGO_ENABLED=0 GOARCH=386 GOOS=linux go build -o dist/binary-for-linux-32-bit
+	@cd cmd && CGO_ENABLED=0 GOARCH=amd64 GOOS=linux go build -o ../dist/binary-for-linux-64-bit
+	@cd cmd && CGO_ENABLED=0 GOARCH=386 GOOS=linux go build -o ../dist/binary-for-linux-32-bit
 	@echo "building mac binaries"
-	@CGO_ENABLED=0 GOARCH=amd64 GOOS=darwin go build -o dist/binary-for-mac-64-bit
+	@cd cmd && CGO_ENABLED=0 GOARCH=amd64 GOOS=darwin go build -o ../dist/binary-for-mac-64-bit
 	@echo "building windows binaries"
-	@CGO_ENABLED=0 GOARCH=amd64 GOOS=windows go build -o dist/binary-for-windows-64-bit.exe
-	@CGO_ENABLED=0 GOARCH=386 GOOS=windows go build -o dist/binary-for-windows-32-bit.exe
+	@cd cmd && CGO_ENABLED=0 GOARCH=amd64 GOOS=windows go build -o ../dist/binary-for-windows-64-bit.exe
+	@cd cmd && CGO_ENABLED=0 GOARCH=386 GOOS=windows go build -o ../dist/binary-for-windows-32-bit.exe
 	@echo "compressing binaries"
 	@gzip dist/*

database/postgresql/base.go

@@ -42,6 +42,8 @@ func (j *JSONB) Scan(value interface{}) error {
 func (pg *PostgreSQL) CreateDocument(auth internal.Auth, dbName, col string, doc map[string]interface{}) (inserted map[string]interface{}, err error) {
 	inserted = doc
 
+	cleancol := internal.CleanCollectionName(col)
+
 	//TODO: find a good way to prevent doing the create
 	// table if not exists each time
 
@@ -53,7 +55,9 @@ func (pg *PostgreSQL) CreateDocument(auth internal.Auth, dbName, col string, doc
 			data jsonb NOT NULL,
 			created timestamp NOT NULL
 		);
-	`, dbName, internal.CleanCollectionName(col), dbName, dbName)
+
+		CREATE INDEX IF NOT EXISTS %s_acctid_idx ON %s.%s (account_id);			
+	`, dbName, cleancol, dbName, dbName, cleancol, dbName, cleancol)
 
 	if _, err = pg.DB.Exec(qry); err != nil {
 		return

database/postgresql/sb.go

@@ -85,6 +85,7 @@ func (pg *PostgreSQL) createSystemTables(schema string) error {
 			data JSONB NOT NULL,
 			created timestamp NOT NULL
 		);
+		CREATE INDEX IF NOT EXISTS sb_forms_name_idx ON {schema}.sb_forms (name);			
 
 		CREATE TABLE IF NOT EXISTS {schema}.sb_files (
 			id uuid PRIMARY KEY DEFAULT uuid_generate_v4 (),
@@ -94,6 +95,7 @@ func (pg *PostgreSQL) createSystemTables(schema string) error {
 			size INTEGER NOT NULL,			
 			uploaded timestamp NOT NULL			
 		);
+		CREATE INDEX IF NOT EXISTS sb_files_acctid_idx ON {schema}.sb_files (account_id);
 
 		CREATE TABLE IF NOT EXISTS {schema}.sb_functions (
 			id uuid PRIMARY KEY DEFAULT uuid_generate_v4 (),
@@ -104,6 +106,7 @@ func (pg *PostgreSQL) createSystemTables(schema string) error {
 			last_updated timestamp NOT NULL,
 			last_run timestamp NOT NULL
 		);
+		CREATE INDEX IF NOT EXISTS sb_functions_trigger_topic_idx ON {schema}.sb_functions (trigger_topic);
 
 		CREATE TABLE IF NOT EXISTS {schema}.sb_function_logs (
 			id uuid PRIMARY KEY DEFAULT uuid_generate_v4 (),

db_test.go

@@ -7,31 +7,52 @@ import (
 	"io/ioutil"
 	"net/http"
 	"net/http/httptest"
+	"net/url"
 	"testing"
 	"time"
 
 	"github.com/staticbackendhq/core/internal"
 	"github.com/staticbackendhq/core/middleware"
 )
 
-// dbReq post on behalf of adminToken by default (use params[0] true for root)
+// dbReq post on behalf of adminToken by default (use:
+// params[0] true for root)
+// params[1] true for Content-Type application/x-www-form-urlencoded
 func dbReq(t *testing.T, hf func(http.ResponseWriter, *http.Request), method, path string, v interface{}, params ...bool) *http.Response {
 	if params == nil {
-		params = make([]bool, 0)
+		params = make([]bool, 2)
 	}
 
-	if len(params) == 0 {
+	for i := len(params); i < 2; i++ {
 		params = append(params, false)
 	}
 
-	b, err := json.Marshal(v)
-	if err != nil {
-		t.Fatal("error marshaling post data:", err)
+	var payload []byte
+	if params[1] {
+		val, ok := v.(url.Values)
+		if !ok {
+			t.Fatal("expected v to be url.Value")
+		}
+
+		payload = []byte(val.Encode())
+	} else {
+		b, err := json.Marshal(v)
+		if err != nil {
+			t.Fatal("error marshaling post data:", err)
+		}
+
+		payload = b
 	}
 
-	req := httptest.NewRequest(method, path, bytes.NewReader(b))
+	req := httptest.NewRequest(method, path, bytes.NewReader(payload))
 	w := httptest.NewRecorder()
 
+	if params[1] {
+		req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
+	} else {
+		req.Header.Add("Content-Type", "application/json")
+	}
+
 	req.Header.Set("SB-PUBLIC-KEY", pubKey)
 
 	tok := adminToken

form.go

@@ -2,6 +2,7 @@ package staticbackend
 
 import (
 	"net/http"
+	"strings"
 
 	"github.com/staticbackendhq/core/middleware"
 )
@@ -20,9 +21,16 @@ func submitForm(w http.ResponseWriter, r *http.Request) {
 
 	doc := make(map[string]interface{})
 
-	if err := r.ParseMultipartForm(32 << 20); err != nil {
+	//TODO: Why forms would need multiplart/form-data
+	// There's no file upload available via form
+	/*if err := r.ParseMultipartForm(32 << 20); err != nil {
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
+	}*/
+
+	if err := r.ParseForm(); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
 	}
 
 	// if there's something in the _hp_ field, it's a bot
@@ -31,6 +39,10 @@ func submitForm(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	for k, v := range r.Form {
+		doc[k] = strings.Join(v, ", ")
+	}
+
 	if err := datastore.AddFormSubmission(conf.Name, form, doc); err != nil {
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return

form_test.go

@@ -0,0 +1,35 @@
+package staticbackend
+
+import (
+	"net/url"
+	"testing"
+)
+
+func TestFormSubmission(t *testing.T) {
+	val := url.Values{}
+	val.Add("name", "unit test")
+	val.Add("email", "[email protected]")
+
+	resp := dbReq(t, submitForm, "POST", "/postform/testform", val, false, true)
+	defer resp.Body.Close()
+
+	if resp.StatusCode > 299 {
+		t.Fatal(GetResponseBody(t, resp))
+	}
+
+	resp2 := dbReq(t, listForm, "GET", "/form?name=testform", nil, true)
+	defer resp2.Body.Close()
+
+	var results []map[string]interface{}
+	if err := parseBody(resp2.Body, &results); err != nil {
+		t.Fatal(err)
+	} else if len(results) == 0 {
+		t.Errorf("expected to get at least one form submission got 0")
+	} else if results[0]["name"] != "unit test" {
+		t.Log(results)
+		t.Errorf("expected name to be unit test got %v", results[0]["name"])
+	} else if results[0]["email"] != "[email protected]" {
+		t.Log(results)
+		t.Errorf("expected email to be [email protected] got %v", results[0]["email"])
+	}
+}

function/runtime.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"log"
 	"net/http"
+	"strings"
 	"time"
 
 	"github.com/staticbackendhq/core/internal"
@@ -76,7 +77,7 @@ func (env *ExecutionEnvironment) prepareArguments(vm *goja.Runtime, data interfa
 		defer r.Body.Close()
 
 		// let's ready the HTTP body
-		if r.Header.Get("Content-Type") == "application/json" {
+		if strings.EqualFold(r.Header.Get("Content-Type"), "application/json") {
 			var v interface{}
 			if err := json.NewDecoder(r.Body).Decode(&v); err != nil {
 				return nil, err
@@ -87,7 +88,12 @@ func (env *ExecutionEnvironment) prepareArguments(vm *goja.Runtime, data interfa
 			if err := r.ParseForm(); err != nil {
 				return nil, err
 			}
-			args = append(args, vm.ToValue(r.Form))
+
+			val := make(map[string]interface{})
+			for k, v := range r.Form {
+				val[k] = strings.Join(v, ", ")
+			}
+			args = append(args, vm.ToValue(val))
 		}
 
 		args = append(args, vm.ToValue(r.URL.Query()))
@@ -224,6 +230,12 @@ func (env *ExecutionEnvironment) addDatabaseFunctions(vm *goja.Runtime) {
 			}
 		}
 
+		// apply default page and limit
+		if params.Size == 0 {
+			params.Size = 25
+			params.Page = 1
+		}
+
 		result, err := env.DataStore.QueryDocuments(env.Auth, env.BaseName, col, filter, params)
 		if err != nil {
 			return vm.ToValue(Result{Content: fmt.Sprintf("error executing query: %v", err)})

functions.go

@@ -82,13 +82,16 @@ func (f *functions) exec(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	var data internal.ExecData
+	//TODONOW: this is not needed as only the fn name is required here
+	/*var data internal.ExecData
 	if err := parseBody(r.Body, &data); err != nil {
 		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
-	}
+	}*/
+
+	functionName := getURLPart(r.URL.Path, 3)
 
-	fn, err := datastore.GetFunctionForExecution(conf.Name, data.FunctionName)
+	fn, err := datastore.GetFunctionForExecution(conf.Name, functionName)
 	if err != nil {
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return

functions_test.go

@@ -3,16 +3,19 @@ package staticbackend
 import (
 	"io"
 	"net/http"
+	"net/url"
+	"strings"
 	"testing"
 
 	"github.com/staticbackendhq/core/internal"
 )
 
 func TestFunctionsExecuteDBOperations(t *testing.T) {
 	code := `
-	log("works here");
 	function handle(body) {
+		log(body);
 		var o = {
+			from: body.from,
 			desc: "yep", 
 			done: false, 
 			subobj: {
@@ -31,6 +34,10 @@ func TestFunctionsExecuteDBOperations(t *testing.T) {
 			log("ERROR: getting doc by id");
 			log(getRes.content);
 			return;
+		} else if (getRes.content.from != "val from unit test") {
+			log("ERROR: asserting data from request body");
+			log(getRes.content);
+			return;			
 		}
 
 		var updata = getRes.content;
@@ -52,6 +59,7 @@ func TestFunctionsExecuteDBOperations(t *testing.T) {
 		if (qres.content.results.length != 1) {
 			log("ERROR");
 			log("expected results to have 1 doc, got: " + qres.content.results.length);
+			log(qres);
 			return;
 		}
 
@@ -81,7 +89,10 @@ func TestFunctionsExecuteDBOperations(t *testing.T) {
 		t.Errorf("add: expected status 200 got %s", addResp.Status)
 	}
 
-	execResp := dbReq(t, funexec.exec, "POST", "/", data, true)
+	val := url.Values{}
+	val.Add("from", "val from unit test")
+
+	execResp := dbReq(t, funexec.exec, "POST", "/fn/exec/unittest", val, false, true)
 	if execResp.StatusCode != http.StatusOK {
 		b, err := io.ReadAll(execResp.Body)
 		if err != nil {
@@ -92,4 +103,32 @@ func TestFunctionsExecuteDBOperations(t *testing.T) {
 		t.Log(string(b))
 		t.Errorf("expected status 200 got %s", execResp.Status)
 	}
+
+	infoResp := dbReq(t, funexec.info, "GET", "/fn/info/unittest", nil, true)
+
+	var checkFn internal.ExecData
+	if err := parseBody(infoResp.Body, &checkFn); err != nil {
+		t.Fatal(err)
+	}
+	defer infoResp.Body.Close()
+
+	var errorLines []string
+	foundError := false
+	for _, h := range checkFn.History {
+		for _, line := range h.Output {
+			if strings.Index(line, "ERROR") > -1 {
+				errorLines = h.Output
+				foundError = true
+				break
+			}
+		}
+
+		if foundError {
+			break
+		}
+	}
+
+	if foundError {
+		t.Errorf("found error in function exec log: %v", errorLines)
+	}
 }

server.go

@@ -192,7 +192,7 @@ func Start(dbHost, port string) {
 	http.Handle("/fn/delete/", middleware.Chain(http.HandlerFunc(f.del), stdRoot...))
 	http.Handle("/fn/del/", middleware.Chain(http.HandlerFunc(f.del), stdRoot...))
 	http.Handle("/fn/info/", middleware.Chain(http.HandlerFunc(f.info), stdRoot...))
-	http.Handle("/fn/exec", middleware.Chain(http.HandlerFunc(f.exec), stdAuth...))
+	http.Handle("/fn/exec/", middleware.Chain(http.HandlerFunc(f.exec), stdAuth...))
 	http.Handle("/fn", middleware.Chain(http.HandlerFunc(f.list), stdRoot...))
 
 	// ui routes