refactored all services in the backend package

Author: dstpierre

account.go

@@ -6,6 +6,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/staticbackendhq/core/backend"
 	"github.com/staticbackendhq/core/config"
 	emailFuncs "github.com/staticbackendhq/core/email"
 	"github.com/staticbackendhq/core/internal"
@@ -55,7 +56,7 @@ func (a *accounts) create(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	exists, err := datastore.EmailExists(email)
+	exists, err := backend.DB.EmailExists(email)
 	if err != nil {
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
@@ -111,7 +112,7 @@ func (a *accounts) create(w http.ResponseWriter, r *http.Request) {
 		Created:        time.Now(),
 	}
 
-	cust, err = datastore.CreateCustomer(cust)
+	cust, err = backend.DB.CreateCustomer(cust)
 	if err != nil {
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
@@ -124,7 +125,7 @@ func (a *accounts) create(w http.ResponseWriter, r *http.Request) {
 		dbName = "dev-memory-pk"
 	}
 	for {
-		exists, err = datastore.DatabaseExists(dbName)
+		exists, err = backend.DB.DatabaseExists(dbName)
 		if err != nil {
 			http.Error(w, err.Error(), http.StatusInternalServerError)
 			return
@@ -144,7 +145,7 @@ func (a *accounts) create(w http.ResponseWriter, r *http.Request) {
 		AllowedDomain: []string{"localhost"},
 	}
 
-	bc, err := datastore.CreateBase(base)
+	bc, err := backend.DB.CreateBase(base)
 	if err != nil {
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
@@ -177,7 +178,7 @@ func (a *accounts) create(w http.ResponseWriter, r *http.Request) {
 		signUpURL = s.URL
 	}
 
-	token, err := datastore.FindTokenByEmail(dbName, email)
+	token, err := backend.DB.FindTokenByEmail(dbName, email)
 	if err != nil {
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
@@ -240,9 +241,9 @@ Refer to the documentation at https://staticbackend.com/docs\n
 		// cache the root token so caller can always use
 		// "safe-to-use-in-dev-root-token" as root token instead of
 		// the changing one across CLI start/stop
-		volatile.Set("dev-root-token", rootToken)
+		backend.Cache.Set("dev-root-token", rootToken)
 	} else {
-		err = emailer.Send(ed)
+		err = backend.Emailer.Send(ed)
 		if err != nil {
 			a.log.Error().Err(err).Msg("error sending email")
 			http.Error(w, err.Error(), http.StatusInternalServerError)
@@ -292,7 +293,7 @@ func (a *accounts) portal(w http.ResponseWriter, r *http.Request) {
 }
 
 func getStripePortalURL(customerID string) (string, error) {
-	cus, err := datastore.FindAccount(customerID)
+	cus, err := backend.DB.FindAccount(customerID)
 	if err != nil {
 		return "", err
 	}

backend/backend.go

@@ -27,13 +27,12 @@ import (
 )
 
 type Backend struct {
-	DB   database.Persister
 	User func(baseID string) User
 	File func(model.Auth, model.BaseConfig) FileStore
 }
 
 var (
-	datastore database.Persister
+	DB database.Persister
 
 	// Emailer sends email
 	Emailer email.Mailer
@@ -63,20 +62,20 @@ func New(cfg config.AppConfig) Backend {
 
 	persister := config.Current.DataStore
 	if strings.EqualFold(cfg.DatabaseURL, "mem") {
-		datastore = memory.New(Cache.PublishDocument)
+		DB = memory.New(Cache.PublishDocument)
 	} else if strings.EqualFold(persister, "mongo") {
 		cl, err := openMongoDatabase(cfg.DatabaseURL)
 		if err != nil {
 			Log.Fatal().Err(err).Msg("failed to create connection with mongodb")
 		}
-		datastore = mongo.New(cl, Cache.PublishDocument, Log)
+		DB = mongo.New(cl, Cache.PublishDocument, Log)
 	} else {
 		cl, err := openPGDatabase(cfg.DatabaseURL)
 		if err != nil {
 			Log.Fatal().Err(err).Msg("failed to create connection with postgres")
 		}
 
-		datastore = postgresql.New(cl, Cache.PublishDocument, "./sql/", Log)
+		DB = postgresql.New(cl, Cache.PublishDocument, "./sql/", Log)
 	}
 
 	mp := cfg.MailProvider
@@ -121,7 +120,7 @@ func New(cfg config.AppConfig) Backend {
 
 		exe.Auth = auth
 		exe.BaseName = conf.Name
-		exe.DataStore = datastore
+		exe.DataStore = DB
 		exe.Volatile = Cache
 
 		return exe, nil
@@ -131,7 +130,6 @@ func New(cfg config.AppConfig) Backend {
 	go sub.Start()
 
 	return Backend{
-		DB:   datastore,
 		User: newUser,
 		File: newFile,
 	}
@@ -169,11 +167,11 @@ func openPGDatabase(dbHost string) (*sql.DB, error) {
 
 // NewID generates a new unique identifier
 func NewID() string {
-	return datastore.NewID()
+	return DB.NewID()
 }
 
 func findAuth(token string) model.Auth {
-	auth, err := middleware.ValidateAuthKey(datastore, Cache, context.Background(), token)
+	auth, err := middleware.ValidateAuthKey(DB, Cache, context.Background(), token)
 	if err != nil {
 		return model.Auth{}
 	}
@@ -183,7 +181,7 @@ func findAuth(token string) model.Auth {
 func findBase(baseID string) model.BaseConfig {
 	var conf model.BaseConfig
 	if err := Cache.GetTyped(baseID, &conf); err != nil {
-		db, err := datastore.FindDatabase(baseID)
+		db, err := DB.FindDatabase(baseID)
 		if err != nil {
 			return conf
 		}

backend/backend_test.go

@@ -58,7 +58,7 @@ func createTenantAndDatabase() error {
 		Created:  time.Now(),
 	}
 
-	cus, err := bkn.DB.CreateCustomer(cus)
+	cus, err := backend.DB.CreateCustomer(cus)
 	if err != nil {
 		return err
 	}
@@ -69,7 +69,7 @@ func createTenantAndDatabase() error {
 		IsActive:   true,
 	}
 
-	base, err = bkn.DB.CreateBase(base)
+	base, err = backend.DB.CreateBase(base)
 	if err != nil {
 		return err
 	}

backend/database.go

@@ -28,7 +28,7 @@ func (d Database[T]) Create(col string, data T) (inserted T, err error) {
 		return
 	}
 
-	doc, err = datastore.CreateDocument(d.auth, d.conf.Name, col, doc)
+	doc, err = DB.CreateDocument(d.auth, d.conf.Name, col, doc)
 	if err != nil {
 		return
 	}
@@ -48,7 +48,7 @@ func (d Database[T]) BulkCreate(col string, entities []T) error {
 
 		docs = append(docs, x)
 	}
-	return datastore.BulkCreateDocument(d.auth, d.conf.Name, col, docs)
+	return DB.BulkCreateDocument(d.auth, d.conf.Name, col, docs)
 }
 
 // PageResult wraps a slice of type T with paging information
@@ -61,7 +61,7 @@ type PagedResult[T any] struct {
 
 // List returns records from a collection/repository using paging/sorting params
 func (d Database[T]) List(col string, lp model.ListParams) (res PagedResult[T], err error) {
-	r, err := datastore.ListDocuments(d.auth, d.conf.Name, col, lp)
+	r, err := DB.ListDocuments(d.auth, d.conf.Name, col, lp)
 	if err != nil {
 		return
 	}
@@ -84,12 +84,12 @@ func (d Database[T]) List(col string, lp model.ListParams) (res PagedResult[T],
 
 // Query returns records that match with the provided filters.
 func (d Database[T]) Query(col string, filters [][]any, lp model.ListParams) (res PagedResult[T], err error) {
-	clauses, err := datastore.ParseQuery(filters)
+	clauses, err := DB.ParseQuery(filters)
 	if err != nil {
 		return
 	}
 
-	r, err := datastore.QueryDocuments(d.auth, d.conf.Name, col, clauses, lp)
+	r, err := DB.QueryDocuments(d.auth, d.conf.Name, col, clauses, lp)
 	if err != nil {
 		return
 	}
@@ -112,7 +112,7 @@ func (d Database[T]) Query(col string, filters [][]any, lp model.ListParams) (re
 
 // GetByID returns a specific record from a collection/repository
 func (d Database[T]) GetByID(col, id string) (entity T, err error) {
-	doc, err := datastore.GetDocumentByID(d.auth, d.conf.Name, col, id)
+	doc, err := DB.GetDocumentByID(d.auth, d.conf.Name, col, id)
 	if err != nil {
 		return
 	}
@@ -128,7 +128,7 @@ func (d Database[T]) Update(col, id string, v any) (entity T, err error) {
 		return
 	}
 
-	x, err := datastore.UpdateDocument(d.auth, d.conf.Name, col, id, doc)
+	x, err := DB.UpdateDocument(d.auth, d.conf.Name, col, id, doc)
 	if err != nil {
 		return
 	}
@@ -139,7 +139,7 @@ func (d Database[T]) Update(col, id string, v any) (entity T, err error) {
 
 // UpdateMany updates multiple records matching filters
 func (d Database[T]) UpdateMany(col string, filters [][]any, v any) (int64, error) {
-	clauses, err := datastore.ParseQuery(filters)
+	clauses, err := DB.ParseQuery(filters)
 	if err != nil {
 		return 0, err
 	}
@@ -148,17 +148,17 @@ func (d Database[T]) UpdateMany(col string, filters [][]any, v any) (int64, erro
 	if err != nil {
 		return 0, err
 	}
-	return datastore.UpdateDocuments(d.auth, d.conf.Name, col, clauses, doc)
+	return DB.UpdateDocuments(d.auth, d.conf.Name, col, clauses, doc)
 }
 
 // IncrementValue increments or decrements a specifc field from a collection/repository
 func (d Database[T]) IncrementValue(col, id, field string, n int) error {
-	return datastore.IncrementValue(d.auth, d.conf.Name, col, id, field, n)
+	return DB.IncrementValue(d.auth, d.conf.Name, col, id, field, n)
 }
 
 // Delete removes a record from a collection
 func (d Database[T]) Delete(col, id string) (int64, error) {
-	return datastore.DeleteDocument(d.auth, d.conf.Name, col, id)
+	return DB.DeleteDocument(d.auth, d.conf.Name, col, id)
 }
 
 func toDoc(v any) (doc map[string]any, err error) {

backend/file.go

@@ -56,7 +56,7 @@ func (f FileStore) Save(filename, name string, file io.ReadSeeker, size int64) (
 		Uploaded:  time.Now(),
 	}
 
-	newID, err := datastore.AddFile(f.conf.Name, sbFile)
+	newID, err := DB.AddFile(f.conf.Name, sbFile)
 	if err != nil {
 		return
 	}
@@ -68,7 +68,7 @@ func (f FileStore) Save(filename, name string, file io.ReadSeeker, size int64) (
 }
 
 func (f FileStore) Delete(fileID string) error {
-	file, err := datastore.GetFileByID(f.conf.Name, fileID)
+	file, err := DB.GetFileByID(f.conf.Name, fileID)
 	if err != nil {
 		return err
 	}
@@ -79,7 +79,7 @@ func (f FileStore) Delete(fileID string) error {
 		return err
 	}
 
-	if err := datastore.DeleteFile(f.conf.Name, file.ID); err != nil {
+	if err := DB.DeleteFile(f.conf.Name, file.ID); err != nil {
 		return err
 	}
 	return nil

backend/user.go

@@ -24,13 +24,13 @@ func newUser(baseID string) User {
 // CreateAccount creates a new account in this database
 func (u User) CreateAccount(email string) (string, error) {
 	email = strings.ToLower(email)
-	if exists, err := datastore.UserEmailExists(u.conf.Name, email); err != nil {
+	if exists, err := DB.UserEmailExists(u.conf.Name, email); err != nil {
 		return "", err
 	} else if exists {
 		return "", errors.New("email not available")
 	}
 
-	return datastore.CreateUserAccount(u.conf.Name, email)
+	return DB.CreateUserAccount(u.conf.Name, email)
 }
 
 // CreateUserToken creates a user token (login) for a specific account in a database
@@ -44,16 +44,16 @@ func (u User) CreateUserToken(accountID, email, password string, role int) (stri
 		AccountID: accountID,
 		Email:     email,
 		Password:  string(b),
-		Token:     datastore.NewID(),
+		Token:     DB.NewID(),
 		Role:      role,
 		Created:   time.Now(),
 	}
-	return datastore.CreateUserToken(u.conf.Name, tok)
+	return DB.CreateUserToken(u.conf.Name, tok)
 }
 
 // Authenticate tries to authenticate an email/password and return a session token
 func (u User) Authenticate(email, password string) (string, error) {
-	tok, err := datastore.FindTokenByEmail(u.conf.Name, email)
+	tok, err := DB.FindTokenByEmail(u.conf.Name, email)
 	if err != nil {
 		return "", err
 	}
@@ -91,7 +91,7 @@ func (u User) Authenticate(email, password string) (string, error) {
 
 // SetPasswordResetCode sets the password forget code for a user
 func (u User) SetPasswordResetCode(tokenID, code string) error {
-	return datastore.SetPasswordResetCode(u.conf.Name, tokenID, code)
+	return DB.SetPasswordResetCode(u.conf.Name, tokenID, code)
 }
 
 // ResetPassword resets the password of a matching email/code for a user
@@ -101,12 +101,12 @@ func (u User) ResetPassword(email, code, password string) error {
 		return err
 	}
 
-	return datastore.ResetPassword(u.conf.Name, email, code, string(b))
+	return DB.ResetPassword(u.conf.Name, email, code, string(b))
 }
 
 // SetUserRole changes the role of a user
 func (u User) SetUserRole(email string, role int) error {
-	return datastore.SetUserRole(u.conf.Name, email, role)
+	return DB.SetUserRole(u.conf.Name, email, role)
 }
 
 // UserSetPassword password changes initiated by the user
@@ -116,7 +116,7 @@ func (u User) UserSetPassword(tokenID, password string) error {
 		return err
 	}
 
-	return datastore.UserSetPassword(u.conf.Name, tokenID, string(b))
+	return DB.UserSetPassword(u.conf.Name, tokenID, string(b))
 }
 
 func GetJWT(token string) ([]byte, error) {