Fix cyclic imports

internal/app/app.go

@@ -17,7 +17,6 @@ import (
 
 	"github.com/Masterminds/sprig/v3"
 	"github.com/claceio/clace/internal/app/dev"
-	"github.com/claceio/clace/internal/app/store"
 	"github.com/claceio/clace/internal/app/util"
 	"github.com/claceio/clace/internal/utils"
 	"github.com/fsnotify/fsnotify"
@@ -41,7 +40,7 @@ type App struct {
 	reloadStartTime time.Time
 	appDev          *dev.AppDev
 	systemConfig    *utils.SystemConfig
-	storeInfo       *store.StoreInfo
+	storeInfo       *utils.StoreInfo
 	plugins         *AppPlugins
 
 	globals       starlark.StringDict
@@ -260,7 +259,7 @@ func (a *App) loadSchemaInfo(sourceFS *util.SourceFs) error {
 		return nil // Ignore absence of schema file
 	}
 
-	a.storeInfo, err = store.ReadStoreInfo(util.SCHEMA_FILE_NAME, schemaInfoData)
+	a.storeInfo, err = util.ReadStoreInfo(util.SCHEMA_FILE_NAME, schemaInfoData)
 	if err != nil {
 		return fmt.Errorf("error reading schema info: %w", err)
 	}

internal/app/plugin.go

@@ -20,8 +20,7 @@ import (
 )
 
 type PluginContext struct {
-	Connection *any
-	Config     utils.PluginSettings
+	Config utils.PluginSettings
 }
 
 type NewPluginFunc func(pluginContext *PluginContext) (any, error)

internal/app/setup.go

@@ -12,7 +12,6 @@ import (
 	"path"
 
 	"github.com/claceio/clace/internal/app/dev"
-	"github.com/claceio/clace/internal/app/store"
 	"github.com/claceio/clace/internal/app/util"
 	"github.com/claceio/clace/internal/utils"
 	"github.com/go-chi/chi"
@@ -139,7 +138,7 @@ func (a *App) addSchemaTypes(builtin starlark.StringDict) (starlark.StringDict,
 
 	typeDict := starlark.StringDict{}
 	for _, t := range a.storeInfo.Types {
-		tb := store.TypeBuilder{Name: t.Name, Fields: t.Fields}
+		tb := utils.TypeBuilder{Name: t.Name, Fields: t.Fields}
 		typeDict[t.Name] = starlark.NewBuiltin(t.Name, tb.CreateType)
 	}
 

internal/app/store/db_plugin.go

@@ -0,0 +1,31 @@
+// Copyright (c) ClaceIO, LLC
+// SPDX-License-Identifier: Apache-2.0
+
+package store
+
+import (
+	"net/http"
+
+	"github.com/claceio/clace/internal/app"
+	"go.starlark.net/starlark"
+)
+
+func init() {
+	h := &dbPlugin{}
+	pluginFuncs := []app.PluginFunc{
+		app.CreatePluginApi(h.Create, false),
+	}
+	app.RegisterPlugin("db", NewDBPlugin, pluginFuncs)
+}
+
+type dbPlugin struct {
+	client *http.Client
+}
+
+func NewDBPlugin(pluginContext *app.PluginContext) (any, error) {
+	return &dbPlugin{}, nil
+}
+
+func (h *dbPlugin) Create(thread *starlark.Thread, builtin *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
+	return nil, nil
+}

internal/app/store/sqlite_store.go

@@ -27,6 +27,11 @@ func NewSqliteStore(logger *utils.Logger, config *utils.ServerConfig, db *sql.DB
 	}, nil
 }
 
+func validateCollectionName(name string) error {
+	// TODO: validate collection name
+	return nil
+}
+
 func (s *SqliteStore) genTableName(collection string) (string, error) {
 	err := validateCollectionName(collection)
 	if err != nil {

internal/app/store/loader.go → internal/app/util/loader.go

@@ -1,12 +1,11 @@
 // Copyright (c) ClaceIO, LLC
 // SPDX-License-Identifier: Apache-2.0
 
-package store
+package util
 
 import (
 	"fmt"
 
-	"github.com/claceio/clace/internal/app/util"
 	"github.com/claceio/clace/internal/utils"
 	"go.starlark.net/starlark"
 	"go.starlark.net/starlarkstruct"
@@ -18,7 +17,7 @@ const (
 	INDEX = "index"
 )
 
-func LoadStoreInfo(fileName string, data []byte) (*StoreInfo, error) {
+func LoadStoreInfo(fileName string, data []byte) (*utils.StoreInfo, error) {
 	definedTypes := make(map[string]starlark.Value)
 
 	typeBuiltin := func(_ *starlark.Thread, _ *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
@@ -48,14 +47,14 @@ func LoadStoreInfo(fileName string, data []byte) (*StoreInfo, error) {
 	}
 
 	builtins := starlark.StringDict{
-		TYPE:            starlark.NewBuiltin(TYPE, typeBuiltin),
-		FIELD:           starlark.NewBuiltin(FIELD, createFieldBuiltin),
-		INDEX:           starlark.NewBuiltin(INDEX, createIndexBuiltin),
-		string(INT):     starlark.String(INT),
-		string(STRING):  starlark.String(STRING),
-		string(BOOLEAN): starlark.String(BOOLEAN),
-		string(DICT):    starlark.String(DICT),
-		string(LIST):    starlark.String(LIST),
+		TYPE:                  starlark.NewBuiltin(TYPE, typeBuiltin),
+		FIELD:                 starlark.NewBuiltin(FIELD, createFieldBuiltin),
+		INDEX:                 starlark.NewBuiltin(INDEX, createIndexBuiltin),
+		string(utils.INT):     starlark.String(utils.INT),
+		string(utils.STRING):  starlark.String(utils.STRING),
+		string(utils.BOOLEAN): starlark.String(utils.BOOLEAN),
+		string(utils.DICT):    starlark.String(utils.DICT),
+		string(utils.LIST):    starlark.String(utils.LIST),
 	}
 
 	thread := &starlark.Thread{
@@ -74,15 +73,15 @@ func LoadStoreInfo(fileName string, data []byte) (*StoreInfo, error) {
 	return createStoreInfo(definedTypes)
 }
 
-func createStoreInfo(definedTypes map[string]starlark.Value) (*StoreInfo, error) {
-	types := make([]StoreType, 0, len(definedTypes))
+func createStoreInfo(definedTypes map[string]starlark.Value) (*utils.StoreInfo, error) {
+	types := make([]utils.StoreType, 0, len(definedTypes))
 	for _, t := range definedTypes {
 		typeStruct, ok := t.(*starlarkstruct.Struct)
 		if !ok {
 			return nil, fmt.Errorf("invalid type definition: %s", t.String())
 		}
 
-		typeName, err := util.GetStringAttr(typeStruct, "name")
+		typeName, err := GetStringAttr(typeStruct, "name")
 		if err != nil {
 			return nil, err
 		}
@@ -96,19 +95,19 @@ func createStoreInfo(definedTypes map[string]starlark.Value) (*StoreInfo, error)
 			return nil, fmt.Errorf("error getting indexes in type %s: %s", typeName, err)
 		}
 
-		types = append(types, StoreType{
+		types = append(types, utils.StoreType{
 			Name:    string(typeName),
 			Fields:  fields,
 			Indexes: indexes,
 		})
 	}
 
-	return &StoreInfo{
+	return &utils.StoreInfo{
 		Types: types,
 	}, nil
 }
 
-func getFields(typeName string, typeStruct *starlarkstruct.Struct, key string) ([]StoreField, error) {
+func getFields(typeName string, typeStruct *starlarkstruct.Struct, key string) ([]utils.StoreField, error) {
 	fieldsAttr, err := typeStruct.Attr(key)
 	if err != nil {
 		return nil, fmt.Errorf("error getting %s attribute in type %s: %s", key, typeName, err)
@@ -123,26 +122,26 @@ func getFields(typeName string, typeStruct *starlarkstruct.Struct, key string) (
 	iter := fieldsList.Iterate()
 	var val starlark.Value
 
-	ret := make([]StoreField, 0, fields.Len())
+	ret := make([]utils.StoreField, 0, fields.Len())
 	for iter.Next(&val) {
 		fieldStruct, ok := val.(*starlarkstruct.Struct)
 		if !ok {
 			return nil, fmt.Errorf("invalid field definition: %s", val.String())
 		}
 
-		fieldName, err := util.GetStringAttr(fieldStruct, "name")
+		fieldName, err := GetStringAttr(fieldStruct, "name")
 		if err != nil {
 			return nil, err
 		}
 
-		fieldType, err := util.GetStringAttr(fieldStruct, "type")
+		fieldType, err := GetStringAttr(fieldStruct, "type")
 		if err != nil {
 			return nil, err
 		}
 
-		field := StoreField{
+		field := utils.StoreField{
 			Name: string(fieldName),
-			Type: TypeName(fieldType),
+			Type: utils.TypeName(fieldType),
 		}
 
 		defaultValue, err := fieldStruct.Attr("default")
@@ -160,14 +159,14 @@ func getFields(typeName string, typeStruct *starlarkstruct.Struct, key string) (
 	return ret, nil
 }
 
-func getIndexes(typeName string, typeStruct *starlarkstruct.Struct, key string) ([]Index, error) {
+func getIndexes(typeName string, typeStruct *starlarkstruct.Struct, key string) ([]utils.Index, error) {
 	indexesAttr, err := typeStruct.Attr(key)
 	if err != nil {
-		return []Index{}, nil // no indexes
+		return []utils.Index{}, nil // no indexes
 	}
 
 	if indexesAttr == nil || indexesAttr == starlark.None {
-		return []Index{}, nil
+		return []utils.Index{}, nil
 	}
 
 	indexes, ok := indexesAttr.(*starlark.List)
@@ -179,24 +178,24 @@ func getIndexes(typeName string, typeStruct *starlarkstruct.Struct, key string)
 	iter := indexesList.Iterate()
 	var val starlark.Value
 
-	ret := make([]Index, 0, indexes.Len())
+	ret := make([]utils.Index, 0, indexes.Len())
 	for iter.Next(&val) {
 		indexStruct, ok := val.(*starlarkstruct.Struct)
 		if !ok {
 			return nil, fmt.Errorf("invalid index definition: %s", val.String())
 		}
 
-		fields, err := util.GetListStringAttr(indexStruct, "fields", false)
+		fields, err := GetListStringAttr(indexStruct, "fields", false)
 		if err != nil {
 			return nil, err
 		}
 
-		unique, err := util.GetBoolAttr(indexStruct, "unique")
+		unique, err := GetBoolAttr(indexStruct, "unique")
 		if err != nil {
 			return nil, err
 		}
 
-		ret = append(ret, Index{
+		ret = append(ret, utils.Index{
 			Fields: fields,
 			Unique: unique,
 		})

internal/app/util/store_info.go

@@ -0,0 +1,33 @@
+// Copyright (c) ClaceIO, LLC
+// SPDX-License-Identifier: Apache-2.0
+
+package util
+
+import "github.com/claceio/clace/internal/utils"
+
+func ReadStoreInfo(fileName string, inp []byte) (*utils.StoreInfo, error) {
+	storeInfo, err := LoadStoreInfo(fileName, inp)
+	if err != nil {
+		return nil, err
+	}
+
+	if err := validateStoreInfo(storeInfo); err != nil {
+		return nil, err
+	}
+
+	return storeInfo, nil
+}
+
+func validateStoreInfo(storeInfo *utils.StoreInfo) error {
+	if err := validateTypes(storeInfo.Types); err != nil {
+		return err
+	}
+
+	// TODO: validate collections
+	return nil
+}
+
+func validateTypes(types []utils.StoreType) error {
+	// TODO: validate types
+	return nil
+}