Merge pull request #68 from VladPetriv/feat/add-count-function

feat(stores/Count): implement count function

Author: dstpierre

database/memory/count.go

@@ -0,0 +1,18 @@
+package memory
+
+import (
+	"github.com/staticbackendhq/core/model"
+)
+
+func (m *Memory) Count(auth model.Auth, dbName, col string, filter map[string]interface{}) (int64, error) {
+	list, err := all[map[string]any](m, dbName, col)
+	if err != nil {
+		return -1, err
+	}
+
+	list = secureRead(auth, col, list)
+
+	filtered := filterByClauses(list, filter)
+
+	return int64(len(filtered)), nil
+}

database/memory/count_test.go

@@ -0,0 +1,55 @@
+package memory
+
+import (
+	"testing"
+)
+
+func TestCount(t *testing.T) {
+	task1 := newTask("task_with_filter", false)
+	_, err := datastore.CreateDocument(adminAuth, confDBName, colName, task1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	task2 := newTask("task_with_filter", false)
+	_, err = datastore.CreateDocument(adminAuth, confDBName, colName, task2)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var clauses [][]interface{}
+
+	clauses = append(clauses, []interface{}{"title", "=", "task_with_filter"})
+
+	filters, err := datastore.ParseQuery(clauses)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	count, err := datastore.Count(adminAuth, confDBName, colName, filters)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if count != 2 {
+		t.Fatalf("expected 2 got %v", count)
+	}
+}
+
+func TestCountWIthNoFilters(t *testing.T) {
+	task1 := newTask("tasknof", false)
+	_, err := datastore.CreateDocument(adminAuth, confDBName, colName, task1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	count, err := datastore.Count(adminAuth, confDBName, colName, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Here we expect this count because after running all tests total count of documents will be 16 + 3
+	if count != 19 {
+		t.Fatalf("expected 19 got %v", count)
+	}
+}

database/mongo/count.go

@@ -0,0 +1,23 @@
+package mongo
+
+import (
+	"github.com/staticbackendhq/core/model"
+)
+
+func (mg *Mongo) Count(auth model.Auth, dbName, col string, filter map[string]interface{}) (count int64, err error) {
+	db := mg.Client.Database(dbName)
+
+	acctID, userID, err := parseObjectID(auth)
+	if err != nil {
+		return
+	}
+
+	secureRead(acctID, userID, auth.Role, col, filter)
+
+	count, err = db.Collection(model.CleanCollectionName(col)).CountDocuments(mg.Ctx, filter)
+	if err != nil {
+		return -1, err
+	}
+
+	return count, nil
+}

database/mongo/count_test.go

@@ -0,0 +1,53 @@
+package mongo
+
+import "testing"
+
+func TestCount(t *testing.T) {
+	task1 := newTask("task_with_filter", false)
+	_, err := datastore.CreateDocument(adminAuth, confDBName, colName, task1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	task2 := newTask("task_with_filter", false)
+	_, err = datastore.CreateDocument(adminAuth, confDBName, colName, task2)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var clauses [][]interface{}
+
+	clauses = append(clauses, []interface{}{"title", "=", "task_with_filter"})
+
+	filters, err := datastore.ParseQuery(clauses)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	count, err := datastore.Count(adminAuth, confDBName, colName, filters)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if count != 2 {
+		t.Fatalf("expected 2 got %v", count)
+	}
+}
+
+func TestCountWithNoFilters(t *testing.T) {
+	task1 := newTask("should be in list", false)
+	_, err := datastore.CreateDocument(adminAuth, confDBName, colName, task1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	count, err := datastore.Count(adminAuth, confDBName, colName, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Here we expect this count because after running all tests total count of documents will be 16 + 3
+	if count != 19 {
+		t.Fatalf("expected 19 got %v", count)
+	}
+}

database/persister.go

@@ -142,4 +142,6 @@ type Persister interface {
 	DeleteFile(dbName, fileID string) error
 	// ListAllFiles lists all file
 	ListAllFiles(dbName, accountID string) ([]model.File, error)
+	// Count returns the numbers of entries in a collection based on optional filters
+	Count(auth model.Auth, dbName, col string, filters map[string]interface{}) (int64, error)
 }

database/postgresql/count.go

@@ -0,0 +1,25 @@
+package postgresql
+
+import (
+	"fmt"
+
+	"github.com/staticbackendhq/core/model"
+)
+
+func (pg *PostgreSQL) Count(auth model.Auth, dbName, col string, filters map[string]interface{}) (count int64, err error) {
+	where := secureRead(auth, col)
+	where = applyFilter(where, filters)
+
+	query := fmt.Sprintf(`
+    SELECT COUNT(*)
+    FROM %s.%s
+    %s;
+    `, dbName, model.CleanCollectionName(col), where)
+
+	err = pg.DB.QueryRow(query, auth.AccountID, auth.UserID).Scan(&count)
+	if err != nil {
+		return -1, err
+	}
+
+	return count, nil
+}

database/postgresql/count_test.go

@@ -0,0 +1,54 @@
+package postgresql
+
+import (
+	"testing"
+)
+
+func TestCount(t *testing.T) {
+	task1 := newTask("task_with_filter", false)
+	_, err := datastore.CreateDocument(adminAuth, confDBName, colName, task1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	task2 := newTask("task_with_filter", false)
+	_, err = datastore.CreateDocument(adminAuth, confDBName, colName, task2)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var clauses [][]interface{}
+
+	clauses = append(clauses, []interface{}{"title", "=", "task_with_filter"})
+
+	filters, err := datastore.ParseQuery(clauses)
+	if err != nil {
+		t.Fatal(err)
+	}
+	count, err := datastore.Count(adminAuth, confDBName, colName, filters)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if count != 2 {
+		t.Fatalf("expected 2 got %v", count)
+	}
+}
+
+func TestCountWithNoFilter(t *testing.T) {
+	task1 := newTask("task1", false)
+	_, err := datastore.CreateDocument(adminAuth, confDBName, colName, task1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	count, err := datastore.Count(adminAuth, confDBName, colName, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Here we expect this count because after running all tests total count of documents will be 16 + 3
+	if count != 19 {
+		t.Fatalf("expected 19 got %v", count)
+	}
+}

db.go

@@ -136,6 +136,40 @@ func (database *Database) list(w http.ResponseWriter, r *http.Request) {
 	respond(w, http.StatusOK, result)
 }
 
+func (database *Database) count(w http.ResponseWriter, r *http.Request) {
+	var clauses [][]interface{}
+
+	if err := json.NewDecoder(r.Body).Decode(&clauses); err != nil {
+		// Here we don't return an error because filters are optional
+		database.log.Error().Err(err).Msg("error parsing body")
+	}
+
+	filter, err := backend.DB.ParseQuery(clauses)
+	if err != nil {
+		// Here we don't return an error because filters are optional
+		database.log.Error().Err(err).Msg("error parsing query")
+	}
+
+	conf, auth, err := middleware.Extract(r, true)
+	if err != nil {
+		database.log.Error().Err(err).Msg("error extracting conf and auth")
+		http.Error(w, err.Error(), http.StatusBadRequest)
+
+		return
+	}
+
+	col := getURLPart(r.URL.Path, 3)
+
+	result, err := backend.DB.Count(auth, conf.Name, col, filter)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+
+		return
+	}
+
+	respond(w, http.StatusOK, map[string]int64{"count": result})
+}
+
 func (database *Database) get(w http.ResponseWriter, r *http.Request) {
 	conf, auth, err := middleware.Extract(r, true)
 	if err != nil {

server.go

@@ -142,6 +142,7 @@ func Start(c config.AppConfig, log *logger.Logger) {
 
 	// database routes
 	http.Handle("/db/", middleware.Chain(http.HandlerFunc(database.dbreq), stdAuth...))
+	http.Handle("/db/count/", middleware.Chain(http.HandlerFunc(database.count), stdAuth...))
 	http.Handle("/query/", middleware.Chain(http.HandlerFunc(database.query), stdAuth...))
 	http.Handle("/inc/", middleware.Chain(http.HandlerFunc(database.increase), stdAuth...))
 	http.Handle("/sudoquery/", middleware.Chain(http.HandlerFunc(database.query), stdRoot...))