autocreate seems to work

.github/workflows/deploy_dev.yaml

@@ -2,12 +2,11 @@ name: deploy (dev)
 
 on:
   push:
-    branches: main
+    branches: [ main ]
 
 jobs:
   build:
     runs-on: ubuntu-latest
-    environment: approval
     steps:
       - name: checkout code
         uses: actions/checkout@v4

server/entry.go

@@ -2,19 +2,18 @@ package server
 
 import (
 	"log/slog"
+	"strings"
 )
 
 type EntryItem struct{}
 
 // fetches path for table name, then removes key from JSON.
 func (EntryItem) Del(request Request) Response {
 	slog.Debug("delete:", "key", request.Key, "table", request.Table)
-	// read file from cache/fs
 	data, err := read(request.Table, request.Mode)
 	if err != nil {
 		return Response{Data: nil, Error: err}
 	}
-	// update contents, and write to cache/fs
 	if err = pop(data, request.Key); err != nil {
 		return Response{Data: nil, Error: err}
 	}
@@ -30,11 +29,20 @@ func (EntryItem) Add(request Request) Response {
 	// if it doesn't exist, create it. still errors? return error.
 	data, err := read(request.Table, request.Mode)
 	if err != nil {
-		return Response{Data: nil, Error: err}
+		if strings.Contains(err.Error(), "not found") {
+			slog.Warn("autocreate table", "name", request.Table)
+			if len(session.cache.tables) > 0 {
+				session.cache.tables = append(session.cache.tables, request.Table)
+			}
+			err = write(request.Table, nil)
+			data = make(map[string]any)
+		}
+		if err != nil {
+			return Response{Data: nil, Error: err}
+		}
 	}
 	// update json, and update cache
-	err = insert(data, request.Key, request.Value, request.Mode)
-	if err != nil {
+	if err = insert(data, request.Key, request.Value, request.Mode); err != nil {
 		return Response{Data: nil, Error: err}
 	}
 	if err = write(request.Table, data); err != nil {

server/table.go

@@ -25,16 +25,16 @@ func (TableItem) Del(request Request) Response {
 // parses payload of table, and creates it if it doesn't exist.
 func (TableItem) Add(request Request) Response {
 	slog.Debug("create:", "table", request.Table)
-	// check if table exists
-	if _, err := read(request.Table, request.Mode); err == nil {
+	// check if table already exists
+	_, err := read(request.Table, request.Mode)
+	if err == nil {
 		return Response{Data: nil, Error: errors.New("table already exists")}
 	}
-	// create table and add to cache
 	if _, err := json.Marshal(request.Value); err != nil {
 		return Response{Data: nil, Error: errors.New("body not valid json")}
 	}
-	err := write(request.Table, request.Value)
-	if err == nil {
+	// create table
+	if err = write(request.Table, request.Value); err == nil {
 		session.cache.tables = append(session.cache.tables, request.Table)
 	}
 	return Response{Data: "added " + request.Table, Error: err}

server/utils.go

@@ -28,7 +28,7 @@ func ValidPort(s string) bool {
 // returns error code based on error message text, default 500.
 func getErrorCode(message string) int {
 	notFound := []string{"not found", "404"}
-	badRequest := []string{"invalid path", "invalid index", "incompatible"}
+	badRequest := []string{"invalid path", "invalid index", "incompatible", "table already exists"}
 	for _, indicator := range notFound {
 		if strings.Contains(message, indicator) {
 			return 404
@@ -97,6 +97,9 @@ func read(filename string, mode string) (any, error) {
 
 // write to cache, and potentially to filesystem (depending on commit strategy)
 func write(table string, data any) error {
+	if data == nil {
+		data = make(map[string]any)
+	}
 	session.cache.data[table] = data
 	if session.config.commit == session.commits {
 		slog.Debug("writing to filesystem")

test/smoke_test.go

@@ -123,12 +123,24 @@ func TestBadIncrement(t *testing.T) {
 	}
 }
 
+func TestAutoCreateTable(t *testing.T) {
+	server.ClearCache()
+	file := testFile()
+	request("PUT", "/api/test/something", `2`)
+	expected := map[string]any{"something": 2}
+	result := readJson(file)
+	if !jsonEqual(result, expected) {
+		t.Errorf("Expected %s, got %s", expected, result)
+	}
+}
+
 func TestNotFound(t *testing.T) {
 	server.ClearCache()
+	testFile()
 	request("PUT", "/api/test", `{"foo":"test"}`)
 	status := request("GET", "/api/test/something", `2`)
 	if status != 404 {
-		t.Errorf("Not found dit not get the correct error code.")
+		t.Errorf("Not found did not get the correct error code.")
 	}
 }