.github/workflows/compile-shared-libraries.yml

@@ -1,31 +0,0 @@
-name: Cross-Compile Shared Libraries
-
-on:
-  workflow_dispatch:
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v3
-
-      - name: Cross-Compile with xgo
-        uses: crazy-max/ghaction-xgo@e22d3c8b089adba750d5a74738b8e95d96f0c991 # v3.1.0
-        with:
-          xgo_version: latest
-          go_version: 1.24.0
-          dest: dist
-          pkg: sharedlibrary
-          prefix: cosmium
-          targets: linux/amd64,linux/arm64,windows/amd64,windows/arm64,darwin/amd64,darwin/arm64
-          v: true
-          buildmode: c-shared
-          buildvcs: true
-
-      - name: Upload artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: shared-libraries
-          path: dist/*

.github/workflows/release.yml

@@ -17,34 +17,18 @@ jobs:
         uses: actions/checkout@v4
         with:
           fetch-depth: 0
-
       - name: Set up Go
         uses: actions/setup-go@v5
         with:
-          go-version: 1.24.0
+          go-version: 1.21.6
-
-      - name: Cross-Compile with xgo
-        uses: crazy-max/ghaction-xgo@e22d3c8b089adba750d5a74738b8e95d96f0c991 # v3.1.0
-        with:
-          xgo_version: latest
-          go_version: 1.24.0
-          dest: sharedlibrary_dist
-          pkg: sharedlibrary
-          prefix: cosmium
-          targets: linux/amd64,linux/arm64,windows/amd64,windows/arm64,darwin/amd64,darwin/arm64
-          v: true
-          buildmode: c-shared
-          buildvcs: true
-
       - name: Docker Login
         uses: docker/login-action@v3
         with:
           registry: ghcr.io
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
-
       - name: Run GoReleaser
-        uses: goreleaser/goreleaser-action@5742e2a039330cbb23ebf35f046f814d4c6ff811 # v5
+        uses: goreleaser/goreleaser-action@v5
         with:
           distribution: goreleaser
           version: ${{ env.GITHUB_REF_NAME }}

.gitignore

@@ -1,5 +1,4 @@
 dist/
-sharedlibrary_dist/
 ignored/
 explorer_www/
 main

.goreleaser.yaml

@@ -1,6 +1,5 @@
 builds:
   - binary: cosmium
-    main: ./cmd/server
     goos:
       - darwin
       - linux
@@ -26,32 +25,13 @@ brews:
     commit_author:
       name: pikami
       email: git@pikami.org
-    skip_upload: auto
-
-archives:
-  - id: bundle
-    format: tar.gz
-    format_overrides:
-      - goos: windows
-        format: zip
-  - id: shared-libraries
-    meta: true
-    format: "tar.gz"
-    wrap_in_directory: true
-    name_template: "{{ .ProjectName }}_{{ .Version }}_shared-libraries"
-    files:
-    - LICENSE
-    - README.md
-    - sharedlibrary_dist/**
 
 dockers:
-  - id: docker-linux-amd64
+  - image_templates:
-    goos: linux
+    - "ghcr.io/pikami/{{ .ProjectName }}:{{ .Version }}"
-    goarch: amd64
+    - "ghcr.io/pikami/{{ .ProjectName }}:latest"
-    image_templates:
-    - "ghcr.io/pikami/{{ .ProjectName }}:{{ .Version }}-amd64"
     dockerfile: Dockerfile
-    use: buildx
+    use: docker
     build_flag_templates:
     - "--platform=linux/amd64"
     - "--pull"
@@ -62,85 +42,6 @@ dockers:
     - "--label=org.opencontainers.image.created={{.Date}}"
     - "--label=org.opencontainers.image.revision={{.FullCommit}}"
     - "--label=org.opencontainers.image.version={{.Version}}"
-  - id: docker-linux-arm64
-    goos: linux
-    goarch: arm64
-    image_templates:
-    - "ghcr.io/pikami/{{ .ProjectName }}:{{ .Version }}-arm64"
-    - "ghcr.io/pikami/{{ .ProjectName }}:{{ .Version }}-arm64v8"
-    dockerfile: Dockerfile
-    use: buildx
-    build_flag_templates:
-    - "--platform=linux/arm64"
-    - "--pull"
-    - "--label=org.opencontainers.image.title={{.ProjectName}}"
-    - "--label=org.opencontainers.image.description=Lightweight Cosmos DB emulator"
-    - "--label=org.opencontainers.image.url=https://github.com/pikami/cosmium"
-    - "--label=org.opencontainers.image.source=https://github.com/pikami/cosmium"
-    - "--label=org.opencontainers.image.created={{.Date}}"
-    - "--label=org.opencontainers.image.revision={{.FullCommit}}"
-    - "--label=org.opencontainers.image.version={{.Version}}"
-  - id: docker-explorer-linux-amd64
-    goos: linux
-    goarch: amd64
-    image_templates:
-    - "ghcr.io/pikami/{{ .ProjectName }}:{{ .Version }}-explorer-amd64"
-    dockerfile: Explorer.Dockerfile
-    use: buildx
-    build_flag_templates:
-    - "--platform=linux/amd64"
-    - "--pull"
-    - "--label=org.opencontainers.image.title={{.ProjectName}}"
-    - "--label=org.opencontainers.image.description=Lightweight Cosmos DB emulator"
-    - "--label=org.opencontainers.image.url=https://github.com/pikami/cosmium"
-    - "--label=org.opencontainers.image.source=https://github.com/pikami/cosmium"
-    - "--label=org.opencontainers.image.created={{.Date}}"
-    - "--label=org.opencontainers.image.revision={{.FullCommit}}"
-    - "--label=org.opencontainers.image.version={{.Version}}"
-  - id: docker-explorer-linux-arm64
-    goos: linux
-    goarch: arm64
-    image_templates:
-    - "ghcr.io/pikami/{{ .ProjectName }}:{{ .Version }}-explorer-arm64"
-    - "ghcr.io/pikami/{{ .ProjectName }}:{{ .Version }}-explorer-arm64v8"
-    dockerfile: Explorer.Dockerfile
-    use: buildx
-    build_flag_templates:
-    - "--platform=linux/arm64"
-    - "--pull"
-    - "--label=org.opencontainers.image.title={{.ProjectName}}"
-    - "--label=org.opencontainers.image.description=Lightweight Cosmos DB emulator"
-    - "--label=org.opencontainers.image.url=https://github.com/pikami/cosmium"
-    - "--label=org.opencontainers.image.source=https://github.com/pikami/cosmium"
-    - "--label=org.opencontainers.image.created={{.Date}}"
-    - "--label=org.opencontainers.image.revision={{.FullCommit}}"
-    - "--label=org.opencontainers.image.version={{.Version}}"
-
-docker_manifests:
-  - name_template: 'ghcr.io/pikami/{{ .ProjectName }}:latest'
-    skip_push: auto
-    image_templates:
-      - "ghcr.io/pikami/{{ .ProjectName }}:{{ .Version }}-amd64"
-      - "ghcr.io/pikami/{{ .ProjectName }}:{{ .Version }}-arm64"
-      - "ghcr.io/pikami/{{ .ProjectName }}:{{ .Version }}-arm64v8"
-  - name_template: 'ghcr.io/pikami/{{ .ProjectName }}:{{ .Version }}'
-    skip_push: auto
-    image_templates:
-      - "ghcr.io/pikami/{{ .ProjectName }}:{{ .Version }}-amd64"
-      - "ghcr.io/pikami/{{ .ProjectName }}:{{ .Version }}-arm64"
-      - "ghcr.io/pikami/{{ .ProjectName }}:{{ .Version }}-arm64v8"
-  - name_template: 'ghcr.io/pikami/{{ .ProjectName }}:explorer'
-    skip_push: auto
-    image_templates:
-      - "ghcr.io/pikami/{{ .ProjectName }}:{{ .Version }}-explorer-amd64"
-      - "ghcr.io/pikami/{{ .ProjectName }}:{{ .Version }}-explorer-arm64"
-      - "ghcr.io/pikami/{{ .ProjectName }}:{{ .Version }}-explorer-arm64v8"
-  - name_template: 'ghcr.io/pikami/{{ .ProjectName }}:{{ .Version }}-explorer'
-    skip_push: auto
-    image_templates:
-      - "ghcr.io/pikami/{{ .ProjectName }}:{{ .Version }}-explorer-amd64"
-      - "ghcr.io/pikami/{{ .ProjectName }}:{{ .Version }}-explorer-arm64"
-      - "ghcr.io/pikami/{{ .ProjectName }}:{{ .Version }}-explorer-arm64v8"
 
 checksum:
   name_template: 'checksums.txt'

Dockerfile

@@ -1,4 +1,4 @@
-FROM alpine:latest
+FROM scratch
 
 WORKDIR /app
 COPY cosmium /app/cosmium

Explorer.Dockerfile

@@ -1,9 +0,0 @@
-FROM ghcr.io/cosmiumdev/cosmos-explorer-base:latest AS explorer-base
-FROM alpine:latest
-
-COPY --from=explorer-base /cosmos-explorer /cosmos-explorer
-
-WORKDIR /app
-COPY cosmium /app/cosmium
-
-ENTRYPOINT ["/app/cosmium", "-ExplorerDir", "/cosmos-explorer"]

Makefile

@@ -4,69 +4,28 @@ GOTEST=$(GOCMD) test
 GOCLEAN=$(GOCMD) clean
 
 BINARY_NAME=cosmium
-SERVER_LOCATION=./cmd/server
-
-SHARED_LIB_LOCATION=./sharedlibrary
-SHARED_LIB_OPT=-buildmode=c-shared
-XGO_TARGETS=linux/amd64,linux/arm64,windows/amd64,windows/arm64,darwin/amd64,darwin/arm64
-GOVERSION=1.24.0
 
 DIST_DIR=dist
 
-SHARED_LIB_TEST_CC=gcc
-SHARED_LIB_TEST_CFLAGS=-Wall -ldl
-SHARED_LIB_TEST_TARGET=$(DIST_DIR)/sharedlibrary_test
-SHARED_LIB_TEST_DIR=./sharedlibrary/tests
-SHARED_LIB_TEST_SOURCES=$(wildcard $(SHARED_LIB_TEST_DIR)/*.c)
-
 all: test build-all
 
-build-all: build-darwin-arm64 build-darwin-amd64 build-linux-amd64 build-linux-arm64 build-windows-amd64 build-windows-arm64
+build-all: build-darwin-arm64 build-darwin-amd64 build-linux-amd64 build-windows-amd64
 
 build-darwin-arm64:
 	@echo "Building macOS ARM binary..."
-	@GOOS=darwin GOARCH=arm64 $(GOBUILD) -o $(DIST_DIR)/$(BINARY_NAME)-darwin-arm64 $(SERVER_LOCATION)
+	@GOOS=darwin GOARCH=arm64 $(GOBUILD) -o $(DIST_DIR)/$(BINARY_NAME)-darwin-arm64 .
 
 build-darwin-amd64:
 	@echo "Building macOS x64 binary..."
-	@GOOS=darwin GOARCH=amd64 $(GOBUILD) -o $(DIST_DIR)/$(BINARY_NAME)-darwin-amd64 $(SERVER_LOCATION)
+	@GOOS=darwin GOARCH=amd64 $(GOBUILD) -o $(DIST_DIR)/$(BINARY_NAME)-darwin-amd64 .
 
 build-linux-amd64:
 	@echo "Building Linux x64 binary..."
-	@GOOS=linux GOARCH=amd64 $(GOBUILD) -o $(DIST_DIR)/$(BINARY_NAME)-linux-amd64 $(SERVER_LOCATION)
+	@GOOS=linux GOARCH=amd64 $(GOBUILD) -o $(DIST_DIR)/$(BINARY_NAME)-linux-amd64 .
-
-build-linux-arm64:
-	@echo "Building Linux ARM binary..."
-	@GOOS=linux GOARCH=arm64 $(GOBUILD) -o $(DIST_DIR)/$(BINARY_NAME)-linux-arm64 $(SERVER_LOCATION)
 
 build-windows-amd64:
 	@echo "Building Windows x64 binary..."
-	@GOOS=windows GOARCH=amd64 $(GOBUILD) -o $(DIST_DIR)/$(BINARY_NAME)-windows-amd64.exe $(SERVER_LOCATION)
+	@GOOS=windows GOARCH=amd64 $(GOBUILD) -o $(DIST_DIR)/$(BINARY_NAME)-windows-amd64.exe .
-
-build-windows-arm64:
-	@echo "Building Windows ARM binary..."
-	@GOOS=windows GOARCH=arm64 $(GOBUILD) -o $(DIST_DIR)/$(BINARY_NAME)-windows-arm64.exe $(SERVER_LOCATION)
-
-build-sharedlib-linux-amd64:
-	@echo "Building shared library for Linux x64..."
-	@GOOS=linux GOARCH=amd64 $(GOBUILD) $(SHARED_LIB_OPT) -o $(DIST_DIR)/$(BINARY_NAME)-linux-amd64.so $(SHARED_LIB_LOCATION)
-
-build-sharedlib-darwin-arm64:
-	@echo "Building shared library for macOS ARM..."
-	@GOOS=darwin GOARCH=arm64 $(GOBUILD) $(SHARED_LIB_OPT) -o $(DIST_DIR)/$(BINARY_NAME)-darwin-arm64.so $(SHARED_LIB_LOCATION)
-
-build-sharedlib-tests: build-sharedlib-linux-amd64
-	@echo "Building shared library tests..."
-	@$(SHARED_LIB_TEST_CC) $(SHARED_LIB_TEST_CFLAGS) -o $(SHARED_LIB_TEST_TARGET) $(SHARED_LIB_TEST_SOURCES)
-
-run-sharedlib-tests: build-sharedlib-tests
-	@echo "Running shared library tests..."
-	@$(SHARED_LIB_TEST_TARGET) $(DIST_DIR)/$(BINARY_NAME)-linux-amd64.so
-
-xgo-compile-sharedlib:
-	@echo "Building shared libraries using xgo..."
-	@mkdir -p $(DIST_DIR)
-	@xgo -targets=$(XGO_TARGETS) -go $(GOVERSION) -buildmode=c-shared -dest=$(DIST_DIR) -out=$(BINARY_NAME) -pkg=$(SHARED_LIB_LOCATION) .
 
 generate-parser-nosql:
 	pigeon -o ./parsers/nosql/nosql.go ./parsers/nosql/nosql.peg

README.md

@@ -26,11 +26,9 @@ You can download the latest version of Cosmium from the [GitHub Releases page](h
 Cosmium is available for the following platforms:
 
 - **Linux**: cosmium-linux-amd64
-- **Linux on ARM**: cosmium-linux-arm64
 - **macOS**: cosmium-darwin-amd64
 - **macOS on Apple Silicon**: cosmium-darwin-arm64
 - **Windows**: cosmium-windows-amd64.exe
-- **Windows on ARM**: cosmium-windows-arm64.exe
 
 ### Running Cosmium
 
@@ -50,17 +48,10 @@ AccountEndpoint=https://localhost:8081/;AccountKey=C2y6yDjf5/R+ob0N8A7Cgv30VRDJI
 
 If you want to run Cosmos DB Explorer alongside Cosmium, you'll need to build it yourself and point the `-ExplorerDir` argument to the dist directory. Please refer to the [Cosmos DB Explorer repository](https://github.com/Azure/cosmos-explorer) for instructions on building the application.
 
-There's also a prebuilt docker image that includes the explorer: `ghcr.io/pikami/cosmium:explorer`
-
 Once running, the explorer can be reached by navigating following URL: `https://127.0.0.1:8081/_explorer/` (might be different depending on your configuration).
 
 ### Running with docker (optional)
 
-There are two docker tags available:
-
-- ghcr.io/pikami/cosmium:latest - Cosmium core service
-- ghcr.io/pikami/cosmium:explorer - Cosmium with database explorer available on `https://127.0.0.1:8081/_explorer/`
-
 If you wan to run the application using docker, configure it using environment variables see example:
 
 ```sh
@@ -68,7 +59,7 @@ docker run --rm \
   -e COSMIUM_PERSIST=/save.json \
   -v ./save.json:/save.json \
   -p 8081:8081 \
-  ghcr.io/pikami/cosmium # or `ghcr.io/pikami/cosmium:explorer`
+  ghcr.io/pikami/cosmium
 ```
 
 ### SSL Certificate
@@ -85,8 +76,7 @@ To disable SSL and run Cosmium on HTTP instead, you can use the `-DisableTls` fl
 - **-InitialData**: Path to JSON containing initial state
 - **-Persist**: Saves data to the given path on application exit (When `-InitialData` argument is not supplied, it will try to load data from path supplied in `-Persist`)
 - **-Port**: Listen port (default 8081)
-- **-LogLevel**: Sets the logging level (one of: debug, info, error, silent) (default info)
+- **-Debug**: Runs application in debug mode, this provides additional logging
-- **-DataStore**: Allows selecting [storage backend](#data-storage-backends) (default "json")
 
 These arguments allow you to configure various aspects of Cosmium's behavior according to your requirements.
 
@@ -98,19 +88,7 @@ All mentioned arguments can also be set using environment variables:
 - **COSMIUM_INITIALDATA** for `-InitialData`
 - **COSMIUM_PERSIST** for `-Persist`
 - **COSMIUM_PORT** for `-Port`
-- **COSMIUM_LOGLEVEL** for `-LogLevel`
+- **COSMIUM_DEBUG** for `-Debug`
-
-### Data Storage Backends
-
-Cosmium supports multiple storage backends for saving, loading, and managing data at runtime.
-
-| Backend  | Storage Location         | Write Behavior           | Memory Usage         | Supports Initial JSON Load |
-|----------|--------------------------|--------------------------|----------------------|----------------------------|
-| `json` (default) | JSON file on disk 📄 | On application exit ⏳ | 🛑 More than Badger | ✅ Yes                      |
-| `badger`  | BadgerDB database on disk ⚡ | Immediately on write 🚀 | ✅ Less than JSON  | ❌ No                       |
-
-
-The `badger` backend is generally recommended as it uses less memory and writes data to disk immediately. However, if you need to load initial data from a JSON file, use the `json` backend.
 
 # License
 

api/api_models/models.go

@@ -1,24 +0,0 @@
-package apimodels
-
-const (
-	BatchOperationTypeCreate  = "Create"
-	BatchOperationTypeDelete  = "Delete"
-	BatchOperationTypeReplace = "Replace"
-	BatchOperationTypeUpsert  = "Upsert"
-	BatchOperationTypeRead    = "Read"
-	BatchOperationTypePatch   = "Patch"
-)
-
-type BatchOperation struct {
-	OperationType string                 `json:"operationType"`
-	Id            string                 `json:"id"`
-	ResourceBody  map[string]interface{} `json:"resourceBody"`
-}
-
-type BatchOperationResult struct {
-	StatusCode    int                    `json:"statusCode"`
-	RequestCharge float64                `json:"requestCharge"`
-	ResourceBody  map[string]interface{} `json:"resourceBody"`
-	Etag          string                 `json:"etag"`
-	Message       string                 `json:"message"`
-}

api/api_server.go

@@ -1,39 +0,0 @@
-package api
-
-import (
-	"github.com/gin-gonic/gin"
-	"github.com/pikami/cosmium/api/config"
-	"github.com/pikami/cosmium/internal/datastore"
-)
-
-type ApiServer struct {
-	stopServer       chan interface{}
-	onServerShutdown chan interface{}
-	isActive         bool
-	router           *gin.Engine
-	config           *config.ServerConfig
-}
-
-func NewApiServer(dataStore datastore.DataStore, config *config.ServerConfig) *ApiServer {
-	stopChan := make(chan interface{})
-	onServerShutdownChan := make(chan interface{})
-
-	apiServer := &ApiServer{
-		stopServer:       stopChan,
-		onServerShutdown: onServerShutdownChan,
-		config:           config,
-	}
-
-	apiServer.CreateRouter(dataStore)
-
-	return apiServer
-}
-
-func (s *ApiServer) GetRouter() *gin.Engine {
-	return s.router
-}
-
-func (s *ApiServer) Stop() {
-	s.stopServer <- true
-	<-s.onServerShutdown
-}

api/config/config.go

@@ -5,8 +5,6 @@ import (
 	"fmt"
 	"os"
 	"strings"
-
-	"github.com/pikami/cosmium/internal/logger"
 )
 
 const (
@@ -15,12 +13,9 @@ const (
 	ExplorerBaseUrlLocation = "/_explorer"
 )
 
-const (
+var Config = ServerConfig{}
-	DataStoreJson   = "json"
-	DataStoreBadger = "badger"
-)
 
-func ParseFlags() ServerConfig {
+func ParseFlags() {
 	host := flag.String("Host", "localhost", "Hostname")
 	port := flag.Int("Port", 8081, "Listen port")
 	explorerPath := flag.String("ExplorerDir", "", "Path to cosmos-explorer files")
@@ -31,86 +26,27 @@ func ParseFlags() ServerConfig {
 	disableAuthentication := flag.Bool("DisableAuth", false, "Disable authentication")
 	disableTls := flag.Bool("DisableTls", false, "Disable TLS, serve over HTTP")
 	persistDataPath := flag.String("Persist", "", "Saves data to given path on application exit")
-	logLevel := NewEnumValue("info", []string{"debug", "info", "error", "silent"})
+	debug := flag.Bool("Debug", false, "Runs application in debug mode, this provides additional logging")
-	flag.Var(logLevel, "LogLevel", fmt.Sprintf("Sets the logging level %s", logLevel.AllowedValuesList()))
-	dataStore := NewEnumValue("json", []string{DataStoreJson, DataStoreBadger})
-	flag.Var(dataStore, "DataStore", fmt.Sprintf("Sets the data store %s", dataStore.AllowedValuesList()))
 
 	flag.Parse()
 	setFlagsFromEnvironment()
 
-	config := ServerConfig{}
+	Config.Host = *host
-	config.Host = *host
+	Config.Port = *port
-	config.Port = *port
+	Config.ExplorerPath = *explorerPath
-	config.ExplorerPath = *explorerPath
+	Config.TLS_CertificatePath = *tlsCertificatePath
-	config.TLS_CertificatePath = *tlsCertificatePath
+	Config.TLS_CertificateKey = *tlsCertificateKey
-	config.TLS_CertificateKey = *tlsCertificateKey
+	Config.InitialDataFilePath = *initialDataPath
-	config.InitialDataFilePath = *initialDataPath
+	Config.PersistDataFilePath = *persistDataPath
-	config.PersistDataFilePath = *persistDataPath
+	Config.DisableAuth = *disableAuthentication
-	config.DisableAuth = *disableAuthentication
+	Config.DisableTls = *disableTls
-	config.DisableTls = *disableTls
+	Config.Debug = *debug
-	config.AccountKey = *accountKey
-	config.LogLevel = logLevel.value
-	config.DataStore = dataStore.value
 
-	config.PopulateCalculatedFields()
+	Config.DatabaseAccount = Config.Host
-
+	Config.DatabaseDomain = Config.Host
-	return config
+	Config.DatabaseEndpoint = fmt.Sprintf("https://%s:%d/", Config.Host, Config.Port)
-}
+	Config.AccountKey = *accountKey
-
+	Config.ExplorerBaseUrlLocation = ExplorerBaseUrlLocation
-func (c *ServerConfig) PopulateCalculatedFields() {
-	c.DatabaseAccount = c.Host
-	c.DatabaseDomain = c.Host
-	c.DatabaseEndpoint = fmt.Sprintf("https://%s:%d/", c.Host, c.Port)
-	c.ExplorerBaseUrlLocation = ExplorerBaseUrlLocation
-
-	switch c.LogLevel {
-	case "debug":
-		logger.SetLogLevel(logger.LogLevelDebug)
-	case "info":
-		logger.SetLogLevel(logger.LogLevelInfo)
-	case "error":
-		logger.SetLogLevel(logger.LogLevelError)
-	case "silent":
-		logger.SetLogLevel(logger.LogLevelSilent)
-	default:
-		logger.SetLogLevel(logger.LogLevelInfo)
-	}
-
-	fileInfo, err := os.Stat(c.PersistDataFilePath)
-	if c.PersistDataFilePath != "" && !os.IsNotExist(err) {
-		if err != nil {
-			logger.ErrorLn("Failed to get file info for persist path:", err)
-			os.Exit(1)
-		}
-
-		if c.DataStore == DataStoreJson && fileInfo.IsDir() {
-			logger.ErrorLn("--Persist cannot be a directory when using json data store")
-			os.Exit(1)
-		}
-
-		if c.DataStore == DataStoreBadger && !fileInfo.IsDir() {
-			logger.ErrorLn("--Persist must be a directory when using Badger data store")
-			os.Exit(1)
-		}
-	}
-
-	if c.DataStore == DataStoreBadger && c.InitialDataFilePath != "" {
-		logger.ErrorLn("InitialData option is currently not supported with Badger data store")
-		os.Exit(1)
-	}
-}
-
-func (c *ServerConfig) ApplyDefaultsToEmptyFields() {
-	if c.Host == "" {
-		c.Host = "localhost"
-	}
-	if c.Port == 0 {
-		c.Port = 8081
-	}
-	if c.AccountKey == "" {
-		c.AccountKey = DefaultAccountKey
-	}
 }
 
 func setFlagsFromEnvironment() (err error) {

api/config/enumFlag.go

@@ -1,36 +0,0 @@
-package config
-
-import (
-	"fmt"
-	"strings"
-)
-
-type EnumValue struct {
-	allowedValues []string
-	value         string
-}
-
-func (e *EnumValue) String() string {
-	return e.value
-}
-
-func (e *EnumValue) Set(v string) error {
-	for _, allowed := range e.allowedValues {
-		if v == allowed {
-			e.value = v
-			return nil
-		}
-	}
-	return fmt.Errorf("invalid value %q, must be one of: %s", v, strings.Join(e.allowedValues, ", "))
-}
-
-func NewEnumValue(defaultValue string, allowedValues []string) *EnumValue {
-	return &EnumValue{
-		allowedValues: allowedValues,
-		value:         defaultValue,
-	}
-}
-
-func (e *EnumValue) AllowedValuesList() string {
-	return fmt.Sprintf("(one of: %s)", strings.Join(e.allowedValues, ", "))
-}

api/config/models.go

@@ -1,22 +1,20 @@
 package config
 
 type ServerConfig struct {
-	DatabaseAccount  string `json:"databaseAccount"`
+	DatabaseAccount  string
-	DatabaseDomain   string `json:"databaseDomain"`
+	DatabaseDomain   string
-	DatabaseEndpoint string `json:"databaseEndpoint"`
+	DatabaseEndpoint string
-	AccountKey       string `json:"accountKey"`
+	AccountKey       string
 
-	ExplorerPath            string `json:"explorerPath"`
+	ExplorerPath            string
-	Port                    int    `json:"port"`
+	Port                    int
-	Host                    string `json:"host"`
+	Host                    string
-	TLS_CertificatePath     string `json:"tlsCertificatePath"`
+	TLS_CertificatePath     string
-	TLS_CertificateKey      string `json:"tlsCertificateKey"`
+	TLS_CertificateKey      string
-	InitialDataFilePath     string `json:"initialDataFilePath"`
+	InitialDataFilePath     string
-	PersistDataFilePath     string `json:"persistDataFilePath"`
+	PersistDataFilePath     string
-	DisableAuth             bool   `json:"disableAuth"`
+	DisableAuth             bool
-	DisableTls              bool   `json:"disableTls"`
+	DisableTls              bool
-	LogLevel                string `json:"logLevel"`
+	Debug                   bool
-	ExplorerBaseUrlLocation string `json:"explorerBaseUrlLocation"`
+	ExplorerBaseUrlLocation string
-
-	DataStore string `json:"dataStore"`
 }

api/handlers/collections.go

@@ -5,16 +5,16 @@ import (
 	"net/http"
 
 	"github.com/gin-gonic/gin"
-	"github.com/pikami/cosmium/internal/constants"
+	"github.com/pikami/cosmium/internal/repositories"
-	"github.com/pikami/cosmium/internal/datastore"
+	repositorymodels "github.com/pikami/cosmium/internal/repository_models"
 )
 
-func (h *Handlers) GetAllCollections(c *gin.Context) {
+func GetAllCollections(c *gin.Context) {
 	databaseId := c.Param("databaseId")
 
-	collections, status := h.dataStore.GetAllCollections(databaseId)
+	collections, status := repositories.GetAllCollections(databaseId)
-	if status == datastore.StatusOk {
+	if status == repositorymodels.StatusOk {
-		database, _ := h.dataStore.GetDatabase(databaseId)
+		database, _ := repositories.GetDatabase(databaseId)
 
 		c.Header("x-ms-item-count", fmt.Sprintf("%d", len(collections)))
 		c.IndentedJSON(http.StatusOK, gin.H{
@@ -25,48 +25,48 @@ func (h *Handlers) GetAllCollections(c *gin.Context) {
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
+	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
 }
 
-func (h *Handlers) GetCollection(c *gin.Context) {
+func GetCollection(c *gin.Context) {
 	databaseId := c.Param("databaseId")
 	id := c.Param("collId")
 
-	collection, status := h.dataStore.GetCollection(databaseId, id)
+	collection, status := repositories.GetCollection(databaseId, id)
-	if status == datastore.StatusOk {
+	if status == repositorymodels.StatusOk {
 		c.IndentedJSON(http.StatusOK, collection)
 		return
 	}
 
-	if status == datastore.StatusNotFound {
+	if status == repositorymodels.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
+		c.IndentedJSON(http.StatusNotFound, gin.H{"message": "NotFound"})
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
+	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
 }
 
-func (h *Handlers) DeleteCollection(c *gin.Context) {
+func DeleteCollection(c *gin.Context) {
 	databaseId := c.Param("databaseId")
 	id := c.Param("collId")
 
-	status := h.dataStore.DeleteCollection(databaseId, id)
+	status := repositories.DeleteCollection(databaseId, id)
-	if status == datastore.StatusOk {
+	if status == repositorymodels.StatusOk {
 		c.Status(http.StatusNoContent)
 		return
 	}
 
-	if status == datastore.StatusNotFound {
+	if status == repositorymodels.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
+		c.IndentedJSON(http.StatusNotFound, gin.H{"message": "NotFound"})
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
+	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
 }
 
-func (h *Handlers) CreateCollection(c *gin.Context) {
+func CreateCollection(c *gin.Context) {
 	databaseId := c.Param("databaseId")
-	var newCollection datastore.Collection
+	var newCollection repositorymodels.Collection
 
 	if err := c.BindJSON(&newCollection); err != nil {
 		c.JSON(http.StatusBadRequest, gin.H{"message": err.Error()})
@@ -74,20 +74,20 @@ func (h *Handlers) CreateCollection(c *gin.Context) {
 	}
 
 	if newCollection.ID == "" {
-		c.JSON(http.StatusBadRequest, constants.BadRequestResponse)
+		c.JSON(http.StatusBadRequest, gin.H{"message": "BadRequest"})
 		return
 	}
 
-	createdCollection, status := h.dataStore.CreateCollection(databaseId, newCollection)
+	createdCollection, status := repositories.CreateCollection(databaseId, newCollection)
-	if status == datastore.Conflict {
+	if status == repositorymodels.Conflict {
-		c.IndentedJSON(http.StatusConflict, constants.ConflictResponse)
+		c.IndentedJSON(http.StatusConflict, gin.H{"message": "Conflict"})
 		return
 	}
 
-	if status == datastore.StatusOk {
+	if status == repositorymodels.StatusOk {
 		c.IndentedJSON(http.StatusCreated, createdCollection)
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
+	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
 }

api/handlers/cosmium.go

@@ -4,14 +4,9 @@ import (
 	"net/http"
 
 	"github.com/gin-gonic/gin"
+	"github.com/pikami/cosmium/internal/repositories"
 )
 
-func (h *Handlers) CosmiumExport(c *gin.Context) {
+func CosmiumExport(c *gin.Context) {
-	dataStoreState, err := h.dataStore.DumpToJson()
+	c.IndentedJSON(http.StatusOK, repositories.GetState())
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		return
-	}
-
-	c.Data(http.StatusOK, "application/json", []byte(dataStoreState))
 }

api/handlers/databases.go

@@ -5,13 +5,13 @@ import (
 	"net/http"
 
 	"github.com/gin-gonic/gin"
-	"github.com/pikami/cosmium/internal/constants"
+	"github.com/pikami/cosmium/internal/repositories"
-	"github.com/pikami/cosmium/internal/datastore"
+	repositorymodels "github.com/pikami/cosmium/internal/repository_models"
 )
 
-func (h *Handlers) GetAllDatabases(c *gin.Context) {
+func GetAllDatabases(c *gin.Context) {
-	databases, status := h.dataStore.GetAllDatabases()
+	databases, status := repositories.GetAllDatabases()
-	if status == datastore.StatusOk {
+	if status == repositorymodels.StatusOk {
 		c.Header("x-ms-item-count", fmt.Sprintf("%d", len(databases)))
 		c.IndentedJSON(http.StatusOK, gin.H{
 			"_rid":      "",
@@ -21,45 +21,45 @@ func (h *Handlers) GetAllDatabases(c *gin.Context) {
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
+	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
 }
 
-func (h *Handlers) GetDatabase(c *gin.Context) {
+func GetDatabase(c *gin.Context) {
 	id := c.Param("databaseId")
 
-	database, status := h.dataStore.GetDatabase(id)
+	database, status := repositories.GetDatabase(id)
-	if status == datastore.StatusOk {
+	if status == repositorymodels.StatusOk {
 		c.IndentedJSON(http.StatusOK, database)
 		return
 	}
 
-	if status == datastore.StatusNotFound {
+	if status == repositorymodels.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
+		c.IndentedJSON(http.StatusNotFound, gin.H{"message": "NotFound"})
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
+	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
 }
 
-func (h *Handlers) DeleteDatabase(c *gin.Context) {
+func DeleteDatabase(c *gin.Context) {
 	id := c.Param("databaseId")
 
-	status := h.dataStore.DeleteDatabase(id)
+	status := repositories.DeleteDatabase(id)
-	if status == datastore.StatusOk {
+	if status == repositorymodels.StatusOk {
 		c.Status(http.StatusNoContent)
 		return
 	}
 
-	if status == datastore.StatusNotFound {
+	if status == repositorymodels.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
+		c.IndentedJSON(http.StatusNotFound, gin.H{"message": "NotFound"})
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
+	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
 }
 
-func (h *Handlers) CreateDatabase(c *gin.Context) {
+func CreateDatabase(c *gin.Context) {
-	var newDatabase datastore.Database
+	var newDatabase repositorymodels.Database
 
 	if err := c.BindJSON(&newDatabase); err != nil {
 		c.JSON(http.StatusBadRequest, gin.H{"message": err.Error()})
@@ -67,20 +67,20 @@ func (h *Handlers) CreateDatabase(c *gin.Context) {
 	}
 
 	if newDatabase.ID == "" {
-		c.JSON(http.StatusBadRequest, constants.BadRequestResponse)
+		c.JSON(http.StatusBadRequest, gin.H{"message": "BadRequest"})
 		return
 	}
 
-	createdDatabase, status := h.dataStore.CreateDatabase(newDatabase)
+	createdDatabase, status := repositories.CreateDatabase(newDatabase)
-	if status == datastore.Conflict {
+	if status == repositorymodels.Conflict {
-		c.IndentedJSON(http.StatusConflict, constants.ConflictResponse)
+		c.IndentedJSON(http.StatusConflict, gin.H{"message": "Conflict"})
 		return
 	}
 
-	if status == datastore.StatusOk {
+	if status == repositorymodels.StatusOk {
 		c.IndentedJSON(http.StatusCreated, createdDatabase)
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
+	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
 }

api/handlers/documents.go

@@ -6,25 +6,21 @@ import (
 	"net/http"
 	"strconv"
 
-	jsonpatch "github.com/cosmiumdev/json-patch/v5"
+	jsonpatch "github.com/evanphx/json-patch/v5"
 	"github.com/gin-gonic/gin"
-	apimodels "github.com/pikami/cosmium/api/api_models"
 	"github.com/pikami/cosmium/internal/constants"
-	"github.com/pikami/cosmium/internal/converters"
-	"github.com/pikami/cosmium/internal/datastore"
 	"github.com/pikami/cosmium/internal/logger"
-	"github.com/pikami/cosmium/parsers"
+	"github.com/pikami/cosmium/internal/repositories"
-	"github.com/pikami/cosmium/parsers/nosql"
+	repositorymodels "github.com/pikami/cosmium/internal/repository_models"
-	memoryexecutor "github.com/pikami/cosmium/query_executors/memory_executor"
 )
 
-func (h *Handlers) GetAllDocuments(c *gin.Context) {
+func GetAllDocuments(c *gin.Context) {
 	databaseId := c.Param("databaseId")
 	collectionId := c.Param("collId")
 
-	documents, status := h.dataStore.GetAllDocuments(databaseId, collectionId)
+	documents, status := repositories.GetAllDocuments(databaseId, collectionId)
-	if status == datastore.StatusOk {
+	if status == repositorymodels.StatusOk {
-		collection, _ := h.dataStore.GetCollection(databaseId, collectionId)
+		collection, _ := repositories.GetCollection(databaseId, collectionId)
 
 		c.Header("x-ms-item-count", fmt.Sprintf("%d", len(documents)))
 		c.IndentedJSON(http.StatusOK, gin.H{
@@ -35,49 +31,49 @@ func (h *Handlers) GetAllDocuments(c *gin.Context) {
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
+	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
 }
 
-func (h *Handlers) GetDocument(c *gin.Context) {
+func GetDocument(c *gin.Context) {
 	databaseId := c.Param("databaseId")
 	collectionId := c.Param("collId")
 	documentId := c.Param("docId")
 
-	document, status := h.dataStore.GetDocument(databaseId, collectionId, documentId)
+	document, status := repositories.GetDocument(databaseId, collectionId, documentId)
-	if status == datastore.StatusOk {
+	if status == repositorymodels.StatusOk {
 		c.IndentedJSON(http.StatusOK, document)
 		return
 	}
 
-	if status == datastore.StatusNotFound {
+	if status == repositorymodels.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
+		c.IndentedJSON(http.StatusNotFound, gin.H{"message": "NotFound"})
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
+	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
 }
 
-func (h *Handlers) DeleteDocument(c *gin.Context) {
+func DeleteDocument(c *gin.Context) {
 	databaseId := c.Param("databaseId")
 	collectionId := c.Param("collId")
 	documentId := c.Param("docId")
 
-	status := h.dataStore.DeleteDocument(databaseId, collectionId, documentId)
+	status := repositories.DeleteDocument(databaseId, collectionId, documentId)
-	if status == datastore.StatusOk {
+	if status == repositorymodels.StatusOk {
 		c.Status(http.StatusNoContent)
 		return
 	}
 
-	if status == datastore.StatusNotFound {
+	if status == repositorymodels.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
+		c.IndentedJSON(http.StatusNotFound, gin.H{"message": "NotFound"})
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
+	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
 }
 
-// TODO: Maybe move "replace" logic to data store
+// TODO: Maybe move "replace" logic to repository
-func (h *Handlers) ReplaceDocument(c *gin.Context) {
+func ReplaceDocument(c *gin.Context) {
 	databaseId := c.Param("databaseId")
 	collectionId := c.Param("collId")
 	documentId := c.Param("docId")
@@ -88,34 +84,34 @@ func (h *Handlers) ReplaceDocument(c *gin.Context) {
 		return
 	}
 
-	status := h.dataStore.DeleteDocument(databaseId, collectionId, documentId)
+	status := repositories.DeleteDocument(databaseId, collectionId, documentId)
-	if status == datastore.StatusNotFound {
+	if status == repositorymodels.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
+		c.IndentedJSON(http.StatusNotFound, gin.H{"message": "NotFound"})
 		return
 	}
 
-	createdDocument, status := h.dataStore.CreateDocument(databaseId, collectionId, requestBody)
+	createdDocument, status := repositories.CreateDocument(databaseId, collectionId, requestBody)
-	if status == datastore.Conflict {
+	if status == repositorymodels.Conflict {
-		c.IndentedJSON(http.StatusConflict, constants.ConflictResponse)
+		c.IndentedJSON(http.StatusConflict, gin.H{"message": "Conflict"})
 		return
 	}
 
-	if status == datastore.StatusOk {
+	if status == repositorymodels.StatusOk {
 		c.IndentedJSON(http.StatusCreated, createdDocument)
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
+	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
 }
 
-func (h *Handlers) PatchDocument(c *gin.Context) {
+func PatchDocument(c *gin.Context) {
 	databaseId := c.Param("databaseId")
 	collectionId := c.Param("collId")
 	documentId := c.Param("docId")
 
-	document, status := h.dataStore.GetDocument(databaseId, collectionId, documentId)
+	document, status := repositories.GetDocument(databaseId, collectionId, documentId)
-	if status == datastore.StatusNotFound {
+	if status == repositorymodels.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
+		c.IndentedJSON(http.StatusNotFound, gin.H{"message": "NotFound"})
 		return
 	}
 
@@ -140,7 +136,7 @@ func (h *Handlers) PatchDocument(c *gin.Context) {
 
 	currentDocumentBytes, err := json.Marshal(document)
 	if err != nil {
-		logger.ErrorLn("Failed to marshal existing document:", err)
+		logger.Error("Failed to marshal existing document:", err)
 		c.JSON(http.StatusInternalServerError, gin.H{"message": "Failed to marshal existing document"})
 		return
 	}
@@ -154,7 +150,7 @@ func (h *Handlers) PatchDocument(c *gin.Context) {
 	var modifiedDocument map[string]interface{}
 	err = json.Unmarshal(modifiedDocumentBytes, &modifiedDocument)
 	if err != nil {
-		logger.ErrorLn("Failed to unmarshal modified document:", err)
+		logger.Error("Failed to unmarshal modified document:", err)
 		c.JSON(http.StatusInternalServerError, gin.H{"message": "Failed to unmarshal modified document"})
 		return
 	}
@@ -164,37 +160,30 @@ func (h *Handlers) PatchDocument(c *gin.Context) {
 		return
 	}
 
-	status = h.dataStore.DeleteDocument(databaseId, collectionId, documentId)
+	status = repositories.DeleteDocument(databaseId, collectionId, documentId)
-	if status == datastore.StatusNotFound {
+	if status == repositorymodels.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
+		c.IndentedJSON(http.StatusNotFound, gin.H{"message": "NotFound"})
 		return
 	}
 
-	createdDocument, status := h.dataStore.CreateDocument(databaseId, collectionId, modifiedDocument)
+	createdDocument, status := repositories.CreateDocument(databaseId, collectionId, modifiedDocument)
-	if status == datastore.Conflict {
+	if status == repositorymodels.Conflict {
-		c.IndentedJSON(http.StatusConflict, constants.ConflictResponse)
+		c.IndentedJSON(http.StatusConflict, gin.H{"message": "Conflict"})
 		return
 	}
 
-	if status == datastore.StatusOk {
+	if status == repositorymodels.StatusOk {
 		c.IndentedJSON(http.StatusCreated, createdDocument)
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
+	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
 }
 
-func (h *Handlers) DocumentsPost(c *gin.Context) {
+func DocumentsPost(c *gin.Context) {
 	databaseId := c.Param("databaseId")
 	collectionId := c.Param("collId")
 
-	// Handle batch requests
-	isBatchRequest, _ := strconv.ParseBool(c.GetHeader("x-ms-cosmos-is-batch-request"))
-	if isBatchRequest {
-		h.handleBatchRequest(c)
-		return
-	}
-
 	var requestBody map[string]interface{}
 	if err := c.BindJSON(&requestBody); err != nil {
 		c.JSON(http.StatusBadRequest, gin.H{"message": err.Error()})
@@ -203,32 +192,55 @@ func (h *Handlers) DocumentsPost(c *gin.Context) {
 
 	query := requestBody["query"]
 	if query != nil {
-		h.handleDocumentQuery(c, requestBody)
+		if c.GetHeader("x-ms-cosmos-is-query-plan-request") != "" {
+			c.IndentedJSON(http.StatusOK, constants.QueryPlanResponse)
+			return
+		}
+
+		var queryParameters map[string]interface{}
+		if paramsArray, ok := requestBody["parameters"].([]interface{}); ok {
+			queryParameters = parametersToMap(paramsArray)
+		}
+
+		docs, status := repositories.ExecuteQueryDocuments(databaseId, collectionId, query.(string), queryParameters)
+		if status != repositorymodels.StatusOk {
+			// TODO: Currently we return everything if the query fails
+			GetAllDocuments(c)
+			return
+		}
+
+		collection, _ := repositories.GetCollection(databaseId, collectionId)
+		c.Header("x-ms-item-count", fmt.Sprintf("%d", len(docs)))
+		c.IndentedJSON(http.StatusOK, gin.H{
+			"_rid":      collection.ResourceID,
+			"Documents": docs,
+			"_count":    len(docs),
+		})
 		return
 	}
 
 	if requestBody["id"] == "" {
-		c.JSON(http.StatusBadRequest, constants.BadRequestResponse)
+		c.JSON(http.StatusBadRequest, gin.H{"message": "BadRequest"})
 		return
 	}
 
 	isUpsert, _ := strconv.ParseBool(c.GetHeader("x-ms-documentdb-is-upsert"))
 	if isUpsert {
-		h.dataStore.DeleteDocument(databaseId, collectionId, requestBody["id"].(string))
+		repositories.DeleteDocument(databaseId, collectionId, requestBody["id"].(string))
 	}
 
-	createdDocument, status := h.dataStore.CreateDocument(databaseId, collectionId, requestBody)
+	createdDocument, status := repositories.CreateDocument(databaseId, collectionId, requestBody)
-	if status == datastore.Conflict {
+	if status == repositorymodels.Conflict {
-		c.IndentedJSON(http.StatusConflict, constants.ConflictResponse)
+		c.IndentedJSON(http.StatusConflict, gin.H{"message": "Conflict"})
 		return
 	}
 
-	if status == datastore.StatusOk {
+	if status == repositorymodels.StatusOk {
 		c.IndentedJSON(http.StatusCreated, createdDocument)
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
+	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
 }
 
 func parametersToMap(pairs []interface{}) map[string]interface{} {
@@ -242,155 +254,3 @@ func parametersToMap(pairs []interface{}) map[string]interface{} {
 
 	return result
 }
-
-func (h *Handlers) handleDocumentQuery(c *gin.Context, requestBody map[string]interface{}) {
-	databaseId := c.Param("databaseId")
-	collectionId := c.Param("collId")
-
-	if c.GetHeader("x-ms-cosmos-is-query-plan-request") != "" {
-		c.IndentedJSON(http.StatusOK, constants.QueryPlanResponse)
-		return
-	}
-
-	var queryParameters map[string]interface{}
-	if paramsArray, ok := requestBody["parameters"].([]interface{}); ok {
-		queryParameters = parametersToMap(paramsArray)
-	}
-
-	queryText := requestBody["query"].(string)
-	docs, status := h.executeQueryDocuments(databaseId, collectionId, queryText, queryParameters)
-	if status != datastore.StatusOk {
-		// TODO: Currently we return everything if the query fails
-		h.GetAllDocuments(c)
-		return
-	}
-
-	collection, _ := h.dataStore.GetCollection(databaseId, collectionId)
-	c.Header("x-ms-item-count", fmt.Sprintf("%d", len(docs)))
-	c.IndentedJSON(http.StatusOK, gin.H{
-		"_rid":      collection.ResourceID,
-		"Documents": docs,
-		"_count":    len(docs),
-	})
-}
-
-func (h *Handlers) handleBatchRequest(c *gin.Context) {
-	databaseId := c.Param("databaseId")
-	collectionId := c.Param("collId")
-
-	batchOperations := make([]apimodels.BatchOperation, 0)
-	if err := c.BindJSON(&batchOperations); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"message": err.Error()})
-		return
-	}
-
-	batchOperationResults := make([]apimodels.BatchOperationResult, len(batchOperations))
-	for idx, operation := range batchOperations {
-		switch operation.OperationType {
-		case apimodels.BatchOperationTypeCreate:
-			createdDocument, status := h.dataStore.CreateDocument(databaseId, collectionId, operation.ResourceBody)
-			responseCode := dataStoreStatusToResponseCode(status)
-			if status == datastore.StatusOk {
-				responseCode = http.StatusCreated
-			}
-			batchOperationResults[idx] = apimodels.BatchOperationResult{
-				StatusCode:   responseCode,
-				ResourceBody: createdDocument,
-			}
-		case apimodels.BatchOperationTypeDelete:
-			status := h.dataStore.DeleteDocument(databaseId, collectionId, operation.Id)
-			responseCode := dataStoreStatusToResponseCode(status)
-			if status == datastore.StatusOk {
-				responseCode = http.StatusNoContent
-			}
-			batchOperationResults[idx] = apimodels.BatchOperationResult{
-				StatusCode: responseCode,
-			}
-		case apimodels.BatchOperationTypeReplace:
-			deleteStatus := h.dataStore.DeleteDocument(databaseId, collectionId, operation.Id)
-			if deleteStatus == datastore.StatusNotFound {
-				batchOperationResults[idx] = apimodels.BatchOperationResult{
-					StatusCode: http.StatusNotFound,
-				}
-				continue
-			}
-			createdDocument, createStatus := h.dataStore.CreateDocument(databaseId, collectionId, operation.ResourceBody)
-			responseCode := dataStoreStatusToResponseCode(createStatus)
-			if createStatus == datastore.StatusOk {
-				responseCode = http.StatusCreated
-			}
-			batchOperationResults[idx] = apimodels.BatchOperationResult{
-				StatusCode:   responseCode,
-				ResourceBody: createdDocument,
-			}
-		case apimodels.BatchOperationTypeUpsert:
-			documentId := operation.ResourceBody["id"].(string)
-			h.dataStore.DeleteDocument(databaseId, collectionId, documentId)
-			createdDocument, createStatus := h.dataStore.CreateDocument(databaseId, collectionId, operation.ResourceBody)
-			responseCode := dataStoreStatusToResponseCode(createStatus)
-			if createStatus == datastore.StatusOk {
-				responseCode = http.StatusCreated
-			}
-			batchOperationResults[idx] = apimodels.BatchOperationResult{
-				StatusCode:   responseCode,
-				ResourceBody: createdDocument,
-			}
-		case apimodels.BatchOperationTypeRead:
-			document, status := h.dataStore.GetDocument(databaseId, collectionId, operation.Id)
-			batchOperationResults[idx] = apimodels.BatchOperationResult{
-				StatusCode:   dataStoreStatusToResponseCode(status),
-				ResourceBody: document,
-			}
-		case apimodels.BatchOperationTypePatch:
-			batchOperationResults[idx] = apimodels.BatchOperationResult{
-				StatusCode: http.StatusNotImplemented,
-				Message:    "Patch operation is not implemented",
-			}
-		default:
-			batchOperationResults[idx] = apimodels.BatchOperationResult{
-				StatusCode: http.StatusBadRequest,
-				Message:    "Unknown operation type",
-			}
-		}
-	}
-
-	c.JSON(http.StatusOK, batchOperationResults)
-}
-
-func dataStoreStatusToResponseCode(status datastore.DataStoreStatus) int {
-	switch status {
-	case datastore.StatusOk:
-		return http.StatusOK
-	case datastore.StatusNotFound:
-		return http.StatusNotFound
-	case datastore.Conflict:
-		return http.StatusConflict
-	case datastore.BadRequest:
-		return http.StatusBadRequest
-	default:
-		return http.StatusInternalServerError
-	}
-}
-
-func (h *Handlers) executeQueryDocuments(databaseId string, collectionId string, query string, queryParameters map[string]interface{}) ([]memoryexecutor.RowType, datastore.DataStoreStatus) {
-	parsedQuery, err := nosql.Parse("", []byte(query))
-	if err != nil {
-		logger.Errorf("Failed to parse query: %s\nerr: %v", query, err)
-		return nil, datastore.BadRequest
-	}
-
-	allDocumentsIterator, status := h.dataStore.GetDocumentIterator(databaseId, collectionId)
-	if status != datastore.StatusOk {
-		return nil, status
-	}
-	defer allDocumentsIterator.Close()
-
-	rowsIterator := converters.NewDocumentToRowTypeIterator(allDocumentsIterator)
-
-	if typedQuery, ok := parsedQuery.(parsers.SelectStmt); ok {
-		typedQuery.Parameters = queryParameters
-		return memoryexecutor.ExecuteQuery(typedQuery, rowsIterator), datastore.StatusOk
-	}
-
-	return nil, datastore.BadRequest
-}

api/handlers/explorer.go

@@ -4,14 +4,15 @@ import (
 	"fmt"
 
 	"github.com/gin-gonic/gin"
+	"github.com/pikami/cosmium/api/config"
 )
 
-func (h *Handlers) RegisterExplorerHandlers(router *gin.Engine) {
+func RegisterExplorerHandlers(router *gin.Engine) {
-	explorer := router.Group(h.config.ExplorerBaseUrlLocation)
+	explorer := router.Group(config.Config.ExplorerBaseUrlLocation)
 	{
 		explorer.Use(func(ctx *gin.Context) {
 			if ctx.Param("filepath") == "/config.json" {
-				endpoint := fmt.Sprintf("https://%s:%d", h.config.Host, h.config.Port)
+				endpoint := fmt.Sprintf("https://%s:%d", config.Config.Host, config.Config.Port)
 				ctx.JSON(200, gin.H{
 					"BACKEND_ENDPOINT":       endpoint,
 					"MONGO_BACKEND_ENDPOINT": endpoint,
@@ -24,8 +25,8 @@ func (h *Handlers) RegisterExplorerHandlers(router *gin.Engine) {
 			}
 		})
 
-		if h.config.ExplorerPath != "" {
+		if config.Config.ExplorerPath != "" {
-			explorer.Static("/", h.config.ExplorerPath)
+			explorer.Static("/", config.Config.ExplorerPath)
 		}
 	}
 }

api/handlers/handlers.go

@@ -1,18 +0,0 @@
-package handlers
-
-import (
-	"github.com/pikami/cosmium/api/config"
-	"github.com/pikami/cosmium/internal/datastore"
-)
-
-type Handlers struct {
-	dataStore datastore.DataStore
-	config    *config.ServerConfig
-}
-
-func NewHandlers(dataStore datastore.DataStore, config *config.ServerConfig) *Handlers {
-	return &Handlers{
-		dataStore: dataStore,
-		config:    config,
-	}
-}

api/handlers/middleware/authentication.go

@@ -10,11 +10,11 @@ import (
 	"github.com/pikami/cosmium/internal/logger"
 )
 
-func Authentication(config *config.ServerConfig) gin.HandlerFunc {
+func Authentication() gin.HandlerFunc {
 	return func(c *gin.Context) {
 		requestUrl := c.Request.URL.String()
-		if config.DisableAuth ||
+		if config.Config.DisableAuth ||
-			strings.HasPrefix(requestUrl, config.ExplorerBaseUrlLocation) ||
+			strings.HasPrefix(requestUrl, config.Config.ExplorerBaseUrlLocation) ||
 			strings.HasPrefix(requestUrl, "/cosmium") {
 			return
 		}
@@ -25,7 +25,7 @@ func Authentication(config *config.ServerConfig) gin.HandlerFunc {
 		authHeader := c.Request.Header.Get("authorization")
 		date := c.Request.Header.Get("x-ms-date")
 		expectedSignature := authentication.GenerateSignature(
-			c.Request.Method, resourceType, resourceId, date, config.AccountKey)
+			c.Request.Method, resourceType, resourceId, date, config.Config.AccountKey)
 
 		decoded, _ := url.QueryUnescape(authHeader)
 		params, _ := url.ParseQuery(decoded)

api/handlers/middleware/loggers.go

@@ -16,7 +16,7 @@ func RequestLogger() gin.HandlerFunc {
 
 		bodyStr := readBody(rdr1)
 		if bodyStr != "" {
-			logger.DebugLn(bodyStr)
+			logger.Debug(bodyStr)
 		}
 
 		c.Request.Body = rdr2

api/handlers/middleware/strip_trailing_slashes.go

@@ -7,10 +7,10 @@ import (
 	"github.com/pikami/cosmium/api/config"
 )
 
-func StripTrailingSlashes(r *gin.Engine, config *config.ServerConfig) gin.HandlerFunc {
+func StripTrailingSlashes(r *gin.Engine) gin.HandlerFunc {
 	return func(c *gin.Context) {
 		path := c.Request.URL.Path
-		if len(path) > 1 && path[len(path)-1] == '/' && !strings.Contains(path, config.ExplorerBaseUrlLocation) {
+		if len(path) > 1 && path[len(path)-1] == '/' && !strings.Contains(path, config.Config.ExplorerBaseUrlLocation) {
 			c.Request.URL.Path = path[:len(path)-1]
 			r.HandleContext(c)
 			c.Abort()

api/handlers/partition_key_ranges.go

@@ -5,12 +5,11 @@ import (
 	"net/http"
 
 	"github.com/gin-gonic/gin"
-	"github.com/pikami/cosmium/internal/constants"
+	"github.com/pikami/cosmium/internal/repositories"
-	"github.com/pikami/cosmium/internal/datastore"
+	repositorymodels "github.com/pikami/cosmium/internal/repository_models"
-	"github.com/pikami/cosmium/internal/resourceid"
 )
 
-func (h *Handlers) GetPartitionKeyRanges(c *gin.Context) {
+func GetPartitionKeyRanges(c *gin.Context) {
 	databaseId := c.Param("databaseId")
 	collectionId := c.Param("collId")
 
@@ -19,8 +18,8 @@ func (h *Handlers) GetPartitionKeyRanges(c *gin.Context) {
 		return
 	}
 
-	partitionKeyRanges, status := h.dataStore.GetPartitionKeyRanges(databaseId, collectionId)
+	partitionKeyRanges, status := repositories.GetPartitionKeyRanges(databaseId, collectionId)
-	if status == datastore.StatusOk {
+	if status == repositorymodels.StatusOk {
 		c.Header("etag", "\"420\"")
 		c.Header("lsn", "420")
 		c.Header("x-ms-cosmos-llsn", "420")
@@ -28,24 +27,23 @@ func (h *Handlers) GetPartitionKeyRanges(c *gin.Context) {
 		c.Header("x-ms-item-count", fmt.Sprintf("%d", len(partitionKeyRanges)))
 
 		collectionRid := collectionId
-		collection, _ := h.dataStore.GetCollection(databaseId, collectionId)
+		collection, _ := repositories.GetCollection(databaseId, collectionId)
 		if collection.ResourceID != "" {
 			collectionRid = collection.ResourceID
 		}
 
-		rid := resourceid.NewCombined(collectionRid, resourceid.New(resourceid.ResourceTypePartitionKeyRange))
 		c.IndentedJSON(http.StatusOK, gin.H{
-			"_rid":               rid,
+			"_rid":               collectionRid,
 			"_count":             len(partitionKeyRanges),
 			"PartitionKeyRanges": partitionKeyRanges,
 		})
 		return
 	}
 
-	if status == datastore.StatusNotFound {
+	if status == repositorymodels.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
+		c.IndentedJSON(http.StatusNotFound, gin.H{"message": "NotFound"})
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
+	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
 }

api/handlers/server_info.go

@@ -5,31 +5,30 @@ import (
 	"net/http"
 
 	"github.com/gin-gonic/gin"
+	"github.com/pikami/cosmium/api/config"
 )
 
-func (h *Handlers) GetServerInfo(c *gin.Context) {
+func GetServerInfo(c *gin.Context) {
 	c.IndentedJSON(http.StatusOK, gin.H{
 		"_self":     "",
-		"id":        h.config.DatabaseAccount,
+		"id":        config.Config.DatabaseAccount,
-		"_rid":      fmt.Sprintf("%s.%s", h.config.DatabaseAccount, h.config.DatabaseDomain),
+		"_rid":      fmt.Sprintf("%s.%s", config.Config.DatabaseAccount, config.Config.DatabaseDomain),
 		"media":     "//media/",
 		"addresses": "//addresses/",
 		"_dbs":      "//dbs/",
 		"writableLocations": []map[string]interface{}{
 			{
 				"name":                    "South Central US",
-				"databaseAccountEndpoint": h.config.DatabaseEndpoint,
+				"databaseAccountEndpoint": config.Config.DatabaseEndpoint,
 			},
 		},
 		"readableLocations": []map[string]interface{}{
 			{
 				"name":                    "South Central US",
-				"databaseAccountEndpoint": h.config.DatabaseEndpoint,
+				"databaseAccountEndpoint": config.Config.DatabaseEndpoint,
 			},
 		},
 		"enableMultipleWriteLocations": false,
-		"continuousBackupEnabled":        false,
-		"enableNRegionSynchronousCommit": false,
 		"userReplicationPolicy": map[string]interface{}{
 			"asyncReplication":  false,
 			"minReplicaSetSize": 1,

api/handlers/stored_procedures.go

@@ -5,115 +5,21 @@ import (
 	"net/http"
 
 	"github.com/gin-gonic/gin"
-	"github.com/pikami/cosmium/internal/constants"
+	"github.com/pikami/cosmium/internal/repositories"
-	"github.com/pikami/cosmium/internal/datastore"
+	repositorymodels "github.com/pikami/cosmium/internal/repository_models"
 )
 
-func (h *Handlers) GetAllStoredProcedures(c *gin.Context) {
+func GetAllStoredProcedures(c *gin.Context) {
 	databaseId := c.Param("databaseId")
 	collectionId := c.Param("collId")
 
-	sps, status := h.dataStore.GetAllStoredProcedures(databaseId, collectionId)
+	sps, status := repositories.GetAllStoredProcedures(databaseId, collectionId)
 
-	if status == datastore.StatusOk {
+	if status == repositorymodels.StatusOk {
 		c.Header("x-ms-item-count", fmt.Sprintf("%d", len(sps)))
 		c.IndentedJSON(http.StatusOK, gin.H{"_rid": "", "StoredProcedures": sps, "_count": len(sps)})
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
+	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
-}
-
-func (h *Handlers) GetStoredProcedure(c *gin.Context) {
-	databaseId := c.Param("databaseId")
-	collectionId := c.Param("collId")
-	spId := c.Param("spId")
-
-	sp, status := h.dataStore.GetStoredProcedure(databaseId, collectionId, spId)
-
-	if status == datastore.StatusOk {
-		c.IndentedJSON(http.StatusOK, sp)
-		return
-	}
-
-	if status == datastore.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
-		return
-	}
-
-	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
-}
-
-func (h *Handlers) DeleteStoredProcedure(c *gin.Context) {
-	databaseId := c.Param("databaseId")
-	collectionId := c.Param("collId")
-	spId := c.Param("spId")
-
-	status := h.dataStore.DeleteStoredProcedure(databaseId, collectionId, spId)
-	if status == datastore.StatusOk {
-		c.Status(http.StatusNoContent)
-		return
-	}
-
-	if status == datastore.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
-		return
-	}
-
-	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
-}
-
-func (h *Handlers) ReplaceStoredProcedure(c *gin.Context) {
-	databaseId := c.Param("databaseId")
-	collectionId := c.Param("collId")
-	spId := c.Param("spId")
-
-	var sp datastore.StoredProcedure
-	if err := c.BindJSON(&sp); err != nil {
-		c.IndentedJSON(http.StatusBadRequest, constants.BadRequestResponse)
-		return
-	}
-
-	status := h.dataStore.DeleteStoredProcedure(databaseId, collectionId, spId)
-	if status == datastore.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
-		return
-	}
-
-	createdSP, status := h.dataStore.CreateStoredProcedure(databaseId, collectionId, sp)
-	if status == datastore.Conflict {
-		c.IndentedJSON(http.StatusConflict, constants.ConflictResponse)
-		return
-	}
-
-	if status == datastore.StatusOk {
-		c.IndentedJSON(http.StatusOK, createdSP)
-		return
-	}
-
-	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
-}
-
-func (h *Handlers) CreateStoredProcedure(c *gin.Context) {
-	databaseId := c.Param("databaseId")
-	collectionId := c.Param("collId")
-
-	var sp datastore.StoredProcedure
-	if err := c.BindJSON(&sp); err != nil {
-		c.IndentedJSON(http.StatusBadRequest, constants.BadRequestResponse)
-		return
-	}
-
-	createdSP, status := h.dataStore.CreateStoredProcedure(databaseId, collectionId, sp)
-	if status == datastore.Conflict {
-		c.IndentedJSON(http.StatusConflict, constants.ConflictResponse)
-		return
-	}
-
-	if status == datastore.StatusOk {
-		c.IndentedJSON(http.StatusCreated, createdSP)
-		return
-	}
-
-	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
 }

api/handlers/triggers.go

@@ -5,115 +5,21 @@ import (
 	"net/http"
 
 	"github.com/gin-gonic/gin"
-	"github.com/pikami/cosmium/internal/constants"
+	"github.com/pikami/cosmium/internal/repositories"
-	"github.com/pikami/cosmium/internal/datastore"
+	repositorymodels "github.com/pikami/cosmium/internal/repository_models"
 )
 
-func (h *Handlers) GetAllTriggers(c *gin.Context) {
+func GetAllTriggers(c *gin.Context) {
 	databaseId := c.Param("databaseId")
 	collectionId := c.Param("collId")
 
-	triggers, status := h.dataStore.GetAllTriggers(databaseId, collectionId)
+	triggers, status := repositories.GetAllTriggers(databaseId, collectionId)
 
-	if status == datastore.StatusOk {
+	if status == repositorymodels.StatusOk {
 		c.Header("x-ms-item-count", fmt.Sprintf("%d", len(triggers)))
 		c.IndentedJSON(http.StatusOK, gin.H{"_rid": "", "Triggers": triggers, "_count": len(triggers)})
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
+	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
-}
-
-func (h *Handlers) GetTrigger(c *gin.Context) {
-	databaseId := c.Param("databaseId")
-	collectionId := c.Param("collId")
-	triggerId := c.Param("triggerId")
-
-	trigger, status := h.dataStore.GetTrigger(databaseId, collectionId, triggerId)
-
-	if status == datastore.StatusOk {
-		c.IndentedJSON(http.StatusOK, trigger)
-		return
-	}
-
-	if status == datastore.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
-		return
-	}
-
-	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
-}
-
-func (h *Handlers) DeleteTrigger(c *gin.Context) {
-	databaseId := c.Param("databaseId")
-	collectionId := c.Param("collId")
-	triggerId := c.Param("triggerId")
-
-	status := h.dataStore.DeleteTrigger(databaseId, collectionId, triggerId)
-	if status == datastore.StatusOk {
-		c.Status(http.StatusNoContent)
-		return
-	}
-
-	if status == datastore.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
-		return
-	}
-
-	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
-}
-
-func (h *Handlers) ReplaceTrigger(c *gin.Context) {
-	databaseId := c.Param("databaseId")
-	collectionId := c.Param("collId")
-	triggerId := c.Param("triggerId")
-
-	var trigger datastore.Trigger
-	if err := c.BindJSON(&trigger); err != nil {
-		c.IndentedJSON(http.StatusBadRequest, constants.BadRequestResponse)
-		return
-	}
-
-	status := h.dataStore.DeleteTrigger(databaseId, collectionId, triggerId)
-	if status == datastore.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
-		return
-	}
-
-	createdTrigger, status := h.dataStore.CreateTrigger(databaseId, collectionId, trigger)
-	if status == datastore.Conflict {
-		c.IndentedJSON(http.StatusConflict, constants.ConflictResponse)
-		return
-	}
-
-	if status == datastore.StatusOk {
-		c.IndentedJSON(http.StatusOK, createdTrigger)
-		return
-	}
-
-	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
-}
-
-func (h *Handlers) CreateTrigger(c *gin.Context) {
-	databaseId := c.Param("databaseId")
-	collectionId := c.Param("collId")
-
-	var trigger datastore.Trigger
-	if err := c.BindJSON(&trigger); err != nil {
-		c.IndentedJSON(http.StatusBadRequest, constants.BadRequestResponse)
-		return
-	}
-
-	createdTrigger, status := h.dataStore.CreateTrigger(databaseId, collectionId, trigger)
-	if status == datastore.Conflict {
-		c.IndentedJSON(http.StatusConflict, constants.ConflictResponse)
-		return
-	}
-
-	if status == datastore.StatusOk {
-		c.IndentedJSON(http.StatusCreated, createdTrigger)
-		return
-	}
-
-	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
 }

api/handlers/user_defined_functions.go

@@ -5,115 +5,21 @@ import (
 	"net/http"
 
 	"github.com/gin-gonic/gin"
-	"github.com/pikami/cosmium/internal/constants"
+	"github.com/pikami/cosmium/internal/repositories"
-	"github.com/pikami/cosmium/internal/datastore"
+	repositorymodels "github.com/pikami/cosmium/internal/repository_models"
 )
 
-func (h *Handlers) GetAllUserDefinedFunctions(c *gin.Context) {
+func GetAllUserDefinedFunctions(c *gin.Context) {
 	databaseId := c.Param("databaseId")
 	collectionId := c.Param("collId")
 
-	udfs, status := h.dataStore.GetAllUserDefinedFunctions(databaseId, collectionId)
+	udfs, status := repositories.GetAllUserDefinedFunctions(databaseId, collectionId)
 
-	if status == datastore.StatusOk {
+	if status == repositorymodels.StatusOk {
 		c.Header("x-ms-item-count", fmt.Sprintf("%d", len(udfs)))
 		c.IndentedJSON(http.StatusOK, gin.H{"_rid": "", "UserDefinedFunctions": udfs, "_count": len(udfs)})
 		return
 	}
 
-	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
+	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
-}
-
-func (h *Handlers) GetUserDefinedFunction(c *gin.Context) {
-	databaseId := c.Param("databaseId")
-	collectionId := c.Param("collId")
-	udfId := c.Param("udfId")
-
-	udf, status := h.dataStore.GetUserDefinedFunction(databaseId, collectionId, udfId)
-
-	if status == datastore.StatusOk {
-		c.IndentedJSON(http.StatusOK, udf)
-		return
-	}
-
-	if status == datastore.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
-		return
-	}
-
-	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
-}
-
-func (h *Handlers) DeleteUserDefinedFunction(c *gin.Context) {
-	databaseId := c.Param("databaseId")
-	collectionId := c.Param("collId")
-	udfId := c.Param("udfId")
-
-	status := h.dataStore.DeleteUserDefinedFunction(databaseId, collectionId, udfId)
-	if status == datastore.StatusOk {
-		c.Status(http.StatusNoContent)
-		return
-	}
-
-	if status == datastore.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
-		return
-	}
-
-	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
-}
-
-func (h *Handlers) ReplaceUserDefinedFunction(c *gin.Context) {
-	databaseId := c.Param("databaseId")
-	collectionId := c.Param("collId")
-	udfId := c.Param("udfId")
-
-	var udf datastore.UserDefinedFunction
-	if err := c.BindJSON(&udf); err != nil {
-		c.IndentedJSON(http.StatusBadRequest, constants.BadRequestResponse)
-		return
-	}
-
-	status := h.dataStore.DeleteUserDefinedFunction(databaseId, collectionId, udfId)
-	if status == datastore.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
-		return
-	}
-
-	createdUdf, status := h.dataStore.CreateUserDefinedFunction(databaseId, collectionId, udf)
-	if status == datastore.Conflict {
-		c.IndentedJSON(http.StatusConflict, constants.ConflictResponse)
-		return
-	}
-
-	if status == datastore.StatusOk {
-		c.IndentedJSON(http.StatusOK, createdUdf)
-		return
-	}
-
-	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
-}
-
-func (h *Handlers) CreateUserDefinedFunction(c *gin.Context) {
-	databaseId := c.Param("databaseId")
-	collectionId := c.Param("collId")
-
-	var udf datastore.UserDefinedFunction
-	if err := c.BindJSON(&udf); err != nil {
-		c.IndentedJSON(http.StatusBadRequest, constants.BadRequestResponse)
-		return
-	}
-
-	createdUdf, status := h.dataStore.CreateUserDefinedFunction(databaseId, collectionId, udf)
-	if status == datastore.Conflict {
-		c.IndentedJSON(http.StatusConflict, constants.ConflictResponse)
-		return
-	}
-
-	if status == datastore.StatusOk {
-		c.IndentedJSON(http.StatusCreated, createdUdf)
-		return
-	}
-
-	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
 }

api/router.go

@@ -1,144 +1,98 @@
 package api
 
 import (
-	"context"
 	"fmt"
 	"net/http"
-	"sync"
-	"time"
 
 	"github.com/gin-gonic/gin"
+	"github.com/pikami/cosmium/api/config"
 	"github.com/pikami/cosmium/api/handlers"
 	"github.com/pikami/cosmium/api/handlers/middleware"
-	"github.com/pikami/cosmium/internal/datastore"
 	"github.com/pikami/cosmium/internal/logger"
 	tlsprovider "github.com/pikami/cosmium/internal/tls_provider"
 )
 
-var ginMux sync.Mutex
+func CreateRouter() *gin.Engine {
-
-func (s *ApiServer) CreateRouter(dataStore datastore.DataStore) {
-	routeHandlers := handlers.NewHandlers(dataStore, s.config)
-
-	ginMux.Lock()
-	gin.DefaultWriter = logger.InfoWriter()
-	gin.DefaultErrorWriter = logger.ErrorWriter()
-
-	if s.config.LogLevel != "debug" {
-		gin.SetMode(gin.ReleaseMode)
-	}
-	ginMux.Unlock()
-
 	router := gin.Default(func(e *gin.Engine) {
 		e.RedirectTrailingSlash = false
 	})
 
-	if s.config.LogLevel == "debug" {
+	if config.Config.Debug {
 		router.Use(middleware.RequestLogger())
 	}
 
-	router.Use(middleware.StripTrailingSlashes(router, s.config))
+	router.Use(middleware.StripTrailingSlashes(router))
-	router.Use(middleware.Authentication(s.config))
+	router.Use(middleware.Authentication())
 
-	router.GET("/dbs/:databaseId/colls/:collId/pkranges", routeHandlers.GetPartitionKeyRanges)
+	router.GET("/dbs/:databaseId/colls/:collId/pkranges", handlers.GetPartitionKeyRanges)
 
-	router.POST("/dbs/:databaseId/colls/:collId/docs", routeHandlers.DocumentsPost)
+	router.POST("/dbs/:databaseId/colls/:collId/docs", handlers.DocumentsPost)
-	router.GET("/dbs/:databaseId/colls/:collId/docs", routeHandlers.GetAllDocuments)
+	router.GET("/dbs/:databaseId/colls/:collId/docs", handlers.GetAllDocuments)
-	router.GET("/dbs/:databaseId/colls/:collId/docs/:docId", routeHandlers.GetDocument)
+	router.GET("/dbs/:databaseId/colls/:collId/docs/:docId", handlers.GetDocument)
-	router.PUT("/dbs/:databaseId/colls/:collId/docs/:docId", routeHandlers.ReplaceDocument)
+	router.PUT("/dbs/:databaseId/colls/:collId/docs/:docId", handlers.ReplaceDocument)
-	router.PATCH("/dbs/:databaseId/colls/:collId/docs/:docId", routeHandlers.PatchDocument)
+	router.PATCH("/dbs/:databaseId/colls/:collId/docs/:docId", handlers.PatchDocument)
-	router.DELETE("/dbs/:databaseId/colls/:collId/docs/:docId", routeHandlers.DeleteDocument)
+	router.DELETE("/dbs/:databaseId/colls/:collId/docs/:docId", handlers.DeleteDocument)
 
-	router.POST("/dbs/:databaseId/colls", routeHandlers.CreateCollection)
+	router.POST("/dbs/:databaseId/colls", handlers.CreateCollection)
-	router.GET("/dbs/:databaseId/colls", routeHandlers.GetAllCollections)
+	router.GET("/dbs/:databaseId/colls", handlers.GetAllCollections)
-	router.GET("/dbs/:databaseId/colls/:collId", routeHandlers.GetCollection)
+	router.GET("/dbs/:databaseId/colls/:collId", handlers.GetCollection)
-	router.DELETE("/dbs/:databaseId/colls/:collId", routeHandlers.DeleteCollection)
+	router.DELETE("/dbs/:databaseId/colls/:collId", handlers.DeleteCollection)
 
-	router.POST("/dbs", routeHandlers.CreateDatabase)
+	router.POST("/dbs", handlers.CreateDatabase)
-	router.GET("/dbs", routeHandlers.GetAllDatabases)
+	router.GET("/dbs", handlers.GetAllDatabases)
-	router.GET("/dbs/:databaseId", routeHandlers.GetDatabase)
+	router.GET("/dbs/:databaseId", handlers.GetDatabase)
-	router.DELETE("/dbs/:databaseId", routeHandlers.DeleteDatabase)
+	router.DELETE("/dbs/:databaseId", handlers.DeleteDatabase)
 
-	router.POST("/dbs/:databaseId/colls/:collId/triggers", routeHandlers.CreateTrigger)
+	router.GET("/dbs/:databaseId/colls/:collId/udfs", handlers.GetAllUserDefinedFunctions)
-	router.GET("/dbs/:databaseId/colls/:collId/triggers", routeHandlers.GetAllTriggers)
+	router.GET("/dbs/:databaseId/colls/:collId/sprocs", handlers.GetAllStoredProcedures)
-	router.GET("/dbs/:databaseId/colls/:collId/triggers/:triggerId", routeHandlers.GetTrigger)
+	router.GET("/dbs/:databaseId/colls/:collId/triggers", handlers.GetAllTriggers)
-	router.PUT("/dbs/:databaseId/colls/:collId/triggers/:triggerId", routeHandlers.ReplaceTrigger)
-	router.DELETE("/dbs/:databaseId/colls/:collId/triggers/:triggerId", routeHandlers.DeleteTrigger)
-
-	router.POST("/dbs/:databaseId/colls/:collId/sprocs", routeHandlers.CreateStoredProcedure)
-	router.GET("/dbs/:databaseId/colls/:collId/sprocs", routeHandlers.GetAllStoredProcedures)
-	router.GET("/dbs/:databaseId/colls/:collId/sprocs/:sprocId", routeHandlers.GetStoredProcedure)
-	router.PUT("/dbs/:databaseId/colls/:collId/sprocs/:sprocId", routeHandlers.ReplaceStoredProcedure)
-	router.DELETE("/dbs/:databaseId/colls/:collId/sprocs/:sprocId", routeHandlers.DeleteStoredProcedure)
-
-	router.POST("/dbs/:databaseId/colls/:collId/udfs", routeHandlers.CreateUserDefinedFunction)
-	router.GET("/dbs/:databaseId/colls/:collId/udfs", routeHandlers.GetAllUserDefinedFunctions)
-	router.GET("/dbs/:databaseId/colls/:collId/udfs/:udfId", routeHandlers.GetUserDefinedFunction)
-	router.PUT("/dbs/:databaseId/colls/:collId/udfs/:udfId", routeHandlers.ReplaceUserDefinedFunction)
-	router.DELETE("/dbs/:databaseId/colls/:collId/udfs/:udfId", routeHandlers.DeleteUserDefinedFunction)
 
 	router.GET("/offers", handlers.GetOffers)
-	router.GET("/", routeHandlers.GetServerInfo)
+	router.GET("/", handlers.GetServerInfo)
 
-	router.GET("/cosmium/export", routeHandlers.CosmiumExport)
+	router.GET("/cosmium/export", handlers.CosmiumExport)
 
-	routeHandlers.RegisterExplorerHandlers(router)
+	handlers.RegisterExplorerHandlers(router)
 
-	s.router = router
+	return router
 }
 
-func (s *ApiServer) Start() error {
+func StartAPI() {
-	listenAddress := fmt.Sprintf(":%d", s.config.Port)
+	if !config.Config.Debug {
-	s.isActive = true
+		gin.SetMode(gin.ReleaseMode)
+	}
 
+	router := CreateRouter()
+	listenAddress := fmt.Sprintf(":%d", config.Config.Port)
+
+	if config.Config.TLS_CertificatePath != "" && config.Config.TLS_CertificateKey != "" {
+		err := router.RunTLS(
+			listenAddress,
+			config.Config.TLS_CertificatePath,
+			config.Config.TLS_CertificateKey)
+		if err != nil {
+			logger.Error("Failed to start HTTPS server:", err)
+		}
+
+		return
+	}
+
+	if config.Config.DisableTls {
+		router.Run(listenAddress)
+	}
+
+	tlsConfig := tlsprovider.GetDefaultTlsConfig()
 	server := &http.Server{
 		Addr:      listenAddress,
-		Handler: s.router.Handler(),
+		Handler:   router.Handler(),
+		TLSConfig: tlsConfig,
 	}
 
-	errChan := make(chan error, 1)
+	logger.Infof("Listening and serving HTTPS on %s\n", server.Addr)
-
+	err := server.ListenAndServeTLS("", "")
-	go func() {
-		<-s.stopServer
-		logger.InfoLn("Shutting down server...")
-		err := server.Shutdown(context.TODO())
 	if err != nil {
-			logger.ErrorLn("Failed to shutdown server:", err)
+		logger.Error("Failed to start HTTPS server:", err)
-		}
-		s.onServerShutdown <- true
-	}()
-
-	go func() {
-		var err error
-		if s.config.DisableTls {
-			logger.Infof("Listening and serving HTTP on %s\n", server.Addr)
-			err = server.ListenAndServe()
-		} else if s.config.TLS_CertificatePath != "" && s.config.TLS_CertificateKey != "" {
-			logger.Infof("Listening and serving HTTPS on %s\n", server.Addr)
-			err = server.ListenAndServeTLS(
-				s.config.TLS_CertificatePath,
-				s.config.TLS_CertificateKey)
-		} else {
-			tlsConfig := tlsprovider.GetDefaultTlsConfig()
-			server.TLSConfig = tlsConfig
-
-			logger.Infof("Listening and serving HTTPS on %s\n", server.Addr)
-			err = server.ListenAndServeTLS("", "")
 	}
 
-		if err != nil && err != http.ErrServerClosed {
+	router.Run()
-			logger.ErrorLn("Failed to start server:", err)
-			errChan <- err
-		} else {
-			errChan <- nil
-		}
-		s.isActive = false
-	}()
-
-	select {
-	case err := <-errChan:
-		return err
-	case <-time.After(50 * time.Millisecond):
-		return nil
-	}
 }

api/tests/authentication_test.go

@@ -2,24 +2,27 @@ package tests_test
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"io"
 	"net/http"
 	"testing"
 
+	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
 	"github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos"
 	"github.com/pikami/cosmium/api/config"
+	"github.com/pikami/cosmium/internal/repositories"
 	"github.com/stretchr/testify/assert"
 )
 
 func Test_Authentication(t *testing.T) {
 	ts := runTestServer()
-	defer ts.Server.Close()
+	defer ts.Close()
 
 	t.Run("Should get 200 when correct account key is used", func(t *testing.T) {
-		ts.DataStore.DeleteDatabase(testDatabaseName)
+		repositories.DeleteDatabase(testDatabaseName)
 		client, err := azcosmos.NewClientFromConnectionString(
-			formatConnectionString(ts.URL, config.DefaultAccountKey),
+			fmt.Sprintf("AccountEndpoint=%s;AccountKey=%s", ts.URL, config.DefaultAccountKey),
 			&azcosmos.ClientOptions{},
 		)
 		assert.Nil(t, err)
@@ -32,10 +35,28 @@ func Test_Authentication(t *testing.T) {
 		assert.Equal(t, createResponse.DatabaseProperties.ID, testDatabaseName)
 	})
 
-	t.Run("Should get 401 when wrong account key is used", func(t *testing.T) {
+	t.Run("Should get 200 when wrong account key is used, but authentication is dissabled", func(t *testing.T) {
-		ts.DataStore.DeleteDatabase(testDatabaseName)
+		config.Config.DisableAuth = true
+		repositories.DeleteDatabase(testDatabaseName)
 		client, err := azcosmos.NewClientFromConnectionString(
-			formatConnectionString(ts.URL, "AAAA"),
+			fmt.Sprintf("AccountEndpoint=%s;AccountKey=%s", ts.URL, "AAAA"),
+			&azcosmos.ClientOptions{},
+		)
+		assert.Nil(t, err)
+
+		createResponse, err := client.CreateDatabase(
+			context.TODO(),
+			azcosmos.DatabaseProperties{ID: testDatabaseName},
+			&azcosmos.CreateDatabaseOptions{})
+		assert.Nil(t, err)
+		assert.Equal(t, createResponse.DatabaseProperties.ID, testDatabaseName)
+		config.Config.DisableAuth = false
+	})
+
+	t.Run("Should get 401 when wrong account key is used", func(t *testing.T) {
+		repositories.DeleteDatabase(testDatabaseName)
+		client, err := azcosmos.NewClientFromConnectionString(
+			fmt.Sprintf("AccountEndpoint=%s;AccountKey=%s", ts.URL, "AAAA"),
 			&azcosmos.ClientOptions{},
 		)
 		assert.Nil(t, err)
@@ -45,7 +66,12 @@ func Test_Authentication(t *testing.T) {
 			azcosmos.DatabaseProperties{ID: testDatabaseName},
 			&azcosmos.CreateDatabaseOptions{})
 
-		assert.Contains(t, err.Error(), "401 Unauthorized")
+		var respErr *azcore.ResponseError
+		if errors.As(err, &respErr) {
+			assert.Equal(t, respErr.StatusCode, http.StatusUnauthorized)
+		} else {
+			panic(err)
+		}
 	})
 
 	t.Run("Should allow unauthorized requests to /_explorer", func(t *testing.T) {
@@ -59,33 +85,3 @@ func Test_Authentication(t *testing.T) {
 		assert.Contains(t, string(responseBody), "BACKEND_ENDPOINT")
 	})
 }
-
-func Test_Authentication_Disabled(t *testing.T) {
-	ts := runTestServerCustomConfig(&config.ServerConfig{
-		AccountKey:              config.DefaultAccountKey,
-		ExplorerPath:            "/tmp/nothing",
-		ExplorerBaseUrlLocation: config.ExplorerBaseUrlLocation,
-		DisableAuth:             true,
-	})
-	defer ts.Server.Close()
-
-	t.Run("Should get 200 when wrong account key is used, but authentication is dissabled", func(t *testing.T) {
-		ts.DataStore.DeleteDatabase(testDatabaseName)
-		client, err := azcosmos.NewClientFromConnectionString(
-			formatConnectionString(ts.URL, "AAAA"),
-			&azcosmos.ClientOptions{},
-		)
-		assert.Nil(t, err)
-
-		createResponse, err := client.CreateDatabase(
-			context.TODO(),
-			azcosmos.DatabaseProperties{ID: testDatabaseName},
-			&azcosmos.CreateDatabaseOptions{})
-		assert.Nil(t, err)
-		assert.Equal(t, createResponse.DatabaseProperties.ID, testDatabaseName)
-	})
-}
-
-func formatConnectionString(endpoint, key string) string {
-	return fmt.Sprintf("AccountEndpoint=%s;AccountKey=%s", endpoint, key)
-}

api/tests/collections_test.go

@@ -3,29 +3,33 @@ package tests_test
 import (
 	"context"
 	"errors"
+	"fmt"
 	"net/http"
 	"testing"
 
 	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
 	"github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos"
-	"github.com/pikami/cosmium/internal/datastore"
+	"github.com/pikami/cosmium/api/config"
+	"github.com/pikami/cosmium/internal/repositories"
+	repositorymodels "github.com/pikami/cosmium/internal/repository_models"
 	"github.com/stretchr/testify/assert"
 )
 
 func Test_Collections(t *testing.T) {
-	presets := []testPreset{PresetJsonStore, PresetBadgerStore}
+	ts := runTestServer()
+	defer ts.Close()
 
-	setUp := func(ts *TestServer, client *azcosmos.Client) *azcosmos.DatabaseClient {
+	client, err := azcosmos.NewClientFromConnectionString(
-		ts.DataStore.CreateDatabase(datastore.Database{ID: testDatabaseName})
+		fmt.Sprintf("AccountEndpoint=%s;AccountKey=%s", ts.URL, config.Config.AccountKey),
+		&azcosmos.ClientOptions{},
+	)
+	assert.Nil(t, err)
+
+	repositories.CreateDatabase(repositorymodels.Database{ID: testDatabaseName})
 	databaseClient, err := client.NewDatabase(testDatabaseName)
 	assert.Nil(t, err)
 
-		return databaseClient
+	t.Run("Collection Create", func(t *testing.T) {
-	}
-
-	runTestsWithPresets(t, "Collection Create", presets, func(t *testing.T, ts *TestServer, client *azcosmos.Client) {
-		databaseClient := setUp(ts, client)
-
 		t.Run("Should create collection", func(t *testing.T) {
 			createResponse, err := databaseClient.CreateContainer(context.TODO(), azcosmos.ContainerProperties{
 				ID: testCollectionName,
@@ -36,7 +40,7 @@ func Test_Collections(t *testing.T) {
 		})
 
 		t.Run("Should return conflict when collection exists", func(t *testing.T) {
-			ts.DataStore.CreateCollection(testDatabaseName, datastore.Collection{
+			repositories.CreateCollection(testDatabaseName, repositorymodels.Collection{
 				ID: testCollectionName,
 			})
 
@@ -54,11 +58,9 @@ func Test_Collections(t *testing.T) {
 		})
 	})
 
-	runTestsWithPresets(t, "Collection Read", presets, func(t *testing.T, ts *TestServer, client *azcosmos.Client) {
+	t.Run("Collection Read", func(t *testing.T) {
-		databaseClient := setUp(ts, client)
-
 		t.Run("Should read collection", func(t *testing.T) {
-			ts.DataStore.CreateCollection(testDatabaseName, datastore.Collection{
+			repositories.CreateCollection(testDatabaseName, repositorymodels.Collection{
 				ID: testCollectionName,
 			})
 
@@ -72,7 +74,7 @@ func Test_Collections(t *testing.T) {
 		})
 
 		t.Run("Should return not found when collection does not exist", func(t *testing.T) {
-			ts.DataStore.DeleteCollection(testDatabaseName, testCollectionName)
+			repositories.DeleteCollection(testDatabaseName, testCollectionName)
 
 			collectionResponse, err := databaseClient.NewContainer(testCollectionName)
 			assert.Nil(t, err)
@@ -89,11 +91,9 @@ func Test_Collections(t *testing.T) {
 		})
 	})
 
-	runTestsWithPresets(t, "Collection Delete", presets, func(t *testing.T, ts *TestServer, client *azcosmos.Client) {
+	t.Run("Collection Delete", func(t *testing.T) {
-		databaseClient := setUp(ts, client)
-
 		t.Run("Should delete collection", func(t *testing.T) {
-			ts.DataStore.CreateCollection(testDatabaseName, datastore.Collection{
+			repositories.CreateCollection(testDatabaseName, repositorymodels.Collection{
 				ID: testCollectionName,
 			})
 
@@ -106,7 +106,7 @@ func Test_Collections(t *testing.T) {
 		})
 
 		t.Run("Should return not found when collection does not exist", func(t *testing.T) {
-			ts.DataStore.DeleteCollection(testDatabaseName, testCollectionName)
+			repositories.DeleteCollection(testDatabaseName, testCollectionName)
 
 			collectionResponse, err := databaseClient.NewContainer(testCollectionName)
 			assert.Nil(t, err)

api/tests/config_test.go

@@ -1,64 +1,18 @@
 package tests_test
 
 import (
-	"fmt"
 	"net/http/httptest"
-	"testing"
 
-	"github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos"
 	"github.com/pikami/cosmium/api"
 	"github.com/pikami/cosmium/api/config"
-	"github.com/pikami/cosmium/internal/datastore"
-	badgerdatastore "github.com/pikami/cosmium/internal/datastore/badger_datastore"
-	jsondatastore "github.com/pikami/cosmium/internal/datastore/json_datastore"
-	"github.com/pikami/cosmium/internal/logger"
-	"github.com/stretchr/testify/assert"
 )
 
-type TestServer struct {
+func runTestServer() *httptest.Server {
-	Server    *httptest.Server
+	config.Config.AccountKey = config.DefaultAccountKey
-	DataStore datastore.DataStore
+	config.Config.ExplorerPath = "/tmp/nothing"
-	URL       string
+	config.Config.ExplorerBaseUrlLocation = config.ExplorerBaseUrlLocation
-}
 
-func getDefaultTestServerConfig() *config.ServerConfig {
+	return httptest.NewServer(api.CreateRouter())
-	return &config.ServerConfig{
-		AccountKey:              config.DefaultAccountKey,
-		ExplorerPath:            "/tmp/nothing",
-		ExplorerBaseUrlLocation: config.ExplorerBaseUrlLocation,
-		DataStore:               "json",
-	}
-}
-
-func runTestServerCustomConfig(configuration *config.ServerConfig) *TestServer {
-	var dataStore datastore.DataStore
-	switch configuration.DataStore {
-	case config.DataStoreBadger:
-		dataStore = badgerdatastore.NewBadgerDataStore(badgerdatastore.BadgerDataStoreOptions{})
-	default:
-		dataStore = jsondatastore.NewJsonDataStore(jsondatastore.JsonDataStoreOptions{})
-	}
-
-	api := api.NewApiServer(dataStore, configuration)
-
-	server := httptest.NewServer(api.GetRouter())
-
-	configuration.DatabaseEndpoint = server.URL
-
-	return &TestServer{
-		Server:    server,
-		DataStore: dataStore,
-		URL:       server.URL,
-	}
-}
-
-func runTestServer() *TestServer {
-	config := getDefaultTestServerConfig()
-
-	config.LogLevel = "debug"
-	logger.SetLogLevel(logger.LogLevelDebug)
-
-	return runTestServerCustomConfig(config)
 }
 
 const (
@@ -66,47 +20,3 @@ const (
 	testDatabaseName   = "test-db"
 	testCollectionName = "test-coll"
 )
-
-type testFunc func(t *testing.T, ts *TestServer, cosmosClient *azcosmos.Client)
-type testPreset string
-
-const (
-	PresetJsonStore   testPreset = "JsonDS"
-	PresetBadgerStore testPreset = "BadgerDS"
-)
-
-func runTestsWithPreset(t *testing.T, name string, testPreset testPreset, f testFunc) {
-	serverConfig := getDefaultTestServerConfig()
-
-	serverConfig.LogLevel = "debug"
-	logger.SetLogLevel(logger.LogLevelDebug)
-
-	switch testPreset {
-	case PresetBadgerStore:
-		serverConfig.DataStore = config.DataStoreBadger
-	case PresetJsonStore:
-		serverConfig.DataStore = config.DataStoreJson
-	}
-
-	ts := runTestServerCustomConfig(serverConfig)
-	defer ts.Server.Close()
-	defer ts.DataStore.Close()
-
-	client, err := azcosmos.NewClientFromConnectionString(
-		fmt.Sprintf("AccountEndpoint=%s;AccountKey=%s", ts.URL, config.DefaultAccountKey),
-		&azcosmos.ClientOptions{},
-	)
-	assert.Nil(t, err)
-
-	testName := fmt.Sprintf("%s_%s", testPreset, name)
-
-	t.Run(testName, func(t *testing.T) {
-		f(t, ts, client)
-	})
-}
-
-func runTestsWithPresets(t *testing.T, name string, testPresets []testPreset, f testFunc) {
-	for _, testPreset := range testPresets {
-		runTestsWithPreset(t, name, testPreset, f)
-	}
-}

api/tests/databases_test.go

@@ -3,21 +3,31 @@ package tests_test
 import (
 	"context"
 	"errors"
+	"fmt"
 	"net/http"
 	"testing"
 
 	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
 	"github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos"
-	"github.com/pikami/cosmium/internal/datastore"
+	"github.com/pikami/cosmium/api/config"
+	"github.com/pikami/cosmium/internal/repositories"
+	repositorymodels "github.com/pikami/cosmium/internal/repository_models"
 	"github.com/stretchr/testify/assert"
 )
 
 func Test_Databases(t *testing.T) {
-	presets := []testPreset{PresetJsonStore, PresetBadgerStore}
+	ts := runTestServer()
+	defer ts.Close()
 
-	runTestsWithPresets(t, "Database Create", presets, func(t *testing.T, ts *TestServer, client *azcosmos.Client) {
+	client, err := azcosmos.NewClientFromConnectionString(
+		fmt.Sprintf("AccountEndpoint=%s;AccountKey=%s", ts.URL, config.Config.AccountKey),
+		&azcosmos.ClientOptions{},
+	)
+	assert.Nil(t, err)
+
+	t.Run("Database Create", func(t *testing.T) {
 		t.Run("Should create database", func(t *testing.T) {
-			ts.DataStore.DeleteDatabase(testDatabaseName)
+			repositories.DeleteDatabase(testDatabaseName)
 
 			createResponse, err := client.CreateDatabase(context.TODO(), azcosmos.DatabaseProperties{
 				ID: testDatabaseName,
@@ -28,7 +38,7 @@ func Test_Databases(t *testing.T) {
 		})
 
 		t.Run("Should return conflict when database exists", func(t *testing.T) {
-			ts.DataStore.CreateDatabase(datastore.Database{
+			repositories.CreateDatabase(repositorymodels.Database{
 				ID: testDatabaseName,
 			})
 
@@ -46,9 +56,9 @@ func Test_Databases(t *testing.T) {
 		})
 	})
 
-	runTestsWithPresets(t, "Database Read", presets, func(t *testing.T, ts *TestServer, client *azcosmos.Client) {
+	t.Run("Database Read", func(t *testing.T) {
 		t.Run("Should read database", func(t *testing.T) {
-			ts.DataStore.CreateDatabase(datastore.Database{
+			repositories.CreateDatabase(repositorymodels.Database{
 				ID: testDatabaseName,
 			})
 
@@ -62,7 +72,7 @@ func Test_Databases(t *testing.T) {
 		})
 
 		t.Run("Should return not found when database does not exist", func(t *testing.T) {
-			ts.DataStore.DeleteDatabase(testDatabaseName)
+			repositories.DeleteDatabase(testDatabaseName)
 
 			databaseResponse, err := client.NewDatabase(testDatabaseName)
 			assert.Nil(t, err)
@@ -79,9 +89,9 @@ func Test_Databases(t *testing.T) {
 		})
 	})
 
-	runTestsWithPresets(t, "Database Delete", presets, func(t *testing.T, ts *TestServer, client *azcosmos.Client) {
+	t.Run("Database Delete", func(t *testing.T) {
 		t.Run("Should delete database", func(t *testing.T) {
-			ts.DataStore.CreateDatabase(datastore.Database{
+			repositories.CreateDatabase(repositorymodels.Database{
 				ID: testDatabaseName,
 			})
 
@@ -94,7 +104,7 @@ func Test_Databases(t *testing.T) {
 		})
 
 		t.Run("Should return not found when database does not exist", func(t *testing.T) {
-			ts.DataStore.DeleteDatabase(testDatabaseName)
+			repositories.DeleteDatabase(testDatabaseName)
 
 			databaseResponse, err := client.NewDatabase(testDatabaseName)
 			assert.Nil(t, err)

api/tests/documents_test.go

@@ -6,15 +6,15 @@ import (
 	"errors"
 	"fmt"
 	"net/http"
+	"net/http/httptest"
 	"reflect"
-	"sync"
 	"testing"
-	"time"
 
 	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
 	"github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos"
 	"github.com/pikami/cosmium/api/config"
-	"github.com/pikami/cosmium/internal/datastore"
+	"github.com/pikami/cosmium/internal/repositories"
+	repositorymodels "github.com/pikami/cosmium/internal/repository_models"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -53,9 +53,9 @@ func testCosmosQuery(t *testing.T,
 	}
 }
 
-func documents_InitializeDb(t *testing.T, ts *TestServer) *azcosmos.ContainerClient {
+func documents_InitializeDb(t *testing.T) (*httptest.Server, *azcosmos.ContainerClient) {
-	ts.DataStore.CreateDatabase(datastore.Database{ID: testDatabaseName})
+	repositories.CreateDatabase(repositorymodels.Database{ID: testDatabaseName})
-	ts.DataStore.CreateCollection(testDatabaseName, datastore.Collection{
+	repositories.CreateCollection(testDatabaseName, repositorymodels.Collection{
 		ID: testCollectionName,
 		PartitionKey: struct {
 			Paths   []string "json:\"paths\""
@@ -65,11 +65,13 @@ func documents_InitializeDb(t *testing.T, ts *TestServer) *azcosmos.ContainerCli
 			Paths: []string{"/pk"},
 		},
 	})
-	ts.DataStore.CreateDocument(testDatabaseName, testCollectionName, map[string]interface{}{"id": "12345", "pk": "123", "isCool": false, "arr": []int{1, 2, 3}})
+	repositories.CreateDocument(testDatabaseName, testCollectionName, map[string]interface{}{"id": "12345", "pk": "123", "isCool": false, "arr": []int{1, 2, 3}})
-	ts.DataStore.CreateDocument(testDatabaseName, testCollectionName, map[string]interface{}{"id": "67890", "pk": "456", "isCool": true, "arr": []int{6, 7, 8}})
+	repositories.CreateDocument(testDatabaseName, testCollectionName, map[string]interface{}{"id": "67890", "pk": "456", "isCool": true, "arr": []int{6, 7, 8}})
+
+	ts := runTestServer()
 
 	client, err := azcosmos.NewClientFromConnectionString(
-		fmt.Sprintf("AccountEndpoint=%s;AccountKey=%s", ts.URL, config.DefaultAccountKey),
+		fmt.Sprintf("AccountEndpoint=%s;AccountKey=%s", ts.URL, config.Config.AccountKey),
 		&azcosmos.ClientOptions{},
 	)
 	assert.Nil(t, err)
@@ -77,14 +79,12 @@ func documents_InitializeDb(t *testing.T, ts *TestServer) *azcosmos.ContainerCli
 	collectionClient, err := client.NewContainer(testDatabaseName, testCollectionName)
 	assert.Nil(t, err)
 
-	return collectionClient
+	return ts, collectionClient
 }
 
 func Test_Documents(t *testing.T) {
-	presets := []testPreset{PresetJsonStore, PresetBadgerStore}
+	ts, collectionClient := documents_InitializeDb(t)
-
+	defer ts.Close()
-	runTestsWithPresets(t, "Test_Documents", presets, func(t *testing.T, ts *TestServer, client *azcosmos.Client) {
-		collectionClient := documents_InitializeDb(t, ts)
 
 	t.Run("Should query document", func(t *testing.T) {
 		testCosmosQuery(t, collectionClient,
@@ -147,21 +147,6 @@ func Test_Documents(t *testing.T) {
 		)
 	})
 
-		t.Run("Should query document with query parameters as accessor", func(t *testing.T) {
-			testCosmosQuery(t, collectionClient,
-				`select c.id
-				FROM c
-				WHERE c[@param]="67890"
-				ORDER BY c.id`,
-				[]azcosmos.QueryParameter{
-					{Name: "@param", Value: "id"},
-				},
-				[]interface{}{
-					map[string]interface{}{"id": "67890"},
-				},
-			)
-		})
-
 	t.Run("Should query array accessor", func(t *testing.T) {
 		testCosmosQuery(t, collectionClient,
 			`SELECT c.id,
@@ -177,71 +162,19 @@ func Test_Documents(t *testing.T) {
 			},
 		)
 	})
-
-		t.Run("Should handle parallel writes", func(t *testing.T) {
-			var wg sync.WaitGroup
-			rutineCount := 100
-			results := make(chan error, rutineCount)
-
-			createCall := func(i int) {
-				defer wg.Done()
-				item := map[string]interface{}{
-					"id":  fmt.Sprintf("id-%d", i),
-					"pk":  fmt.Sprintf("pk-%d", i),
-					"val": i,
-				}
-				bytes, err := json.Marshal(item)
-				if err != nil {
-					results <- err
-					return
 }
 
-				ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+func Test_Documents_Patch(t *testing.T) {
-				defer cancel()
+	ts, collectionClient := documents_InitializeDb(t)
-
+	defer ts.Close()
-				_, err = collectionClient.CreateItem(
-					ctx,
-					azcosmos.PartitionKey{},
-					bytes,
-					&azcosmos.ItemOptions{
-						EnableContentResponseOnWrite: false,
-					},
-				)
-				results <- err
-
-				collectionClient.ReadItem(ctx, azcosmos.PartitionKey{}, fmt.Sprintf("id-%d", i), nil)
-				collectionClient.DeleteItem(ctx, azcosmos.PartitionKey{}, fmt.Sprintf("id-%d", i), nil)
-			}
-
-			for i := 0; i < rutineCount; i++ {
-				wg.Add(1)
-				go createCall(i)
-			}
-
-			wg.Wait()
-			close(results)
-
-			for err := range results {
-				if err != nil {
-					t.Errorf("Error creating item: %v", err)
-				}
-			}
-		})
-	})
-
-	runTestsWithPresets(t, "Test_Documents_Patch", presets, func(t *testing.T, ts *TestServer, client *azcosmos.Client) {
-		collectionClient := documents_InitializeDb(t, ts)
 
 	t.Run("Should PATCH document", func(t *testing.T) {
 		context := context.TODO()
-			expectedData := map[string]interface{}{"id": "67890", "pk": "666", "newField": "newValue", "incr": 15., "setted": "isSet"}
+		expectedData := map[string]interface{}{"id": "67890", "pk": "456", "newField": "newValue"}
 
 		patch := azcosmos.PatchOperations{}
 		patch.AppendAdd("/newField", "newValue")
-			patch.AppendIncrement("/incr", 15)
 		patch.AppendRemove("/isCool")
-			patch.AppendReplace("/pk", "666")
-			patch.AppendSet("/setted", "isSet")
 
 		itemResponse, err := collectionClient.PatchItem(
 			context,
@@ -254,15 +187,13 @@ func Test_Documents(t *testing.T) {
 		)
 		assert.Nil(t, err)
 
-			var itemResponseBody map[string]interface{}
+		var itemResponseBody map[string]string
 		json.Unmarshal(itemResponse.Value, &itemResponseBody)
 
 		assert.Equal(t, expectedData["id"], itemResponseBody["id"])
 		assert.Equal(t, expectedData["pk"], itemResponseBody["pk"])
 		assert.Empty(t, itemResponseBody["isCool"])
 		assert.Equal(t, expectedData["newField"], itemResponseBody["newField"])
-			assert.Equal(t, expectedData["incr"], itemResponseBody["incr"])
-			assert.Equal(t, expectedData["setted"], itemResponseBody["setted"])
 	})
 
 	t.Run("Should not allow to PATCH document ID", func(t *testing.T) {
@@ -376,140 +307,5 @@ func Test_Documents(t *testing.T) {
 		assert.NotNil(t, r)
 		assert.Nil(t, err2)
 	})
-	})
 
-	runTestsWithPresets(t, "Test_Documents_TransactionalBatch", presets, func(t *testing.T, ts *TestServer, client *azcosmos.Client) {
-		collectionClient := documents_InitializeDb(t, ts)
-
-		t.Run("Should execute CREATE transactional batch", func(t *testing.T) {
-			context := context.TODO()
-			batch := collectionClient.NewTransactionalBatch(azcosmos.NewPartitionKeyString("pk"))
-
-			newItem := map[string]interface{}{
-				"id": "678901",
-			}
-			bytes, err := json.Marshal(newItem)
-			assert.Nil(t, err)
-
-			batch.CreateItem(bytes, nil)
-			response, err := collectionClient.ExecuteTransactionalBatch(context, batch, &azcosmos.TransactionalBatchOptions{})
-			assert.Nil(t, err)
-			assert.True(t, response.Success)
-			assert.Equal(t, 1, len(response.OperationResults))
-
-			operationResponse := response.OperationResults[0]
-			assert.NotNil(t, operationResponse)
-			assert.NotNil(t, operationResponse.ResourceBody)
-			assert.Equal(t, int32(http.StatusCreated), operationResponse.StatusCode)
-
-			var itemResponseBody map[string]interface{}
-			json.Unmarshal(operationResponse.ResourceBody, &itemResponseBody)
-			assert.Equal(t, newItem["id"], itemResponseBody["id"])
-
-			createdDoc, _ := ts.DataStore.GetDocument(testDatabaseName, testCollectionName, newItem["id"].(string))
-			assert.Equal(t, newItem["id"], createdDoc["id"])
-		})
-
-		t.Run("Should execute DELETE transactional batch", func(t *testing.T) {
-			context := context.TODO()
-			batch := collectionClient.NewTransactionalBatch(azcosmos.NewPartitionKeyString("pk"))
-
-			batch.DeleteItem("12345", nil)
-			response, err := collectionClient.ExecuteTransactionalBatch(context, batch, &azcosmos.TransactionalBatchOptions{})
-			assert.Nil(t, err)
-			assert.True(t, response.Success)
-			assert.Equal(t, 1, len(response.OperationResults))
-
-			operationResponse := response.OperationResults[0]
-			assert.NotNil(t, operationResponse)
-			assert.Equal(t, int32(http.StatusNoContent), operationResponse.StatusCode)
-
-			_, status := ts.DataStore.GetDocument(testDatabaseName, testCollectionName, "12345")
-			assert.Equal(t, datastore.StatusNotFound, int(status))
-		})
-
-		t.Run("Should execute REPLACE transactional batch", func(t *testing.T) {
-			context := context.TODO()
-			batch := collectionClient.NewTransactionalBatch(azcosmos.NewPartitionKeyString("pk"))
-
-			newItem := map[string]interface{}{
-				"id": "67890",
-				"pk": "666",
-			}
-			bytes, err := json.Marshal(newItem)
-			assert.Nil(t, err)
-
-			batch.ReplaceItem("67890", bytes, nil)
-			response, err := collectionClient.ExecuteTransactionalBatch(context, batch, &azcosmos.TransactionalBatchOptions{})
-			assert.Nil(t, err)
-			assert.True(t, response.Success)
-			assert.Equal(t, 1, len(response.OperationResults))
-
-			operationResponse := response.OperationResults[0]
-			assert.NotNil(t, operationResponse)
-			assert.NotNil(t, operationResponse.ResourceBody)
-			assert.Equal(t, int32(http.StatusCreated), operationResponse.StatusCode)
-
-			var itemResponseBody map[string]interface{}
-			json.Unmarshal(operationResponse.ResourceBody, &itemResponseBody)
-			assert.Equal(t, newItem["id"], itemResponseBody["id"])
-			assert.Equal(t, newItem["pk"], itemResponseBody["pk"])
-
-			updatedDoc, _ := ts.DataStore.GetDocument(testDatabaseName, testCollectionName, newItem["id"].(string))
-			assert.Equal(t, newItem["id"], updatedDoc["id"])
-			assert.Equal(t, newItem["pk"], updatedDoc["pk"])
-		})
-
-		t.Run("Should execute UPSERT transactional batch", func(t *testing.T) {
-			context := context.TODO()
-			batch := collectionClient.NewTransactionalBatch(azcosmos.NewPartitionKeyString("pk"))
-
-			newItem := map[string]interface{}{
-				"id": "678901",
-				"pk": "666",
-			}
-			bytes, err := json.Marshal(newItem)
-			assert.Nil(t, err)
-
-			batch.UpsertItem(bytes, nil)
-			response, err := collectionClient.ExecuteTransactionalBatch(context, batch, &azcosmos.TransactionalBatchOptions{})
-			assert.Nil(t, err)
-			assert.True(t, response.Success)
-			assert.Equal(t, 1, len(response.OperationResults))
-
-			operationResponse := response.OperationResults[0]
-			assert.NotNil(t, operationResponse)
-			assert.NotNil(t, operationResponse.ResourceBody)
-			assert.Equal(t, int32(http.StatusCreated), operationResponse.StatusCode)
-
-			var itemResponseBody map[string]interface{}
-			json.Unmarshal(operationResponse.ResourceBody, &itemResponseBody)
-			assert.Equal(t, newItem["id"], itemResponseBody["id"])
-			assert.Equal(t, newItem["pk"], itemResponseBody["pk"])
-
-			updatedDoc, _ := ts.DataStore.GetDocument(testDatabaseName, testCollectionName, newItem["id"].(string))
-			assert.Equal(t, newItem["id"], updatedDoc["id"])
-			assert.Equal(t, newItem["pk"], updatedDoc["pk"])
-		})
-
-		t.Run("Should execute READ transactional batch", func(t *testing.T) {
-			context := context.TODO()
-			batch := collectionClient.NewTransactionalBatch(azcosmos.NewPartitionKeyString("pk"))
-
-			batch.ReadItem("67890", nil)
-			response, err := collectionClient.ExecuteTransactionalBatch(context, batch, &azcosmos.TransactionalBatchOptions{})
-			assert.Nil(t, err)
-			assert.True(t, response.Success)
-			assert.Equal(t, 1, len(response.OperationResults))
-
-			operationResponse := response.OperationResults[0]
-			assert.NotNil(t, operationResponse)
-			assert.NotNil(t, operationResponse.ResourceBody)
-			assert.Equal(t, int32(http.StatusOK), operationResponse.StatusCode)
-
-			var itemResponseBody map[string]interface{}
-			json.Unmarshal(operationResponse.ResourceBody, &itemResponseBody)
-			assert.Equal(t, "67890", itemResponseBody["id"])
-		})
-	})
 }

api/tests/documents_trailingslash_test.go

@@ -14,16 +14,15 @@ import (
 
 // Request document with trailing slash like python cosmosdb client does.
 func Test_Documents_Read_Trailing_Slash(t *testing.T) {
-	ts := runTestServer()
+	ts, _ := documents_InitializeDb(t)
-	documents_InitializeDb(t, ts)
+	defer ts.Close()
-	defer ts.Server.Close()
 
 	t.Run("Read doc with client that appends slash to path", func(t *testing.T) {
 		resourceIdTemplate := "dbs/%s/colls/%s/docs/%s"
 		path := fmt.Sprintf(resourceIdTemplate, testDatabaseName, testCollectionName, "12345")
 		testUrl := ts.URL + "/" + path + "/"
 		date := time.Now().Format(time.RFC1123)
-		signature := authentication.GenerateSignature("GET", "docs", path, date, config.DefaultAccountKey)
+		signature := authentication.GenerateSignature("GET", "docs", path, date, config.Config.AccountKey)
 		httpClient := &http.Client{}
 		req, _ := http.NewRequest("GET", testUrl, nil)
 		req.Header.Add("x-ms-date", date)

cmd/server/server.go

@@ -1,54 +0,0 @@
-package main
-
-import (
-	"os"
-	"os/signal"
-	"syscall"
-
-	"github.com/pikami/cosmium/api"
-	"github.com/pikami/cosmium/api/config"
-	"github.com/pikami/cosmium/internal/datastore"
-	badgerdatastore "github.com/pikami/cosmium/internal/datastore/badger_datastore"
-	jsondatastore "github.com/pikami/cosmium/internal/datastore/json_datastore"
-	"github.com/pikami/cosmium/internal/logger"
-)
-
-func main() {
-	configuration := config.ParseFlags()
-
-	var dataStore datastore.DataStore
-	switch configuration.DataStore {
-	case config.DataStoreBadger:
-		dataStore = badgerdatastore.NewBadgerDataStore(badgerdatastore.BadgerDataStoreOptions{
-			PersistDataFilePath: configuration.PersistDataFilePath,
-		})
-		logger.InfoLn("Using Badger data store")
-	default:
-		dataStore = jsondatastore.NewJsonDataStore(jsondatastore.JsonDataStoreOptions{
-			InitialDataFilePath: configuration.InitialDataFilePath,
-			PersistDataFilePath: configuration.PersistDataFilePath,
-		})
-		logger.InfoLn("Using in-memory data store")
-	}
-
-	server := api.NewApiServer(dataStore, &configuration)
-	err := server.Start()
-	if err != nil {
-		panic(err)
-	}
-
-	waitForExit(server, dataStore)
-}
-
-func waitForExit(server *api.ApiServer, dataStore datastore.DataStore) {
-	sigs := make(chan os.Signal, 1)
-	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
-
-	// Block until a exit signal is received
-	<-sigs
-
-	// Stop the server
-	server.Stop()
-
-	dataStore.Close()
-}

docs/COMPATIBILITY.md

@@ -18,8 +18,8 @@ Cosmium strives to support the core features of Cosmos DB, including:
 
 | Feature                       | Implemented |
 | ----------------------------- | ----------- |
-| Subqueries                    | Yes         |
+| Subqueries                    | No          |
-| Joins                         | Yes         |
+| Joins                         | No          |
 | Computed properties           | No          |
 | Coalesce operators            | No          |
 | Bitwise operators             | No          |
@@ -63,11 +63,9 @@ Cosmium strives to support the core features of Cosmos DB, including:
 ### Array Functions
 
 | Function       | Implemented |
-| ------------------ | ----------- |
+| -------------- | ----------- |
 | ARRAY_CONCAT   | Yes         |
-| ARRAY_CONTAINS     | Yes         |
+| ARRAY_CONTAINS | No          |
-| ARRAY_CONTAINS_ANY | Yes         |
-| ARRAY_CONTAINS_ALL | Yes         |
 | ARRAY_LENGTH   | Yes         |
 | ARRAY_SLICE    | Yes         |
 | CHOOSE         | No          |
@@ -79,7 +77,7 @@ Cosmium strives to support the core features of Cosmos DB, including:
 
 | Function | Implemented |
 | -------- | ----------- |
-| IIF      | Yes         |
+| IIF      | No          |
 
 ### Date and time Functions
 
@@ -204,19 +202,6 @@ Cosmium strives to support the core features of Cosmos DB, including:
 | IS_PRIMITIVE     | Yes         |
 | IS_STRING        | Yes         |
 
-### Transactional batch operations
-
-Note: There's actually no transaction here. Think of this as a 'bulk operation' that can partially succeed.
-
-| Operation | Implemented |
-| --------- | ----------- |
-| Create    | Yes         |
-| Delete    | Yes         |
-| Replace   | Yes         |
-| Upsert    | Yes         |
-| Read      | Yes         |
-| Patch     | No          |
-
 ## Known Differences
 
 While Cosmium aims to replicate the behavior of Cosmos DB as closely as possible, there are certain differences and limitations to be aware of:

go.mod

@@ -1,60 +1,47 @@
 module github.com/pikami/cosmium
 
-go 1.24.0
+go 1.21.6
 
 require (
-	github.com/Azure/azure-sdk-for-go/sdk/azcore v1.18.0
+	github.com/Azure/azure-sdk-for-go/sdk/azcore v1.9.2
-	github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos v1.4.0
+	github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos v0.3.6
-	github.com/cosmiumdev/json-patch/v5 v5.9.11
+	github.com/evanphx/json-patch/v5 v5.9.0
-	github.com/dgraph-io/badger/v4 v4.7.0
 	github.com/gin-gonic/gin v1.10.0
 	github.com/google/uuid v1.6.0
-	github.com/stretchr/testify v1.10.0
+	github.com/stretchr/testify v1.9.0
-	github.com/vmihailenco/msgpack/v5 v5.4.1
+	golang.org/x/exp v0.0.0-20240531132922-fd00a4e0eefc
-	golang.org/x/exp v0.0.0-20250506013437-ce4c2cf36ca6
 )
 
 require (
 	github.com/Azure/azure-sdk-for-go v68.0.0+incompatible // indirect
-	github.com/Azure/azure-sdk-for-go/sdk/internal v1.11.1 // indirect
+	github.com/Azure/azure-sdk-for-go/sdk/internal v1.5.2 // indirect
-	github.com/bytedance/sonic v1.13.2 // indirect
+	github.com/bytedance/sonic v1.11.8 // indirect
-	github.com/bytedance/sonic/loader v0.2.4 // indirect
+	github.com/bytedance/sonic/loader v0.1.1 // indirect
-	github.com/cespare/xxhash/v2 v2.3.0 // indirect
+	github.com/cloudwego/base64x v0.1.4 // indirect
-	github.com/cloudwego/base64x v0.1.5 // indirect
+	github.com/cloudwego/iasm v0.2.0 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/dgraph-io/ristretto/v2 v2.2.0 // indirect
+	github.com/gabriel-vasile/mimetype v1.4.4 // indirect
-	github.com/dustin/go-humanize v1.0.1 // indirect
+	github.com/gin-contrib/sse v0.1.0 // indirect
-	github.com/gabriel-vasile/mimetype v1.4.9 // indirect
-	github.com/gin-contrib/sse v1.1.0 // indirect
-	github.com/go-logr/logr v1.4.2 // indirect
-	github.com/go-logr/stdr v1.2.2 // indirect
 	github.com/go-playground/locales v0.14.1 // indirect
 	github.com/go-playground/universal-translator v0.18.1 // indirect
-	github.com/go-playground/validator/v10 v10.26.0 // indirect
+	github.com/go-playground/validator/v10 v10.21.0 // indirect
-	github.com/goccy/go-json v0.10.5 // indirect
+	github.com/goccy/go-json v0.10.3 // indirect
-	github.com/google/flatbuffers v25.2.10+incompatible // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
-	github.com/klauspost/compress v1.18.0 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.7 // indirect
-	github.com/klauspost/cpuid/v2 v2.2.10 // indirect
 	github.com/leodido/go-urn v1.4.0 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
-	github.com/pelletier/go-toml/v2 v2.2.4 // indirect
+	github.com/pelletier/go-toml/v2 v2.2.2 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
 	github.com/ugorji/go/codec v1.2.12 // indirect
-	github.com/vmihailenco/tagparser/v2 v2.0.0 // indirect
+	golang.org/x/arch v0.8.0 // indirect
-	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
+	golang.org/x/crypto v0.23.0 // indirect
-	go.opentelemetry.io/otel v1.35.0 // indirect
+	golang.org/x/net v0.25.0 // indirect
-	go.opentelemetry.io/otel/metric v1.35.0 // indirect
+	golang.org/x/sys v0.20.0 // indirect
-	go.opentelemetry.io/otel/trace v1.35.0 // indirect
+	golang.org/x/text v0.15.0 // indirect
-	golang.org/x/arch v0.17.0 // indirect
+	google.golang.org/protobuf v1.34.1 // indirect
-	golang.org/x/crypto v0.38.0 // indirect
-	golang.org/x/net v0.40.0 // indirect
-	golang.org/x/sys v0.33.0 // indirect
-	golang.org/x/text v0.25.0 // indirect
-	google.golang.org/protobuf v1.36.6 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -1,102 +1,57 @@
 github.com/Azure/azure-sdk-for-go v68.0.0+incompatible h1:fcYLmCpyNYRnvJbPerq7U0hS+6+I79yEDJBqVNcqUzU=
 github.com/Azure/azure-sdk-for-go v68.0.0+incompatible/go.mod h1:9XXNKU+eRnpl9moKnB4QOLf1HestfXbmab5FXxiDBjc=
-github.com/Azure/azure-sdk-for-go/sdk/azcore v1.17.0 h1:g0EZJwz7xkXQiZAI5xi9f3WWFYBlX1CPTrR+NDToRkQ=
+github.com/Azure/azure-sdk-for-go/sdk/azcore v1.9.2 h1:c4k2FIYIh4xtwqrQwV0Ct1v5+ehlNXj5NI/MWVsiTkQ=
-github.com/Azure/azure-sdk-for-go/sdk/azcore v1.17.0/go.mod h1:XCW7KnZet0Opnr7HccfUw1PLc4CjHqpcaxW8DHklNkQ=
+github.com/Azure/azure-sdk-for-go/sdk/azcore v1.9.2/go.mod h1:5FDJtLEO/GxwNgUxbwrY3LP0pEoThTQJtk2oysdXHxM=
-github.com/Azure/azure-sdk-for-go/sdk/azcore v1.18.0 h1:Gt0j3wceWMwPmiazCa8MzMA0MfhmPIz0Qp0FJ6qcM0U=
+github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.0.0 h1:Yoicul8bnVdQrhDMTHxdEckRGX01XvwXDHUT9zYZ3k0=
-github.com/Azure/azure-sdk-for-go/sdk/azcore v1.18.0/go.mod h1:Ot/6aikWnKWi4l9QB7qVSwa8iMphQNqkWALMoNT3rzM=
+github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.0.0/go.mod h1:+6sju8gk8FRmSajX3Oz4G5Gm7P+mbqE9FVaXXFYTkCM=
-github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.8.0 h1:B/dfvscEQtew9dVuoxqxrUKKv8Ih2f55PydknDamU+g=
+github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos v0.3.6 h1:oBqQLSI1pZwGOdXJAoJJSzmff9tlfD4KroVfjQQmd0g=
-github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.8.0/go.mod h1:fiPSssYvltE08HJchL04dOy+RD4hgrjph0cwGGMntdI=
+github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos v0.3.6/go.mod h1:Beh5cHIXJ0oWEDWk9lNFtuklCojLLQ5hl+LqSNTTs0I=
-github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.8.2 h1:F0gBpfdPLGsw+nsgk6aqqkZS1jiixa5WwFe3fk/T3Ys=
+github.com/Azure/azure-sdk-for-go/sdk/internal v1.5.2 h1:LqbJ/WzJUwBf8UiaSzgX7aMclParm9/5Vgp+TY51uBQ=
-github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos v1.3.0 h1:RGcdpSElvcXCwxydI0xzOBu1Gvp88OoiTGfbtO/z1m0=
+github.com/Azure/azure-sdk-for-go/sdk/internal v1.5.2/go.mod h1:yInRyqWXAuaPrgI7p70+lDDgh3mlBohis29jGMISnmc=
-github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos v1.3.0/go.mod h1:YwUyrNUtcZcibA99JcfCP6UUp95VVQKO2MJfBzgJDwA=
+github.com/AzureAD/microsoft-authentication-library-for-go v0.4.0 h1:WVsrXCnHlDDX8ls+tootqRE87/hL9S/g4ewig9RsD/c=
-github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos v1.4.0 h1:TSaH6Lj0m8bDr4vX1+LC1KLQTnLzZb3tOxrx/PLqw+c=
+github.com/AzureAD/microsoft-authentication-library-for-go v0.4.0/go.mod h1:Vt9sXTKwMyGcOxSmLDMnGPgqsUg7m8pe215qMLrDXw4=
-github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos v1.4.0/go.mod h1:Krtog/7tz27z75TwM5cIS8bxEH4dcBUezcq+kGVeZEo=
+github.com/bytedance/sonic v1.11.8 h1:Zw/j1KfiS+OYTi9lyB3bb0CFxPJVkM17k1wyDG32LRA=
-github.com/Azure/azure-sdk-for-go/sdk/internal v1.10.0 h1:ywEEhmNahHBihViHepv3xPBn1663uRv2t2q/ESv9seY=
+github.com/bytedance/sonic v1.11.8/go.mod h1:LysEHSvpvDySVdC2f87zGWf6CIKJcAvqab1ZaiQtds4=
-github.com/Azure/azure-sdk-for-go/sdk/internal v1.10.0/go.mod h1:iZDifYGJTIgIIkYRNWPENUnqx6bJ2xnSDFI2tjwZNuY=
+github.com/bytedance/sonic/loader v0.1.1 h1:c+e5Pt1k/cy5wMveRDyk2X4B9hF4g7an8N3zCYjJFNM=
-github.com/Azure/azure-sdk-for-go/sdk/internal v1.11.1 h1:FPKJS1T+clwv+OLGt13a8UjqeRuh0O4SJ3lUriThc+4=
-github.com/Azure/azure-sdk-for-go/sdk/internal v1.11.1/go.mod h1:j2chePtV91HrC22tGoRX3sGY42uF13WzmmV80/OdVAA=
-github.com/AzureAD/microsoft-authentication-library-for-go v1.3.2 h1:kYRSnvJju5gYVyhkij+RTJ/VR6QIUaCfWeaFm2ycsjQ=
-github.com/AzureAD/microsoft-authentication-library-for-go v1.3.2/go.mod h1:wP83P5OoQ5p6ip3ScPr0BAq0BvuPAvacpEuSzyouqAI=
-github.com/AzureAD/microsoft-authentication-library-for-go v1.4.2 h1:oygO0locgZJe7PpYPXT5A29ZkwJaPqcva7BVeemZOZs=
-github.com/bytedance/sonic v1.13.1 h1:Jyd5CIvdFnkOWuKXr+wm4Nyk2h0yAFsr8ucJgEasO3g=
-github.com/bytedance/sonic v1.13.1/go.mod h1:o68xyaF9u2gvVBuGHPlUVCy+ZfmNNO5ETf1+KgkJhz4=
-github.com/bytedance/sonic v1.13.2 h1:8/H1FempDZqC4VqjptGo14QQlJx8VdZJegxs6wwfqpQ=
-github.com/bytedance/sonic v1.13.2/go.mod h1:o68xyaF9u2gvVBuGHPlUVCy+ZfmNNO5ETf1+KgkJhz4=
 github.com/bytedance/sonic/loader v0.1.1/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
-github.com/bytedance/sonic/loader v0.2.4 h1:ZWCw4stuXUsn1/+zQDqeE7JKP+QO47tz7QCNan80NzY=
+github.com/cloudwego/base64x v0.1.4 h1:jwCgWpFanWmN8xoIUHa2rtzmkd5J2plF/dnLS6Xd/0Y=
-github.com/bytedance/sonic/loader v0.2.4/go.mod h1:N8A3vUdtUebEY2/VQC0MyhYeKUFosQU6FxH2JmUe6VI=
+github.com/cloudwego/base64x v0.1.4/go.mod h1:0zlkT4Wn5C6NdauXdJRhSKRlJvmclQ1hhJgA0rcu/8w=
-github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
+github.com/cloudwego/iasm v0.2.0 h1:1KNIy1I1H9hNNFEEH3DVnI4UujN+1zjpuk6gwHLTssg=
-github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/cloudwego/base64x v0.1.5 h1:XPciSp1xaq2VCSt6lF0phncD4koWyULpl5bUxbfCyP4=
-github.com/cloudwego/base64x v0.1.5/go.mod h1:0zlkT4Wn5C6NdauXdJRhSKRlJvmclQ1hhJgA0rcu/8w=
 github.com/cloudwego/iasm v0.2.0/go.mod h1:8rXZaNYT2n95jn+zTI1sDr+IgcD2GVs0nlbbQPiEFhY=
-github.com/cosmiumdev/json-patch/v5 v5.9.11 h1:WD2Wqaz/vO987z2FFdqgkj15HgYZ/Y5TpqE3I4T/iOQ=
-github.com/cosmiumdev/json-patch/v5 v5.9.11/go.mod h1:YPZmckmv4ZY+oxKIOjgq3sIudHVB6VEMcicCS9LtVLM=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/dgraph-io/badger/v4 v4.6.0 h1:acOwfOOZ4p1dPRnYzvkVm7rUk2Y21TgPVepCy5dJdFQ=
+github.com/evanphx/json-patch/v5 v5.9.0 h1:kcBlZQbplgElYIlo/n1hJbls2z/1awpXxpRi0/FOJfg=
-github.com/dgraph-io/badger/v4 v4.6.0/go.mod h1:KSJ5VTuZNC3Sd+YhvVjk2nYua9UZnnTr/SkXvdtiPgI=
+github.com/evanphx/json-patch/v5 v5.9.0/go.mod h1:VNkHZ/282BpEyt/tObQO8s5CMPmYYq14uClGH4abBuQ=
-github.com/dgraph-io/badger/v4 v4.7.0 h1:Q+J8HApYAY7UMpL8d9owqiB+odzEc0zn/aqOD9jhc6Y=
+github.com/gabriel-vasile/mimetype v1.4.4 h1:QjV6pZ7/XZ7ryI2KuyeEDE8wnh7fHP9YnQy+R0LnH8I=
-github.com/dgraph-io/badger/v4 v4.7.0/go.mod h1:He7TzG3YBy3j4f5baj5B7Zl2XyfNe5bl4Udl0aPemVA=
+github.com/gabriel-vasile/mimetype v1.4.4/go.mod h1:JwLei5XPtWdGiMFB5Pjle1oEeoSeEuJfJE+TtfvdB/s=
-github.com/dgraph-io/ristretto/v2 v2.1.0 h1:59LjpOJLNDULHh8MC4UaegN52lC4JnO2dITsie/Pa8I=
+github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
-github.com/dgraph-io/ristretto/v2 v2.1.0/go.mod h1:uejeqfYXpUomfse0+lO+13ATz4TypQYLJZzBSAemuB4=
+github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
-github.com/dgraph-io/ristretto/v2 v2.2.0 h1:bkY3XzJcXoMuELV8F+vS8kzNgicwQFAaGINAEJdWGOM=
-github.com/dgraph-io/ristretto/v2 v2.2.0/go.mod h1:RZrm63UmcBAaYWC1DotLYBmTvgkrs0+XhBd7Npn7/zI=
-github.com/dgryski/go-farm v0.0.0-20200201041132-a6ae2369ad13 h1:fAjc9m62+UWV/WAFKLNi6ZS0675eEUC9y3AlwSbQu1Y=
-github.com/dgryski/go-farm v0.0.0-20200201041132-a6ae2369ad13/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw=
-github.com/dgryski/go-farm v0.0.0-20240924180020-3414d57e47da h1:aIftn67I1fkbMa512G+w+Pxci9hJPB8oMnkcP3iZF38=
-github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
-github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
-github.com/gabriel-vasile/mimetype v1.4.8 h1:FfZ3gj38NjllZIeJAmMhr+qKL8Wu+nOoI3GqacKw1NM=
-github.com/gabriel-vasile/mimetype v1.4.8/go.mod h1:ByKUIKGjh1ODkGM1asKUbQZOLGrPjydw3hYPU2YU9t8=
-github.com/gabriel-vasile/mimetype v1.4.9 h1:5k+WDwEsD9eTLL8Tz3L0VnmVh9QxGjRmjBvAG7U/oYY=
-github.com/gabriel-vasile/mimetype v1.4.9/go.mod h1:WnSQhFKJuBlRyLiKohA/2DtIlPFAbguNaG7QCHcyGok=
-github.com/gin-contrib/sse v1.0.0 h1:y3bT1mUWUxDpW4JLQg/HnTqV4rozuW4tC9eFKTxYI9E=
-github.com/gin-contrib/sse v1.0.0/go.mod h1:zNuFdwarAygJBht0NTKiSi3jRf6RbqeILZ9Sp6Slhe0=
-github.com/gin-contrib/sse v1.1.0 h1:n0w2GMuUpWDVp7qSpvze6fAu9iRxJY4Hmj6AmBOU05w=
-github.com/gin-contrib/sse v1.1.0/go.mod h1:hxRZ5gVpWMT7Z0B0gSNYqqsSCNIJMjzvm6fqCz9vjwM=
 github.com/gin-gonic/gin v1.10.0 h1:nTuyha1TYqgedzytsKYqna+DfLos46nTv2ygFy86HFU=
 github.com/gin-gonic/gin v1.10.0/go.mod h1:4PMNQiOhvDRa013RKVbsiNwoyezlm2rm0uX/T7kzp5Y=
-github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
-github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY=
-github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
-github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
-github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
 github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
 github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
 github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
 github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
 github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
 github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
-github.com/go-playground/validator/v10 v10.25.0 h1:5Dh7cjvzR7BRZadnsVOzPhWsrwUr0nmsZJxEAnFLNO8=
+github.com/go-playground/validator/v10 v10.21.0 h1:4fZA11ovvtkdgaeev9RGWPgc1uj3H8W+rNYyH/ySBb0=
-github.com/go-playground/validator/v10 v10.25.0/go.mod h1:GGzBIJMuE98Ic/kJsBXbz1x/7cByt++cQ+YOuDM5wus=
+github.com/go-playground/validator/v10 v10.21.0/go.mod h1:dbuPbCMFw/DrkbEynArYaCwl3amGuJotoKCe95atGMM=
-github.com/go-playground/validator/v10 v10.26.0 h1:SP05Nqhjcvz81uJaRfEV0YBSSSGMc/iMaVtFbr3Sw2k=
+github.com/goccy/go-json v0.10.3 h1:KZ5WoDbxAIgm2HNbYckL0se1fHD6rz5j4ywS6ebzDqA=
-github.com/go-playground/validator/v10 v10.26.0/go.mod h1:I5QpIEbmr8On7W0TktmJAumgzX4CA1XNl4ZmDuVHKKo=
+github.com/goccy/go-json v0.10.3/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
-github.com/goccy/go-json v0.10.5 h1:Fq85nIqj+gXn/S5ahsiTlK3TmC85qgirsdTP/+DeaC4=
+github.com/golang-jwt/jwt v3.2.1+incompatible h1:73Z+4BJcrTC+KczS6WvTPvRGOp1WmfEP4Q1lOd9Z/+c=
-github.com/goccy/go-json v0.10.5/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
+github.com/golang-jwt/jwt v3.2.1+incompatible/go.mod h1:8pz2t5EyA70fFQQSrl6XZXzqecmYZeUEB8OUGHkxJ+I=
-github.com/golang-jwt/jwt/v5 v5.2.1 h1:OuVbFODueb089Lh128TAcimifWaLhJwVflnrgM17wHk=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
-github.com/golang-jwt/jwt/v5 v5.2.1/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
-github.com/golang-jwt/jwt/v5 v5.2.2 h1:Rl4B7itRWVtYIHFrSNd7vhTiz9UpLdi6gZhZ3wEeDy8=
-github.com/google/flatbuffers v25.2.10+incompatible h1:F3vclr7C3HpB1k9mxCGRMXq6FdUalZ6H/pNX4FP1v0Q=
-github.com/google/flatbuffers v25.2.10+incompatible/go.mod h1:1AeVuKshWv4vARoZatz6mlQ0JxURH0Kv5+zNeJKJCa8=
-github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
-github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
 github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
-github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo=
-github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ=
 github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
-github.com/klauspost/cpuid/v2 v2.2.10 h1:tBs3QSyvjDyFTq3uoc/9xFpCuOsJQFNPiAhYdw2skhE=
+github.com/klauspost/cpuid/v2 v2.2.7 h1:ZWSB3igEs+d0qvnxR/ZBzXVmxkgt8DdzP6m9pfuVLDM=
-github.com/klauspost/cpuid/v2 v2.2.10/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
+github.com/klauspost/cpuid/v2 v2.2.7/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
 github.com/knz/go-libedit v1.10.1/go.mod h1:MZTVkCWyz0oBc7JOWP3wNAzd002ZbM/5hgShxwh4x8M=
-github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
-github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
-github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
-github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
 github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
 github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ=
@@ -108,18 +63,14 @@ github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
 github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
-github.com/pelletier/go-toml/v2 v2.2.3 h1:YmeHyLY8mFWbdkNWwpr+qIL2bEqT0o95WSdkNHvL12M=
+github.com/pelletier/go-toml/v2 v2.2.2 h1:aYUidT7k73Pcl9nb2gScu7NSrKCSHIDE89b3+6Wq+LM=
-github.com/pelletier/go-toml/v2 v2.2.3/go.mod h1:MfCQTFTvCcUyyvvwm1+G6H/jORL20Xlb6rzQu9GuUkc=
+github.com/pelletier/go-toml/v2 v2.2.2/go.mod h1:1t835xjRzz80PqgE6HHgN2JOsmgYu/h4qDAS4n929Rs=
-github.com/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0t5Ec4=
+github.com/pkg/browser v0.0.0-20210115035449-ce105d075bb4 h1:Qj1ukM4GlMWXNdMBuXcXfz/Kw9s1qm0CLY32QxuSImI=
-github.com/pelletier/go-toml/v2 v2.2.4/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY=
+github.com/pkg/browser v0.0.0-20210115035449-ce105d075bb4/go.mod h1:N6UoU20jOqggOuDwUaBQpluzLNDqif3kq9z2wpdYEfQ=
-github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c h1:+mdjkGKdHQG3305AYmdv1U2eRNDiU2ErMBj1gwrq8eQ=
-github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c/go.mod h1:7rwL4CYBLnjLxUqIJNnCWiEdr3bn6IUYi15bNlnbCCU=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
-github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
@@ -130,57 +81,33 @@ github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
 github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
 github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
 github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
 github.com/ugorji/go/codec v1.2.12 h1:9LC83zGrHhuUA9l16C9AHXAqEV/2wBQ4nkvumAE65EE=
 github.com/ugorji/go/codec v1.2.12/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
-github.com/vmihailenco/msgpack/v5 v5.4.1 h1:cQriyiUvjTwOHg8QZaPihLWeRAAVoCpE00IUPn0Bjt8=
+golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
-github.com/vmihailenco/msgpack/v5 v5.4.1/go.mod h1:GaZTsDaehaPpQVyxrf5mtQlH+pc21PIudVV/E3rRQok=
+golang.org/x/arch v0.8.0 h1:3wRIsP3pM4yUptoR96otTUOXI367OS0+c9eeRi9doIc=
-github.com/vmihailenco/tagparser/v2 v2.0.0 h1:y09buUbR+b5aycVFQs/g70pqKVZNBmxwAhO7/IwNM9g=
+golang.org/x/arch v0.8.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
-github.com/vmihailenco/tagparser/v2 v2.0.0/go.mod h1:Wri+At7QHww0WTrCBeu4J6bNtoV6mEfg5OIWRZA9qds=
+golang.org/x/crypto v0.23.0 h1:dIJU/v2J8Mdglj/8rJ6UUOM3Zc9zLZxVZwwxMooUSAI=
-go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
+golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8=
-go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
+golang.org/x/exp v0.0.0-20240531132922-fd00a4e0eefc h1:O9NuF4s+E/PvMIy+9IUZB9znFwUIXEWSstNjek6VpVg=
-go.opentelemetry.io/otel v1.35.0 h1:xKWKPxrxB6OtMCbmMY021CqC45J+3Onta9MqjhnusiQ=
+golang.org/x/exp v0.0.0-20240531132922-fd00a4e0eefc/go.mod h1:XtvwrStGgqGPLc4cjQfWqZHG1YFdYs6swckp8vpsjnc=
-go.opentelemetry.io/otel v1.35.0/go.mod h1:UEqy8Zp11hpkUrL73gSlELM0DupHoiq72dR+Zqel/+Y=
+golang.org/x/net v0.25.0 h1:d/OCCoBEUq33pjydKrGQhw7IlUPI2Oylr+8qLx49kac=
-go.opentelemetry.io/otel/metric v1.35.0 h1:0znxYu2SNyuMSQT4Y9WDWej0VpcsxkuklLa4/siN90M=
+golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM=
-go.opentelemetry.io/otel/metric v1.35.0/go.mod h1:nKVFgxBZ2fReX6IlyW28MgZojkoAkJGaE8CpgeAU3oE=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-go.opentelemetry.io/otel/trace v1.35.0 h1:dPpEfJu1sDIqruz7BHFG3c7528f6ddfSWfFDVt/xgMs=
-go.opentelemetry.io/otel/trace v1.35.0/go.mod h1:WUk7DtFp1Aw2MkvqGdwiXYDZZNvA/1J8o6xRXLrIkyc=
-golang.org/x/arch v0.15.0 h1:QtOrQd0bTUnhNVNndMpLHNWrDmYzZ2KDqSrEymqInZw=
-golang.org/x/arch v0.15.0/go.mod h1:JmwW7aLIoRUKgaTzhkiEFxvcEiQGyOg9BMonBJUS7EE=
-golang.org/x/arch v0.17.0 h1:4O3dfLzd+lQewptAHqjewQZQDyEdejz3VwgeYwkZneU=
-golang.org/x/arch v0.17.0/go.mod h1:bdwinDaKcfZUGpH09BB7ZmOfhalA8lQdzl62l8gGWsk=
-golang.org/x/crypto v0.36.0 h1:AnAEvhDddvBdpY+uR+MyHmuZzzNqXSe/GvuDeob5L34=
-golang.org/x/crypto v0.36.0/go.mod h1:Y4J0ReaxCR1IMaabaSMugxJES1EpwhBHhv2bDHklZvc=
-golang.org/x/crypto v0.38.0 h1:jt+WWG8IZlBnVbomuhg2Mdq0+BBQaHbtqHEFEigjUV8=
-golang.org/x/crypto v0.38.0/go.mod h1:MvrbAqul58NNYPKnOra203SB9vpuZW0e+RRZV+Ggqjw=
-golang.org/x/exp v0.0.0-20250305212735-054e65f0b394 h1:nDVHiLt8aIbd/VzvPWN6kSOPE7+F/fNFDSXLVYkE/Iw=
-golang.org/x/exp v0.0.0-20250305212735-054e65f0b394/go.mod h1:sIifuuw/Yco/y6yb6+bDNfyeQ/MdPUy/hKEMYQV17cM=
-golang.org/x/exp v0.0.0-20250506013437-ce4c2cf36ca6 h1:y5zboxd6LQAqYIhHnB48p0ByQ/GnQx2BE33L8BOHQkI=
-golang.org/x/exp v0.0.0-20250506013437-ce4c2cf36ca6/go.mod h1:U6Lno4MTRCDY+Ba7aCcauB9T60gsv5s4ralQzP72ZoQ=
-golang.org/x/net v0.37.0 h1:1zLorHbz+LYj7MQlSf1+2tPIIgibq2eL5xkrGk6f+2c=
-golang.org/x/net v0.37.0/go.mod h1:ivrbrMbzFq5J41QOQh0siUuly180yBYtLp+CKbEaFx8=
-golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
-golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.31.0 h1:ioabZlmFYtWhL+TRYpcnNlLwhyxaM9kWTDEmfnprqik=
+golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y=
-golang.org/x/sys v0.31.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
+golang.org/x/text v0.15.0 h1:h1V/4gjBv8v9cjcR6+AR5+/cIYK5N/WAgiv4xlsEtAk=
-golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
-golang.org/x/text v0.23.0 h1:D71I7dUrlY+VX0gQShAThNGHFxZ13dGLBHQLVl1mJlY=
+google.golang.org/protobuf v1.34.1 h1:9ddQBjfCyZPOHPUiPxpYESBLc+T8P3E+Vo4IbKZgFWg=
-golang.org/x/text v0.23.0/go.mod h1:/BLNzu4aZCJ1+kcD0DNRotWKage4q2rGVAg4o22unh4=
+google.golang.org/protobuf v1.34.1/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
-golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
-golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
-google.golang.org/protobuf v1.36.5 h1:tPhr+woSbjfYvY6/GPufUoYizxw1cF/yFoxJ2fmpwlM=
-google.golang.org/protobuf v1.36.5/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
-google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY=
-google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
-gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 nullprogram.com/x/optparse v1.0.0/go.mod h1:KdyPE+Igbe0jQUrVfMqDMeJQIJZEuyV7pjYmp6pbG50=
+rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4=

internal/constants/responses.go

@@ -30,8 +30,3 @@ var QueryPlanResponse = gin.H{
 		},
 	},
 }
-
-var UnknownErrorResponse = gin.H{"message": "Unknown error"}
-var NotFoundResponse = gin.H{"message": "NotFound"}
-var ConflictResponse = gin.H{"message": "Conflict"}
-var BadRequestResponse = gin.H{"message": "BadRequest"}

internal/converters/document_to_rowtype.go

@@ -1,20 +0,0 @@
-package converters
-
-import (
-	"github.com/pikami/cosmium/internal/datastore"
-	memoryexecutor "github.com/pikami/cosmium/query_executors/memory_executor"
-)
-
-type DocumentToRowTypeIterator struct {
-	documents datastore.DocumentIterator
-}
-
-func NewDocumentToRowTypeIterator(documents datastore.DocumentIterator) *DocumentToRowTypeIterator {
-	return &DocumentToRowTypeIterator{
-		documents: documents,
-	}
-}
-
-func (di *DocumentToRowTypeIterator) Next() (memoryexecutor.RowType, datastore.DataStoreStatus) {
-	return di.documents.Next()
-}

internal/datastore/badger_datastore/badger_datastore.go

@@ -1,66 +0,0 @@
-package badgerdatastore
-
-import (
-	"time"
-
-	"github.com/dgraph-io/badger/v4"
-	"github.com/pikami/cosmium/internal/logger"
-)
-
-type BadgerDataStore struct {
-	db       *badger.DB
-	gcTicker *time.Ticker
-}
-
-type BadgerDataStoreOptions struct {
-	PersistDataFilePath string
-}
-
-func NewBadgerDataStore(options BadgerDataStoreOptions) *BadgerDataStore {
-	badgerOpts := badger.DefaultOptions(options.PersistDataFilePath)
-	badgerOpts = badgerOpts.WithLogger(newBadgerLogger())
-	if options.PersistDataFilePath == "" {
-		badgerOpts = badgerOpts.WithInMemory(true)
-	}
-
-	db, err := badger.Open(badgerOpts)
-	if err != nil {
-		panic(err)
-	}
-
-	gcTicker := time.NewTicker(5 * time.Minute)
-
-	ds := &BadgerDataStore{
-		db:       db,
-		gcTicker: gcTicker,
-	}
-
-	go ds.runGarbageCollector()
-
-	return ds
-}
-
-func (r *BadgerDataStore) Close() {
-	if r.gcTicker != nil {
-		r.gcTicker.Stop()
-		r.gcTicker = nil
-	}
-
-	r.db.Close()
-	r.db = nil
-}
-
-func (r *BadgerDataStore) DumpToJson() (string, error) {
-	logger.ErrorLn("Badger datastore does not support state export currently.")
-	return "{}", nil
-}
-
-func (r *BadgerDataStore) runGarbageCollector() {
-	for range r.gcTicker.C {
-	again:
-		err := r.db.RunValueLogGC(0.7)
-		if err == nil {
-			goto again
-		}
-	}
-}

internal/datastore/badger_datastore/badger_logger.go

@@ -1,28 +0,0 @@
-package badgerdatastore
-
-import (
-	"github.com/dgraph-io/badger/v4"
-	"github.com/pikami/cosmium/internal/logger"
-)
-
-type badgerLogger struct{}
-
-func newBadgerLogger() badger.Logger {
-	return &badgerLogger{}
-}
-
-func (l *badgerLogger) Errorf(format string, v ...interface{}) {
-	logger.Errorf(format, v...)
-}
-
-func (l *badgerLogger) Warningf(format string, v ...interface{}) {
-	logger.Infof(format, v...)
-}
-
-func (l *badgerLogger) Infof(format string, v ...interface{}) {
-	logger.Infof(format, v...)
-}
-
-func (l *badgerLogger) Debugf(format string, v ...interface{}) {
-	logger.Debugf(format, v...)
-}

internal/datastore/badger_datastore/collections.go

@@ -1,103 +0,0 @@
-package badgerdatastore
-
-import (
-	"fmt"
-	"time"
-
-	"github.com/google/uuid"
-	"github.com/pikami/cosmium/internal/datastore"
-	"github.com/pikami/cosmium/internal/logger"
-	"github.com/pikami/cosmium/internal/resourceid"
-	structhidrators "github.com/pikami/cosmium/internal/struct_hidrators"
-)
-
-func (r *BadgerDataStore) GetAllCollections(databaseId string) ([]datastore.Collection, datastore.DataStoreStatus) {
-	exists, err := keyExists(r.db.NewTransaction(false), generateDatabaseKey(databaseId))
-	if err != nil {
-		logger.ErrorLn("Error while checking if database exists:", err)
-		return nil, datastore.Unknown
-	}
-
-	if !exists {
-		return nil, datastore.StatusNotFound
-	}
-
-	colls, status := listByPrefix[datastore.Collection](r.db, generateKey(resourceid.ResourceTypeCollection, databaseId, "", ""))
-	if status == datastore.StatusOk {
-		return colls, datastore.StatusOk
-	}
-
-	return nil, status
-}
-
-func (r *BadgerDataStore) GetCollection(databaseId string, collectionId string) (datastore.Collection, datastore.DataStoreStatus) {
-	collectionKey := generateCollectionKey(databaseId, collectionId)
-
-	txn := r.db.NewTransaction(false)
-	defer txn.Discard()
-
-	var collection datastore.Collection
-	status := getKey(txn, collectionKey, &collection)
-
-	return collection, status
-}
-
-func (r *BadgerDataStore) DeleteCollection(databaseId string, collectionId string) datastore.DataStoreStatus {
-	collectionKey := generateCollectionKey(databaseId, collectionId)
-
-	txn := r.db.NewTransaction(true)
-	defer txn.Discard()
-
-	prefixes := []string{
-		generateKey(resourceid.ResourceTypeDocument, databaseId, collectionId, ""),
-		generateKey(resourceid.ResourceTypeTrigger, databaseId, collectionId, ""),
-		generateKey(resourceid.ResourceTypeStoredProcedure, databaseId, collectionId, ""),
-		generateKey(resourceid.ResourceTypeUserDefinedFunction, databaseId, collectionId, ""),
-		collectionKey,
-	}
-	for _, prefix := range prefixes {
-		if err := deleteKeysByPrefix(txn, prefix); err != nil {
-			return datastore.Unknown
-		}
-	}
-
-	err := txn.Commit()
-	if err != nil {
-		logger.ErrorLn("Error while committing transaction:", err)
-		return datastore.Unknown
-	}
-
-	return datastore.StatusOk
-}
-
-func (r *BadgerDataStore) CreateCollection(databaseId string, newCollection datastore.Collection) (datastore.Collection, datastore.DataStoreStatus) {
-	collectionKey := generateCollectionKey(databaseId, newCollection.ID)
-
-	txn := r.db.NewTransaction(true)
-	defer txn.Discard()
-
-	collectionExists, err := keyExists(txn, collectionKey)
-	if err != nil || collectionExists {
-		return datastore.Collection{}, datastore.Conflict
-	}
-
-	var database datastore.Database
-	status := getKey(txn, generateDatabaseKey(databaseId), &database)
-	if status != datastore.StatusOk {
-		return datastore.Collection{}, status
-	}
-
-	newCollection = structhidrators.Hidrate(newCollection).(datastore.Collection)
-
-	newCollection.TimeStamp = time.Now().Unix()
-	newCollection.ResourceID = resourceid.NewCombined(database.ResourceID, resourceid.New(resourceid.ResourceTypeCollection))
-	newCollection.ETag = fmt.Sprintf("\"%s\"", uuid.New())
-	newCollection.Self = fmt.Sprintf("dbs/%s/colls/%s/", database.ResourceID, newCollection.ResourceID)
-
-	status = insertKey(txn, collectionKey, newCollection)
-	if status != datastore.StatusOk {
-		return datastore.Collection{}, status
-	}
-
-	return newCollection, datastore.StatusOk
-}

internal/datastore/badger_datastore/databases.go

@@ -1,80 +0,0 @@
-package badgerdatastore
-
-import (
-	"fmt"
-	"time"
-
-	"github.com/google/uuid"
-	"github.com/pikami/cosmium/internal/datastore"
-	"github.com/pikami/cosmium/internal/logger"
-	"github.com/pikami/cosmium/internal/resourceid"
-)
-
-func (r *BadgerDataStore) GetAllDatabases() ([]datastore.Database, datastore.DataStoreStatus) {
-	dbs, status := listByPrefix[datastore.Database](r.db, DatabaseKeyPrefix)
-	if status == datastore.StatusOk {
-		return dbs, datastore.StatusOk
-	}
-
-	return nil, status
-}
-
-func (r *BadgerDataStore) GetDatabase(id string) (datastore.Database, datastore.DataStoreStatus) {
-	databaseKey := generateDatabaseKey(id)
-
-	txn := r.db.NewTransaction(false)
-	defer txn.Discard()
-
-	var database datastore.Database
-	status := getKey(txn, databaseKey, &database)
-
-	return database, status
-}
-
-func (r *BadgerDataStore) DeleteDatabase(id string) datastore.DataStoreStatus {
-	databaseKey := generateDatabaseKey(id)
-
-	txn := r.db.NewTransaction(true)
-	defer txn.Discard()
-
-	prefixes := []string{
-		generateKey(resourceid.ResourceTypeCollection, id, "", ""),
-		generateKey(resourceid.ResourceTypeDocument, id, "", ""),
-		generateKey(resourceid.ResourceTypeTrigger, id, "", ""),
-		generateKey(resourceid.ResourceTypeStoredProcedure, id, "", ""),
-		generateKey(resourceid.ResourceTypeUserDefinedFunction, id, "", ""),
-		databaseKey,
-	}
-	for _, prefix := range prefixes {
-		if err := deleteKeysByPrefix(txn, prefix); err != nil {
-			return datastore.Unknown
-		}
-	}
-
-	err := txn.Commit()
-	if err != nil {
-		logger.ErrorLn("Error while committing transaction:", err)
-		return datastore.Unknown
-	}
-
-	return datastore.StatusOk
-}
-
-func (r *BadgerDataStore) CreateDatabase(newDatabase datastore.Database) (datastore.Database, datastore.DataStoreStatus) {
-	databaseKey := generateDatabaseKey(newDatabase.ID)
-
-	txn := r.db.NewTransaction(true)
-	defer txn.Discard()
-
-	newDatabase.TimeStamp = time.Now().Unix()
-	newDatabase.ResourceID = resourceid.New(resourceid.ResourceTypeDatabase)
-	newDatabase.ETag = fmt.Sprintf("\"%s\"", uuid.New())
-	newDatabase.Self = fmt.Sprintf("dbs/%s/", newDatabase.ResourceID)
-
-	status := insertKey(txn, databaseKey, newDatabase)
-	if status != datastore.StatusOk {
-		return datastore.Database{}, status
-	}
-
-	return newDatabase, datastore.StatusOk
-}

internal/datastore/badger_datastore/db_abstractions.go

@@ -1,204 +0,0 @@
-package badgerdatastore
-
-import (
-	"github.com/dgraph-io/badger/v4"
-	"github.com/pikami/cosmium/internal/datastore"
-	"github.com/pikami/cosmium/internal/logger"
-	"github.com/pikami/cosmium/internal/resourceid"
-	"github.com/vmihailenco/msgpack/v5"
-)
-
-const (
-	DatabaseKeyPrefix            = "DB:"
-	CollectionKeyPrefix          = "COL:"
-	DocumentKeyPrefix            = "DOC:"
-	TriggerKeyPrefix             = "TRG:"
-	StoredProcedureKeyPrefix     = "SP:"
-	UserDefinedFunctionKeyPrefix = "UDF:"
-)
-
-func generateKey(
-	resourceType resourceid.ResourceType,
-	databaseId string,
-	collectionId string,
-	resourceId string,
-) string {
-	result := ""
-
-	switch resourceType {
-	case resourceid.ResourceTypeDatabase:
-		result += DatabaseKeyPrefix
-	case resourceid.ResourceTypeCollection:
-		result += CollectionKeyPrefix
-	case resourceid.ResourceTypeDocument:
-		result += DocumentKeyPrefix
-	case resourceid.ResourceTypeTrigger:
-		result += TriggerKeyPrefix
-	case resourceid.ResourceTypeStoredProcedure:
-		result += StoredProcedureKeyPrefix
-	case resourceid.ResourceTypeUserDefinedFunction:
-		result += UserDefinedFunctionKeyPrefix
-	}
-
-	if databaseId != "" {
-		result += databaseId
-	}
-
-	if collectionId != "" {
-		result += "/colls/" + collectionId
-	}
-
-	if resourceId != "" {
-		result += "/" + resourceId
-	}
-
-	return result
-}
-
-func generateDatabaseKey(databaseId string) string {
-	return generateKey(resourceid.ResourceTypeDatabase, databaseId, "", "")
-}
-
-func generateCollectionKey(databaseId string, collectionId string) string {
-	return generateKey(resourceid.ResourceTypeCollection, databaseId, collectionId, "")
-}
-
-func generateDocumentKey(databaseId string, collectionId string, documentId string) string {
-	return generateKey(resourceid.ResourceTypeDocument, databaseId, collectionId, documentId)
-}
-
-func generateTriggerKey(databaseId string, collectionId string, triggerId string) string {
-	return generateKey(resourceid.ResourceTypeTrigger, databaseId, collectionId, triggerId)
-}
-
-func generateStoredProcedureKey(databaseId string, collectionId string, storedProcedureId string) string {
-	return generateKey(resourceid.ResourceTypeStoredProcedure, databaseId, collectionId, storedProcedureId)
-}
-
-func generateUserDefinedFunctionKey(databaseId string, collectionId string, udfId string) string {
-	return generateKey(resourceid.ResourceTypeUserDefinedFunction, databaseId, collectionId, udfId)
-}
-
-func insertKey(txn *badger.Txn, key string, value interface{}) datastore.DataStoreStatus {
-	_, err := txn.Get([]byte(key))
-	if err == nil {
-		return datastore.Conflict
-	}
-
-	if err != badger.ErrKeyNotFound {
-		logger.ErrorLn("Error while checking if key exists:", err)
-		return datastore.Unknown
-	}
-
-	buf, err := msgpack.Marshal(value)
-	if err != nil {
-		logger.ErrorLn("Error while encoding value:", err)
-		return datastore.Unknown
-	}
-
-	err = txn.Set([]byte(key), buf)
-	if err != nil {
-		logger.ErrorLn("Error while setting key:", err)
-		return datastore.Unknown
-	}
-
-	err = txn.Commit()
-	if err != nil {
-		logger.ErrorLn("Error while committing transaction:", err)
-		return datastore.Unknown
-	}
-
-	return datastore.StatusOk
-}
-
-func getKey(txn *badger.Txn, key string, value interface{}) datastore.DataStoreStatus {
-	item, err := txn.Get([]byte(key))
-	if err != nil {
-		if err == badger.ErrKeyNotFound {
-			return datastore.StatusNotFound
-		}
-		logger.ErrorLn("Error while getting key:", err)
-		return datastore.Unknown
-	}
-
-	val, err := item.ValueCopy(nil)
-	if err != nil {
-		logger.ErrorLn("Error while copying value:", err)
-		return datastore.Unknown
-	}
-
-	if value == nil {
-		logger.ErrorLn("getKey called with nil value")
-		return datastore.Unknown
-	}
-
-	err = msgpack.Unmarshal(val, &value)
-	if err != nil {
-		logger.ErrorLn("Error while decoding value:", err)
-		return datastore.Unknown
-	}
-
-	return datastore.StatusOk
-}
-
-func keyExists(txn *badger.Txn, key string) (bool, error) {
-	_, err := txn.Get([]byte(key))
-	if err == nil {
-		return true, nil
-	}
-
-	if err == badger.ErrKeyNotFound {
-		return false, nil
-	}
-
-	return false, err
-}
-
-func listByPrefix[T any](db *badger.DB, prefix string) ([]T, datastore.DataStoreStatus) {
-	results := make([]T, 0)
-
-	err := db.View(func(txn *badger.Txn) error {
-		opts := badger.DefaultIteratorOptions
-		opts.Prefix = []byte(prefix)
-		it := txn.NewIterator(opts)
-		defer it.Close()
-
-		for it.Rewind(); it.Valid(); it.Next() {
-			item := it.Item()
-			var entry T
-
-			status := getKey(txn, string(item.Key()), &entry)
-			if status != datastore.StatusOk {
-				logger.ErrorLn("Failed to retrieve entry:", string(item.Key()))
-				continue
-			}
-
-			results = append(results, entry)
-		}
-		return nil
-	})
-
-	if err != nil {
-		logger.ErrorLn("Error while listing entries:", err)
-		return nil, datastore.Unknown
-	}
-
-	return results, datastore.StatusOk
-}
-
-func deleteKeysByPrefix(txn *badger.Txn, prefix string) error {
-	opts := badger.DefaultIteratorOptions
-	opts.Prefix = []byte(prefix)
-	it := txn.NewIterator(opts)
-	defer it.Close()
-
-	for it.Rewind(); it.Valid(); it.Next() {
-		key := it.Item().KeyCopy(nil)
-		if err := txn.Delete(key); err != nil {
-			logger.ErrorLn("Failed to delete key:", string(key), "Error:", err)
-			return err
-		}
-	}
-
-	return nil
-}

internal/datastore/badger_datastore/document_iterator.go

@@ -1,58 +0,0 @@
-package badgerdatastore
-
-import (
-	"github.com/dgraph-io/badger/v4"
-	"github.com/pikami/cosmium/internal/datastore"
-	"github.com/pikami/cosmium/internal/logger"
-	"github.com/vmihailenco/msgpack/v5"
-)
-
-type BadgerDocumentIterator struct {
-	txn    *badger.Txn
-	it     *badger.Iterator
-	prefix string
-}
-
-func NewBadgerDocumentIterator(txn *badger.Txn, prefix string) *BadgerDocumentIterator {
-	opts := badger.DefaultIteratorOptions
-	opts.Prefix = []byte(prefix)
-
-	it := txn.NewIterator(opts)
-	it.Rewind()
-
-	return &BadgerDocumentIterator{
-		txn:    txn,
-		it:     it,
-		prefix: prefix,
-	}
-}
-
-func (i *BadgerDocumentIterator) Next() (datastore.Document, datastore.DataStoreStatus) {
-	if !i.it.Valid() {
-		i.it.Close()
-		return datastore.Document{}, datastore.IterEOF
-	}
-
-	item := i.it.Item()
-	val, err := item.ValueCopy(nil)
-	if err != nil {
-		logger.ErrorLn("Error while copying value:", err)
-		return datastore.Document{}, datastore.Unknown
-	}
-
-	current := &datastore.Document{}
-	err = msgpack.Unmarshal(val, &current)
-	if err != nil {
-		logger.ErrorLn("Error while decoding value:", err)
-		return datastore.Document{}, datastore.Unknown
-	}
-
-	i.it.Next()
-
-	return *current, datastore.StatusOk
-}
-
-func (i *BadgerDocumentIterator) Close() {
-	i.it.Close()
-	i.txn.Discard()
-}

internal/datastore/badger_datastore/documents.go

@@ -1,127 +0,0 @@
-package badgerdatastore
-
-import (
-	"fmt"
-	"time"
-
-	"github.com/google/uuid"
-	"github.com/pikami/cosmium/internal/datastore"
-	"github.com/pikami/cosmium/internal/logger"
-	"github.com/pikami/cosmium/internal/resourceid"
-)
-
-func (r *BadgerDataStore) GetAllDocuments(databaseId string, collectionId string) ([]datastore.Document, datastore.DataStoreStatus) {
-	txn := r.db.NewTransaction(false)
-	defer txn.Discard()
-
-	dbExists, err := keyExists(txn, generateDatabaseKey(databaseId))
-	if err != nil || !dbExists {
-		return nil, datastore.StatusNotFound
-	}
-
-	collExists, err := keyExists(txn, generateCollectionKey(databaseId, collectionId))
-	if err != nil || !collExists {
-		return nil, datastore.StatusNotFound
-	}
-
-	docs, status := listByPrefix[datastore.Document](r.db, generateKey(resourceid.ResourceTypeDocument, databaseId, collectionId, ""))
-	if status == datastore.StatusOk {
-		return docs, datastore.StatusOk
-	}
-
-	return nil, status
-}
-
-func (r *BadgerDataStore) GetDocumentIterator(databaseId string, collectionId string) (datastore.DocumentIterator, datastore.DataStoreStatus) {
-	txn := r.db.NewTransaction(false)
-
-	dbExists, err := keyExists(txn, generateDatabaseKey(databaseId))
-	if err != nil || !dbExists {
-		return nil, datastore.StatusNotFound
-	}
-
-	collExists, err := keyExists(txn, generateCollectionKey(databaseId, collectionId))
-	if err != nil || !collExists {
-		return nil, datastore.StatusNotFound
-	}
-
-	iter := NewBadgerDocumentIterator(txn, generateKey(resourceid.ResourceTypeDocument, databaseId, collectionId, ""))
-	return iter, datastore.StatusOk
-}
-
-func (r *BadgerDataStore) GetDocument(databaseId string, collectionId string, documentId string) (datastore.Document, datastore.DataStoreStatus) {
-	documentKey := generateDocumentKey(databaseId, collectionId, documentId)
-
-	txn := r.db.NewTransaction(false)
-	defer txn.Discard()
-
-	var document datastore.Document
-	status := getKey(txn, documentKey, &document)
-
-	return document, status
-}
-
-func (r *BadgerDataStore) DeleteDocument(databaseId string, collectionId string, documentId string) datastore.DataStoreStatus {
-	documentKey := generateDocumentKey(databaseId, collectionId, documentId)
-
-	txn := r.db.NewTransaction(true)
-	defer txn.Discard()
-
-	exists, err := keyExists(txn, documentKey)
-	if err != nil {
-		return datastore.Unknown
-	}
-	if !exists {
-		return datastore.StatusNotFound
-	}
-
-	err = txn.Delete([]byte(documentKey))
-	if err != nil {
-		logger.ErrorLn("Error while deleting document:", err)
-		return datastore.Unknown
-	}
-
-	err = txn.Commit()
-	if err != nil {
-		logger.ErrorLn("Error while committing transaction:", err)
-		return datastore.Unknown
-	}
-
-	return datastore.StatusOk
-}
-
-func (r *BadgerDataStore) CreateDocument(databaseId string, collectionId string, document map[string]interface{}) (datastore.Document, datastore.DataStoreStatus) {
-	txn := r.db.NewTransaction(true)
-	defer txn.Discard()
-
-	var database datastore.Database
-	status := getKey(txn, generateDatabaseKey(databaseId), &database)
-	if status != datastore.StatusOk {
-		return datastore.Document{}, status
-	}
-
-	var collection datastore.Collection
-	status = getKey(txn, generateCollectionKey(databaseId, collectionId), &collection)
-	if status != datastore.StatusOk {
-		return datastore.Document{}, status
-	}
-
-	var ok bool
-	var documentId string
-	if documentId, ok = document["id"].(string); !ok || documentId == "" {
-		documentId = fmt.Sprint(uuid.New())
-		document["id"] = documentId
-	}
-
-	document["_ts"] = time.Now().Unix()
-	document["_rid"] = resourceid.NewCombined(collection.ResourceID, resourceid.New(resourceid.ResourceTypeDocument))
-	document["_etag"] = fmt.Sprintf("\"%s\"", uuid.New())
-	document["_self"] = fmt.Sprintf("dbs/%s/colls/%s/docs/%s/", database.ResourceID, collection.ResourceID, document["_rid"])
-
-	status = insertKey(txn, generateDocumentKey(databaseId, collectionId, documentId), document)
-	if status != datastore.StatusOk {
-		return datastore.Document{}, status
-	}
-
-	return document, datastore.StatusOk
-}

internal/datastore/badger_datastore/partition_key_ranges.go

@@ -1,53 +0,0 @@
-package badgerdatastore
-
-import (
-	"fmt"
-
-	"github.com/google/uuid"
-	"github.com/pikami/cosmium/internal/datastore"
-	"github.com/pikami/cosmium/internal/resourceid"
-)
-
-// I have no idea what this is tbh
-func (r *BadgerDataStore) GetPartitionKeyRanges(databaseId string, collectionId string) ([]datastore.PartitionKeyRange, datastore.DataStoreStatus) {
-	databaseRid := databaseId
-	collectionRid := collectionId
-	var timestamp int64 = 0
-
-	txn := r.db.NewTransaction(false)
-	defer txn.Discard()
-
-	var database datastore.Database
-	status := getKey(txn, generateDatabaseKey(databaseId), &database)
-	if status != datastore.StatusOk {
-		databaseRid = database.ResourceID
-	}
-
-	var collection datastore.Collection
-	status = getKey(txn, generateCollectionKey(databaseId, collectionId), &collection)
-	if status != datastore.StatusOk {
-		collectionRid = collection.ResourceID
-		timestamp = collection.TimeStamp
-	}
-
-	pkrResourceId := resourceid.NewCombined(collectionRid, resourceid.New(resourceid.ResourceTypePartitionKeyRange))
-	pkrSelf := fmt.Sprintf("dbs/%s/colls/%s/pkranges/%s/", databaseRid, collectionRid, pkrResourceId)
-	etag := fmt.Sprintf("\"%s\"", uuid.New())
-
-	return []datastore.PartitionKeyRange{
-		{
-			ResourceID:         pkrResourceId,
-			ID:                 "0",
-			Etag:               etag,
-			MinInclusive:       "",
-			MaxExclusive:       "FF",
-			RidPrefix:          0,
-			Self:               pkrSelf,
-			ThroughputFraction: 1,
-			Status:             "online",
-			Parents:            []interface{}{},
-			TimeStamp:          timestamp,
-			Lsn:                17,
-		},
-	}, datastore.StatusOk
-}

internal/datastore/badger_datastore/stored_procedures.go

@@ -1,107 +0,0 @@
-package badgerdatastore
-
-import (
-	"fmt"
-	"time"
-
-	"github.com/google/uuid"
-	"github.com/pikami/cosmium/internal/datastore"
-	"github.com/pikami/cosmium/internal/logger"
-	"github.com/pikami/cosmium/internal/resourceid"
-)
-
-func (r *BadgerDataStore) GetAllStoredProcedures(databaseId string, collectionId string) ([]datastore.StoredProcedure, datastore.DataStoreStatus) {
-	txn := r.db.NewTransaction(false)
-	defer txn.Discard()
-
-	dbExists, err := keyExists(txn, generateDatabaseKey(databaseId))
-	if err != nil || !dbExists {
-		return nil, datastore.StatusNotFound
-	}
-
-	collExists, err := keyExists(txn, generateCollectionKey(databaseId, collectionId))
-	if err != nil || !collExists {
-		return nil, datastore.StatusNotFound
-	}
-
-	storedProcedures, status := listByPrefix[datastore.StoredProcedure](r.db, generateKey(resourceid.ResourceTypeStoredProcedure, databaseId, collectionId, ""))
-	if status == datastore.StatusOk {
-		return storedProcedures, datastore.StatusOk
-	}
-
-	return nil, status
-}
-
-func (r *BadgerDataStore) GetStoredProcedure(databaseId string, collectionId string, storedProcedureId string) (datastore.StoredProcedure, datastore.DataStoreStatus) {
-	storedProcedureKey := generateStoredProcedureKey(databaseId, collectionId, storedProcedureId)
-
-	txn := r.db.NewTransaction(false)
-	defer txn.Discard()
-
-	var storedProcedure datastore.StoredProcedure
-	status := getKey(txn, storedProcedureKey, &storedProcedure)
-
-	return storedProcedure, status
-}
-
-func (r *BadgerDataStore) DeleteStoredProcedure(databaseId string, collectionId string, storedProcedureId string) datastore.DataStoreStatus {
-	storedProcedureKey := generateStoredProcedureKey(databaseId, collectionId, storedProcedureId)
-
-	txn := r.db.NewTransaction(true)
-	defer txn.Discard()
-
-	exists, err := keyExists(txn, storedProcedureKey)
-	if err != nil {
-		return datastore.Unknown
-	}
-	if !exists {
-		return datastore.StatusNotFound
-	}
-
-	err = txn.Delete([]byte(storedProcedureKey))
-	if err != nil {
-		logger.ErrorLn("Error while deleting stored procedure:", err)
-		return datastore.Unknown
-	}
-
-	err = txn.Commit()
-	if err != nil {
-		logger.ErrorLn("Error while committing transaction:", err)
-		return datastore.Unknown
-	}
-
-	return datastore.StatusOk
-}
-
-func (r *BadgerDataStore) CreateStoredProcedure(databaseId string, collectionId string, storedProcedure datastore.StoredProcedure) (datastore.StoredProcedure, datastore.DataStoreStatus) {
-	txn := r.db.NewTransaction(true)
-	defer txn.Discard()
-
-	if storedProcedure.ID == "" {
-		return datastore.StoredProcedure{}, datastore.BadRequest
-	}
-
-	var database datastore.Database
-	status := getKey(txn, generateDatabaseKey(databaseId), &database)
-	if status != datastore.StatusOk {
-		return datastore.StoredProcedure{}, status
-	}
-
-	var collection datastore.Collection
-	status = getKey(txn, generateCollectionKey(databaseId, collectionId), &collection)
-	if status != datastore.StatusOk {
-		return datastore.StoredProcedure{}, status
-	}
-
-	storedProcedure.TimeStamp = time.Now().Unix()
-	storedProcedure.ResourceID = resourceid.NewCombined(collection.ResourceID, resourceid.New(resourceid.ResourceTypeStoredProcedure))
-	storedProcedure.ETag = fmt.Sprintf("\"%s\"", uuid.New())
-	storedProcedure.Self = fmt.Sprintf("dbs/%s/colls/%s/sprocs/%s/", database.ResourceID, collection.ResourceID, storedProcedure.ResourceID)
-
-	status = insertKey(txn, generateStoredProcedureKey(databaseId, collectionId, storedProcedure.ID), storedProcedure)
-	if status != datastore.StatusOk {
-		return datastore.StoredProcedure{}, status
-	}
-
-	return storedProcedure, datastore.StatusOk
-}

internal/datastore/badger_datastore/triggers.go

@@ -1,107 +0,0 @@
-package badgerdatastore
-
-import (
-	"fmt"
-	"time"
-
-	"github.com/google/uuid"
-	"github.com/pikami/cosmium/internal/datastore"
-	"github.com/pikami/cosmium/internal/logger"
-	"github.com/pikami/cosmium/internal/resourceid"
-)
-
-func (r *BadgerDataStore) GetAllTriggers(databaseId string, collectionId string) ([]datastore.Trigger, datastore.DataStoreStatus) {
-	txn := r.db.NewTransaction(false)
-	defer txn.Discard()
-
-	dbExists, err := keyExists(txn, generateDatabaseKey(databaseId))
-	if err != nil || !dbExists {
-		return nil, datastore.StatusNotFound
-	}
-
-	collExists, err := keyExists(txn, generateCollectionKey(databaseId, collectionId))
-	if err != nil || !collExists {
-		return nil, datastore.StatusNotFound
-	}
-
-	triggers, status := listByPrefix[datastore.Trigger](r.db, generateKey(resourceid.ResourceTypeTrigger, databaseId, collectionId, ""))
-	if status == datastore.StatusOk {
-		return triggers, datastore.StatusOk
-	}
-
-	return nil, status
-}
-
-func (r *BadgerDataStore) GetTrigger(databaseId string, collectionId string, triggerId string) (datastore.Trigger, datastore.DataStoreStatus) {
-	triggerKey := generateTriggerKey(databaseId, collectionId, triggerId)
-
-	txn := r.db.NewTransaction(false)
-	defer txn.Discard()
-
-	var trigger datastore.Trigger
-	status := getKey(txn, triggerKey, &trigger)
-
-	return trigger, status
-}
-
-func (r *BadgerDataStore) DeleteTrigger(databaseId string, collectionId string, triggerId string) datastore.DataStoreStatus {
-	triggerKey := generateTriggerKey(databaseId, collectionId, triggerId)
-
-	txn := r.db.NewTransaction(true)
-	defer txn.Discard()
-
-	exists, err := keyExists(txn, triggerKey)
-	if err != nil {
-		return datastore.Unknown
-	}
-	if !exists {
-		return datastore.StatusNotFound
-	}
-
-	err = txn.Delete([]byte(triggerKey))
-	if err != nil {
-		logger.ErrorLn("Error while deleting trigger:", err)
-		return datastore.Unknown
-	}
-
-	err = txn.Commit()
-	if err != nil {
-		logger.ErrorLn("Error while committing transaction:", err)
-		return datastore.Unknown
-	}
-
-	return datastore.StatusOk
-}
-
-func (r *BadgerDataStore) CreateTrigger(databaseId string, collectionId string, trigger datastore.Trigger) (datastore.Trigger, datastore.DataStoreStatus) {
-	txn := r.db.NewTransaction(true)
-	defer txn.Discard()
-
-	if trigger.ID == "" {
-		return datastore.Trigger{}, datastore.BadRequest
-	}
-
-	var database datastore.Database
-	status := getKey(txn, generateDatabaseKey(databaseId), &database)
-	if status != datastore.StatusOk {
-		return datastore.Trigger{}, status
-	}
-
-	var collection datastore.Collection
-	status = getKey(txn, generateCollectionKey(databaseId, collectionId), &collection)
-	if status != datastore.StatusOk {
-		return datastore.Trigger{}, status
-	}
-
-	trigger.TimeStamp = time.Now().Unix()
-	trigger.ResourceID = resourceid.NewCombined(collection.ResourceID, resourceid.New(resourceid.ResourceTypeTrigger))
-	trigger.ETag = fmt.Sprintf("\"%s\"", uuid.New())
-	trigger.Self = fmt.Sprintf("dbs/%s/colls/%s/triggers/%s/", database.ResourceID, collection.ResourceID, trigger.ResourceID)
-
-	status = insertKey(txn, generateTriggerKey(databaseId, collectionId, trigger.ID), trigger)
-	if status != datastore.StatusOk {
-		return datastore.Trigger{}, status
-	}
-
-	return trigger, datastore.StatusOk
-}

internal/datastore/badger_datastore/user_defined_functions.go

@@ -1,107 +0,0 @@
-package badgerdatastore
-
-import (
-	"fmt"
-	"time"
-
-	"github.com/google/uuid"
-	"github.com/pikami/cosmium/internal/datastore"
-	"github.com/pikami/cosmium/internal/logger"
-	"github.com/pikami/cosmium/internal/resourceid"
-)
-
-func (r *BadgerDataStore) GetAllUserDefinedFunctions(databaseId string, collectionId string) ([]datastore.UserDefinedFunction, datastore.DataStoreStatus) {
-	txn := r.db.NewTransaction(false)
-	defer txn.Discard()
-
-	dbExists, err := keyExists(txn, generateDatabaseKey(databaseId))
-	if err != nil || !dbExists {
-		return nil, datastore.StatusNotFound
-	}
-
-	collExists, err := keyExists(txn, generateCollectionKey(databaseId, collectionId))
-	if err != nil || !collExists {
-		return nil, datastore.StatusNotFound
-	}
-
-	udfs, status := listByPrefix[datastore.UserDefinedFunction](r.db, generateKey(resourceid.ResourceTypeUserDefinedFunction, databaseId, collectionId, ""))
-	if status == datastore.StatusOk {
-		return udfs, datastore.StatusOk
-	}
-
-	return nil, status
-}
-
-func (r *BadgerDataStore) GetUserDefinedFunction(databaseId string, collectionId string, udfId string) (datastore.UserDefinedFunction, datastore.DataStoreStatus) {
-	udfKey := generateUserDefinedFunctionKey(databaseId, collectionId, udfId)
-
-	txn := r.db.NewTransaction(false)
-	defer txn.Discard()
-
-	var udf datastore.UserDefinedFunction
-	status := getKey(txn, udfKey, &udf)
-
-	return udf, status
-}
-
-func (r *BadgerDataStore) DeleteUserDefinedFunction(databaseId string, collectionId string, udfId string) datastore.DataStoreStatus {
-	udfKey := generateUserDefinedFunctionKey(databaseId, collectionId, udfId)
-
-	txn := r.db.NewTransaction(true)
-	defer txn.Discard()
-
-	exists, err := keyExists(txn, udfKey)
-	if err != nil {
-		return datastore.Unknown
-	}
-	if !exists {
-		return datastore.StatusNotFound
-	}
-
-	err = txn.Delete([]byte(udfKey))
-	if err != nil {
-		logger.ErrorLn("Error while deleting user defined function:", err)
-		return datastore.Unknown
-	}
-
-	err = txn.Commit()
-	if err != nil {
-		logger.ErrorLn("Error while committing transaction:", err)
-		return datastore.Unknown
-	}
-
-	return datastore.StatusOk
-}
-
-func (r *BadgerDataStore) CreateUserDefinedFunction(databaseId string, collectionId string, udf datastore.UserDefinedFunction) (datastore.UserDefinedFunction, datastore.DataStoreStatus) {
-	txn := r.db.NewTransaction(true)
-	defer txn.Discard()
-
-	if udf.ID == "" {
-		return datastore.UserDefinedFunction{}, datastore.BadRequest
-	}
-
-	var database datastore.Database
-	status := getKey(txn, generateDatabaseKey(databaseId), &database)
-	if status != datastore.StatusOk {
-		return datastore.UserDefinedFunction{}, status
-	}
-
-	var collection datastore.Collection
-	status = getKey(txn, generateCollectionKey(databaseId, collectionId), &collection)
-	if status != datastore.StatusOk {
-		return datastore.UserDefinedFunction{}, status
-	}
-
-	udf.TimeStamp = time.Now().Unix()
-	udf.ResourceID = resourceid.NewCombined(collection.ResourceID, resourceid.New(resourceid.ResourceTypeUserDefinedFunction))
-	udf.ETag = fmt.Sprintf("\"%s\"", uuid.New())
-	udf.Self = fmt.Sprintf("dbs/%s/colls/%s/udfs/%s/", database.ResourceID, collection.ResourceID, udf.ResourceID)
-
-	status = insertKey(txn, generateUserDefinedFunctionKey(databaseId, collectionId, udf.ID), udf)
-	if status != datastore.StatusOk {
-		return datastore.UserDefinedFunction{}, status
-	}
-
-	return udf, datastore.StatusOk
-}

internal/datastore/datastore.go

@@ -1,44 +0,0 @@
-package datastore
-
-type DataStore interface {
-	GetAllDatabases() ([]Database, DataStoreStatus)
-	GetDatabase(databaseId string) (Database, DataStoreStatus)
-	DeleteDatabase(databaseId string) DataStoreStatus
-	CreateDatabase(newDatabase Database) (Database, DataStoreStatus)
-
-	GetAllCollections(databaseId string) ([]Collection, DataStoreStatus)
-	GetCollection(databaseId string, collectionId string) (Collection, DataStoreStatus)
-	DeleteCollection(databaseId string, collectionId string) DataStoreStatus
-	CreateCollection(databaseId string, newCollection Collection) (Collection, DataStoreStatus)
-
-	GetAllDocuments(databaseId string, collectionId string) ([]Document, DataStoreStatus)
-	GetDocumentIterator(databaseId string, collectionId string) (DocumentIterator, DataStoreStatus)
-	GetDocument(databaseId string, collectionId string, documentId string) (Document, DataStoreStatus)
-	DeleteDocument(databaseId string, collectionId string, documentId string) DataStoreStatus
-	CreateDocument(databaseId string, collectionId string, document map[string]interface{}) (Document, DataStoreStatus)
-
-	GetAllTriggers(databaseId string, collectionId string) ([]Trigger, DataStoreStatus)
-	GetTrigger(databaseId string, collectionId string, triggerId string) (Trigger, DataStoreStatus)
-	DeleteTrigger(databaseId string, collectionId string, triggerId string) DataStoreStatus
-	CreateTrigger(databaseId string, collectionId string, trigger Trigger) (Trigger, DataStoreStatus)
-
-	GetAllStoredProcedures(databaseId string, collectionId string) ([]StoredProcedure, DataStoreStatus)
-	GetStoredProcedure(databaseId string, collectionId string, storedProcedureId string) (StoredProcedure, DataStoreStatus)
-	DeleteStoredProcedure(databaseId string, collectionId string, storedProcedureId string) DataStoreStatus
-	CreateStoredProcedure(databaseId string, collectionId string, storedProcedure StoredProcedure) (StoredProcedure, DataStoreStatus)
-
-	GetAllUserDefinedFunctions(databaseId string, collectionId string) ([]UserDefinedFunction, DataStoreStatus)
-	GetUserDefinedFunction(databaseId string, collectionId string, udfId string) (UserDefinedFunction, DataStoreStatus)
-	DeleteUserDefinedFunction(databaseId string, collectionId string, udfId string) DataStoreStatus
-	CreateUserDefinedFunction(databaseId string, collectionId string, udf UserDefinedFunction) (UserDefinedFunction, DataStoreStatus)
-
-	GetPartitionKeyRanges(databaseId string, collectionId string) ([]PartitionKeyRange, DataStoreStatus)
-
-	Close()
-	DumpToJson() (string, error)
-}
-
-type DocumentIterator interface {
-	Next() (Document, DataStoreStatus)
-	Close()
-}

internal/datastore/json_datastore/array_document_iterator.go

@@ -1,21 +0,0 @@
-package jsondatastore
-
-import "github.com/pikami/cosmium/internal/datastore"
-
-type ArrayDocumentIterator struct {
-	documents []datastore.Document
-	index     int
-}
-
-func (i *ArrayDocumentIterator) Next() (datastore.Document, datastore.DataStoreStatus) {
-	i.index++
-	if i.index >= len(i.documents) {
-		return datastore.Document{}, datastore.StatusNotFound
-	}
-
-	return i.documents[i.index], datastore.StatusOk
-}
-
-func (i *ArrayDocumentIterator) Close() {
-	i.documents = []datastore.Document{}
-}

internal/datastore/json_datastore/collections.go

@@ -1,89 +0,0 @@
-package jsondatastore
-
-import (
-	"fmt"
-	"time"
-
-	"github.com/google/uuid"
-	"github.com/pikami/cosmium/internal/datastore"
-	"github.com/pikami/cosmium/internal/resourceid"
-	structhidrators "github.com/pikami/cosmium/internal/struct_hidrators"
-	"golang.org/x/exp/maps"
-)
-
-func (r *JsonDataStore) GetAllCollections(databaseId string) ([]datastore.Collection, datastore.DataStoreStatus) {
-	r.storeState.RLock()
-	defer r.storeState.RUnlock()
-
-	if _, ok := r.storeState.Databases[databaseId]; !ok {
-		return make([]datastore.Collection, 0), datastore.StatusNotFound
-	}
-
-	return maps.Values(r.storeState.Collections[databaseId]), datastore.StatusOk
-}
-
-func (r *JsonDataStore) GetCollection(databaseId string, collectionId string) (datastore.Collection, datastore.DataStoreStatus) {
-	r.storeState.RLock()
-	defer r.storeState.RUnlock()
-
-	if _, ok := r.storeState.Databases[databaseId]; !ok {
-		return datastore.Collection{}, datastore.StatusNotFound
-	}
-
-	if _, ok := r.storeState.Collections[databaseId][collectionId]; !ok {
-		return datastore.Collection{}, datastore.StatusNotFound
-	}
-
-	return r.storeState.Collections[databaseId][collectionId], datastore.StatusOk
-}
-
-func (r *JsonDataStore) DeleteCollection(databaseId string, collectionId string) datastore.DataStoreStatus {
-	r.storeState.Lock()
-	defer r.storeState.Unlock()
-
-	if _, ok := r.storeState.Databases[databaseId]; !ok {
-		return datastore.StatusNotFound
-	}
-
-	if _, ok := r.storeState.Collections[databaseId][collectionId]; !ok {
-		return datastore.StatusNotFound
-	}
-
-	delete(r.storeState.Collections[databaseId], collectionId)
-	delete(r.storeState.Documents[databaseId], collectionId)
-	delete(r.storeState.Triggers[databaseId], collectionId)
-	delete(r.storeState.StoredProcedures[databaseId], collectionId)
-	delete(r.storeState.UserDefinedFunctions[databaseId], collectionId)
-
-	return datastore.StatusOk
-}
-
-func (r *JsonDataStore) CreateCollection(databaseId string, newCollection datastore.Collection) (datastore.Collection, datastore.DataStoreStatus) {
-	r.storeState.Lock()
-	defer r.storeState.Unlock()
-
-	var ok bool
-	var database datastore.Database
-	if database, ok = r.storeState.Databases[databaseId]; !ok {
-		return datastore.Collection{}, datastore.StatusNotFound
-	}
-
-	if _, ok = r.storeState.Collections[databaseId][newCollection.ID]; ok {
-		return datastore.Collection{}, datastore.Conflict
-	}
-
-	newCollection = structhidrators.Hidrate(newCollection).(datastore.Collection)
-
-	newCollection.TimeStamp = time.Now().Unix()
-	newCollection.ResourceID = resourceid.NewCombined(database.ResourceID, resourceid.New(resourceid.ResourceTypeCollection))
-	newCollection.ETag = fmt.Sprintf("\"%s\"", uuid.New())
-	newCollection.Self = fmt.Sprintf("dbs/%s/colls/%s/", database.ResourceID, newCollection.ResourceID)
-
-	r.storeState.Collections[databaseId][newCollection.ID] = newCollection
-	r.storeState.Documents[databaseId][newCollection.ID] = make(map[string]datastore.Document)
-	r.storeState.Triggers[databaseId][newCollection.ID] = make(map[string]datastore.Trigger)
-	r.storeState.StoredProcedures[databaseId][newCollection.ID] = make(map[string]datastore.StoredProcedure)
-	r.storeState.UserDefinedFunctions[databaseId][newCollection.ID] = make(map[string]datastore.UserDefinedFunction)
-
-	return newCollection, datastore.StatusOk
-}

internal/datastore/json_datastore/databases.go

@@ -1,70 +0,0 @@
-package jsondatastore
-
-import (
-	"fmt"
-	"time"
-
-	"github.com/google/uuid"
-	"github.com/pikami/cosmium/internal/datastore"
-	"github.com/pikami/cosmium/internal/resourceid"
-	"golang.org/x/exp/maps"
-)
-
-func (r *JsonDataStore) GetAllDatabases() ([]datastore.Database, datastore.DataStoreStatus) {
-	r.storeState.RLock()
-	defer r.storeState.RUnlock()
-
-	return maps.Values(r.storeState.Databases), datastore.StatusOk
-}
-
-func (r *JsonDataStore) GetDatabase(id string) (datastore.Database, datastore.DataStoreStatus) {
-	r.storeState.RLock()
-	defer r.storeState.RUnlock()
-
-	if database, ok := r.storeState.Databases[id]; ok {
-		return database, datastore.StatusOk
-	}
-
-	return datastore.Database{}, datastore.StatusNotFound
-}
-
-func (r *JsonDataStore) DeleteDatabase(id string) datastore.DataStoreStatus {
-	r.storeState.Lock()
-	defer r.storeState.Unlock()
-
-	if _, ok := r.storeState.Databases[id]; !ok {
-		return datastore.StatusNotFound
-	}
-
-	delete(r.storeState.Databases, id)
-	delete(r.storeState.Collections, id)
-	delete(r.storeState.Documents, id)
-	delete(r.storeState.Triggers, id)
-	delete(r.storeState.StoredProcedures, id)
-	delete(r.storeState.UserDefinedFunctions, id)
-
-	return datastore.StatusOk
-}
-
-func (r *JsonDataStore) CreateDatabase(newDatabase datastore.Database) (datastore.Database, datastore.DataStoreStatus) {
-	r.storeState.Lock()
-	defer r.storeState.Unlock()
-
-	if _, ok := r.storeState.Databases[newDatabase.ID]; ok {
-		return datastore.Database{}, datastore.Conflict
-	}
-
-	newDatabase.TimeStamp = time.Now().Unix()
-	newDatabase.ResourceID = resourceid.New(resourceid.ResourceTypeDatabase)
-	newDatabase.ETag = fmt.Sprintf("\"%s\"", uuid.New())
-	newDatabase.Self = fmt.Sprintf("dbs/%s/", newDatabase.ResourceID)
-
-	r.storeState.Databases[newDatabase.ID] = newDatabase
-	r.storeState.Collections[newDatabase.ID] = make(map[string]datastore.Collection)
-	r.storeState.Documents[newDatabase.ID] = make(map[string]map[string]datastore.Document)
-	r.storeState.Triggers[newDatabase.ID] = make(map[string]map[string]datastore.Trigger)
-	r.storeState.StoredProcedures[newDatabase.ID] = make(map[string]map[string]datastore.StoredProcedure)
-	r.storeState.UserDefinedFunctions[newDatabase.ID] = make(map[string]map[string]datastore.UserDefinedFunction)
-
-	return newDatabase, datastore.StatusOk
-}

internal/datastore/json_datastore/documents.go

@@ -1,113 +0,0 @@
-package jsondatastore
-
-import (
-	"fmt"
-	"time"
-
-	"github.com/google/uuid"
-	"github.com/pikami/cosmium/internal/datastore"
-	"github.com/pikami/cosmium/internal/resourceid"
-	"golang.org/x/exp/maps"
-)
-
-func (r *JsonDataStore) GetAllDocuments(databaseId string, collectionId string) ([]datastore.Document, datastore.DataStoreStatus) {
-	r.storeState.RLock()
-	defer r.storeState.RUnlock()
-
-	if _, ok := r.storeState.Databases[databaseId]; !ok {
-		return make([]datastore.Document, 0), datastore.StatusNotFound
-	}
-
-	if _, ok := r.storeState.Collections[databaseId][collectionId]; !ok {
-		return make([]datastore.Document, 0), datastore.StatusNotFound
-	}
-
-	return maps.Values(r.storeState.Documents[databaseId][collectionId]), datastore.StatusOk
-}
-
-func (r *JsonDataStore) GetDocument(databaseId string, collectionId string, documentId string) (datastore.Document, datastore.DataStoreStatus) {
-	r.storeState.RLock()
-	defer r.storeState.RUnlock()
-
-	if _, ok := r.storeState.Databases[databaseId]; !ok {
-		return datastore.Document{}, datastore.StatusNotFound
-	}
-
-	if _, ok := r.storeState.Collections[databaseId][collectionId]; !ok {
-		return datastore.Document{}, datastore.StatusNotFound
-	}
-
-	if _, ok := r.storeState.Documents[databaseId][collectionId][documentId]; !ok {
-		return datastore.Document{}, datastore.StatusNotFound
-	}
-
-	return r.storeState.Documents[databaseId][collectionId][documentId], datastore.StatusOk
-}
-
-func (r *JsonDataStore) DeleteDocument(databaseId string, collectionId string, documentId string) datastore.DataStoreStatus {
-	r.storeState.Lock()
-	defer r.storeState.Unlock()
-
-	if _, ok := r.storeState.Databases[databaseId]; !ok {
-		return datastore.StatusNotFound
-	}
-
-	if _, ok := r.storeState.Collections[databaseId][collectionId]; !ok {
-		return datastore.StatusNotFound
-	}
-
-	if _, ok := r.storeState.Documents[databaseId][collectionId][documentId]; !ok {
-		return datastore.StatusNotFound
-	}
-
-	delete(r.storeState.Documents[databaseId][collectionId], documentId)
-
-	return datastore.StatusOk
-}
-
-func (r *JsonDataStore) CreateDocument(databaseId string, collectionId string, document map[string]interface{}) (datastore.Document, datastore.DataStoreStatus) {
-	r.storeState.Lock()
-	defer r.storeState.Unlock()
-
-	var ok bool
-	var documentId string
-	var database datastore.Database
-	var collection datastore.Collection
-	if documentId, ok = document["id"].(string); !ok || documentId == "" {
-		documentId = fmt.Sprint(uuid.New())
-		document["id"] = documentId
-	}
-
-	if database, ok = r.storeState.Databases[databaseId]; !ok {
-		return datastore.Document{}, datastore.StatusNotFound
-	}
-
-	if collection, ok = r.storeState.Collections[databaseId][collectionId]; !ok {
-		return datastore.Document{}, datastore.StatusNotFound
-	}
-
-	if _, ok := r.storeState.Documents[databaseId][collectionId][documentId]; ok {
-		return datastore.Document{}, datastore.Conflict
-	}
-
-	document["_ts"] = time.Now().Unix()
-	document["_rid"] = resourceid.NewCombined(collection.ResourceID, resourceid.New(resourceid.ResourceTypeDocument))
-	document["_etag"] = fmt.Sprintf("\"%s\"", uuid.New())
-	document["_self"] = fmt.Sprintf("dbs/%s/colls/%s/docs/%s/", database.ResourceID, collection.ResourceID, document["_rid"])
-
-	r.storeState.Documents[databaseId][collectionId][documentId] = document
-
-	return document, datastore.StatusOk
-}
-
-func (r *JsonDataStore) GetDocumentIterator(databaseId string, collectionId string) (datastore.DocumentIterator, datastore.DataStoreStatus) {
-	documents, status := r.GetAllDocuments(databaseId, collectionId)
-	if status != datastore.StatusOk {
-		return nil, status
-	}
-
-	return &ArrayDocumentIterator{
-		documents: documents,
-		index:     -1,
-	}, datastore.StatusOk
-}

internal/datastore/json_datastore/map_datastore.go

@@ -1,34 +0,0 @@
-package jsondatastore
-
-import "github.com/pikami/cosmium/internal/datastore"
-
-type JsonDataStore struct {
-	storeState State
-
-	initialDataFilePath string
-	persistDataFilePath string
-}
-
-type JsonDataStoreOptions struct {
-	InitialDataFilePath string
-	PersistDataFilePath string
-}
-
-func NewJsonDataStore(options JsonDataStoreOptions) *JsonDataStore {
-	dataStore := &JsonDataStore{
-		storeState: State{
-			Databases:            make(map[string]datastore.Database),
-			Collections:          make(map[string]map[string]datastore.Collection),
-			Documents:            make(map[string]map[string]map[string]datastore.Document),
-			Triggers:             make(map[string]map[string]map[string]datastore.Trigger),
-			StoredProcedures:     make(map[string]map[string]map[string]datastore.StoredProcedure),
-			UserDefinedFunctions: make(map[string]map[string]map[string]datastore.UserDefinedFunction),
-		},
-		initialDataFilePath: options.InitialDataFilePath,
-		persistDataFilePath: options.PersistDataFilePath,
-	}
-
-	dataStore.InitializeDataStore()
-
-	return dataStore
-}

internal/datastore/json_datastore/state.go

@@ -1,236 +0,0 @@
-package jsondatastore
-
-import (
-	"encoding/json"
-	"log"
-	"os"
-	"reflect"
-	"sync"
-
-	"github.com/pikami/cosmium/internal/datastore"
-	"github.com/pikami/cosmium/internal/logger"
-)
-
-type State struct {
-	sync.RWMutex
-
-	// Map databaseId -> Database
-	Databases map[string]datastore.Database `json:"databases"`
-
-	// Map databaseId -> collectionId -> Collection
-	Collections map[string]map[string]datastore.Collection `json:"collections"`
-
-	// Map databaseId -> collectionId -> documentId -> Documents
-	Documents map[string]map[string]map[string]datastore.Document `json:"documents"`
-
-	// Map databaseId -> collectionId -> triggerId -> Trigger
-	Triggers map[string]map[string]map[string]datastore.Trigger `json:"triggers"`
-
-	// Map databaseId -> collectionId -> spId -> StoredProcedure
-	StoredProcedures map[string]map[string]map[string]datastore.StoredProcedure `json:"sprocs"`
-
-	// Map databaseId -> collectionId -> udfId -> UserDefinedFunction
-	UserDefinedFunctions map[string]map[string]map[string]datastore.UserDefinedFunction `json:"udfs"`
-}
-
-func (r *JsonDataStore) InitializeDataStore() {
-	if r.initialDataFilePath != "" {
-		r.LoadStateFS(r.initialDataFilePath)
-		return
-	}
-
-	if r.persistDataFilePath != "" {
-		stat, err := os.Stat(r.persistDataFilePath)
-		if err != nil {
-			return
-		}
-
-		if stat.IsDir() {
-			logger.ErrorLn("Argument '-Persist' must be a path to file, not a directory.")
-			os.Exit(1)
-		}
-
-		r.LoadStateFS(r.persistDataFilePath)
-		return
-	}
-}
-
-func (r *JsonDataStore) LoadStateFS(filePath string) {
-	data, err := os.ReadFile(filePath)
-	if err != nil {
-		log.Fatalf("Error reading state JSON file: %v", err)
-		return
-	}
-
-	err = r.LoadStateJSON(string(data))
-	if err != nil {
-		log.Fatalf("Error unmarshalling state JSON: %v", err)
-	}
-}
-
-func (r *JsonDataStore) LoadStateJSON(jsonData string) error {
-	r.storeState.Lock()
-	defer r.storeState.Unlock()
-
-	var state State
-	if err := json.Unmarshal([]byte(jsonData), &state); err != nil {
-		return err
-	}
-
-	r.storeState.Collections = state.Collections
-	r.storeState.Databases = state.Databases
-	r.storeState.Documents = state.Documents
-
-	r.ensureStoreStateNoNullReferences()
-
-	logger.InfoLn("Loaded state:")
-	logger.Infof("Databases: %d\n", getLength(r.storeState.Databases))
-	logger.Infof("Collections: %d\n", getLength(r.storeState.Collections))
-	logger.Infof("Documents: %d\n", getLength(r.storeState.Documents))
-	logger.Infof("Triggers: %d\n", getLength(r.storeState.Triggers))
-	logger.Infof("Stored procedures: %d\n", getLength(r.storeState.StoredProcedures))
-	logger.Infof("User defined functions: %d\n", getLength(r.storeState.UserDefinedFunctions))
-
-	return nil
-}
-
-func (r *JsonDataStore) SaveStateFS(filePath string) {
-	r.storeState.RLock()
-	defer r.storeState.RUnlock()
-
-	data, err := json.MarshalIndent(r.storeState, "", "\t")
-	if err != nil {
-		logger.Errorf("Failed to save state: %v\n", err)
-		return
-	}
-
-	os.WriteFile(filePath, data, os.ModePerm)
-
-	logger.InfoLn("Saved state:")
-	logger.Infof("Databases: %d\n", getLength(r.storeState.Databases))
-	logger.Infof("Collections: %d\n", getLength(r.storeState.Collections))
-	logger.Infof("Documents: %d\n", getLength(r.storeState.Documents))
-	logger.Infof("Triggers: %d\n", getLength(r.storeState.Triggers))
-	logger.Infof("Stored procedures: %d\n", getLength(r.storeState.StoredProcedures))
-	logger.Infof("User defined functions: %d\n", getLength(r.storeState.UserDefinedFunctions))
-}
-
-func (r *JsonDataStore) DumpToJson() (string, error) {
-	r.storeState.RLock()
-	defer r.storeState.RUnlock()
-
-	data, err := json.MarshalIndent(r.storeState, "", "\t")
-	if err != nil {
-		logger.Errorf("Failed to serialize state: %v\n", err)
-		return "", err
-	}
-
-	return string(data), nil
-
-}
-
-func (r *JsonDataStore) Close() {
-	if r.persistDataFilePath != "" {
-		r.SaveStateFS(r.persistDataFilePath)
-	}
-}
-
-func getLength(v interface{}) int {
-	switch v.(type) {
-	case datastore.Database,
-		datastore.Collection,
-		datastore.Document,
-		datastore.Trigger,
-		datastore.StoredProcedure,
-		datastore.UserDefinedFunction:
-		return 1
-	}
-
-	rv := reflect.ValueOf(v)
-	if rv.Kind() != reflect.Map {
-		return -1
-	}
-
-	count := 0
-	for _, key := range rv.MapKeys() {
-		if rv.MapIndex(key).Kind() == reflect.Map {
-			count += getLength(rv.MapIndex(key).Interface())
-		} else {
-			count++
-		}
-	}
-
-	return count
-}
-
-func (r *JsonDataStore) ensureStoreStateNoNullReferences() {
-	if r.storeState.Databases == nil {
-		r.storeState.Databases = make(map[string]datastore.Database)
-	}
-
-	if r.storeState.Collections == nil {
-		r.storeState.Collections = make(map[string]map[string]datastore.Collection)
-	}
-
-	if r.storeState.Documents == nil {
-		r.storeState.Documents = make(map[string]map[string]map[string]datastore.Document)
-	}
-
-	if r.storeState.Triggers == nil {
-		r.storeState.Triggers = make(map[string]map[string]map[string]datastore.Trigger)
-	}
-
-	if r.storeState.StoredProcedures == nil {
-		r.storeState.StoredProcedures = make(map[string]map[string]map[string]datastore.StoredProcedure)
-	}
-
-	if r.storeState.UserDefinedFunctions == nil {
-		r.storeState.UserDefinedFunctions = make(map[string]map[string]map[string]datastore.UserDefinedFunction)
-	}
-
-	for database := range r.storeState.Databases {
-		if r.storeState.Collections[database] == nil {
-			r.storeState.Collections[database] = make(map[string]datastore.Collection)
-		}
-
-		if r.storeState.Documents[database] == nil {
-			r.storeState.Documents[database] = make(map[string]map[string]datastore.Document)
-		}
-
-		if r.storeState.Triggers[database] == nil {
-			r.storeState.Triggers[database] = make(map[string]map[string]datastore.Trigger)
-		}
-
-		if r.storeState.StoredProcedures[database] == nil {
-			r.storeState.StoredProcedures[database] = make(map[string]map[string]datastore.StoredProcedure)
-		}
-
-		if r.storeState.UserDefinedFunctions[database] == nil {
-			r.storeState.UserDefinedFunctions[database] = make(map[string]map[string]datastore.UserDefinedFunction)
-		}
-
-		for collection := range r.storeState.Collections[database] {
-			if r.storeState.Documents[database][collection] == nil {
-				r.storeState.Documents[database][collection] = make(map[string]datastore.Document)
-			}
-
-			for document := range r.storeState.Documents[database][collection] {
-				if r.storeState.Documents[database][collection][document] == nil {
-					delete(r.storeState.Documents[database][collection], document)
-				}
-			}
-
-			if r.storeState.Triggers[database][collection] == nil {
-				r.storeState.Triggers[database][collection] = make(map[string]datastore.Trigger)
-			}
-
-			if r.storeState.StoredProcedures[database][collection] == nil {
-				r.storeState.StoredProcedures[database][collection] = make(map[string]datastore.StoredProcedure)
-			}
-
-			if r.storeState.UserDefinedFunctions[database][collection] == nil {
-				r.storeState.UserDefinedFunctions[database][collection] = make(map[string]datastore.UserDefinedFunction)
-			}
-		}
-	}
-}

internal/datastore/json_datastore/stored_procedures.go

@@ -1,91 +0,0 @@
-package jsondatastore
-
-import (
-	"fmt"
-	"time"
-
-	"github.com/google/uuid"
-	"github.com/pikami/cosmium/internal/datastore"
-	"github.com/pikami/cosmium/internal/resourceid"
-	"golang.org/x/exp/maps"
-)
-
-func (r *JsonDataStore) GetAllStoredProcedures(databaseId string, collectionId string) ([]datastore.StoredProcedure, datastore.DataStoreStatus) {
-	r.storeState.RLock()
-	defer r.storeState.RUnlock()
-
-	return maps.Values(r.storeState.StoredProcedures[databaseId][collectionId]), datastore.StatusOk
-}
-
-func (r *JsonDataStore) GetStoredProcedure(databaseId string, collectionId string, spId string) (datastore.StoredProcedure, datastore.DataStoreStatus) {
-	r.storeState.RLock()
-	defer r.storeState.RUnlock()
-
-	if _, ok := r.storeState.Databases[databaseId]; !ok {
-		return datastore.StoredProcedure{}, datastore.StatusNotFound
-	}
-
-	if _, ok := r.storeState.Collections[databaseId][collectionId]; !ok {
-		return datastore.StoredProcedure{}, datastore.StatusNotFound
-	}
-
-	if sp, ok := r.storeState.StoredProcedures[databaseId][collectionId][spId]; ok {
-		return sp, datastore.StatusOk
-	}
-
-	return datastore.StoredProcedure{}, datastore.StatusNotFound
-}
-
-func (r *JsonDataStore) DeleteStoredProcedure(databaseId string, collectionId string, spId string) datastore.DataStoreStatus {
-	r.storeState.Lock()
-	defer r.storeState.Unlock()
-
-	if _, ok := r.storeState.Databases[databaseId]; !ok {
-		return datastore.StatusNotFound
-	}
-
-	if _, ok := r.storeState.Collections[databaseId][collectionId]; !ok {
-		return datastore.StatusNotFound
-	}
-
-	if _, ok := r.storeState.StoredProcedures[databaseId][collectionId][spId]; !ok {
-		return datastore.StatusNotFound
-	}
-
-	delete(r.storeState.StoredProcedures[databaseId][collectionId], spId)
-
-	return datastore.StatusOk
-}
-
-func (r *JsonDataStore) CreateStoredProcedure(databaseId string, collectionId string, sp datastore.StoredProcedure) (datastore.StoredProcedure, datastore.DataStoreStatus) {
-	r.storeState.Lock()
-	defer r.storeState.Unlock()
-
-	var ok bool
-	var database datastore.Database
-	var collection datastore.Collection
-	if sp.ID == "" {
-		return datastore.StoredProcedure{}, datastore.BadRequest
-	}
-
-	if database, ok = r.storeState.Databases[databaseId]; !ok {
-		return datastore.StoredProcedure{}, datastore.StatusNotFound
-	}
-
-	if collection, ok = r.storeState.Collections[databaseId][collectionId]; !ok {
-		return datastore.StoredProcedure{}, datastore.StatusNotFound
-	}
-
-	if _, ok = r.storeState.StoredProcedures[databaseId][collectionId][sp.ID]; ok {
-		return datastore.StoredProcedure{}, datastore.Conflict
-	}
-
-	sp.TimeStamp = time.Now().Unix()
-	sp.ResourceID = resourceid.NewCombined(collection.ResourceID, resourceid.New(resourceid.ResourceTypeStoredProcedure))
-	sp.ETag = fmt.Sprintf("\"%s\"", uuid.New())
-	sp.Self = fmt.Sprintf("dbs/%s/colls/%s/sprocs/%s/", database.ResourceID, collection.ResourceID, sp.ResourceID)
-
-	r.storeState.StoredProcedures[databaseId][collectionId][sp.ID] = sp
-
-	return sp, datastore.StatusOk
-}

internal/datastore/json_datastore/triggers.go

@@ -1,91 +0,0 @@
-package jsondatastore
-
-import (
-	"fmt"
-	"time"
-
-	"github.com/google/uuid"
-	"github.com/pikami/cosmium/internal/datastore"
-	"github.com/pikami/cosmium/internal/resourceid"
-	"golang.org/x/exp/maps"
-)
-
-func (r *JsonDataStore) GetAllTriggers(databaseId string, collectionId string) ([]datastore.Trigger, datastore.DataStoreStatus) {
-	r.storeState.RLock()
-	defer r.storeState.RUnlock()
-
-	return maps.Values(r.storeState.Triggers[databaseId][collectionId]), datastore.StatusOk
-}
-
-func (r *JsonDataStore) GetTrigger(databaseId string, collectionId string, triggerId string) (datastore.Trigger, datastore.DataStoreStatus) {
-	r.storeState.RLock()
-	defer r.storeState.RUnlock()
-
-	if _, ok := r.storeState.Databases[databaseId]; !ok {
-		return datastore.Trigger{}, datastore.StatusNotFound
-	}
-
-	if _, ok := r.storeState.Collections[databaseId][collectionId]; !ok {
-		return datastore.Trigger{}, datastore.StatusNotFound
-	}
-
-	if trigger, ok := r.storeState.Triggers[databaseId][collectionId][triggerId]; ok {
-		return trigger, datastore.StatusOk
-	}
-
-	return datastore.Trigger{}, datastore.StatusNotFound
-}
-
-func (r *JsonDataStore) DeleteTrigger(databaseId string, collectionId string, triggerId string) datastore.DataStoreStatus {
-	r.storeState.Lock()
-	defer r.storeState.Unlock()
-
-	if _, ok := r.storeState.Databases[databaseId]; !ok {
-		return datastore.StatusNotFound
-	}
-
-	if _, ok := r.storeState.Collections[databaseId][collectionId]; !ok {
-		return datastore.StatusNotFound
-	}
-
-	if _, ok := r.storeState.Triggers[databaseId][collectionId][triggerId]; !ok {
-		return datastore.StatusNotFound
-	}
-
-	delete(r.storeState.Triggers[databaseId][collectionId], triggerId)
-
-	return datastore.StatusOk
-}
-
-func (r *JsonDataStore) CreateTrigger(databaseId string, collectionId string, trigger datastore.Trigger) (datastore.Trigger, datastore.DataStoreStatus) {
-	r.storeState.Lock()
-	defer r.storeState.Unlock()
-
-	var ok bool
-	var database datastore.Database
-	var collection datastore.Collection
-	if trigger.ID == "" {
-		return datastore.Trigger{}, datastore.BadRequest
-	}
-
-	if database, ok = r.storeState.Databases[databaseId]; !ok {
-		return datastore.Trigger{}, datastore.StatusNotFound
-	}
-
-	if collection, ok = r.storeState.Collections[databaseId][collectionId]; !ok {
-		return datastore.Trigger{}, datastore.StatusNotFound
-	}
-
-	if _, ok = r.storeState.Triggers[databaseId][collectionId][trigger.ID]; ok {
-		return datastore.Trigger{}, datastore.Conflict
-	}
-
-	trigger.TimeStamp = time.Now().Unix()
-	trigger.ResourceID = resourceid.NewCombined(collection.ResourceID, resourceid.New(resourceid.ResourceTypeTrigger))
-	trigger.ETag = fmt.Sprintf("\"%s\"", uuid.New())
-	trigger.Self = fmt.Sprintf("dbs/%s/colls/%s/triggers/%s/", database.ResourceID, collection.ResourceID, trigger.ResourceID)
-
-	r.storeState.Triggers[databaseId][collectionId][trigger.ID] = trigger
-
-	return trigger, datastore.StatusOk
-}

internal/datastore/json_datastore/user_defined_functions.go

@@ -1,91 +0,0 @@
-package jsondatastore
-
-import (
-	"fmt"
-	"time"
-
-	"github.com/google/uuid"
-	"github.com/pikami/cosmium/internal/datastore"
-	"github.com/pikami/cosmium/internal/resourceid"
-	"golang.org/x/exp/maps"
-)
-
-func (r *JsonDataStore) GetAllUserDefinedFunctions(databaseId string, collectionId string) ([]datastore.UserDefinedFunction, datastore.DataStoreStatus) {
-	r.storeState.RLock()
-	defer r.storeState.RUnlock()
-
-	return maps.Values(r.storeState.UserDefinedFunctions[databaseId][collectionId]), datastore.StatusOk
-}
-
-func (r *JsonDataStore) GetUserDefinedFunction(databaseId string, collectionId string, udfId string) (datastore.UserDefinedFunction, datastore.DataStoreStatus) {
-	r.storeState.RLock()
-	defer r.storeState.RUnlock()
-
-	if _, ok := r.storeState.Databases[databaseId]; !ok {
-		return datastore.UserDefinedFunction{}, datastore.StatusNotFound
-	}
-
-	if _, ok := r.storeState.Collections[databaseId][collectionId]; !ok {
-		return datastore.UserDefinedFunction{}, datastore.StatusNotFound
-	}
-
-	if udf, ok := r.storeState.UserDefinedFunctions[databaseId][collectionId][udfId]; ok {
-		return udf, datastore.StatusOk
-	}
-
-	return datastore.UserDefinedFunction{}, datastore.StatusNotFound
-}
-
-func (r *JsonDataStore) DeleteUserDefinedFunction(databaseId string, collectionId string, udfId string) datastore.DataStoreStatus {
-	r.storeState.Lock()
-	defer r.storeState.Unlock()
-
-	if _, ok := r.storeState.Databases[databaseId]; !ok {
-		return datastore.StatusNotFound
-	}
-
-	if _, ok := r.storeState.Collections[databaseId][collectionId]; !ok {
-		return datastore.StatusNotFound
-	}
-
-	if _, ok := r.storeState.UserDefinedFunctions[databaseId][collectionId][udfId]; !ok {
-		return datastore.StatusNotFound
-	}
-
-	delete(r.storeState.UserDefinedFunctions[databaseId][collectionId], udfId)
-
-	return datastore.StatusOk
-}
-
-func (r *JsonDataStore) CreateUserDefinedFunction(databaseId string, collectionId string, udf datastore.UserDefinedFunction) (datastore.UserDefinedFunction, datastore.DataStoreStatus) {
-	r.storeState.Lock()
-	defer r.storeState.Unlock()
-
-	var ok bool
-	var database datastore.Database
-	var collection datastore.Collection
-	if udf.ID == "" {
-		return datastore.UserDefinedFunction{}, datastore.BadRequest
-	}
-
-	if database, ok = r.storeState.Databases[databaseId]; !ok {
-		return datastore.UserDefinedFunction{}, datastore.StatusNotFound
-	}
-
-	if collection, ok = r.storeState.Collections[databaseId][collectionId]; !ok {
-		return datastore.UserDefinedFunction{}, datastore.StatusNotFound
-	}
-
-	if _, ok := r.storeState.UserDefinedFunctions[databaseId][collectionId][udf.ID]; ok {
-		return datastore.UserDefinedFunction{}, datastore.Conflict
-	}
-
-	udf.TimeStamp = time.Now().Unix()
-	udf.ResourceID = resourceid.NewCombined(collection.ResourceID, resourceid.New(resourceid.ResourceTypeUserDefinedFunction))
-	udf.ETag = fmt.Sprintf("\"%s\"", uuid.New())
-	udf.Self = fmt.Sprintf("dbs/%s/colls/%s/udfs/%s/", database.ResourceID, collection.ResourceID, udf.ResourceID)
-
-	r.storeState.UserDefinedFunctions[databaseId][collectionId][udf.ID] = udf
-
-	return udf, datastore.StatusOk
-}

internal/logger/logger.go

@@ -1,140 +1,40 @@
 package logger
 
 import (
-	"fmt"
 	"log"
 	"os"
-	"runtime"
+
-	"strings"
+	"github.com/pikami/cosmium/api/config"
-	"sync"
 )
 
-type LogLevelType int
+var DebugLogger = log.New(os.Stdout, "", log.Ldate|log.Ltime|log.Lshortfile)
-
-var (
-	LogLevelDebug  LogLevelType = 0
-	LogLevelInfo   LogLevelType = 1
-	LogLevelError  LogLevelType = 2
-	LogLevelSilent LogLevelType = 10
-)
-
-type LogWriter struct {
-	WriterLevel LogLevelType
-}
-
-var logLevelMutex sync.RWMutex
-var logLevel = LogLevelInfo
-
-var DebugLogger = log.New(os.Stdout, "", log.Ldate|log.Ltime)
 var InfoLogger = log.New(os.Stdout, "", log.Ldate|log.Ltime)
-var ErrorLogger = log.New(os.Stderr, "", log.Ldate|log.Ltime)
+var ErrorLogger = log.New(os.Stderr, "", log.Ldate|log.Ltime|log.Lshortfile)
-
-func DebugLn(v ...any) {
-	if GetLogLevel() <= LogLevelDebug {
-		prefix := getCallerPrefix()
-		DebugLogger.Println(append([]interface{}{prefix}, v...)...)
-	}
-}
 
 func Debug(v ...any) {
-	if GetLogLevel() <= LogLevelDebug {
+	if config.Config.Debug {
-		prefix := getCallerPrefix()
+		DebugLogger.Println(v...)
-		DebugLogger.Println(append([]interface{}{prefix}, v...)...)
 	}
 }
 
 func Debugf(format string, v ...any) {
-	if GetLogLevel() <= LogLevelDebug {
+	if config.Config.Debug {
-		prefix := getCallerPrefix()
+		DebugLogger.Printf(format, v...)
-		DebugLogger.Printf(prefix+format, v...)
-	}
-}
-
-func InfoLn(v ...any) {
-	if GetLogLevel() <= LogLevelInfo {
-		InfoLogger.Println(v...)
 	}
 }
 
 func Info(v ...any) {
-	if GetLogLevel() <= LogLevelInfo {
+	InfoLogger.Println(v...)
-		InfoLogger.Print(v...)
-	}
 }
 
 func Infof(format string, v ...any) {
-	if GetLogLevel() <= LogLevelInfo {
 	InfoLogger.Printf(format, v...)
 }
-}
-
-func ErrorLn(v ...any) {
-	if GetLogLevel() <= LogLevelError {
-		prefix := getCallerPrefix()
-		ErrorLogger.Println(append([]interface{}{prefix}, v...)...)
-	}
-}
 
 func Error(v ...any) {
-	if GetLogLevel() <= LogLevelError {
+	ErrorLogger.Println(v...)
-		prefix := getCallerPrefix()
-		ErrorLogger.Print(append([]interface{}{prefix}, v...)...)
-	}
 }
 
 func Errorf(format string, v ...any) {
-	if GetLogLevel() <= LogLevelError {
+	ErrorLogger.Printf(format, v...)
-		prefix := getCallerPrefix()
-		ErrorLogger.Printf(prefix+format, v...)
-	}
-}
-
-func (lw *LogWriter) Write(p []byte) (n int, err error) {
-	switch lw.WriterLevel {
-	case LogLevelDebug:
-		Debug(string(p))
-	case LogLevelInfo:
-		Info(string(p))
-	case LogLevelError:
-		Error(string(p))
-	}
-
-	return len(p), nil
-}
-
-func ErrorWriter() *LogWriter {
-	return &LogWriter{WriterLevel: LogLevelError}
-}
-
-func InfoWriter() *LogWriter {
-	return &LogWriter{WriterLevel: LogLevelInfo}
-}
-
-func DebugWriter() *LogWriter {
-	return &LogWriter{WriterLevel: LogLevelDebug}
-}
-
-func SetLogLevel(level LogLevelType) {
-	logLevelMutex.Lock()
-	defer logLevelMutex.Unlock()
-	logLevel = level
-}
-
-func GetLogLevel() LogLevelType {
-	logLevelMutex.RLock()
-	defer logLevelMutex.RUnlock()
-	return logLevel
-}
-
-func getCallerPrefix() string {
-	_, file, line, ok := runtime.Caller(2)
-	if ok {
-		parts := strings.Split(file, "/")
-		if len(parts) > 0 {
-			file = parts[len(parts)-1]
-		}
-		return fmt.Sprintf("%s:%d - ", file, line)
-	}
-
-	return ""
 }

internal/repositories/collections.go

@@ -0,0 +1,70 @@
+package repositories
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/google/uuid"
+	repositorymodels "github.com/pikami/cosmium/internal/repository_models"
+	"github.com/pikami/cosmium/internal/resourceid"
+	structhidrators "github.com/pikami/cosmium/internal/struct_hidrators"
+	"golang.org/x/exp/maps"
+)
+
+func GetAllCollections(databaseId string) ([]repositorymodels.Collection, repositorymodels.RepositoryStatus) {
+	if _, ok := storeState.Databases[databaseId]; !ok {
+		return make([]repositorymodels.Collection, 0), repositorymodels.StatusNotFound
+	}
+
+	return maps.Values(storeState.Collections[databaseId]), repositorymodels.StatusOk
+}
+
+func GetCollection(databaseId string, collectionId string) (repositorymodels.Collection, repositorymodels.RepositoryStatus) {
+	if _, ok := storeState.Databases[databaseId]; !ok {
+		return repositorymodels.Collection{}, repositorymodels.StatusNotFound
+	}
+
+	if _, ok := storeState.Collections[databaseId][collectionId]; !ok {
+		return repositorymodels.Collection{}, repositorymodels.StatusNotFound
+	}
+
+	return storeState.Collections[databaseId][collectionId], repositorymodels.StatusOk
+}
+
+func DeleteCollection(databaseId string, collectionId string) repositorymodels.RepositoryStatus {
+	if _, ok := storeState.Databases[databaseId]; !ok {
+		return repositorymodels.StatusNotFound
+	}
+
+	if _, ok := storeState.Collections[databaseId][collectionId]; !ok {
+		return repositorymodels.StatusNotFound
+	}
+
+	delete(storeState.Collections[databaseId], collectionId)
+
+	return repositorymodels.StatusOk
+}
+
+func CreateCollection(databaseId string, newCollection repositorymodels.Collection) (repositorymodels.Collection, repositorymodels.RepositoryStatus) {
+	var ok bool
+	var database repositorymodels.Database
+	if database, ok = storeState.Databases[databaseId]; !ok {
+		return repositorymodels.Collection{}, repositorymodels.StatusNotFound
+	}
+
+	if _, ok = storeState.Collections[databaseId][newCollection.ID]; ok {
+		return repositorymodels.Collection{}, repositorymodels.Conflict
+	}
+
+	newCollection = structhidrators.Hidrate(newCollection).(repositorymodels.Collection)
+
+	newCollection.TimeStamp = time.Now().Unix()
+	newCollection.ResourceID = resourceid.NewCombined(database.ResourceID, resourceid.New())
+	newCollection.ETag = fmt.Sprintf("\"%s\"", uuid.New())
+	newCollection.Self = fmt.Sprintf("dbs/%s/colls/%s/", database.ResourceID, newCollection.ResourceID)
+
+	storeState.Collections[databaseId][newCollection.ID] = newCollection
+	storeState.Documents[databaseId][newCollection.ID] = make(map[string]repositorymodels.Document)
+
+	return newCollection, repositorymodels.StatusOk
+}

internal/repositories/databases.go

@@ -0,0 +1,50 @@
+package repositories
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/google/uuid"
+	repositorymodels "github.com/pikami/cosmium/internal/repository_models"
+	"github.com/pikami/cosmium/internal/resourceid"
+	"golang.org/x/exp/maps"
+)
+
+func GetAllDatabases() ([]repositorymodels.Database, repositorymodels.RepositoryStatus) {
+	return maps.Values(storeState.Databases), repositorymodels.StatusOk
+}
+
+func GetDatabase(id string) (repositorymodels.Database, repositorymodels.RepositoryStatus) {
+	if database, ok := storeState.Databases[id]; ok {
+		return database, repositorymodels.StatusOk
+	}
+
+	return repositorymodels.Database{}, repositorymodels.StatusNotFound
+}
+
+func DeleteDatabase(id string) repositorymodels.RepositoryStatus {
+	if _, ok := storeState.Databases[id]; !ok {
+		return repositorymodels.StatusNotFound
+	}
+
+	delete(storeState.Databases, id)
+
+	return repositorymodels.StatusOk
+}
+
+func CreateDatabase(newDatabase repositorymodels.Database) (repositorymodels.Database, repositorymodels.RepositoryStatus) {
+	if _, ok := storeState.Databases[newDatabase.ID]; ok {
+		return repositorymodels.Database{}, repositorymodels.Conflict
+	}
+
+	newDatabase.TimeStamp = time.Now().Unix()
+	newDatabase.ResourceID = resourceid.New()
+	newDatabase.ETag = fmt.Sprintf("\"%s\"", uuid.New())
+	newDatabase.Self = fmt.Sprintf("dbs/%s/", newDatabase.ResourceID)
+
+	storeState.Databases[newDatabase.ID] = newDatabase
+	storeState.Collections[newDatabase.ID] = make(map[string]repositorymodels.Collection)
+	storeState.Documents[newDatabase.ID] = make(map[string]map[string]repositorymodels.Document)
+
+	return newDatabase, repositorymodels.StatusOk
+}

internal/repositories/documents.go

@@ -0,0 +1,118 @@
+package repositories
+
+import (
+	"fmt"
+	"log"
+	"time"
+
+	"github.com/google/uuid"
+	repositorymodels "github.com/pikami/cosmium/internal/repository_models"
+	"github.com/pikami/cosmium/internal/resourceid"
+	"github.com/pikami/cosmium/parsers"
+	"github.com/pikami/cosmium/parsers/nosql"
+	memoryexecutor "github.com/pikami/cosmium/query_executors/memory_executor"
+	"golang.org/x/exp/maps"
+)
+
+func GetAllDocuments(databaseId string, collectionId string) ([]repositorymodels.Document, repositorymodels.RepositoryStatus) {
+	if _, ok := storeState.Databases[databaseId]; !ok {
+		return make([]repositorymodels.Document, 0), repositorymodels.StatusNotFound
+	}
+
+	if _, ok := storeState.Collections[databaseId][collectionId]; !ok {
+		return make([]repositorymodels.Document, 0), repositorymodels.StatusNotFound
+	}
+
+	return maps.Values(storeState.Documents[databaseId][collectionId]), repositorymodels.StatusOk
+}
+
+func GetDocument(databaseId string, collectionId string, documentId string) (repositorymodels.Document, repositorymodels.RepositoryStatus) {
+	if _, ok := storeState.Databases[databaseId]; !ok {
+		return repositorymodels.Document{}, repositorymodels.StatusNotFound
+	}
+
+	if _, ok := storeState.Collections[databaseId][collectionId]; !ok {
+		return repositorymodels.Document{}, repositorymodels.StatusNotFound
+	}
+
+	if _, ok := storeState.Documents[databaseId][collectionId][documentId]; !ok {
+		return repositorymodels.Document{}, repositorymodels.StatusNotFound
+	}
+
+	return storeState.Documents[databaseId][collectionId][documentId], repositorymodels.StatusOk
+}
+
+func DeleteDocument(databaseId string, collectionId string, documentId string) repositorymodels.RepositoryStatus {
+	if _, ok := storeState.Databases[databaseId]; !ok {
+		return repositorymodels.StatusNotFound
+	}
+
+	if _, ok := storeState.Collections[databaseId][collectionId]; !ok {
+		return repositorymodels.StatusNotFound
+	}
+
+	if _, ok := storeState.Documents[databaseId][collectionId][documentId]; !ok {
+		return repositorymodels.StatusNotFound
+	}
+
+	delete(storeState.Documents[databaseId][collectionId], documentId)
+
+	return repositorymodels.StatusOk
+}
+
+func CreateDocument(databaseId string, collectionId string, document map[string]interface{}) (repositorymodels.Document, repositorymodels.RepositoryStatus) {
+	var ok bool
+	var documentId string
+	var database repositorymodels.Database
+	var collection repositorymodels.Collection
+	if documentId, ok = document["id"].(string); !ok || documentId == "" {
+		documentId = fmt.Sprint(uuid.New())
+		document["id"] = documentId
+	}
+
+	if database, ok = storeState.Databases[databaseId]; !ok {
+		return repositorymodels.Document{}, repositorymodels.StatusNotFound
+	}
+
+	if collection, ok = storeState.Collections[databaseId][collectionId]; !ok {
+		return repositorymodels.Document{}, repositorymodels.StatusNotFound
+	}
+
+	if _, ok := storeState.Documents[databaseId][collectionId][documentId]; ok {
+		return repositorymodels.Document{}, repositorymodels.Conflict
+	}
+
+	document["_ts"] = time.Now().Unix()
+	document["_rid"] = resourceid.NewCombined(database.ResourceID, collection.ResourceID, resourceid.New())
+	document["_etag"] = fmt.Sprintf("\"%s\"", uuid.New())
+	document["_self"] = fmt.Sprintf("dbs/%s/colls/%s/docs/%s/", database.ResourceID, collection.ResourceID, document["_rid"])
+
+	storeState.Documents[databaseId][collectionId][documentId] = document
+
+	return document, repositorymodels.StatusOk
+}
+
+func ExecuteQueryDocuments(databaseId string, collectionId string, query string, queryParameters map[string]interface{}) ([]memoryexecutor.RowType, repositorymodels.RepositoryStatus) {
+	parsedQuery, err := nosql.Parse("", []byte(query))
+	if err != nil {
+		log.Printf("Failed to parse query: %s\nerr: %v", query, err)
+		return nil, repositorymodels.BadRequest
+	}
+
+	collectionDocuments, status := GetAllDocuments(databaseId, collectionId)
+	if status != repositorymodels.StatusOk {
+		return nil, status
+	}
+
+	covDocs := make([]memoryexecutor.RowType, 0)
+	for _, doc := range collectionDocuments {
+		covDocs = append(covDocs, map[string]interface{}(doc))
+	}
+
+	if typedQuery, ok := parsedQuery.(parsers.SelectStmt); ok {
+		typedQuery.Parameters = queryParameters
+		return memoryexecutor.Execute(typedQuery, covDocs), repositorymodels.StatusOk
+	}
+
+	return nil, repositorymodels.BadRequest
+}

internal/repositories/partition_key_ranges.go

@@ -1,36 +1,33 @@
-package jsondatastore
+package repositories
 
 import (
 	"fmt"
 
 	"github.com/google/uuid"
-	"github.com/pikami/cosmium/internal/datastore"
+	repositorymodels "github.com/pikami/cosmium/internal/repository_models"
 	"github.com/pikami/cosmium/internal/resourceid"
 )
 
 // I have no idea what this is tbh
-func (r *JsonDataStore) GetPartitionKeyRanges(databaseId string, collectionId string) ([]datastore.PartitionKeyRange, datastore.DataStoreStatus) {
+func GetPartitionKeyRanges(databaseId string, collectionId string) ([]repositorymodels.PartitionKeyRange, repositorymodels.RepositoryStatus) {
-	r.storeState.RLock()
-	defer r.storeState.RUnlock()
-
 	databaseRid := databaseId
 	collectionRid := collectionId
 	var timestamp int64 = 0
 
-	if database, ok := r.storeState.Databases[databaseId]; !ok {
+	if database, ok := storeState.Databases[databaseId]; !ok {
 		databaseRid = database.ResourceID
 	}
 
-	if collection, ok := r.storeState.Collections[databaseId][collectionId]; !ok {
+	if collection, ok := storeState.Collections[databaseId][collectionId]; !ok {
 		collectionRid = collection.ResourceID
 		timestamp = collection.TimeStamp
 	}
 
-	pkrResourceId := resourceid.NewCombined(collectionRid, resourceid.New(resourceid.ResourceTypePartitionKeyRange))
+	pkrResourceId := resourceid.NewCombined(databaseRid, collectionRid, resourceid.New())
 	pkrSelf := fmt.Sprintf("dbs/%s/colls/%s/pkranges/%s/", databaseRid, collectionRid, pkrResourceId)
 	etag := fmt.Sprintf("\"%s\"", uuid.New())
 
-	return []datastore.PartitionKeyRange{
+	return []repositorymodels.PartitionKeyRange{
 		{
 			ResourceID:         pkrResourceId,
 			ID:                 "0",
@@ -45,5 +42,5 @@ func (r *JsonDataStore) GetPartitionKeyRanges(databaseId string, collectionId st
 			TimeStamp:          timestamp,
 			Lsn:                17,
 		},
-	}, datastore.StatusOk
+	}, repositorymodels.StatusOk
 }

internal/repositories/state.go

@@ -0,0 +1,146 @@
+package repositories
+
+import (
+	"encoding/json"
+	"log"
+	"os"
+	"reflect"
+
+	"github.com/pikami/cosmium/api/config"
+	"github.com/pikami/cosmium/internal/logger"
+	repositorymodels "github.com/pikami/cosmium/internal/repository_models"
+)
+
+var storedProcedures = []repositorymodels.StoredProcedure{}
+var triggers = []repositorymodels.Trigger{}
+var userDefinedFunctions = []repositorymodels.UserDefinedFunction{}
+var storeState = repositorymodels.State{
+	Databases:   make(map[string]repositorymodels.Database),
+	Collections: make(map[string]map[string]repositorymodels.Collection),
+	Documents:   make(map[string]map[string]map[string]repositorymodels.Document),
+}
+
+func InitializeRepository() {
+	if config.Config.InitialDataFilePath != "" {
+		LoadStateFS(config.Config.InitialDataFilePath)
+		return
+	}
+
+	if config.Config.PersistDataFilePath != "" {
+		stat, err := os.Stat(config.Config.PersistDataFilePath)
+		if err != nil {
+			return
+		}
+
+		if stat.IsDir() {
+			logger.Error("Argument '-Persist' must be a path to file, not a directory.")
+			os.Exit(1)
+		}
+
+		LoadStateFS(config.Config.PersistDataFilePath)
+		return
+	}
+}
+
+func LoadStateFS(filePath string) {
+	data, err := os.ReadFile(filePath)
+	if err != nil {
+		log.Fatalf("Error reading state JSON file: %v", err)
+		return
+	}
+
+	var state repositorymodels.State
+	if err := json.Unmarshal(data, &state); err != nil {
+		log.Fatalf("Error unmarshalling state JSON: %v", err)
+		return
+	}
+
+	logger.Info("Loaded state:")
+	logger.Infof("Databases: %d\n", getLength(state.Databases))
+	logger.Infof("Collections: %d\n", getLength(state.Collections))
+	logger.Infof("Documents: %d\n", getLength(state.Documents))
+
+	storeState = state
+
+	ensureStoreStateNoNullReferences()
+}
+
+func SaveStateFS(filePath string) {
+	data, err := json.MarshalIndent(storeState, "", "\t")
+	if err != nil {
+		logger.Errorf("Failed to save state: %v\n", err)
+		return
+	}
+
+	os.WriteFile(filePath, data, os.ModePerm)
+
+	logger.Info("Saved state:")
+	logger.Infof("Databases: %d\n", getLength(storeState.Databases))
+	logger.Infof("Collections: %d\n", getLength(storeState.Collections))
+	logger.Infof("Documents: %d\n", getLength(storeState.Documents))
+}
+
+func GetState() repositorymodels.State {
+	return storeState
+}
+
+func getLength(v interface{}) int {
+	switch v.(type) {
+	case repositorymodels.Database,
+		repositorymodels.Collection,
+		repositorymodels.Document:
+		return 1
+	}
+
+	rv := reflect.ValueOf(v)
+	if rv.Kind() != reflect.Map {
+		return -1
+	}
+
+	count := 0
+	for _, key := range rv.MapKeys() {
+		if rv.MapIndex(key).Kind() == reflect.Map {
+			count += getLength(rv.MapIndex(key).Interface())
+		} else {
+			count++
+		}
+	}
+
+	return count
+}
+
+func ensureStoreStateNoNullReferences() {
+	if storeState.Databases == nil {
+		storeState.Databases = make(map[string]repositorymodels.Database)
+	}
+
+	if storeState.Collections == nil {
+		storeState.Collections = make(map[string]map[string]repositorymodels.Collection)
+	}
+
+	if storeState.Documents == nil {
+		storeState.Documents = make(map[string]map[string]map[string]repositorymodels.Document)
+	}
+
+	for database := range storeState.Databases {
+		if storeState.Collections[database] == nil {
+			storeState.Collections[database] = make(map[string]repositorymodels.Collection)
+		}
+
+		if storeState.Documents[database] == nil {
+			storeState.Documents[database] = make(map[string]map[string]repositorymodels.Document)
+		}
+
+		for collection := range storeState.Collections[database] {
+			if storeState.Documents[database][collection] == nil {
+				storeState.Documents[database][collection] = make(map[string]repositorymodels.Document)
+			}
+
+			for document := range storeState.Documents[database][collection] {
+				if storeState.Documents[database][collection][document] == nil {
+					delete(storeState.Documents[database][collection], document)
+				}
+			}
+		}
+	}
+}

internal/repositories/stored_procedures.go

@@ -0,0 +1,7 @@
+package repositories
+
+import repositorymodels "github.com/pikami/cosmium/internal/repository_models"
+
+func GetAllStoredProcedures(databaseId string, collectionId string) ([]repositorymodels.StoredProcedure, repositorymodels.RepositoryStatus) {
+	return storedProcedures, repositorymodels.StatusOk
+}

internal/repositories/triggers.go

@@ -0,0 +1,7 @@
+package repositories
+
+import repositorymodels "github.com/pikami/cosmium/internal/repository_models"
+
+func GetAllTriggers(databaseId string, collectionId string) ([]repositorymodels.Trigger, repositorymodels.RepositoryStatus) {
+	return triggers, repositorymodels.StatusOk
+}

internal/repositories/user_defined_functions.go

@@ -0,0 +1,7 @@
+package repositories
+
+import repositorymodels "github.com/pikami/cosmium/internal/repository_models"
+
+func GetAllUserDefinedFunctions(databaseId string, collectionId string) ([]repositorymodels.UserDefinedFunction, repositorymodels.RepositoryStatus) {
+	return userDefinedFunctions, repositorymodels.StatusOk
+}

internal/repository_models/models.go

@@ -1,4 +1,4 @@
-package datastore
+package repositorymodels
 
 type Database struct {
 	ID         string `json:"id"`
@@ -8,31 +8,13 @@ type Database struct {
 	Self       string `json:"_self"`
 }
 
-type DataStoreStatus int
+type RepositoryStatus int
 
 const (
 	StatusOk       = 1
 	StatusNotFound = 2
 	Conflict       = 3
 	BadRequest     = 4
-	IterEOF        = 5
-	Unknown        = 6
-)
-
-type TriggerOperation string
-
-const (
-	All     TriggerOperation = "All"
-	Create  TriggerOperation = "Create"
-	Delete  TriggerOperation = "Delete"
-	Replace TriggerOperation = "Replace"
-)
-
-type TriggerType string
-
-const (
-	Pre  TriggerType = "Pre"
-	Post TriggerType = "Post"
 )
 
 type Collection struct {
@@ -76,29 +58,29 @@ type UserDefinedFunction struct {
 	Body       string `json:"body"`
 	ID         string `json:"id"`
 	ResourceID string `json:"_rid"`
-	TimeStamp  int64  `json:"_ts"`
+	TimeStamp  int    `json:"_ts"`
 	Self       string `json:"_self"`
-	ETag       string `json:"_etag"`
+	Etag       string `json:"_etag"`
 }
 
 type StoredProcedure struct {
 	Body       string `json:"body"`
 	ID         string `json:"id"`
 	ResourceID string `json:"_rid"`
-	TimeStamp  int64  `json:"_ts"`
+	TimeStamp  int    `json:"_ts"`
 	Self       string `json:"_self"`
-	ETag       string `json:"_etag"`
+	Etag       string `json:"_etag"`
 }
 
 type Trigger struct {
 	Body             string `json:"body"`
 	ID               string `json:"id"`
-	TriggerOperation TriggerOperation `json:"triggerOperation"`
+	TriggerOperation string `json:"triggerOperation"`
-	TriggerType      TriggerType      `json:"triggerType"`
+	TriggerType      string `json:"triggerType"`
 	ResourceID       string `json:"_rid"`
-	TimeStamp        int64            `json:"_ts"`
+	TimeStamp        int    `json:"_ts"`
 	Self             string `json:"_self"`
-	ETag             string           `json:"_etag"`
+	Etag             string `json:"_etag"`
 }
 
 type Document map[string]interface{}
@@ -117,3 +99,14 @@ type PartitionKeyRange struct {
 	TimeStamp          int64  `json:"_ts"`
 	Lsn                int    `json:"lsn"`
 }
+
+type State struct {
+	// Map databaseId -> Database
+	Databases map[string]Database `json:"databases"`
+
+	// Map databaseId -> collectionId -> Collection
+	Collections map[string]map[string]Collection `json:"collections"`
+
+	// Map databaseId -> collectionId -> documentId -> Documents
+	Documents map[string]map[string]map[string]Document `json:"documents"`
+}

internal/resourceid/resourceid.go

@@ -3,76 +3,32 @@ package resourceid
 import (
 	"encoding/base64"
 	"math/rand"
-	"strings"
 
 	"github.com/google/uuid"
 )
 
-type ResourceType int
+func New() string {
+	id := uuid.New().ID()
+	idBytes := uintToBytes(id)
 
-const (
-	ResourceTypeDatabase ResourceType = iota
-	ResourceTypeCollection
-	ResourceTypeDocument
-	ResourceTypeStoredProcedure
-	ResourceTypeTrigger
-	ResourceTypeUserDefinedFunction
-	ResourceTypeConflict
-	ResourceTypePartitionKeyRange
-	ResourceTypeSchema
-)
-
-func New(resourceType ResourceType) string {
-	var idBytes []byte
-	switch resourceType {
-	case ResourceTypeDatabase:
-		idBytes = randomBytes(4)
-	case ResourceTypeCollection:
-		idBytes = randomBytes(4)
 	// first byte should be bigger than 0x80 for collection ids
 	// clients classify this id as "user" otherwise
 	if (idBytes[0] & 0x80) <= 0 {
 		idBytes[0] = byte(rand.Intn(0x80) + 0x80)
 	}
-	case ResourceTypeDocument:
-		idBytes = randomBytes(8)
-		idBytes[7] = byte(rand.Intn(0x10)) // Upper 4 bits = 0
-	case ResourceTypeStoredProcedure:
-		idBytes = randomBytes(8)
-		idBytes[7] = byte(rand.Intn(0x10)) | 0x08 // Upper 4 bits = 0x08
-	case ResourceTypeTrigger:
-		idBytes = randomBytes(8)
-		idBytes[7] = byte(rand.Intn(0x10)) | 0x07 // Upper 4 bits = 0x07
-	case ResourceTypeUserDefinedFunction:
-		idBytes = randomBytes(8)
-		idBytes[7] = byte(rand.Intn(0x10)) | 0x06 // Upper 4 bits = 0x06
-	case ResourceTypeConflict:
-		idBytes = randomBytes(8)
-		idBytes[7] = byte(rand.Intn(0x10)) | 0x04 // Upper 4 bits = 0x04
-	case ResourceTypePartitionKeyRange:
-		// we don't do partitions yet, so just use a fixed id
-		idBytes = []byte{0x69, 0x69, 0x69, 0x69, 0x69, 0x69, 0x69, 0x50}
-	case ResourceTypeSchema:
-		idBytes = randomBytes(8)
-		idBytes[7] = byte(rand.Intn(0x10)) | 0x09 // Upper 4 bits = 0x09
-	default:
-		idBytes = randomBytes(4)
-	}
 
-	encoded := base64.StdEncoding.EncodeToString(idBytes)
+	return base64.StdEncoding.EncodeToString(idBytes)
-	return strings.ReplaceAll(encoded, "/", "-")
 }
 
 func NewCombined(ids ...string) string {
 	combinedIdBytes := make([]byte, 0)
 
 	for _, id := range ids {
-		idBytes, _ := base64.StdEncoding.DecodeString(strings.ReplaceAll(id, "-", "/"))
+		idBytes, _ := base64.StdEncoding.DecodeString(id)
 		combinedIdBytes = append(combinedIdBytes, idBytes...)
 	}
 
-	encoded := base64.StdEncoding.EncodeToString(combinedIdBytes)
+	return base64.StdEncoding.EncodeToString(combinedIdBytes)
-	return strings.ReplaceAll(encoded, "/", "-")
 }
 
 func uintToBytes(id uint32) []byte {
@@ -83,13 +39,3 @@ func uintToBytes(id uint32) []byte {
 
 	return buf
 }
-
-func randomBytes(count int) []byte {
-	buf := make([]byte, count)
-	for i := 0; i < count; i += 4 {
-		id := uuid.New().ID()
-		idBytes := uintToBytes(id)
-		copy(buf[i:], idBytes)
-	}
-	return buf
-}

internal/struct_hidrators/collection_defaults.go

@@ -1,19 +1,21 @@
 package structhidrators
 
-import "github.com/pikami/cosmium/internal/datastore"
+import (
+	repositorymodels "github.com/pikami/cosmium/internal/repository_models"
+)
 
-var defaultCollection datastore.Collection = datastore.Collection{
+var defaultCollection repositorymodels.Collection = repositorymodels.Collection{
-	IndexingPolicy: datastore.CollectionIndexingPolicy{
+	IndexingPolicy: repositorymodels.CollectionIndexingPolicy{
 		IndexingMode: "consistent",
 		Automatic:    true,
-		IncludedPaths: []datastore.CollectionIndexingPolicyPath{
+		IncludedPaths: []repositorymodels.CollectionIndexingPolicyPath{
 			{Path: "/*"},
 		},
-		ExcludedPaths: []datastore.CollectionIndexingPolicyPath{
+		ExcludedPaths: []repositorymodels.CollectionIndexingPolicyPath{
 			{Path: "/\"_etag\"/?"},
 		},
 	},
-	PartitionKey: datastore.CollectionPartitionKey{
+	PartitionKey: repositorymodels.CollectionPartitionKey{
 		Paths:   []string{"/_partitionKey"},
 		Kind:    "Hash",
 		Version: 2,

internal/struct_hidrators/hidrate.go

@@ -3,11 +3,11 @@ package structhidrators
 import (
 	"reflect"
 
-	"github.com/pikami/cosmium/internal/datastore"
+	repositorymodels "github.com/pikami/cosmium/internal/repository_models"
 )
 
 func Hidrate(input interface{}) interface{} {
-	if reflect.TypeOf(input) == reflect.TypeOf(datastore.Collection{}) {
+	if reflect.TypeOf(input) == reflect.TypeOf(repositorymodels.Collection{}) {
 		return hidrate(input, defaultCollection)
 	}
 	return input

internal/tls_provider/tls_provider.go

@@ -9,7 +9,7 @@ import (
 func GetDefaultTlsConfig() *tls.Config {
 	cert, err := tls.X509KeyPair([]byte(certificate), []byte(certificateKey))
 	if err != nil {
-		logger.ErrorLn("Failed to parse certificate and key:", err)
+		logger.Error("Failed to parse certificate and key:", err)
 		return &tls.Config{}
 	}
 

main.go

@@ -0,0 +1,33 @@
+package main
+
+import (
+	"os"
+	"os/signal"
+	"syscall"
+
+	"github.com/pikami/cosmium/api"
+	"github.com/pikami/cosmium/api/config"
+	"github.com/pikami/cosmium/internal/repositories"
+)
+
+func main() {
+	config.ParseFlags()
+
+	repositories.InitializeRepository()
+
+	go api.StartAPI()
+
+	waitForExit()
+}
+
+func waitForExit() {
+	sigs := make(chan os.Signal, 1)
+	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
+
+	// Block until a exit signal is received
+	<-sigs
+
+	if config.Config.PersistDataFilePath != "" {
+		repositories.SaveStateFS(config.Config.PersistDataFilePath)
+	}
+}

parsers/models.go

@@ -5,7 +5,6 @@ type SelectStmt struct {
 	Table            Table
 	JoinItems        []JoinItem
 	Filters          interface{}
-	Exists           bool
 	Distinct         bool
 	Count            int
 	Offset           int
@@ -16,8 +15,6 @@ type SelectStmt struct {
 
 type Table struct {
 	Value string
-	SelectItem SelectItem
-	IsInSelect bool
 }
 
 type JoinItem struct {
@@ -33,9 +30,6 @@ const (
 	SelectItemTypeArray
 	SelectItemTypeConstant
 	SelectItemTypeFunctionCall
-	SelectItemTypeSubQuery
-	SelectItemTypeExpression
-	SelectItemTypeBinaryExpression
 )
 
 type SelectItem struct {
@@ -44,7 +38,6 @@ type SelectItem struct {
 	SelectItems []SelectItem
 	Type        SelectItemType
 	Value       interface{}
-	Invert      bool
 	IsTopLevel  bool
 }
 
@@ -66,12 +59,6 @@ type ComparisonExpression struct {
 	Operation string
 }
 
-type BinaryExpression struct {
-	Left      interface{}
-	Right     interface{}
-	Operation string
-}
-
 type ConstantType int
 
 const (
@@ -134,16 +121,11 @@ const (
 	FunctionCallIsString       FunctionCallType = "IsString"
 
 	FunctionCallArrayConcat  FunctionCallType = "ArrayConcat"
-	FunctionCallArrayContains    FunctionCallType = "ArrayContains"
-	FunctionCallArrayContainsAny FunctionCallType = "ArrayContainsAny"
-	FunctionCallArrayContainsAll FunctionCallType = "ArrayContainsAll"
 	FunctionCallArrayLength  FunctionCallType = "ArrayLength"
 	FunctionCallArraySlice   FunctionCallType = "ArraySlice"
 	FunctionCallSetIntersect FunctionCallType = "SetIntersect"
 	FunctionCallSetUnion     FunctionCallType = "SetUnion"
 
-	FunctionCallIif FunctionCallType = "Iif"
-
 	FunctionCallMathAbs              FunctionCallType = "MathAbs"
 	FunctionCallMathAcos             FunctionCallType = "MathAcos"
 	FunctionCallMathAsin             FunctionCallType = "MathAsin"

parsers/nosql/aggregate_functions_test.go

@@ -4,7 +4,6 @@ import (
 	"testing"
 
 	"github.com/pikami/cosmium/parsers"
-	testutils "github.com/pikami/cosmium/test_utils"
 )
 
 func Test_Parse_AggregateFunctions(t *testing.T) {
@@ -28,7 +27,7 @@ func Test_Parse_AggregateFunctions(t *testing.T) {
 						},
 					},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 			},
 		)
 	})
@@ -52,7 +51,7 @@ func Test_Parse_AggregateFunctions(t *testing.T) {
 						},
 					},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 			},
 		)
 	})
@@ -76,7 +75,7 @@ func Test_Parse_AggregateFunctions(t *testing.T) {
 						},
 					},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 			},
 		)
 	})
@@ -100,7 +99,7 @@ func Test_Parse_AggregateFunctions(t *testing.T) {
 						},
 					},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 			},
 		)
 	})
@@ -124,7 +123,7 @@ func Test_Parse_AggregateFunctions(t *testing.T) {
 						},
 					},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 			},
 		)
 	})

parsers/nosql/arithmetics_test.go

@@ -1,366 +0,0 @@
-package nosql_test
-
-import (
-	"testing"
-
-	"github.com/pikami/cosmium/parsers"
-	testutils "github.com/pikami/cosmium/test_utils"
-)
-
-func Test_Parse_Arithmetics(t *testing.T) {
-	t.Run("Should parse multiplication before addition", func(t *testing.T) {
-		testQueryParse(
-			t,
-			`SELECT c.a + c.b * c.c FROM c`,
-			parsers.SelectStmt{
-				SelectItems: []parsers.SelectItem{
-					{
-						Type: parsers.SelectItemTypeBinaryExpression,
-						Value: parsers.BinaryExpression{
-							Operation: "+",
-							Left:      testutils.SelectItem_Path("c", "a"),
-							Right: parsers.SelectItem{
-								Type: parsers.SelectItemTypeBinaryExpression,
-								Value: parsers.BinaryExpression{
-									Operation: "*",
-									Left:      testutils.SelectItem_Path("c", "b"),
-									Right:     testutils.SelectItem_Path("c", "c"),
-								},
-							},
-						},
-					},
-				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
-			},
-		)
-	})
-
-	t.Run("Should parse division before subtraction", func(t *testing.T) {
-		testQueryParse(
-			t,
-			`SELECT c.x - c.y / c.z FROM c`,
-			parsers.SelectStmt{
-				SelectItems: []parsers.SelectItem{
-					{
-						Type: parsers.SelectItemTypeBinaryExpression,
-						Value: parsers.BinaryExpression{
-							Operation: "-",
-							Left:      testutils.SelectItem_Path("c", "x"),
-							Right: parsers.SelectItem{
-								Type: parsers.SelectItemTypeBinaryExpression,
-								Value: parsers.BinaryExpression{
-									Operation: "/",
-									Left:      testutils.SelectItem_Path("c", "y"),
-									Right:     testutils.SelectItem_Path("c", "z"),
-								},
-							},
-						},
-					},
-				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
-			},
-		)
-	})
-
-	t.Run("Should handle complex mixed operations", func(t *testing.T) {
-		testQueryParse(
-			t,
-			`SELECT c.a + c.b * c.c - c.d / c.e FROM c`,
-			parsers.SelectStmt{
-				SelectItems: []parsers.SelectItem{
-					{
-						Type: parsers.SelectItemTypeBinaryExpression,
-						Value: parsers.BinaryExpression{
-							Operation: "-",
-							Left: parsers.SelectItem{
-								Type: parsers.SelectItemTypeBinaryExpression,
-								Value: parsers.BinaryExpression{
-									Operation: "+",
-									Left:      testutils.SelectItem_Path("c", "a"),
-									Right: parsers.SelectItem{
-										Type: parsers.SelectItemTypeBinaryExpression,
-										Value: parsers.BinaryExpression{
-											Operation: "*",
-											Left:      testutils.SelectItem_Path("c", "b"),
-											Right:     testutils.SelectItem_Path("c", "c"),
-										},
-									},
-								},
-							},
-							Right: parsers.SelectItem{
-								Type: parsers.SelectItemTypeBinaryExpression,
-								Value: parsers.BinaryExpression{
-									Operation: "/",
-									Left:      testutils.SelectItem_Path("c", "d"),
-									Right:     testutils.SelectItem_Path("c", "e"),
-								},
-							},
-						},
-					},
-				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
-			},
-		)
-	})
-
-	t.Run("Should respect parentheses overriding precedence", func(t *testing.T) {
-		testQueryParse(
-			t,
-			`SELECT (c.a + c.b) * c.c FROM c`,
-			parsers.SelectStmt{
-				SelectItems: []parsers.SelectItem{
-					{
-						Type: parsers.SelectItemTypeBinaryExpression,
-						Value: parsers.BinaryExpression{
-							Operation: "*",
-							Left: parsers.SelectItem{
-								Type: parsers.SelectItemTypeBinaryExpression,
-								Value: parsers.BinaryExpression{
-									Operation: "+",
-									Left:      testutils.SelectItem_Path("c", "a"),
-									Right:     testutils.SelectItem_Path("c", "b"),
-								},
-							},
-							Right: testutils.SelectItem_Path("c", "c"),
-						},
-					},
-				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
-			},
-		)
-	})
-
-	t.Run("Should handle nested parentheses", func(t *testing.T) {
-		testQueryParse(
-			t,
-			`SELECT ((c.a + c.b) * c.c) - c.d FROM c`,
-			parsers.SelectStmt{
-				SelectItems: []parsers.SelectItem{
-					{
-						Type: parsers.SelectItemTypeBinaryExpression,
-						Value: parsers.BinaryExpression{
-							Operation: "-",
-							Left: parsers.SelectItem{
-								Type: parsers.SelectItemTypeBinaryExpression,
-								Value: parsers.BinaryExpression{
-									Operation: "*",
-									Left: parsers.SelectItem{
-										Type: parsers.SelectItemTypeBinaryExpression,
-										Value: parsers.BinaryExpression{
-											Operation: "+",
-											Left:      testutils.SelectItem_Path("c", "a"),
-											Right:     testutils.SelectItem_Path("c", "b"),
-										},
-									},
-									Right: testutils.SelectItem_Path("c", "c"),
-								},
-							},
-							Right: testutils.SelectItem_Path("c", "d"),
-						},
-					},
-				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
-			},
-		)
-	})
-
-	t.Run("Should be left associative for same precedence operators", func(t *testing.T) {
-		testQueryParse(
-			t,
-			`SELECT c.a - c.b - c.c FROM c`,
-			parsers.SelectStmt{
-				SelectItems: []parsers.SelectItem{
-					{
-						Type: parsers.SelectItemTypeBinaryExpression,
-						Value: parsers.BinaryExpression{
-							Operation: "-",
-							Left: parsers.SelectItem{
-								Type: parsers.SelectItemTypeBinaryExpression,
-								Value: parsers.BinaryExpression{
-									Operation: "-",
-									Left:      testutils.SelectItem_Path("c", "a"),
-									Right:     testutils.SelectItem_Path("c", "b"),
-								},
-							},
-							Right: testutils.SelectItem_Path("c", "c"),
-						},
-					},
-				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
-			},
-		)
-	})
-
-	t.Run("Should be left associative with multiplication and division", func(t *testing.T) {
-		testQueryParse(
-			t,
-			`SELECT c.a * c.b / c.c FROM c`,
-			parsers.SelectStmt{
-				SelectItems: []parsers.SelectItem{
-					{
-						Type: parsers.SelectItemTypeBinaryExpression,
-						Value: parsers.BinaryExpression{
-							Operation: "/",
-							Left: parsers.SelectItem{
-								Type: parsers.SelectItemTypeBinaryExpression,
-								Value: parsers.BinaryExpression{
-									Operation: "*",
-									Left:      testutils.SelectItem_Path("c", "a"),
-									Right:     testutils.SelectItem_Path("c", "b"),
-								},
-							},
-							Right: testutils.SelectItem_Path("c", "c"),
-						},
-					},
-				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
-			},
-		)
-	})
-
-	t.Run("Should handle math with constants", func(t *testing.T) {
-		testQueryParse(
-			t,
-			`SELECT 10 + 20 * 5 FROM c`,
-			parsers.SelectStmt{
-				SelectItems: []parsers.SelectItem{
-					{
-						Type: parsers.SelectItemTypeBinaryExpression,
-						Value: parsers.BinaryExpression{
-							Operation: "+",
-							Left:      testutils.SelectItem_Constant_Int(10),
-							Right: parsers.SelectItem{
-								Type: parsers.SelectItemTypeBinaryExpression,
-								Value: parsers.BinaryExpression{
-									Operation: "*",
-									Left:      testutils.SelectItem_Constant_Int(20),
-									Right:     testutils.SelectItem_Constant_Int(5),
-								},
-							},
-						},
-					},
-				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
-			},
-		)
-	})
-
-	t.Run("Should handle math with floating point numbers", func(t *testing.T) {
-		testQueryParse(
-			t,
-			`SELECT c.price * 1.08 FROM c`,
-			parsers.SelectStmt{
-				SelectItems: []parsers.SelectItem{
-					{
-						Type: parsers.SelectItemTypeBinaryExpression,
-						Value: parsers.BinaryExpression{
-							Operation: "*",
-							Left:      testutils.SelectItem_Path("c", "price"),
-							Right:     testutils.SelectItem_Constant_Float(1.08),
-						},
-					},
-				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
-			},
-		)
-	})
-
-	t.Run("Should handle parentheses around single value", func(t *testing.T) {
-		testQueryParse(
-			t,
-			`SELECT (c.value) FROM c`,
-			parsers.SelectStmt{
-				SelectItems: []parsers.SelectItem{
-					testutils.SelectItem_Path("c", "value"),
-				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
-			},
-		)
-	})
-
-	t.Run("Should handle function calls in math expressions", func(t *testing.T) {
-		testQueryParse(
-			t,
-			`SELECT LENGTH(c.name) * 2 + 10 FROM c`,
-			parsers.SelectStmt{
-				SelectItems: []parsers.SelectItem{
-					{
-						Type: parsers.SelectItemTypeBinaryExpression,
-						Value: parsers.BinaryExpression{
-							Operation: "+",
-							Left: parsers.SelectItem{
-								Type: parsers.SelectItemTypeBinaryExpression,
-								Value: parsers.BinaryExpression{
-									Operation: "*",
-									Left: parsers.SelectItem{
-										Type: parsers.SelectItemTypeFunctionCall,
-										Value: parsers.FunctionCall{
-											Type:      parsers.FunctionCallLength,
-											Arguments: []interface{}{testutils.SelectItem_Path("c", "name")},
-										},
-									},
-									Right: testutils.SelectItem_Constant_Int(2),
-								},
-							},
-							Right: testutils.SelectItem_Constant_Int(10),
-						},
-					},
-				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
-			},
-		)
-	})
-
-	t.Run("Should handle multiple select items with math", func(t *testing.T) {
-		testQueryParse(
-			t,
-			`SELECT c.a + c.b, c.x * c.y FROM c`,
-			parsers.SelectStmt{
-				SelectItems: []parsers.SelectItem{
-					{
-						Type: parsers.SelectItemTypeBinaryExpression,
-						Value: parsers.BinaryExpression{
-							Operation: "+",
-							Left:      testutils.SelectItem_Path("c", "a"),
-							Right:     testutils.SelectItem_Path("c", "b"),
-						},
-					},
-					{
-						Type: parsers.SelectItemTypeBinaryExpression,
-						Value: parsers.BinaryExpression{
-							Operation: "*",
-							Left:      testutils.SelectItem_Path("c", "x"),
-							Right:     testutils.SelectItem_Path("c", "y"),
-						},
-					},
-				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
-			},
-		)
-	})
-
-	t.Run("Should handle math in WHERE clause", func(t *testing.T) {
-		testQueryParse(
-			t,
-			`SELECT c.id FROM c WHERE c.price * 1.08 > 100`,
-			parsers.SelectStmt{
-				SelectItems: []parsers.SelectItem{
-					testutils.SelectItem_Path("c", "id"),
-				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
-				Filters: parsers.ComparisonExpression{
-					Operation: ">",
-					Left: parsers.SelectItem{
-						Type: parsers.SelectItemTypeBinaryExpression,
-						Value: parsers.BinaryExpression{
-							Operation: "*",
-							Left:      testutils.SelectItem_Path("c", "price"),
-							Right:     testutils.SelectItem_Constant_Float(1.08),
-						},
-					},
-					Right: testutils.SelectItem_Constant_Int(100),
-				},
-			},
-		)
-	})
-}

parsers/nosql/array_functions_test.go

@@ -4,7 +4,6 @@ import (
 	"testing"
 
 	"github.com/pikami/cosmium/parsers"
-	testutils "github.com/pikami/cosmium/test_utils"
 )
 
 func Test_Parse_ArrayFunctions(t *testing.T) {
@@ -32,120 +31,7 @@ func Test_Parse_ArrayFunctions(t *testing.T) {
 						},
 					},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
-			},
-		)
-	})
-
-	t.Run("Should parse function ARRAY_CONTAINS()", func(t *testing.T) {
-		testQueryParse(
-			t,
-			`SELECT ARRAY_CONTAINS(c.a1, "value") FROM c`,
-			parsers.SelectStmt{
-				SelectItems: []parsers.SelectItem{
-					{
-						Type: parsers.SelectItemTypeFunctionCall,
-						Value: parsers.FunctionCall{
-							Type: parsers.FunctionCallArrayContains,
-							Arguments: []interface{}{
-								parsers.SelectItem{
-									Path: []string{"c", "a1"},
-									Type: parsers.SelectItemTypeField,
-								},
-								testutils.SelectItem_Constant_String("value"),
-								nil,
-							},
-						},
-					},
-				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
-			},
-		)
-	})
-
-	t.Run("Should parse function ARRAY_CONTAINS() with partial match", func(t *testing.T) {
-		testQueryParse(
-			t,
-			`SELECT ARRAY_CONTAINS(["a", "b"], "value", true) FROM c`,
-			parsers.SelectStmt{
-				SelectItems: []parsers.SelectItem{
-					{
-						Type: parsers.SelectItemTypeFunctionCall,
-						Value: parsers.FunctionCall{
-							Type: parsers.FunctionCallArrayContains,
-							Arguments: []interface{}{
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeArray,
-									SelectItems: []parsers.SelectItem{
-										testutils.SelectItem_Constant_String("a"),
-										testutils.SelectItem_Constant_String("b"),
-									},
-								},
-								testutils.SelectItem_Constant_String("value"),
-								testutils.SelectItem_Constant_Bool(true),
-							},
-						},
-					},
-				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
-			},
-		)
-	})
-
-	t.Run("Should parse function ARRAY_CONTAINS_ANY()", func(t *testing.T) {
-		testQueryParse(
-			t,
-			`SELECT ARRAY_CONTAINS_ANY(["a", "b"], "value", true) FROM c`,
-			parsers.SelectStmt{
-				SelectItems: []parsers.SelectItem{
-					{
-						Type: parsers.SelectItemTypeFunctionCall,
-						Value: parsers.FunctionCall{
-							Type: parsers.FunctionCallArrayContainsAny,
-							Arguments: []interface{}{
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeArray,
-									SelectItems: []parsers.SelectItem{
-										testutils.SelectItem_Constant_String("a"),
-										testutils.SelectItem_Constant_String("b"),
-									},
-								},
-								testutils.SelectItem_Constant_String("value"),
-								testutils.SelectItem_Constant_Bool(true),
-							},
-						},
-					},
-				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
-			},
-		)
-	})
-
-	t.Run("Should parse function ARRAY_CONTAINS_ALL()", func(t *testing.T) {
-		testQueryParse(
-			t,
-			`SELECT ARRAY_CONTAINS_ALL(["a", "b"], "value", true) FROM c`,
-			parsers.SelectStmt{
-				SelectItems: []parsers.SelectItem{
-					{
-						Type: parsers.SelectItemTypeFunctionCall,
-						Value: parsers.FunctionCall{
-							Type: parsers.FunctionCallArrayContainsAll,
-							Arguments: []interface{}{
-								parsers.SelectItem{
-									Type: parsers.SelectItemTypeArray,
-									SelectItems: []parsers.SelectItem{
-										testutils.SelectItem_Constant_String("a"),
-										testutils.SelectItem_Constant_String("b"),
-									},
-								},
-								testutils.SelectItem_Constant_String("value"),
-								testutils.SelectItem_Constant_Bool(true),
-							},
-						},
-					},
-				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
 			},
 		)
 	})
@@ -169,7 +55,7 @@ func Test_Parse_ArrayFunctions(t *testing.T) {
 						},
 					},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 			},
 		)
 	})
@@ -189,13 +75,25 @@ func Test_Parse_ArrayFunctions(t *testing.T) {
 									Path: []string{"c", "array"},
 									Type: parsers.SelectItemTypeField,
 								},
-								testutils.SelectItem_Constant_Int(0),
+								parsers.SelectItem{
-								testutils.SelectItem_Constant_Int(2),
+									Type: parsers.SelectItemTypeConstant,
+									Value: parsers.Constant{
+										Type:  parsers.ConstantTypeInteger,
+										Value: 0,
+									},
+								},
+								parsers.SelectItem{
+									Type: parsers.SelectItemTypeConstant,
+									Value: parsers.Constant{
+										Type:  parsers.ConstantTypeInteger,
+										Value: 2,
 									},
 								},
 							},
 						},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+					},
+				},
+				Table: parsers.Table{Value: "c"},
 			},
 		)
 	})
@@ -223,7 +121,7 @@ func Test_Parse_ArrayFunctions(t *testing.T) {
 						},
 					},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 			},
 		)
 	})
@@ -251,7 +149,7 @@ func Test_Parse_ArrayFunctions(t *testing.T) {
 						},
 					},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 			},
 		)
 	})

parsers/nosql/join_test.go

@@ -4,7 +4,6 @@ import (
 	"testing"
 
 	"github.com/pikami/cosmium/parsers"
-	testutils "github.com/pikami/cosmium/test_utils"
 )
 
 func Test_Parse_Join(t *testing.T) {
@@ -18,7 +17,7 @@ func Test_Parse_Join(t *testing.T) {
 					{Path: []string{"c", "id"}},
 					{Path: []string{"c", "pk"}},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 				JoinItems: []parsers.JoinItem{
 					{
 						Table: parsers.Table{
@@ -41,7 +40,7 @@ func Test_Parse_Join(t *testing.T) {
 				SelectItems: []parsers.SelectItem{
 					{Path: []string{"cc"}, IsTopLevel: true},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 				JoinItems: []parsers.JoinItem{
 					{
 						Table: parsers.Table{

parsers/nosql/math_functions_test.go

@@ -4,7 +4,6 @@ import (
 	"testing"
 
 	"github.com/pikami/cosmium/parsers"
-	testutils "github.com/pikami/cosmium/test_utils"
 )
 
 func Test_Execute_MathFunctions(t *testing.T) {
@@ -645,7 +644,7 @@ func testMathFunctionParse(
 					},
 				},
 			},
-			Table: parsers.Table{SelectItem: testutils.SelectItem_Path(expectedTable)},
+			Table: parsers.Table{Value: expectedTable},
 		},
 	)
 }

parsers/nosql/misc_test.go

@@ -7,7 +7,6 @@ import (
 
 	"github.com/pikami/cosmium/parsers"
 	"github.com/pikami/cosmium/parsers/nosql"
-	testutils "github.com/pikami/cosmium/test_utils"
 )
 
 // For Parser Debugging
@@ -49,7 +48,7 @@ func Test_Parse(t *testing.T) {
 					{Path: []string{"c", "id"}},
 					{Path: []string{"c", "pk"}},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 				OrderExpressions: []parsers.OrderExpression{
 					{
 						SelectItem: parsers.SelectItem{Path: []string{"c", "id"}},
@@ -73,7 +72,7 @@ func Test_Parse(t *testing.T) {
 					{Path: []string{"c", "id"}},
 					{Path: []string{"c", "pk"}},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 				GroupBy: []parsers.SelectItem{
 					{Path: []string{"c", "id"}},
 					{Path: []string{"c", "pk"}},
@@ -93,7 +92,7 @@ func Test_Parse(t *testing.T) {
 						Type: parsers.SelectItemTypeField,
 					},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 				Filters: parsers.SelectItem{
 					Type: parsers.SelectItemTypeFunctionCall,
 					Value: parsers.FunctionCall{
@@ -103,87 +102,24 @@ func Test_Parse(t *testing.T) {
 								Path: []string{"c", "id"},
 								Type: parsers.SelectItemTypeField,
 							},
-							testutils.SelectItem_Constant_String("123"),
-							testutils.SelectItem_Constant_String("456"),
-						},
-					},
-				},
-			},
-		)
-	})
-
-	t.Run("Should parse IN function with function call", func(t *testing.T) {
-		testQueryParse(
-			t,
-			`Select c.id FROM c WHERE (ToString(c.id) IN ("123", "456"))`,
-			parsers.SelectStmt{
-				SelectItems: []parsers.SelectItem{
-					testutils.SelectItem_Path("c", "id"),
-				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
-				Filters: parsers.SelectItem{
-					Type: parsers.SelectItemTypeFunctionCall,
-					Value: parsers.FunctionCall{
-						Type: parsers.FunctionCallIn,
-						Arguments: []interface{}{
 							parsers.SelectItem{
-								Type: parsers.SelectItemTypeFunctionCall,
+								Type: parsers.SelectItemTypeConstant,
-								Value: parsers.FunctionCall{
+								Value: parsers.Constant{
-									Type: parsers.FunctionCallToString,
+									Type:  parsers.ConstantTypeString,
-									Arguments: []interface{}{
+									Value: "123",
-										testutils.SelectItem_Path("c", "id"),
 								},
 							},
-							},
+							parsers.SelectItem{
-							testutils.SelectItem_Constant_String("123"),
+								Type: parsers.SelectItemTypeConstant,
-							testutils.SelectItem_Constant_String("456"),
+								Value: parsers.Constant{
+									Type:  parsers.ConstantTypeString,
+									Value: "456",
 								},
 							},
 						},
 					},
-		)
-	})
-
-	t.Run("Should parse IN selector", func(t *testing.T) {
-		testQueryParse(
-			t,
-			`SELECT c.id FROM c IN c.tags`,
-			parsers.SelectStmt{
-				SelectItems: []parsers.SelectItem{
-					{
-						Path: []string{"c", "id"},
-						Type: parsers.SelectItemTypeField,
 				},
 			},
-				Table: parsers.Table{
-					Value:      "c",
-					SelectItem: testutils.SelectItem_Path("c", "tags"),
-					IsInSelect: true,
-				},
-			},
-		)
-	})
-
-	t.Run("Should parse IIF function", func(t *testing.T) {
-		testQueryParse(
-			t,
-			`SELECT IIF(true, c.pk, c.id) FROM c`,
-			parsers.SelectStmt{
-				SelectItems: []parsers.SelectItem{
-					{
-						Type: parsers.SelectItemTypeFunctionCall,
-						Value: parsers.FunctionCall{
-							Type: parsers.FunctionCallIif,
-							Arguments: []interface{}{
-								testutils.SelectItem_Constant_Bool(true),
-								testutils.SelectItem_Path("c", "pk"),
-								testutils.SelectItem_Path("c", "id"),
-							},
-						},
-					},
-				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
-			},
 		)
 	})
 }

parsers/nosql/nosql.peg

@@ -4,17 +4,14 @@ package nosql
 import "github.com/pikami/cosmium/parsers"
 
 func makeSelectStmt(
-    columns, fromClause, joinItems,
+	columns, table, joinItems,
 	whereClause interface{}, distinctClause interface{},
 	count interface{}, groupByClause interface{}, orderList interface{},
 	offsetClause interface{},
 ) (parsers.SelectStmt, error) {
 	selectStmt := parsers.SelectStmt{
 		SelectItems: columns.([]parsers.SelectItem),
-    }
+		Table:       table.(parsers.Table),
-
-    if fromTable, ok := fromClause.(parsers.Table); ok {
-        selectStmt.Table = fromTable
 	}
 
     if joinItemsArray, ok := joinItems.([]interface{}); ok && len(joinItemsArray) > 0 {
@@ -59,18 +56,10 @@ func makeSelectStmt(
 }
 
 func makeJoin(table interface{}, column interface{}) (parsers.JoinItem, error) {
-    joinItem := parsers.JoinItem{}
+    return parsers.JoinItem{
-
+        Table:      table.(parsers.Table),
-    if selectItem, isSelectItem := column.(parsers.SelectItem); isSelectItem {
+        SelectItem: column.(parsers.SelectItem),
-        joinItem.SelectItem = selectItem
+    }, nil
-        joinItem.Table.Value = selectItem.Alias
-    }
-
-    if tableTyped, isTable := table.(parsers.Table); isTable {
-        joinItem.Table = tableTyped
-    }
-
-    return joinItem, nil
 }
 
 func makeSelectItem(name interface{}, path interface{}, selectItemType parsers.SelectItemType) (parsers.SelectItem, error) {
@@ -178,32 +167,6 @@ func combineExpressions(ex1 interface{}, exs interface{}, operation parsers.Logi
 	}, nil
 }
 
-func makeMathExpression(left interface{}, operations interface{}) (interface{}, error) {
-    if operations == nil || len(operations.([]interface{})) == 0 {
-        return left, nil
-    }
-
-    result := left.(parsers.SelectItem)
-    ops := operations.([]interface{})
-    
-    for _, op := range ops {
-        opData := op.([]interface{})
-        operation := opData[0].(string)
-        right := opData[1].(parsers.SelectItem)
-
-        result = parsers.SelectItem{
-			Type: parsers.SelectItemTypeBinaryExpression,
-			Value: parsers.BinaryExpression{
-				Left: result,
-				Right: right,
-				Operation: operation,
-			},
-		}
-    }
-    
-    return result, nil
-}
-
 }
 
 Input <- selectStmt:SelectStmt {
@@ -214,13 +177,13 @@ SelectStmt <- Select ws
     distinctClause:DistinctClause? ws
     topClause:TopClause? ws
     columns:Selection ws
-    fromClause:FromClause? ws
+    From ws table:TableName ws
-    joinClauses:(ws join:JoinClause { return join, nil })* ws
+    joinClauses:JoinClause* ws
     whereClause:(ws Where ws condition:Condition { return condition, nil })?
     groupByClause:(ws GroupBy ws columns:ColumnList { return columns, nil })?
-    orderByClause:(ws order:OrderByClause { return order, nil })?
+    orderByClause:OrderByClause?
-    offsetClause:(ws offset:OffsetClause { return offset, nil })? {
+    offsetClause:OffsetClause? {
-    return makeSelectStmt(columns, fromClause, joinClauses, whereClause,
+    return makeSelectStmt(columns, table, joinClauses, whereClause,
         distinctClause, topClause, groupByClause, orderByClause, offsetClause)
 }
 
@@ -230,60 +193,11 @@ TopClause <- Top ws count:Integer {
     return count, nil
 }
 
-FromClause <- From ws table:TableName selectItem:(ws In ws column:SelectItemWithAlias { return column, nil }) {
+JoinClause <- Join ws table:TableName ws "IN"i ws column:SelectItem {
-    tableTyped := table.(parsers.Table)
-
-    if selectItem != nil {
-        tableTyped.SelectItem = selectItem.(parsers.SelectItem)
-        tableTyped.IsInSelect = true
-    }
-
-    return tableTyped, nil
-} / From ws column:SelectItemWithAlias {
-    tableSelectItem := column.(parsers.SelectItem)
-    table := parsers.Table{
-        Value: tableSelectItem.Alias,
-        SelectItem: tableSelectItem,
-    }
-    return table, nil
-} / From ws subQuery:SubQuerySelectItem {
-    subQueryTyped := subQuery.(parsers.SelectItem)
-    table := parsers.Table{
-        Value: subQueryTyped.Alias,
-        SelectItem: subQueryTyped,
-    }
-    return table, nil
-}
-
-SubQuery <- exists:(exists:Exists ws { return exists, nil })? "(" ws selectStmt:SelectStmt ws ")" {
-    if selectStatement, isGoodValue := selectStmt.(parsers.SelectStmt); isGoodValue {
-        selectStatement.Exists = exists != nil
-        return selectStatement, nil
-    }
-
-    return selectStmt, nil
-}
-
-SubQuerySelectItem <- subQuery:SubQuery asClause:(ws alias:AsClause { return alias, nil })? {
-    selectItem := parsers.SelectItem{
-        Type: parsers.SelectItemTypeSubQuery,
-        Value: subQuery,
-    }
-
-    if tableName, isString := asClause.(string); isString {
-        selectItem.Alias = tableName
-    }
-
-    return selectItem, nil
-}
-
-JoinClause <- Join ws table:TableName ws In ws column:SelectItemWithAlias {
     return makeJoin(table, column)
-} / Join ws subQuery:SubQuerySelectItem {
-    return makeJoin(nil, subQuery)
 }
 
-OffsetClause <- Offset ws offset:IntegerLiteral ws "LIMIT"i ws limit:IntegerLiteral {
+OffsetClause <- "OFFSET"i ws offset:IntegerLiteral ws "LIMIT"i ws limit:IntegerLiteral {
     return []interface{}{offset.(parsers.Constant).Value, limit.(parsers.Constant).Value}, nil
 }
 
@@ -295,34 +209,11 @@ SelectAsterisk <- "*" {
     return makeColumnList(selectItem, make([]interface{}, 0))
 }
 
-ColumnList <- column:ExpressionOrSelectItem other_columns:(ws "," ws coll:ExpressionOrSelectItem {return coll, nil })* {
+ColumnList <- column:SelectItem other_columns:(ws "," ws coll:SelectItem {return coll, nil })* {
     return makeColumnList(column, other_columns)
 }
 
-ExpressionOrSelectItem <- expression:OrExpression asClause:AsClause? {
+SelectValueSpec <- "VALUE"i ws column:SelectItem {
-    switch typedValue := expression.(type) {
-    case parsers.ComparisonExpression, parsers.LogicalExpression:
-        selectItem := parsers.SelectItem{
-            Type: parsers.SelectItemTypeExpression,
-            Value: typedValue,
-        }
-
-        if aliasValue, ok := asClause.(string); ok {
-            selectItem.Alias = aliasValue
-        }
-
-        return selectItem, nil
-    case parsers.SelectItem:
-        if aliasValue, ok := asClause.(string); ok {
-            typedValue.Alias = aliasValue
-        }
-        return typedValue, nil
-    default:
-        return typedValue, nil
-    }
-} / item:SelectItemWithAlias { return item, nil }
-
-SelectValueSpec <- "VALUE"i ws column:SelectItemWithAlias {
     selectItem := column.(parsers.SelectItem)
 	selectItem.IsTopLevel = true
     return makeColumnList(selectItem, make([]interface{}, 0))
@@ -338,11 +229,6 @@ SelectArray <- "[" ws columns:ColumnList ws "]" {
 
 SelectObject <- "{" ws field:SelectObjectField ws other_fields:(ws "," ws coll:SelectObjectField {return coll, nil })* ws "}" {
     return makeSelectObject(field, other_fields)
-} / "{" ws "}" {
-    return parsers.SelectItem{
-        SelectItems: []parsers.SelectItem{},
-        Type:        parsers.SelectItemTypeObject,
-    }, nil
 }
 
 SelectObjectField <- name:(Identifier / "\"" key:Identifier "\"" { return key, nil }) ws ":" ws selectItem:SelectItem {
@@ -355,15 +241,7 @@ SelectProperty <- name:Identifier path:(DotFieldAccess / ArrayFieldAccess)* {
     return makeSelectItem(name, path, parsers.SelectItemTypeField)
 }
 
-SelectItemWithAlias <- selectItem:SelectItem asClause:AsClause? {
+SelectItem <- selectItem:(Literal / FunctionCall / SelectArray / SelectObject / SelectProperty) asClause:AsClause? {
-    item := selectItem.(parsers.SelectItem)
-    if aliasValue, ok := asClause.(string); ok {
-        item.Alias = aliasValue
-    }
-    return item, nil
-}
-
-SelectItem <- selectItem:(SubQuerySelectItem / Literal / FunctionCall / SelectArray / SelectObject / SelectProperty) {
     var itemResult parsers.SelectItem
     switch typedValue := selectItem.(type) {
     case parsers.SelectItem:
@@ -380,14 +258,14 @@ SelectItem <- selectItem:(SubQuerySelectItem / Literal / FunctionCall / SelectAr
         }
     }
 
+	if aliasValue, ok := asClause.(string); ok {
+		itemResult.Alias = aliasValue
+	}
+
 	return itemResult, nil
 }
 
-AsClause <- (ws As)? ws !ExcludedKeywords alias:Identifier {
+AsClause <- ws As ws alias:Identifier { return alias, nil }
-    return alias, nil
-}
-
-ExcludedKeywords <- Select / Top / As / From / In / Join / Exists / Where / And / Or / Not / GroupBy / OrderBy / Offset
 
 DotFieldAccess <- "." id:Identifier {
     return id, nil
@@ -395,7 +273,6 @@ DotFieldAccess <- "." id:Identifier {
 
 ArrayFieldAccess <- "[\"" id:Identifier "\"]" { return id, nil }
   / "[" id:Integer "]" { return strconv.Itoa(id.(int)), nil }
-  / "[" id:ParameterConstant "]" { return id.(parsers.Constant).Value.(string), nil }
 
 Identifier <- [a-zA-Z_][a-zA-Z0-9_]* {
     return string(c.text), nil
@@ -413,27 +290,11 @@ AndExpression <- ex1:ComparisonExpression ex2:(ws And ws ex:ComparisonExpression
     return combineExpressions(ex1, ex2, parsers.LogicalExpressionTypeAnd)
 }
 
-ComparisonExpression <- left:AddSubExpression ws op:ComparisonOperator ws right:AddSubExpression {
+ComparisonExpression <- "(" ws ex:OrExpression ws ")" { return ex, nil }
+    / left:SelectItem ws op:ComparisonOperator ws right:SelectItem {
     return parsers.ComparisonExpression{Left:left,Right:right,Operation:op.(string)}, nil
-} / ex:AddSubExpression { return ex, nil }
-
-AddSubExpression <- left:MulDivExpression operations:(ws op:AddOrSubtractOperation ws right:MulDivExpression { return []interface{}{op, right}, nil })* {
-    return makeMathExpression(left, operations)
-}
-
-MulDivExpression <- left:SelectItemWithParentheses operations:(ws op:MultiplyOrDivideOperation ws right:SelectItemWithParentheses { return []interface{}{op, right}, nil })* {
-    return makeMathExpression(left, operations)
-}
-
-SelectItemWithParentheses <- "(" ws ex:OrExpression ws ")" { return ex, nil }
-    / inv:(Not ws)? ex:SelectItem {
-    if inv != nil {
-        ex1 := ex.(parsers.SelectItem)
-        ex1.Invert = true
-        return ex1, nil
-    }
-    return ex, nil
 } / ex:BooleanLiteral { return ex, nil }
+  / ex:SelectItem { return ex, nil }
 
 OrderByClause <- OrderBy ws ex1:OrderExpression others:(ws "," ws ex:OrderExpression { return ex, nil })* {
     return makeOrderByClause(ex1, others)
@@ -459,34 +320,22 @@ As <- "AS"i
 
 From <- "FROM"i
 
-In <- "IN"i
-
 Join <- "JOIN"i
 
-Exists <- "EXISTS"i
-
 Where <- "WHERE"i
 
 And <- "AND"i
 
-Or <- "OR"i wss
+Or <- "OR"i
-
-Not <- "NOT"i
 
 GroupBy <- "GROUP"i ws "BY"i
 
 OrderBy <- "ORDER"i ws "BY"i
 
-Offset <- "OFFSET"i
+ComparisonOperator <- ("=" / "!=" / "<" / "<=" / ">" / ">=") {
-
-ComparisonOperator <- ("<=" / ">=" / "=" / "!=" / "<" / ">") {
     return string(c.text), nil
 }
 
-AddOrSubtractOperation <- ("+" / "-") { return string(c.text), nil }
-
-MultiplyOrDivideOperation <- ("*" / "/") { return string(c.text), nil }
-
 Literal <- FloatLiteral / IntegerLiteral / StringLiteral / BooleanLiteral / ParameterConstant / NullConstant
 
 ParameterConstant <- "@" Identifier {
@@ -514,7 +363,6 @@ BooleanLiteral <- ("true"i / "false"i) {
 FunctionCall <- StringFunctions
     / TypeCheckingFunctions
     / ArrayFunctions
-    / ConditionalFunctions
     / InFunction
     / AggregateFunctions
     / MathFunctions
@@ -554,16 +402,11 @@ AggregateFunctions <- AvgAggregateExpression
     / SumAggregateExpression
 
 ArrayFunctions <- ArrayConcatExpression
-    / ArrayContainsExpression
-    / ArrayContainsAnyExpression
-    / ArrayContainsAllExpression
     / ArrayLengthExpression
     / ArraySliceExpression
     / SetIntersectExpression
     / SetUnionExpression
 
-ConditionalFunctions <- IifExpression
-
 MathFunctions <- MathAbsExpression
     / MathAcosExpression
     / MathAsinExpression
@@ -728,18 +571,6 @@ ArrayConcatExpression <- "ARRAY_CONCAT"i ws "(" ws arrays:SelectItem others:(ws
     return createFunctionCall(parsers.FunctionCallArrayConcat, append([]interface{}{arrays}, others.([]interface{})...))
 }
 
-ArrayContainsExpression <- "ARRAY_CONTAINS"i ws "(" ws array:SelectItem ws "," ws item:SelectItem partialMatch:(ws "," ws ex:SelectItem { return ex, nil })? ws ")" {
-    return createFunctionCall(parsers.FunctionCallArrayContains, []interface{}{array, item, partialMatch})
-}
-
-ArrayContainsAnyExpression <- "ARRAY_CONTAINS_ANY"i ws "(" ws array:SelectItem items:(ws "," ws ex:SelectItem { return ex, nil })+ ws ")" {
-    return createFunctionCall(parsers.FunctionCallArrayContainsAny, append([]interface{}{array}, items.([]interface{})...))
-}
-
-ArrayContainsAllExpression <- "ARRAY_CONTAINS_ALL"i ws "(" ws array:SelectItem items:(ws "," ws ex:SelectItem { return ex, nil })+ ws ")" {
-    return createFunctionCall(parsers.FunctionCallArrayContainsAll, append([]interface{}{array}, items.([]interface{})...))
-}
-
 ArrayLengthExpression <- "ARRAY_LENGTH"i ws "(" ws array:SelectItem ws ")" {
     return createFunctionCall(parsers.FunctionCallArrayLength, []interface{}{array})
 }
@@ -756,10 +587,6 @@ SetUnionExpression <- "SetUnion"i ws "(" ws set1:SelectItem ws "," ws set2:Selec
     return createFunctionCall(parsers.FunctionCallSetUnion, []interface{}{set1, set2})
 }
 
-IifExpression <- "IIF"i ws "(" ws condition:SelectItem ws "," ws trueValue:SelectItem ws "," ws falseValue:SelectItem ws ")" {
-    return createFunctionCall(parsers.FunctionCallIif, []interface{}{condition, trueValue, falseValue})
-}
-
 MathAbsExpression <- "ABS"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathAbs, []interface{}{ex}) }
 MathAcosExpression <- "ACOS"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathAcos, []interface{}{ex}) }
 MathAsinExpression <- "ASIN"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathAsin, []interface{}{ex}) }
@@ -803,9 +630,7 @@ MathNumberBinExpression <- "NumberBin"i ws "(" ws ex1:SelectItem others:(ws ","
 MathPiExpression <- "PI"i ws "(" ws ")" { return createFunctionCall(parsers.FunctionCallMathPi, []interface{}{}) }
 MathRandExpression <- "RAND"i ws "(" ws ")" { return createFunctionCall(parsers.FunctionCallMathRand, []interface{}{}) }
 
-InFunction <- ex1:SelectProperty ws In ws "(" ws ex2:SelectItem others:(ws "," ws ex:SelectItem { return ex, nil })* ws ")" {
+InFunction <- ex1:SelectProperty ws "IN"i ws "(" ws ex2:SelectItem others:(ws "," ws ex:SelectItem { return ex, nil })* ws ")" {
-    return createFunctionCall(parsers.FunctionCallIn, append([]interface{}{ex1, ex2}, others.([]interface{})...))
-} / "(" ws ex1:SelectItem ws In ws "(" ws ex2:SelectItem others:(ws "," ws ex:SelectItem { return ex, nil })* ws ")" ws ")" {
     return createFunctionCall(parsers.FunctionCallIn, append([]interface{}{ex1, ex2}, others.([]interface{})...))
 }
 
@@ -852,6 +677,4 @@ non_escape_character <- !(escape_character) char:.
 
 ws <- [ \t\n\r]*
 
-wss <- [ \t\n\r]+
-
 EOF <- !.

parsers/nosql/select_test.go

@@ -4,7 +4,6 @@ import (
 	"testing"
 
 	"github.com/pikami/cosmium/parsers"
-	testutils "github.com/pikami/cosmium/test_utils"
 )
 
 func Test_Parse_Select(t *testing.T) {
@@ -18,21 +17,7 @@ func Test_Parse_Select(t *testing.T) {
 					{Path: []string{"c", "id"}},
 					{Path: []string{"c", "pk"}},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
-			},
-		)
-	})
-
-	t.Run("Should parse SELECT with query parameters as accessor", func(t *testing.T) {
-		testQueryParse(
-			t,
-			`SELECT c.id, c[@param] FROM c`,
-			parsers.SelectStmt{
-				SelectItems: []parsers.SelectItem{
-					{Path: []string{"c", "id"}},
-					{Path: []string{"c", "@param"}},
-				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
 			},
 		)
 	})
@@ -45,7 +30,7 @@ func Test_Parse_Select(t *testing.T) {
 				SelectItems: []parsers.SelectItem{
 					{Path: []string{"c", "id"}},
 				},
-				Table:    parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table:    parsers.Table{Value: "c"},
 				Distinct: true,
 			},
 		)
@@ -59,7 +44,7 @@ func Test_Parse_Select(t *testing.T) {
 				SelectItems: []parsers.SelectItem{
 					{Path: []string{"c", "id"}},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 				Count: 1,
 			},
 		)
@@ -73,7 +58,7 @@ func Test_Parse_Select(t *testing.T) {
 				SelectItems: []parsers.SelectItem{
 					{Path: []string{"c", "id"}},
 				},
-				Table:  parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table:  parsers.Table{Value: "c"},
 				Count:  5,
 				Offset: 3,
 			},
@@ -88,7 +73,7 @@ func Test_Parse_Select(t *testing.T) {
 				SelectItems: []parsers.SelectItem{
 					{Path: []string{"c", "id"}, IsTopLevel: true},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 			},
 		)
 	})
@@ -101,20 +86,7 @@ func Test_Parse_Select(t *testing.T) {
 				SelectItems: []parsers.SelectItem{
 					{Path: []string{"c"}, IsTopLevel: true},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
-			},
-		)
-	})
-
-	t.Run("Should parse SELECT c", func(t *testing.T) {
-		testQueryParse(
-			t,
-			`SELECT c FROM c`,
-			parsers.SelectStmt{
-				SelectItems: []parsers.SelectItem{
-					{Path: []string{"c"}, IsTopLevel: false},
-				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
 			},
 		)
 	})
@@ -134,27 +106,7 @@ func Test_Parse_Select(t *testing.T) {
 						},
 					},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
-			},
-		)
-	})
-
-	t.Run("Should parse SELECT with alias", func(t *testing.T) {
-		testQueryParse(
-			t,
-			`SELECT
-			  c.id AS aliasWithAs,
-			  c.pk aliasWithoutAs
-			FROM root c`,
-			parsers.SelectStmt{
-				SelectItems: []parsers.SelectItem{
-					{Alias: "aliasWithAs", Path: []string{"c", "id"}},
-					{Alias: "aliasWithoutAs", Path: []string{"c", "pk"}},
-				},
-				Table: parsers.Table{
-					Value:      "c",
-					SelectItem: parsers.SelectItem{Alias: "c", Path: []string{"root"}},
-				},
 			},
 		)
 	})
@@ -174,93 +126,7 @@ func Test_Parse_Select(t *testing.T) {
 						},
 					},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
-			},
-		)
-	})
-
-	t.Run("Should parse SELECT empty object", func(t *testing.T) {
-		testQueryParse(
-			t,
-			`SELECT {} AS obj FROM c`,
-			parsers.SelectStmt{
-				SelectItems: []parsers.SelectItem{
-					{
-						Alias:       "obj",
-						Type:        parsers.SelectItemTypeObject,
-						SelectItems: []parsers.SelectItem{},
-					},
-				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
-			},
-		)
-	})
-
-	t.Run("Should parse comparison expressions in SELECT", func(t *testing.T) {
-		testQueryParse(
-			t,
-			`SELECT c["id"] = "123", c["pk"] > 456 FROM c`,
-			parsers.SelectStmt{
-				SelectItems: []parsers.SelectItem{
-					{
-						Type: parsers.SelectItemTypeExpression,
-						Value: parsers.ComparisonExpression{
-							Operation: "=",
-							Left:      testutils.SelectItem_Path("c", "id"),
-							Right:     testutils.SelectItem_Constant_String("123"),
-						},
-					},
-					{
-						Type: parsers.SelectItemTypeExpression,
-						Value: parsers.ComparisonExpression{
-							Operation: ">",
-							Left:      testutils.SelectItem_Path("c", "pk"),
-							Right:     testutils.SelectItem_Constant_Int(456),
-						},
-					},
-				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
-			},
-		)
-	})
-
-	t.Run("Should parse logical expressions in SELECT", func(t *testing.T) {
-		testQueryParse(
-			t,
-			`SELECT c["id"] = "123" OR c["pk"] > 456, c["isCool"] AND c["hasRizz"] AS isRizzler FROM c`,
-			parsers.SelectStmt{
-				SelectItems: []parsers.SelectItem{
-					{
-						Type: parsers.SelectItemTypeExpression,
-						Value: parsers.LogicalExpression{
-							Operation: parsers.LogicalExpressionTypeOr,
-							Expressions: []interface{}{
-								parsers.ComparisonExpression{
-									Operation: "=",
-									Left:      testutils.SelectItem_Path("c", "id"),
-									Right:     testutils.SelectItem_Constant_String("123"),
-								},
-								parsers.ComparisonExpression{
-									Operation: ">",
-									Left:      testutils.SelectItem_Path("c", "pk"),
-									Right:     testutils.SelectItem_Constant_Int(456),
-								},
-							},
-						},
-					},
-					{
-						Type:  parsers.SelectItemTypeExpression,
-						Alias: "isRizzler",
-						Value: parsers.LogicalExpression{
-							Operation: parsers.LogicalExpressionTypeAnd,
-							Expressions: []interface{}{
-								testutils.SelectItem_Path("c", "isCool"),
-								testutils.SelectItem_Path("c", "hasRizz"),
-							},
-						},
-					},
-				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
 			},
 		)
 	})

parsers/nosql/string_functions_test.go

@@ -4,7 +4,6 @@ import (
 	"testing"
 
 	"github.com/pikami/cosmium/parsers"
-	testutils "github.com/pikami/cosmium/test_utils"
 )
 
 func Test_Execute_StringFunctions(t *testing.T) {
@@ -24,13 +23,25 @@ func Test_Execute_StringFunctions(t *testing.T) {
 									Path: []string{"c", "id"},
 									Type: parsers.SelectItemTypeField,
 								},
-								testutils.SelectItem_Constant_String("123"),
+								parsers.SelectItem{
-								testutils.SelectItem_Constant_Bool(true),
+									Type: parsers.SelectItemTypeConstant,
+									Value: parsers.Constant{
+										Type:  parsers.ConstantTypeString,
+										Value: "123",
+									},
+								},
+								parsers.SelectItem{
+									Type: parsers.SelectItemTypeConstant,
+									Value: parsers.Constant{
+										Type:  parsers.ConstantTypeBoolean,
+										Value: true,
 									},
 								},
 							},
 						},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+					},
+				},
+				Table: parsers.Table{Value: "c"},
 			},
 		)
 	})
@@ -50,13 +61,19 @@ func Test_Execute_StringFunctions(t *testing.T) {
 									Path: []string{"c", "id"},
 									Type: parsers.SelectItemTypeField,
 								},
-								testutils.SelectItem_Constant_String("123"),
+								parsers.SelectItem{
+									Type: parsers.SelectItemTypeConstant,
+									Value: parsers.Constant{
+										Type:  parsers.ConstantTypeString,
+										Value: "123",
+									},
+								},
 								nil,
 							},
 						},
 					},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 			},
 		)
 	})
@@ -76,7 +93,13 @@ func Test_Execute_StringFunctions(t *testing.T) {
 									Path: []string{"c", "id"},
 									Type: parsers.SelectItemTypeField,
 								},
-								testutils.SelectItem_Constant_String("123"),
+								parsers.SelectItem{
+									Type: parsers.SelectItemTypeConstant,
+									Value: parsers.Constant{
+										Type:  parsers.ConstantTypeString,
+										Value: "123",
+									},
+								},
 								parsers.SelectItem{
 									Path: []string{"c", "pk"},
 									Type: parsers.SelectItemTypeField,
@@ -85,7 +108,7 @@ func Test_Execute_StringFunctions(t *testing.T) {
 						},
 					},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 			},
 		)
 	})
@@ -105,13 +128,25 @@ func Test_Execute_StringFunctions(t *testing.T) {
 									Path: []string{"c", "id"},
 									Type: parsers.SelectItemTypeField,
 								},
-								testutils.SelectItem_Constant_String("123"),
+								parsers.SelectItem{
-								testutils.SelectItem_Constant_Bool(true),
+									Type: parsers.SelectItemTypeConstant,
+									Value: parsers.Constant{
+										Type:  parsers.ConstantTypeString,
+										Value: "123",
+									},
+								},
+								parsers.SelectItem{
+									Type: parsers.SelectItemTypeConstant,
+									Value: parsers.Constant{
+										Type:  parsers.ConstantTypeBoolean,
+										Value: true,
 									},
 								},
 							},
 						},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+					},
+				},
+				Table: parsers.Table{Value: "c"},
 			},
 		)
 	})
@@ -131,13 +166,25 @@ func Test_Execute_StringFunctions(t *testing.T) {
 									Path: []string{"c", "id"},
 									Type: parsers.SelectItemTypeField,
 								},
-								testutils.SelectItem_Constant_String("123"),
+								parsers.SelectItem{
-								testutils.SelectItem_Constant_Bool(true),
+									Type: parsers.SelectItemTypeConstant,
+									Value: parsers.Constant{
+										Type:  parsers.ConstantTypeString,
+										Value: "123",
+									},
+								},
+								parsers.SelectItem{
+									Type: parsers.SelectItemTypeConstant,
+									Value: parsers.Constant{
+										Type:  parsers.ConstantTypeBoolean,
+										Value: true,
 									},
 								},
 							},
 						},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+					},
+				},
+				Table: parsers.Table{Value: "c"},
 			},
 		)
 	})
@@ -157,13 +204,25 @@ func Test_Execute_StringFunctions(t *testing.T) {
 									Path: []string{"c", "id"},
 									Type: parsers.SelectItemTypeField,
 								},
-								testutils.SelectItem_Constant_String("123"),
+								parsers.SelectItem{
-								testutils.SelectItem_Constant_Bool(true),
+									Type: parsers.SelectItemTypeConstant,
+									Value: parsers.Constant{
+										Type:  parsers.ConstantTypeString,
+										Value: "123",
+									},
+								},
+								parsers.SelectItem{
+									Type: parsers.SelectItemTypeConstant,
+									Value: parsers.Constant{
+										Type:  parsers.ConstantTypeBoolean,
+										Value: true,
 									},
 								},
 							},
 						},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+					},
+				},
+				Table: parsers.Table{Value: "c"},
 			},
 		)
 	})
@@ -183,13 +242,25 @@ func Test_Execute_StringFunctions(t *testing.T) {
 									Path: []string{"c", "id"},
 									Type: parsers.SelectItemTypeField,
 								},
-								testutils.SelectItem_Constant_String("2"),
+								parsers.SelectItem{
-								testutils.SelectItem_Constant_Int(1),
+									Type: parsers.SelectItemTypeConstant,
+									Value: parsers.Constant{
+										Type:  parsers.ConstantTypeString,
+										Value: "2",
+									},
+								},
+								parsers.SelectItem{
+									Type: parsers.SelectItemTypeConstant,
+									Value: parsers.Constant{
+										Type:  parsers.ConstantTypeInteger,
+										Value: 1,
 									},
 								},
 							},
 						},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+					},
+				},
+				Table: parsers.Table{Value: "c"},
 			},
 		)
 	})
@@ -213,7 +284,7 @@ func Test_Execute_StringFunctions(t *testing.T) {
 						},
 					},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 			},
 		)
 	})
@@ -237,7 +308,7 @@ func Test_Execute_StringFunctions(t *testing.T) {
 						},
 					},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 			},
 		)
 	})
@@ -261,7 +332,7 @@ func Test_Execute_StringFunctions(t *testing.T) {
 						},
 					},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 			},
 		)
 	})
@@ -281,12 +352,18 @@ func Test_Execute_StringFunctions(t *testing.T) {
 									Path: []string{"c", "id"},
 									Type: parsers.SelectItemTypeField,
 								},
-								testutils.SelectItem_Constant_Int(5),
+								parsers.SelectItem{
+									Type: parsers.SelectItemTypeConstant,
+									Value: parsers.Constant{
+										Type:  parsers.ConstantTypeInteger,
+										Value: 5,
 									},
 								},
 							},
 						},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+					},
+				},
+				Table: parsers.Table{Value: "c"},
 			},
 		)
 	})
@@ -310,7 +387,7 @@ func Test_Execute_StringFunctions(t *testing.T) {
 						},
 					},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 			},
 		)
 	})
@@ -334,7 +411,7 @@ func Test_Execute_StringFunctions(t *testing.T) {
 						},
 					},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 			},
 		)
 	})
@@ -354,13 +431,25 @@ func Test_Execute_StringFunctions(t *testing.T) {
 									Path: []string{"c", "id"},
 									Type: parsers.SelectItemTypeField,
 								},
-								testutils.SelectItem_Constant_String("old"),
+								parsers.SelectItem{
-								testutils.SelectItem_Constant_String("new"),
+									Type: parsers.SelectItemTypeConstant,
+									Value: parsers.Constant{
+										Type:  parsers.ConstantTypeString,
+										Value: "old",
+									},
+								},
+								parsers.SelectItem{
+									Type: parsers.SelectItemTypeConstant,
+									Value: parsers.Constant{
+										Type:  parsers.ConstantTypeString,
+										Value: "new",
 									},
 								},
 							},
 						},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+					},
+				},
+				Table: parsers.Table{Value: "c"},
 			},
 		)
 	})
@@ -380,12 +469,18 @@ func Test_Execute_StringFunctions(t *testing.T) {
 									Path: []string{"c", "id"},
 									Type: parsers.SelectItemTypeField,
 								},
-								testutils.SelectItem_Constant_Int(3),
+								parsers.SelectItem{
+									Type: parsers.SelectItemTypeConstant,
+									Value: parsers.Constant{
+										Type:  parsers.ConstantTypeInteger,
+										Value: 3,
 									},
 								},
 							},
 						},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+					},
+				},
+				Table: parsers.Table{Value: "c"},
 			},
 		)
 	})
@@ -409,7 +504,7 @@ func Test_Execute_StringFunctions(t *testing.T) {
 						},
 					},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 			},
 		)
 	})
@@ -429,12 +524,18 @@ func Test_Execute_StringFunctions(t *testing.T) {
 									Path: []string{"c", "id"},
 									Type: parsers.SelectItemTypeField,
 								},
-								testutils.SelectItem_Constant_Int(3),
+								parsers.SelectItem{
+									Type: parsers.SelectItemTypeConstant,
+									Value: parsers.Constant{
+										Type:  parsers.ConstantTypeInteger,
+										Value: 3,
 									},
 								},
 							},
 						},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+					},
+				},
+				Table: parsers.Table{Value: "c"},
 			},
 		)
 	})
@@ -458,7 +559,7 @@ func Test_Execute_StringFunctions(t *testing.T) {
 						},
 					},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 			},
 		)
 	})
@@ -478,13 +579,25 @@ func Test_Execute_StringFunctions(t *testing.T) {
 									Path: []string{"c", "id"},
 									Type: parsers.SelectItemTypeField,
 								},
-								testutils.SelectItem_Constant_Int(1),
+								parsers.SelectItem{
-								testutils.SelectItem_Constant_Int(5),
+									Type: parsers.SelectItemTypeConstant,
+									Value: parsers.Constant{
+										Type:  parsers.ConstantTypeInteger,
+										Value: 1,
+									},
+								},
+								parsers.SelectItem{
+									Type: parsers.SelectItemTypeConstant,
+									Value: parsers.Constant{
+										Type:  parsers.ConstantTypeInteger,
+										Value: 5,
 									},
 								},
 							},
 						},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+					},
+				},
+				Table: parsers.Table{Value: "c"},
 			},
 		)
 	})
@@ -508,7 +621,7 @@ func Test_Execute_StringFunctions(t *testing.T) {
 						},
 					},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 			},
 		)
 	})

parsers/nosql/subquery_test.go

@@ -1,122 +0,0 @@
-package nosql_test
-
-import (
-	"testing"
-
-	"github.com/pikami/cosmium/parsers"
-	testutils "github.com/pikami/cosmium/test_utils"
-)
-
-func Test_Parse_SubQuery(t *testing.T) {
-
-	t.Run("Should parse FROM subquery", func(t *testing.T) {
-		testQueryParse(
-			t,
-			`SELECT c.id FROM (SELECT VALUE cc["info"] FROM cc) AS c`,
-			parsers.SelectStmt{
-				SelectItems: []parsers.SelectItem{
-					{Path: []string{"c", "id"}},
-				},
-				Table: parsers.Table{
-					Value: "c",
-					SelectItem: parsers.SelectItem{
-						Alias: "c",
-						Type:  parsers.SelectItemTypeSubQuery,
-						Value: parsers.SelectStmt{
-							Table: parsers.Table{SelectItem: testutils.SelectItem_Path("cc")},
-							SelectItems: []parsers.SelectItem{
-								{Path: []string{"cc", "info"}, IsTopLevel: true},
-							},
-						},
-					},
-				},
-			},
-		)
-	})
-
-	t.Run("Should parse JOIN subquery", func(t *testing.T) {
-		testQueryParse(
-			t,
-			`SELECT c.id, cc.name FROM c JOIN (SELECT tag.name FROM tag IN c.tags) AS cc`,
-			parsers.SelectStmt{
-				SelectItems: []parsers.SelectItem{
-					{Path: []string{"c", "id"}},
-					{Path: []string{"cc", "name"}},
-				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
-				JoinItems: []parsers.JoinItem{
-					{
-						Table: parsers.Table{
-							Value: "cc",
-						},
-						SelectItem: parsers.SelectItem{
-							Alias: "cc",
-							Type:  parsers.SelectItemTypeSubQuery,
-							Value: parsers.SelectStmt{
-								SelectItems: []parsers.SelectItem{
-									testutils.SelectItem_Path("tag", "name"),
-								},
-								Table: parsers.Table{
-									Value:      "tag",
-									SelectItem: testutils.SelectItem_Path("c", "tags"),
-									IsInSelect: true,
-								},
-							},
-						},
-					},
-				},
-			},
-		)
-	})
-
-	t.Run("Should parse JOIN EXISTS subquery", func(t *testing.T) {
-		testQueryParse(
-			t,
-			`SELECT c.id
-			FROM c
-			JOIN (
-				SELECT VALUE EXISTS(SELECT tag.name FROM tag IN c.tags)
-			) AS hasTags
-			WHERE hasTags`,
-			parsers.SelectStmt{
-				SelectItems: []parsers.SelectItem{
-					testutils.SelectItem_Path("c", "id"),
-				},
-				Table: parsers.Table{
-					SelectItem: testutils.SelectItem_Path("c"),
-				},
-				JoinItems: []parsers.JoinItem{
-					{
-						Table: parsers.Table{Value: "hasTags"},
-						SelectItem: parsers.SelectItem{
-							Alias: "hasTags",
-							Type:  parsers.SelectItemTypeSubQuery,
-							Value: parsers.SelectStmt{
-								SelectItems: []parsers.SelectItem{
-									{
-										IsTopLevel: true,
-										Type:       parsers.SelectItemTypeSubQuery,
-										Value: parsers.SelectStmt{
-											SelectItems: []parsers.SelectItem{
-												testutils.SelectItem_Path("tag", "name"),
-											},
-											Table: parsers.Table{
-												Value:      "tag",
-												SelectItem: testutils.SelectItem_Path("c", "tags"),
-												IsInSelect: true,
-											},
-											Exists: true,
-										},
-									},
-								},
-							},
-						},
-					},
-				},
-				Filters: parsers.SelectItem{
-					Path: []string{"hasTags"},
-				},
-			},
-		)
-	})
-}

parsers/nosql/type_checking_functions_test.go

@@ -4,7 +4,6 @@ import (
 	"testing"
 
 	"github.com/pikami/cosmium/parsers"
-	testutils "github.com/pikami/cosmium/test_utils"
 )
 
 func Test_Execute_TypeCheckingFunctions(t *testing.T) {
@@ -28,7 +27,7 @@ func Test_Execute_TypeCheckingFunctions(t *testing.T) {
 						},
 					},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 				Filters: parsers.SelectItem{
 					Type: parsers.SelectItemTypeFunctionCall,
 					Value: parsers.FunctionCall{
@@ -64,7 +63,7 @@ func Test_Execute_TypeCheckingFunctions(t *testing.T) {
 						},
 					},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 				Filters: parsers.SelectItem{
 					Type: parsers.SelectItemTypeFunctionCall,
 					Value: parsers.FunctionCall{
@@ -100,7 +99,7 @@ func Test_Execute_TypeCheckingFunctions(t *testing.T) {
 						},
 					},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 				Filters: parsers.SelectItem{
 					Type: parsers.SelectItemTypeFunctionCall,
 					Value: parsers.FunctionCall{
@@ -136,7 +135,7 @@ func Test_Execute_TypeCheckingFunctions(t *testing.T) {
 						},
 					},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 				Filters: parsers.SelectItem{
 					Type: parsers.SelectItemTypeFunctionCall,
 					Value: parsers.FunctionCall{
@@ -172,7 +171,7 @@ func Test_Execute_TypeCheckingFunctions(t *testing.T) {
 						},
 					},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 				Filters: parsers.SelectItem{
 					Type: parsers.SelectItemTypeFunctionCall,
 					Value: parsers.FunctionCall{
@@ -208,7 +207,7 @@ func Test_Execute_TypeCheckingFunctions(t *testing.T) {
 						},
 					},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 				Filters: parsers.SelectItem{
 					Type: parsers.SelectItemTypeFunctionCall,
 					Value: parsers.FunctionCall{
@@ -244,7 +243,7 @@ func Test_Execute_TypeCheckingFunctions(t *testing.T) {
 						},
 					},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 				Filters: parsers.SelectItem{
 					Type: parsers.SelectItemTypeFunctionCall,
 					Value: parsers.FunctionCall{
@@ -280,7 +279,7 @@ func Test_Execute_TypeCheckingFunctions(t *testing.T) {
 						},
 					},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 				Filters: parsers.SelectItem{
 					Type: parsers.SelectItemTypeFunctionCall,
 					Value: parsers.FunctionCall{
@@ -316,7 +315,7 @@ func Test_Execute_TypeCheckingFunctions(t *testing.T) {
 						},
 					},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 				Filters: parsers.SelectItem{
 					Type: parsers.SelectItemTypeFunctionCall,
 					Value: parsers.FunctionCall{
@@ -352,7 +351,7 @@ func Test_Execute_TypeCheckingFunctions(t *testing.T) {
 						},
 					},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 				Filters: parsers.SelectItem{
 					Type: parsers.SelectItemTypeFunctionCall,
 					Value: parsers.FunctionCall{

parsers/nosql/were_test.go

@@ -4,7 +4,6 @@ import (
 	"testing"
 
 	"github.com/pikami/cosmium/parsers"
-	testutils "github.com/pikami/cosmium/test_utils"
 )
 
 func Test_Parse_Were(t *testing.T) {
@@ -19,11 +18,14 @@ func Test_Parse_Were(t *testing.T) {
 				SelectItems: []parsers.SelectItem{
 					{Path: []string{"c", "id"}},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 				Filters: parsers.ComparisonExpression{
 					Operation: "=",
 					Left:      parsers.SelectItem{Path: []string{"c", "isCool"}},
-					Right:     testutils.SelectItem_Constant_Bool(true),
+					Right: parsers.SelectItem{
+						Type:  parsers.SelectItemTypeConstant,
+						Value: parsers.Constant{Type: parsers.ConstantTypeBoolean, Value: true},
+					},
 				},
 			},
 		)
@@ -42,19 +44,25 @@ func Test_Parse_Were(t *testing.T) {
 					{Path: []string{"c", "_rid"}},
 					{Path: []string{"c", "_ts"}},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 				Filters: parsers.LogicalExpression{
 					Operation: parsers.LogicalExpressionTypeOr,
 					Expressions: []interface{}{
 						parsers.ComparisonExpression{
 							Operation: "=",
 							Left:      parsers.SelectItem{Path: []string{"c", "id"}},
-							Right:     testutils.SelectItem_Constant_String("12345"),
+							Right: parsers.SelectItem{
+								Type:  parsers.SelectItemTypeConstant,
+								Value: parsers.Constant{Type: parsers.ConstantTypeString, Value: "12345"},
+							},
 						},
 						parsers.ComparisonExpression{
 							Operation: "=",
 							Left:      parsers.SelectItem{Path: []string{"c", "pk"}},
-							Right:     testutils.SelectItem_Constant_Int(123),
+							Right: parsers.SelectItem{
+								Type:  parsers.SelectItemTypeConstant,
+								Value: parsers.Constant{Type: parsers.ConstantTypeInteger, Value: 123},
+							},
 						},
 					},
 				},
@@ -67,19 +75,22 @@ func Test_Parse_Were(t *testing.T) {
 			t,
 			`select c.id
 		FROM c
-		WHERE c.isCool=true AND (c.id = "123" OR c.id <= "456")`,
+		WHERE c.isCool=true AND (c.id = "123" OR c.id = "456")`,
 			parsers.SelectStmt{
 				SelectItems: []parsers.SelectItem{
 					{Path: []string{"c", "id"}},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 				Filters: parsers.LogicalExpression{
 					Operation: parsers.LogicalExpressionTypeAnd,
 					Expressions: []interface{}{
 						parsers.ComparisonExpression{
 							Operation: "=",
 							Left:      parsers.SelectItem{Path: []string{"c", "isCool"}},
-							Right:     testutils.SelectItem_Constant_Bool(true),
+							Right: parsers.SelectItem{
+								Type:  parsers.SelectItemTypeConstant,
+								Value: parsers.Constant{Type: parsers.ConstantTypeBoolean, Value: true},
+							},
 						},
 						parsers.LogicalExpression{
 							Operation: parsers.LogicalExpressionTypeOr,
@@ -87,12 +98,18 @@ func Test_Parse_Were(t *testing.T) {
 								parsers.ComparisonExpression{
 									Operation: "=",
 									Left:      parsers.SelectItem{Path: []string{"c", "id"}},
-									Right:     testutils.SelectItem_Constant_String("123"),
+									Right: parsers.SelectItem{
+										Type:  parsers.SelectItemTypeConstant,
+										Value: parsers.Constant{Type: parsers.ConstantTypeString, Value: "123"},
+									},
 								},
 								parsers.ComparisonExpression{
-									Operation: "<=",
+									Operation: "=",
 									Left:      parsers.SelectItem{Path: []string{"c", "id"}},
-									Right:     testutils.SelectItem_Constant_String("456"),
+									Right: parsers.SelectItem{
+										Type:  parsers.SelectItemTypeConstant,
+										Value: parsers.Constant{Type: parsers.ConstantTypeString, Value: "456"},
+									},
 								},
 							},
 						},
@@ -114,32 +131,47 @@ func Test_Parse_Were(t *testing.T) {
 			AND c.param=@param_id1`,
 			parsers.SelectStmt{
 				SelectItems: []parsers.SelectItem{{Path: []string{"c", "id"}, Alias: ""}},
-				Table:       parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table:       parsers.Table{Value: "c"},
 				Filters: parsers.LogicalExpression{
 					Expressions: []interface{}{
 						parsers.ComparisonExpression{
 							Left: parsers.SelectItem{Path: []string{"c", "boolean"}},
-							Right:     testutils.SelectItem_Constant_Bool(true),
+							Right: parsers.SelectItem{
+								Type:  parsers.SelectItemTypeConstant,
+								Value: parsers.Constant{Type: parsers.ConstantTypeBoolean, Value: true},
+							},
 							Operation: "=",
 						},
 						parsers.ComparisonExpression{
 							Left: parsers.SelectItem{Path: []string{"c", "integer"}},
-							Right:     testutils.SelectItem_Constant_Int(1),
+							Right: parsers.SelectItem{
+								Type:  parsers.SelectItemTypeConstant,
+								Value: parsers.Constant{Type: parsers.ConstantTypeInteger, Value: 1},
+							},
 							Operation: "=",
 						},
 						parsers.ComparisonExpression{
 							Left: parsers.SelectItem{Path: []string{"c", "float"}},
-							Right:     testutils.SelectItem_Constant_Float(6.9),
+							Right: parsers.SelectItem{
+								Type:  parsers.SelectItemTypeConstant,
+								Value: parsers.Constant{Type: parsers.ConstantTypeFloat, Value: 6.9},
+							},
 							Operation: "=",
 						},
 						parsers.ComparisonExpression{
 							Left: parsers.SelectItem{Path: []string{"c", "string"}},
-							Right:     testutils.SelectItem_Constant_String("hello"),
+							Right: parsers.SelectItem{
+								Type:  parsers.SelectItemTypeConstant,
+								Value: parsers.Constant{Type: parsers.ConstantTypeString, Value: "hello"},
+							},
 							Operation: "=",
 						},
 						parsers.ComparisonExpression{
 							Left: parsers.SelectItem{Path: []string{"c", "param"}},
-							Right:     testutils.SelectItem_Constant_Parameter("@param_id1"),
+							Right: parsers.SelectItem{
+								Type:  parsers.SelectItemTypeConstant,
+								Value: parsers.Constant{Type: parsers.ConstantTypeParameterConstant, Value: "@param_id1"},
+							},
 							Operation: "=",
 						},
 					},
@@ -148,21 +180,4 @@ func Test_Parse_Were(t *testing.T) {
 			},
 		)
 	})
-
-	t.Run("Should correctly parse NOT conditions", func(t *testing.T) {
-		testQueryParse(
-			t,
-			`select c.id
-		FROM c
-		WHERE NOT c.boolean`,
-			parsers.SelectStmt{
-				SelectItems: []parsers.SelectItem{{Path: []string{"c", "id"}, Alias: ""}},
-				Table:       parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
-				Filters: parsers.SelectItem{
-					Path:   []string{"c", "boolean"},
-					Invert: true,
-				},
-			},
-		)
-	})
 }

query_executors/memory_executor/aggregate_functions.go

@@ -6,13 +6,14 @@ import (
 	"github.com/pikami/cosmium/parsers"
 )
 
-func (r rowContext) aggregate_Avg(arguments []interface{}) interface{} {
+func (c memoryExecutorContext) aggregate_Avg(arguments []interface{}, row RowType) interface{} {
 	selectExpression := arguments[0].(parsers.SelectItem)
 	sum := 0.0
 	count := 0
 
-	for _, item := range r.grouppedRows {
+	if array, isArray := row.([]RowWithJoins); isArray {
-		value := item.resolveSelectItem(selectExpression)
+		for _, item := range array {
+			value := c.getFieldValue(selectExpression, item)
 			if numericValue, ok := value.(float64); ok {
 				sum += numericValue
 				count++
@@ -21,6 +22,7 @@ func (r rowContext) aggregate_Avg(arguments []interface{}) interface{} {
 				count++
 			}
 		}
+	}
 
 	if count > 0 {
 		return sum / float64(count)
@@ -29,27 +31,30 @@ func (r rowContext) aggregate_Avg(arguments []interface{}) interface{} {
 	}
 }
 
-func (r rowContext) aggregate_Count(arguments []interface{}) interface{} {
+func (c memoryExecutorContext) aggregate_Count(arguments []interface{}, row RowType) interface{} {
 	selectExpression := arguments[0].(parsers.SelectItem)
 	count := 0
 
-	for _, item := range r.grouppedRows {
+	if array, isArray := row.([]RowWithJoins); isArray {
-		value := item.resolveSelectItem(selectExpression)
+		for _, item := range array {
+			value := c.getFieldValue(selectExpression, item)
 			if value != nil {
 				count++
 			}
 		}
+	}
 
 	return count
 }
 
-func (r rowContext) aggregate_Max(arguments []interface{}) interface{} {
+func (c memoryExecutorContext) aggregate_Max(arguments []interface{}, row RowType) interface{} {
 	selectExpression := arguments[0].(parsers.SelectItem)
 	max := 0.0
 	count := 0
 
-	for _, item := range r.grouppedRows {
+	if array, isArray := row.([]RowWithJoins); isArray {
-		value := item.resolveSelectItem(selectExpression)
+		for _, item := range array {
+			value := c.getFieldValue(selectExpression, item)
 			if numericValue, ok := value.(float64); ok {
 				if numericValue > max {
 					max = numericValue
@@ -62,6 +67,7 @@ func (r rowContext) aggregate_Max(arguments []interface{}) interface{} {
 				count++
 			}
 		}
+	}
 
 	if count > 0 {
 		return max
@@ -70,13 +76,14 @@ func (r rowContext) aggregate_Max(arguments []interface{}) interface{} {
 	}
 }
 
-func (r rowContext) aggregate_Min(arguments []interface{}) interface{} {
+func (c memoryExecutorContext) aggregate_Min(arguments []interface{}, row RowType) interface{} {
 	selectExpression := arguments[0].(parsers.SelectItem)
 	min := math.MaxFloat64
 	count := 0
 
-	for _, item := range r.grouppedRows {
+	if array, isArray := row.([]RowWithJoins); isArray {
-		value := item.resolveSelectItem(selectExpression)
+		for _, item := range array {
+			value := c.getFieldValue(selectExpression, item)
 			if numericValue, ok := value.(float64); ok {
 				if numericValue < min {
 					min = numericValue
@@ -89,6 +96,7 @@ func (r rowContext) aggregate_Min(arguments []interface{}) interface{} {
 				count++
 			}
 		}
+	}
 
 	if count > 0 {
 		return min
@@ -97,13 +105,14 @@ func (r rowContext) aggregate_Min(arguments []interface{}) interface{} {
 	}
 }
 
-func (r rowContext) aggregate_Sum(arguments []interface{}) interface{} {
+func (c memoryExecutorContext) aggregate_Sum(arguments []interface{}, row RowType) interface{} {
 	selectExpression := arguments[0].(parsers.SelectItem)
 	sum := 0.0
 	count := 0
 
-	for _, item := range r.grouppedRows {
+	if array, isArray := row.([]RowWithJoins); isArray {
-		value := item.resolveSelectItem(selectExpression)
+		for _, item := range array {
+			value := c.getFieldValue(selectExpression, item)
 			if numericValue, ok := value.(float64); ok {
 				sum += numericValue
 				count++
@@ -112,6 +121,7 @@ func (r rowContext) aggregate_Sum(arguments []interface{}) interface{} {
 				count++
 			}
 		}
+	}
 
 	if count > 0 {
 		return sum

query_executors/memory_executor/aggregate_functions_test.go

@@ -5,7 +5,6 @@ import (
 
 	"github.com/pikami/cosmium/parsers"
 	memoryexecutor "github.com/pikami/cosmium/query_executors/memory_executor"
-	testutils "github.com/pikami/cosmium/test_utils"
 )
 
 func Test_Execute_AggregateFunctions(t *testing.T) {
@@ -39,7 +38,7 @@ func Test_Execute_AggregateFunctions(t *testing.T) {
 				GroupBy: []parsers.SelectItem{
 					{Path: []string{"c", "key"}},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 			},
 			mockData,
 			[]memoryexecutor.RowType{
@@ -68,7 +67,7 @@ func Test_Execute_AggregateFunctions(t *testing.T) {
 						},
 					},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 			},
 			mockData,
 			[]memoryexecutor.RowType{
@@ -100,7 +99,7 @@ func Test_Execute_AggregateFunctions(t *testing.T) {
 				GroupBy: []parsers.SelectItem{
 					{Path: []string{"c", "key"}},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 			},
 			mockData,
 			[]memoryexecutor.RowType{
@@ -133,7 +132,7 @@ func Test_Execute_AggregateFunctions(t *testing.T) {
 				GroupBy: []parsers.SelectItem{
 					{Path: []string{"c", "key"}},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 			},
 			mockData,
 			[]memoryexecutor.RowType{
@@ -166,7 +165,7 @@ func Test_Execute_AggregateFunctions(t *testing.T) {
 				GroupBy: []parsers.SelectItem{
 					{Path: []string{"c", "key"}},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 			},
 			mockData,
 			[]memoryexecutor.RowType{
@@ -199,7 +198,7 @@ func Test_Execute_AggregateFunctions(t *testing.T) {
 				GroupBy: []parsers.SelectItem{
 					{Path: []string{"c", "key"}},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 			},
 			mockData,
 			[]memoryexecutor.RowType{

query_executors/memory_executor/arithmetics_test.go

@@ -1,91 +0,0 @@
-package memoryexecutor_test
-
-import (
-	"testing"
-
-	"github.com/pikami/cosmium/parsers"
-	memoryexecutor "github.com/pikami/cosmium/query_executors/memory_executor"
-	testutils "github.com/pikami/cosmium/test_utils"
-)
-
-func Test_Execute_Arithmetics(t *testing.T) {
-	mockData := []memoryexecutor.RowType{
-		map[string]interface{}{"id": 1, "a": 420},
-		map[string]interface{}{"id": 2, "a": 6.9},
-		map[string]interface{}{"id": 3},
-	}
-
-	t.Run("Should execute simple arithmetics", func(t *testing.T) {
-		testQueryExecute(
-			t,
-			parsers.SelectStmt{
-				SelectItems: []parsers.SelectItem{
-					{
-						Path: []string{"c", "id"},
-						Type: parsers.SelectItemTypeField,
-					},
-					{
-						Type:  parsers.SelectItemTypeBinaryExpression,
-						Alias: "result",
-						Value: parsers.BinaryExpression{
-							Operation: "+",
-							Left:      testutils.SelectItem_Path("c", "a"),
-							Right: parsers.SelectItem{
-								Type: parsers.SelectItemTypeBinaryExpression,
-								Value: parsers.BinaryExpression{
-									Operation: "*",
-									Left:      testutils.SelectItem_Constant_Float(2.0),
-									Right:     testutils.SelectItem_Constant_Int(3),
-								},
-							},
-						},
-					},
-				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
-			},
-			mockData,
-			[]memoryexecutor.RowType{
-				map[string]interface{}{"id": 1, "result": 426.0},
-				map[string]interface{}{"id": 2, "result": 12.9},
-				map[string]interface{}{"id": 3, "result": nil},
-			},
-		)
-	})
-
-	t.Run("Should execute arithmetics in WHERE clause", func(t *testing.T) {
-		testQueryExecute(
-			t,
-			parsers.SelectStmt{
-				SelectItems: []parsers.SelectItem{
-					testutils.SelectItem_Path("c", "id"),
-					{
-						Alias: "result",
-						Type:  parsers.SelectItemTypeBinaryExpression,
-						Value: parsers.BinaryExpression{
-							Operation: "*",
-							Left:      testutils.SelectItem_Path("c", "a"),
-							Right:     testutils.SelectItem_Constant_Int(2),
-						},
-					},
-				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
-				Filters: parsers.ComparisonExpression{
-					Operation: ">",
-					Left: parsers.SelectItem{
-						Type: parsers.SelectItemTypeBinaryExpression,
-						Value: parsers.BinaryExpression{
-							Operation: "*",
-							Left:      testutils.SelectItem_Path("c", "a"),
-							Right:     testutils.SelectItem_Constant_Int(2),
-						},
-					},
-					Right: testutils.SelectItem_Constant_Int(500),
-				},
-			},
-			mockData,
-			[]memoryexecutor.RowType{
-				map[string]interface{}{"id": 1, "result": 840.0},
-			},
-		)
-	})
-}

query_executors/memory_executor/array_functions.go

@@ -7,97 +7,17 @@ import (
 	"github.com/pikami/cosmium/parsers"
 )
 
-func (r rowContext) array_Concat(arguments []interface{}) []interface{} {
+func (c memoryExecutorContext) array_Concat(arguments []interface{}, row RowType) []interface{} {
 	var result []interface{}
 	for _, arg := range arguments {
-		array := r.parseArray(arg)
+		array := c.parseArray(arg, row)
 		result = append(result, array...)
 	}
 	return result
 }
 
-func (r rowContext) array_Contains(arguments []interface{}) bool {
+func (c memoryExecutorContext) array_Length(arguments []interface{}, row RowType) int {
-	array := r.parseArray(arguments[0])
+	array := c.parseArray(arguments[0], row)
-	if array == nil {
-		return false
-	}
-
-	exprToSearch := r.resolveSelectItem(arguments[1].(parsers.SelectItem))
-
-	partialSearch := false
-	if len(arguments) > 2 {
-		boolExpr := r.resolveSelectItem(arguments[2].(parsers.SelectItem))
-		if boolValue, ok := boolExpr.(bool); ok {
-			partialSearch = boolValue
-		} else {
-			logger.ErrorLn("array_Contains - got parameters of wrong type")
-			return false
-		}
-	}
-
-	for _, item := range array {
-		if partialSearch {
-			if r.partialMatch(item, exprToSearch) {
-				return true
-			}
-		} else {
-			if reflect.DeepEqual(item, exprToSearch) {
-				return true
-			}
-		}
-	}
-
-	return false
-}
-
-func (r rowContext) array_Contains_Any(arguments []interface{}) bool {
-	array := r.parseArray(arguments[0])
-	if array == nil {
-		return false
-	}
-
-	valueSelectItems := arguments[1:]
-
-	for _, valueSelectItem := range valueSelectItems {
-		value := r.resolveSelectItem(valueSelectItem.(parsers.SelectItem))
-		for _, item := range array {
-			if reflect.DeepEqual(item, value) {
-				return true
-			}
-		}
-	}
-
-	return false
-}
-
-func (r rowContext) array_Contains_All(arguments []interface{}) bool {
-	array := r.parseArray(arguments[0])
-	if array == nil {
-		return false
-	}
-
-	valueSelectItems := arguments[1:]
-
-	for _, valueSelectItem := range valueSelectItems {
-		value := r.resolveSelectItem(valueSelectItem.(parsers.SelectItem))
-
-		found := false
-		for _, item := range array {
-			if reflect.DeepEqual(item, value) {
-				found = true
-				break
-			}
-		}
-		if !found {
-			return false
-		}
-	}
-
-	return true
-}
-
-func (r rowContext) array_Length(arguments []interface{}) int {
-	array := r.parseArray(arguments[0])
 	if array == nil {
 		return 0
 	}
@@ -105,24 +25,24 @@ func (r rowContext) array_Length(arguments []interface{}) int {
 	return len(array)
 }
 
-func (r rowContext) array_Slice(arguments []interface{}) []interface{} {
+func (c memoryExecutorContext) array_Slice(arguments []interface{}, row RowType) []interface{} {
 	var ok bool
 	var start int
 	var length int
-	array := r.parseArray(arguments[0])
+	array := c.parseArray(arguments[0], row)
-	startEx := r.resolveSelectItem(arguments[1].(parsers.SelectItem))
+	startEx := c.getFieldValue(arguments[1].(parsers.SelectItem), row)
 
 	if arguments[2] != nil {
-		lengthEx := r.resolveSelectItem(arguments[2].(parsers.SelectItem))
+		lengthEx := c.getFieldValue(arguments[2].(parsers.SelectItem), row)
 
 		if length, ok = lengthEx.(int); !ok {
-			logger.ErrorLn("array_Slice - got length parameters of wrong type")
+			logger.Error("array_Slice - got length parameters of wrong type")
 			return []interface{}{}
 		}
 	}
 
 	if start, ok = startEx.(int); !ok {
-		logger.ErrorLn("array_Slice - got start parameters of wrong type")
+		logger.Error("array_Slice - got start parameters of wrong type")
 		return []interface{}{}
 	}
 
@@ -145,9 +65,9 @@ func (r rowContext) array_Slice(arguments []interface{}) []interface{} {
 	return array[start:end]
 }
 
-func (r rowContext) set_Intersect(arguments []interface{}) []interface{} {
+func (c memoryExecutorContext) set_Intersect(arguments []interface{}, row RowType) []interface{} {
-	set1 := r.parseArray(arguments[0])
+	set1 := c.parseArray(arguments[0], row)
-	set2 := r.parseArray(arguments[1])
+	set2 := c.parseArray(arguments[1], row)
 
 	intersection := make(map[interface{}]struct{})
 	if set1 == nil || set2 == nil {
@@ -168,9 +88,9 @@ func (r rowContext) set_Intersect(arguments []interface{}) []interface{} {
 	return result
 }
 
-func (r rowContext) set_Union(arguments []interface{}) []interface{} {
+func (c memoryExecutorContext) set_Union(arguments []interface{}, row RowType) []interface{} {
-	set1 := r.parseArray(arguments[0])
+	set1 := c.parseArray(arguments[0], row)
-	set2 := r.parseArray(arguments[1])
+	set2 := c.parseArray(arguments[1], row)
 
 	var result []interface{}
 	union := make(map[interface{}]struct{})
@@ -191,17 +111,13 @@ func (r rowContext) set_Union(arguments []interface{}) []interface{} {
 	return result
 }
 
-func (r rowContext) parseArray(argument interface{}) []interface{} {
+func (c memoryExecutorContext) parseArray(argument interface{}, row RowType) []interface{} {
 	exItem := argument.(parsers.SelectItem)
-	ex := r.resolveSelectItem(exItem)
+	ex := c.getFieldValue(exItem, row)
 
 	arrValue := reflect.ValueOf(ex)
-	if arrValue.Kind() == reflect.Invalid {
-		return nil
-	}
-
 	if arrValue.Kind() != reflect.Slice {
-		logger.ErrorLn("parseArray got parameters of wrong type")
+		logger.Error("parseArray got parameters of wrong type")
 		return nil
 	}
 
@@ -213,21 +129,3 @@ func (r rowContext) parseArray(argument interface{}) []interface{} {
 
 	return result
 }
-
-func (r rowContext) partialMatch(item interface{}, exprToSearch interface{}) bool {
-	itemValue := reflect.ValueOf(item)
-	exprValue := reflect.ValueOf(exprToSearch)
-
-	if itemValue.Kind() != reflect.Map || exprValue.Kind() != reflect.Map {
-		logger.ErrorLn("partialMatch got parameters of wrong type")
-		return false
-	}
-
-	for _, key := range exprValue.MapKeys() {
-		if !reflect.DeepEqual(itemValue.MapIndex(key).Interface(), exprValue.MapIndex(key).Interface()) {
-			return false
-		}
-	}
-
-	return true
-}

query_executors/memory_executor/array_functions_test.go

@@ -5,7 +5,6 @@ import (
 
 	"github.com/pikami/cosmium/parsers"
 	memoryexecutor "github.com/pikami/cosmium/query_executors/memory_executor"
-	testutils "github.com/pikami/cosmium/test_utils"
 )
 
 func Test_Execute_ArrayFunctions(t *testing.T) {
@@ -42,7 +41,7 @@ func Test_Execute_ArrayFunctions(t *testing.T) {
 						},
 					},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 			},
 			mockData,
 			[]memoryexecutor.RowType{
@@ -53,300 +52,6 @@ func Test_Execute_ArrayFunctions(t *testing.T) {
 		)
 	})
 
-	t.Run("Should execute function ARRAY_CONTAINS()", func(t *testing.T) {
-		testQueryExecute(
-			t,
-			parsers.SelectStmt{
-				Parameters: map[string]interface{}{
-					"@categories":                []interface{}{"coats", "jackets", "sweatshirts"},
-					"@objectArray":               []interface{}{map[string]interface{}{"category": "shirts", "color": "blue", "nestedObject": map[string]interface{}{"size": "M"}}},
-					"@fullMatchObject":           map[string]interface{}{"category": "shirts", "color": "blue", "nestedObject": map[string]interface{}{"size": "M"}},
-					"@partialMatchObject":        map[string]interface{}{"category": "shirts"},
-					"@missingPartialMatchObject": map[string]interface{}{"category": "shorts", "color": "blue"},
-					"@nestedPartialMatchObject":  map[string]interface{}{"nestedObject": map[string]interface{}{"size": "M"}},
-				},
-				SelectItems: []parsers.SelectItem{
-					{
-						Alias: "ContainsItem",
-						Type:  parsers.SelectItemTypeFunctionCall,
-						Value: parsers.FunctionCall{
-							Type: parsers.FunctionCallArrayContains,
-							Arguments: []interface{}{
-								testutils.SelectItem_Constant_Parameter("@categories"),
-								testutils.SelectItem_Constant_String("coats"),
-							},
-						},
-					},
-					{
-						Alias: "MissingItem",
-						Type:  parsers.SelectItemTypeFunctionCall,
-						Value: parsers.FunctionCall{
-							Type: parsers.FunctionCallArrayContains,
-							Arguments: []interface{}{
-								testutils.SelectItem_Constant_Parameter("@categories"),
-								testutils.SelectItem_Constant_String("hoodies"),
-							},
-						},
-					},
-					{
-						Alias: "ContainsFullMatchObject",
-						Type:  parsers.SelectItemTypeFunctionCall,
-						Value: parsers.FunctionCall{
-							Type: parsers.FunctionCallArrayContains,
-							Arguments: []interface{}{
-								testutils.SelectItem_Constant_Parameter("@objectArray"),
-								testutils.SelectItem_Constant_Parameter("@fullMatchObject"),
-							},
-						},
-					},
-					{
-						Alias: "MissingFullMatchObject",
-						Type:  parsers.SelectItemTypeFunctionCall,
-						Value: parsers.FunctionCall{
-							Type: parsers.FunctionCallArrayContains,
-							Arguments: []interface{}{
-								testutils.SelectItem_Constant_Parameter("@objectArray"),
-								testutils.SelectItem_Constant_Parameter("@partialMatchObject"),
-							},
-						},
-					},
-					{
-						Alias: "ContainsPartialMatchObject",
-						Type:  parsers.SelectItemTypeFunctionCall,
-						Value: parsers.FunctionCall{
-							Type: parsers.FunctionCallArrayContains,
-							Arguments: []interface{}{
-								testutils.SelectItem_Constant_Parameter("@objectArray"),
-								testutils.SelectItem_Constant_Parameter("@partialMatchObject"),
-								testutils.SelectItem_Constant_Bool(true),
-							},
-						},
-					},
-					{
-						Alias: "MissingPartialMatchObject",
-						Type:  parsers.SelectItemTypeFunctionCall,
-						Value: parsers.FunctionCall{
-							Type: parsers.FunctionCallArrayContains,
-							Arguments: []interface{}{
-								testutils.SelectItem_Constant_Parameter("@objectArray"),
-								testutils.SelectItem_Constant_Parameter("@missingPartialMatchObject"),
-								testutils.SelectItem_Constant_Bool(true),
-							},
-						},
-					},
-					{
-						Alias: "ContainsNestedPartialMatchObject",
-						Type:  parsers.SelectItemTypeFunctionCall,
-						Value: parsers.FunctionCall{
-							Type: parsers.FunctionCallArrayContains,
-							Arguments: []interface{}{
-								testutils.SelectItem_Constant_Parameter("@objectArray"),
-								testutils.SelectItem_Constant_Parameter("@nestedPartialMatchObject"),
-								testutils.SelectItem_Constant_Bool(true),
-							},
-						},
-					},
-				},
-			},
-			[]memoryexecutor.RowType{map[string]interface{}{"id": "123"}},
-			[]memoryexecutor.RowType{
-				map[string]interface{}{
-					"ContainsItem":                     true,
-					"MissingItem":                      false,
-					"ContainsFullMatchObject":          true,
-					"MissingFullMatchObject":           false,
-					"ContainsPartialMatchObject":       true,
-					"MissingPartialMatchObject":        false,
-					"ContainsNestedPartialMatchObject": true,
-				},
-			},
-		)
-	})
-
-	t.Run("Should execute function ARRAY_CONTAINS_ANY()", func(t *testing.T) {
-		testQueryExecute(
-			t,
-			parsers.SelectStmt{
-				Parameters: map[string]interface{}{
-					"@mixedArray": []interface{}{1, true, "3", []int{1, 2, 3}},
-					"@numbers":    []interface{}{1, 2, 3, 4},
-					"@emptyArray": []interface{}{},
-					"@arr123":     []interface{}{1, 2, 3},
-				},
-				SelectItems: []parsers.SelectItem{
-					{
-						Alias: "matchesEntireArray",
-						Type:  parsers.SelectItemTypeFunctionCall,
-						Value: parsers.FunctionCall{
-							Type: parsers.FunctionCallArrayContainsAny,
-							Arguments: []interface{}{
-								testutils.SelectItem_Constant_Parameter("@mixedArray"),
-								testutils.SelectItem_Constant_Int(1),
-								testutils.SelectItem_Constant_Bool(true),
-								testutils.SelectItem_Constant_String("3"),
-								testutils.SelectItem_Constant_Parameter("@arr123"),
-							},
-						},
-					},
-					{
-						Alias: "matchesSomeValues",
-						Type:  parsers.SelectItemTypeFunctionCall,
-						Value: parsers.FunctionCall{
-							Type: parsers.FunctionCallArrayContainsAny,
-							Arguments: []interface{}{
-								testutils.SelectItem_Constant_Parameter("@numbers"),
-								testutils.SelectItem_Constant_Int(2),
-								testutils.SelectItem_Constant_Int(3),
-								testutils.SelectItem_Constant_Int(4),
-								testutils.SelectItem_Constant_Int(5),
-							},
-						},
-					},
-					{
-						Alias: "matchSingleValue",
-						Type:  parsers.SelectItemTypeFunctionCall,
-						Value: parsers.FunctionCall{
-							Type: parsers.FunctionCallArrayContainsAny,
-							Arguments: []interface{}{
-								testutils.SelectItem_Constant_Parameter("@numbers"),
-								testutils.SelectItem_Constant_Int(1),
-							},
-						},
-					},
-					{
-						Alias: "noMatches",
-						Type:  parsers.SelectItemTypeFunctionCall,
-						Value: parsers.FunctionCall{
-							Type: parsers.FunctionCallArrayContainsAny,
-							Arguments: []interface{}{
-								testutils.SelectItem_Constant_Parameter("@numbers"),
-								testutils.SelectItem_Constant_Int(5),
-								testutils.SelectItem_Constant_Int(6),
-								testutils.SelectItem_Constant_Int(7),
-								testutils.SelectItem_Constant_Int(8),
-							},
-						},
-					},
-					{
-						Alias: "emptyArray",
-						Type:  parsers.SelectItemTypeFunctionCall,
-						Value: parsers.FunctionCall{
-							Type: parsers.FunctionCallArrayContainsAny,
-							Arguments: []interface{}{
-								testutils.SelectItem_Constant_Parameter("@emptyArray"),
-								testutils.SelectItem_Constant_Int(1),
-								testutils.SelectItem_Constant_Int(2),
-								testutils.SelectItem_Constant_Int(3),
-							},
-						},
-					},
-				},
-			},
-			[]memoryexecutor.RowType{map[string]interface{}{"id": "123"}},
-			[]memoryexecutor.RowType{
-				map[string]interface{}{
-					"matchesEntireArray": true,
-					"matchesSomeValues":  true,
-					"matchSingleValue":   true,
-					"noMatches":          false,
-					"emptyArray":         false,
-				},
-			},
-		)
-	})
-
-	t.Run("Should execute function ARRAY_CONTAINS_ALL()", func(t *testing.T) {
-		testQueryExecute(
-			t,
-			parsers.SelectStmt{
-				Parameters: map[string]interface{}{
-					"@mixedArray": []interface{}{1, true, "3", []interface{}{1, 2, 3}},
-					"@numbers":    []interface{}{1, 2, 3, 4},
-					"@emptyArray": []interface{}{},
-					"@arr123":     []interface{}{1, 2, 3},
-				},
-				SelectItems: []parsers.SelectItem{
-					{
-						Alias: "matchesEntireArray",
-						Type:  parsers.SelectItemTypeFunctionCall,
-						Value: parsers.FunctionCall{
-							Type: parsers.FunctionCallArrayContainsAll,
-							Arguments: []interface{}{
-								testutils.SelectItem_Constant_Parameter("@mixedArray"),
-								testutils.SelectItem_Constant_Int(1),
-								testutils.SelectItem_Constant_Bool(true),
-								testutils.SelectItem_Constant_String("3"),
-								testutils.SelectItem_Constant_Parameter("@arr123"),
-							},
-						},
-					},
-					{
-						Alias: "matchesSomeValues",
-						Type:  parsers.SelectItemTypeFunctionCall,
-						Value: parsers.FunctionCall{
-							Type: parsers.FunctionCallArrayContainsAll,
-							Arguments: []interface{}{
-								testutils.SelectItem_Constant_Parameter("@numbers"),
-								testutils.SelectItem_Constant_Int(2),
-								testutils.SelectItem_Constant_Int(3),
-								testutils.SelectItem_Constant_Int(4),
-								testutils.SelectItem_Constant_Int(5),
-							},
-						},
-					},
-					{
-						Alias: "matchSingleValue",
-						Type:  parsers.SelectItemTypeFunctionCall,
-						Value: parsers.FunctionCall{
-							Type: parsers.FunctionCallArrayContainsAll,
-							Arguments: []interface{}{
-								testutils.SelectItem_Constant_Parameter("@numbers"),
-								testutils.SelectItem_Constant_Int(1),
-							},
-						},
-					},
-					{
-						Alias: "noMatches",
-						Type:  parsers.SelectItemTypeFunctionCall,
-						Value: parsers.FunctionCall{
-							Type: parsers.FunctionCallArrayContainsAll,
-							Arguments: []interface{}{
-								testutils.SelectItem_Constant_Parameter("@numbers"),
-								testutils.SelectItem_Constant_Int(5),
-								testutils.SelectItem_Constant_Int(6),
-								testutils.SelectItem_Constant_Int(7),
-								testutils.SelectItem_Constant_Int(8),
-							},
-						},
-					},
-					{
-						Alias: "emptyArray",
-						Type:  parsers.SelectItemTypeFunctionCall,
-						Value: parsers.FunctionCall{
-							Type: parsers.FunctionCallArrayContainsAll,
-							Arguments: []interface{}{
-								testutils.SelectItem_Constant_Parameter("@emptyArray"),
-								testutils.SelectItem_Constant_Int(1),
-								testutils.SelectItem_Constant_Int(2),
-								testutils.SelectItem_Constant_Int(3),
-							},
-						},
-					},
-				},
-			},
-			[]memoryexecutor.RowType{map[string]interface{}{"id": "123"}},
-			[]memoryexecutor.RowType{
-				map[string]interface{}{
-					"matchesEntireArray": true,
-					"matchesSomeValues":  false,
-					"matchSingleValue":   true,
-					"noMatches":          false,
-					"emptyArray":         false,
-				},
-			},
-		)
-	})
-
 	t.Run("Should execute function ARRAY_LENGTH()", func(t *testing.T) {
 		testQueryExecute(
 			t,
@@ -370,7 +75,7 @@ func Test_Execute_ArrayFunctions(t *testing.T) {
 						},
 					},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 			},
 			mockData,
 			[]memoryexecutor.RowType{
@@ -400,13 +105,25 @@ func Test_Execute_ArrayFunctions(t *testing.T) {
 									Path: []string{"c", "arr2"},
 									Type: parsers.SelectItemTypeField,
 								},
-								testutils.SelectItem_Constant_Int(1),
+								parsers.SelectItem{
-								testutils.SelectItem_Constant_Int(2),
+									Type: parsers.SelectItemTypeConstant,
+									Value: parsers.Constant{
+										Type:  parsers.ConstantTypeInteger,
+										Value: 1,
+									},
+								},
+								parsers.SelectItem{
+									Type: parsers.SelectItemTypeConstant,
+									Value: parsers.Constant{
+										Type:  parsers.ConstantTypeInteger,
+										Value: 2,
 									},
 								},
 							},
 						},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+					},
+				},
+				Table: parsers.Table{Value: "c"},
 			},
 			mockData,
 			[]memoryexecutor.RowType{
@@ -444,7 +161,7 @@ func Test_Execute_ArrayFunctions(t *testing.T) {
 						},
 					},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 			},
 			mockData,
 			[]memoryexecutor.RowType{
@@ -482,7 +199,7 @@ func Test_Execute_ArrayFunctions(t *testing.T) {
 						},
 					},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Table: parsers.Table{Value: "c"},
 			},
 			mockData,
 			[]memoryexecutor.RowType{

query_executors/memory_executor/array_iterator.go

@@ -1,27 +0,0 @@
-package memoryexecutor
-
-import "github.com/pikami/cosmium/internal/datastore"
-
-type rowArrayIterator struct {
-	documents []rowContext
-	index     int
-}
-
-func NewRowArrayIterator(documents []rowContext) *rowArrayIterator {
-	return &rowArrayIterator{
-		documents: documents,
-		index:     -1,
-	}
-}
-
-func (i *rowArrayIterator) Next() (rowContext, datastore.DataStoreStatus) {
-	i.index++
-	if i.index >= len(i.documents) {
-		return rowContext{}, datastore.IterEOF
-	}
-
-	row := i.documents[i.index]
-	i.documents[i.index] = rowContext{} // Help GC reclaim memory
-
-	return row, datastore.StatusOk
-}

query_executors/memory_executor/common.go

@@ -1,459 +0,0 @@
-package memoryexecutor
-
-import (
-	"fmt"
-	"reflect"
-	"strconv"
-	"strings"
-
-	"github.com/pikami/cosmium/internal/datastore"
-	"github.com/pikami/cosmium/internal/logger"
-	"github.com/pikami/cosmium/parsers"
-)
-
-type RowType interface{}
-type rowContext struct {
-	tables       map[string]RowType
-	parameters   map[string]interface{}
-	grouppedRows []rowContext
-}
-
-type rowIterator interface {
-	Next() (rowContext, datastore.DataStoreStatus)
-}
-
-type rowTypeIterator interface {
-	Next() (RowType, datastore.DataStoreStatus)
-}
-
-func resolveDestinationColumnName(selectItem parsers.SelectItem, itemIndex int, queryParameters map[string]interface{}) string {
-	if selectItem.Alias != "" {
-		return selectItem.Alias
-	}
-
-	destinationName := fmt.Sprintf("$%d", itemIndex+1)
-	if len(selectItem.Path) > 0 {
-		destinationName = selectItem.Path[len(selectItem.Path)-1]
-	}
-
-	if destinationName[0] == '@' {
-		destinationName = queryParameters[destinationName].(string)
-	}
-
-	return destinationName
-}
-
-func (r rowContext) resolveSelectItem(selectItem parsers.SelectItem) interface{} {
-	if selectItem.Type == parsers.SelectItemTypeArray {
-		return r.selectItem_SelectItemTypeArray(selectItem)
-	}
-
-	if selectItem.Type == parsers.SelectItemTypeObject {
-		return r.selectItem_SelectItemTypeObject(selectItem)
-	}
-
-	if selectItem.Type == parsers.SelectItemTypeConstant {
-		return r.selectItem_SelectItemTypeConstant(selectItem)
-	}
-
-	if selectItem.Type == parsers.SelectItemTypeSubQuery {
-		return r.selectItem_SelectItemTypeSubQuery(selectItem)
-	}
-
-	if selectItem.Type == parsers.SelectItemTypeFunctionCall {
-		if typedFunctionCall, ok := selectItem.Value.(parsers.FunctionCall); ok {
-			return r.selectItem_SelectItemTypeFunctionCall(typedFunctionCall)
-		}
-
-		logger.ErrorLn("parsers.SelectItem has incorrect Value type (expected parsers.FunctionCall)")
-		return nil
-	}
-
-	if selectItem.Type == parsers.SelectItemTypeExpression {
-		if typedExpression, ok := selectItem.Value.(parsers.ComparisonExpression); ok {
-			return r.filters_ComparisonExpression(typedExpression)
-		}
-
-		if typedExpression, ok := selectItem.Value.(parsers.LogicalExpression); ok {
-			return r.filters_LogicalExpression(typedExpression)
-		}
-
-		logger.ErrorLn("parsers.SelectItem has incorrect Value type (expected parsers.ComparisonExpression)")
-		return nil
-	}
-
-	if selectItem.Type == parsers.SelectItemTypeBinaryExpression {
-		if typedSelectItem, ok := selectItem.Value.(parsers.BinaryExpression); ok {
-			return r.selectItem_SelectItemTypeBinaryExpression(typedSelectItem)
-		}
-
-		logger.ErrorLn("parsers.SelectItem has incorrect Value type (expected parsers.BinaryExpression)")
-		return nil
-	}
-
-	return r.selectItem_SelectItemTypeField(selectItem)
-}
-
-func (r rowContext) selectItem_SelectItemTypeArray(selectItem parsers.SelectItem) interface{} {
-	arrayValue := make([]interface{}, 0)
-	for _, subSelectItem := range selectItem.SelectItems {
-		arrayValue = append(arrayValue, r.resolveSelectItem(subSelectItem))
-	}
-	return arrayValue
-}
-
-func (r rowContext) selectItem_SelectItemTypeObject(selectItem parsers.SelectItem) interface{} {
-	objectValue := make(map[string]interface{})
-	for _, subSelectItem := range selectItem.SelectItems {
-		objectValue[subSelectItem.Alias] = r.resolveSelectItem(subSelectItem)
-	}
-	return objectValue
-}
-
-func (r rowContext) selectItem_SelectItemTypeConstant(selectItem parsers.SelectItem) interface{} {
-	var typedValue parsers.Constant
-	var ok bool
-	if typedValue, ok = selectItem.Value.(parsers.Constant); !ok {
-		// TODO: Handle error
-		logger.ErrorLn("parsers.Constant has incorrect Value type")
-	}
-
-	if typedValue.Type == parsers.ConstantTypeParameterConstant &&
-		r.parameters != nil {
-		if key, ok := typedValue.Value.(string); ok {
-			return r.parameters[key]
-		}
-	}
-
-	return typedValue.Value
-}
-
-func (r rowContext) selectItem_SelectItemTypeSubQuery(selectItem parsers.SelectItem) interface{} {
-	subQuery := selectItem.Value.(parsers.SelectStmt)
-	subQueryResult := executeQuery(
-		subQuery,
-		NewRowArrayIterator([]rowContext{r}),
-	)
-
-	if subQuery.Exists {
-		_, status := subQueryResult.Next()
-		return status == datastore.StatusOk
-	}
-
-	allDocuments := make([]RowType, 0)
-	for {
-		row, status := subQueryResult.Next()
-		if status != datastore.StatusOk {
-			break
-		}
-		allDocuments = append(allDocuments, row)
-	}
-
-	return allDocuments
-}
-
-func (r rowContext) selectItem_SelectItemTypeFunctionCall(functionCall parsers.FunctionCall) interface{} {
-	switch functionCall.Type {
-	case parsers.FunctionCallStringEquals:
-		return r.strings_StringEquals(functionCall.Arguments)
-	case parsers.FunctionCallContains:
-		return r.strings_Contains(functionCall.Arguments)
-	case parsers.FunctionCallEndsWith:
-		return r.strings_EndsWith(functionCall.Arguments)
-	case parsers.FunctionCallStartsWith:
-		return r.strings_StartsWith(functionCall.Arguments)
-	case parsers.FunctionCallConcat:
-		return r.strings_Concat(functionCall.Arguments)
-	case parsers.FunctionCallIndexOf:
-		return r.strings_IndexOf(functionCall.Arguments)
-	case parsers.FunctionCallToString:
-		return r.strings_ToString(functionCall.Arguments)
-	case parsers.FunctionCallUpper:
-		return r.strings_Upper(functionCall.Arguments)
-	case parsers.FunctionCallLower:
-		return r.strings_Lower(functionCall.Arguments)
-	case parsers.FunctionCallLeft:
-		return r.strings_Left(functionCall.Arguments)
-	case parsers.FunctionCallLength:
-		return r.strings_Length(functionCall.Arguments)
-	case parsers.FunctionCallLTrim:
-		return r.strings_LTrim(functionCall.Arguments)
-	case parsers.FunctionCallReplace:
-		return r.strings_Replace(functionCall.Arguments)
-	case parsers.FunctionCallReplicate:
-		return r.strings_Replicate(functionCall.Arguments)
-	case parsers.FunctionCallReverse:
-		return r.strings_Reverse(functionCall.Arguments)
-	case parsers.FunctionCallRight:
-		return r.strings_Right(functionCall.Arguments)
-	case parsers.FunctionCallRTrim:
-		return r.strings_RTrim(functionCall.Arguments)
-	case parsers.FunctionCallSubstring:
-		return r.strings_Substring(functionCall.Arguments)
-	case parsers.FunctionCallTrim:
-		return r.strings_Trim(functionCall.Arguments)
-
-	case parsers.FunctionCallIsDefined:
-		return r.typeChecking_IsDefined(functionCall.Arguments)
-	case parsers.FunctionCallIsArray:
-		return r.typeChecking_IsArray(functionCall.Arguments)
-	case parsers.FunctionCallIsBool:
-		return r.typeChecking_IsBool(functionCall.Arguments)
-	case parsers.FunctionCallIsFiniteNumber:
-		return r.typeChecking_IsFiniteNumber(functionCall.Arguments)
-	case parsers.FunctionCallIsInteger:
-		return r.typeChecking_IsInteger(functionCall.Arguments)
-	case parsers.FunctionCallIsNull:
-		return r.typeChecking_IsNull(functionCall.Arguments)
-	case parsers.FunctionCallIsNumber:
-		return r.typeChecking_IsNumber(functionCall.Arguments)
-	case parsers.FunctionCallIsObject:
-		return r.typeChecking_IsObject(functionCall.Arguments)
-	case parsers.FunctionCallIsPrimitive:
-		return r.typeChecking_IsPrimitive(functionCall.Arguments)
-	case parsers.FunctionCallIsString:
-		return r.typeChecking_IsString(functionCall.Arguments)
-
-	case parsers.FunctionCallArrayConcat:
-		return r.array_Concat(functionCall.Arguments)
-	case parsers.FunctionCallArrayContains:
-		return r.array_Contains(functionCall.Arguments)
-	case parsers.FunctionCallArrayContainsAny:
-		return r.array_Contains_Any(functionCall.Arguments)
-	case parsers.FunctionCallArrayContainsAll:
-		return r.array_Contains_All(functionCall.Arguments)
-	case parsers.FunctionCallArrayLength:
-		return r.array_Length(functionCall.Arguments)
-	case parsers.FunctionCallArraySlice:
-		return r.array_Slice(functionCall.Arguments)
-	case parsers.FunctionCallSetIntersect:
-		return r.set_Intersect(functionCall.Arguments)
-	case parsers.FunctionCallSetUnion:
-		return r.set_Union(functionCall.Arguments)
-
-	case parsers.FunctionCallIif:
-		return r.misc_Iif(functionCall.Arguments)
-
-	case parsers.FunctionCallMathAbs:
-		return r.math_Abs(functionCall.Arguments)
-	case parsers.FunctionCallMathAcos:
-		return r.math_Acos(functionCall.Arguments)
-	case parsers.FunctionCallMathAsin:
-		return r.math_Asin(functionCall.Arguments)
-	case parsers.FunctionCallMathAtan:
-		return r.math_Atan(functionCall.Arguments)
-	case parsers.FunctionCallMathCeiling:
-		return r.math_Ceiling(functionCall.Arguments)
-	case parsers.FunctionCallMathCos:
-		return r.math_Cos(functionCall.Arguments)
-	case parsers.FunctionCallMathCot:
-		return r.math_Cot(functionCall.Arguments)
-	case parsers.FunctionCallMathDegrees:
-		return r.math_Degrees(functionCall.Arguments)
-	case parsers.FunctionCallMathExp:
-		return r.math_Exp(functionCall.Arguments)
-	case parsers.FunctionCallMathFloor:
-		return r.math_Floor(functionCall.Arguments)
-	case parsers.FunctionCallMathIntBitNot:
-		return r.math_IntBitNot(functionCall.Arguments)
-	case parsers.FunctionCallMathLog10:
-		return r.math_Log10(functionCall.Arguments)
-	case parsers.FunctionCallMathRadians:
-		return r.math_Radians(functionCall.Arguments)
-	case parsers.FunctionCallMathRound:
-		return r.math_Round(functionCall.Arguments)
-	case parsers.FunctionCallMathSign:
-		return r.math_Sign(functionCall.Arguments)
-	case parsers.FunctionCallMathSin:
-		return r.math_Sin(functionCall.Arguments)
-	case parsers.FunctionCallMathSqrt:
-		return r.math_Sqrt(functionCall.Arguments)
-	case parsers.FunctionCallMathSquare:
-		return r.math_Square(functionCall.Arguments)
-	case parsers.FunctionCallMathTan:
-		return r.math_Tan(functionCall.Arguments)
-	case parsers.FunctionCallMathTrunc:
-		return r.math_Trunc(functionCall.Arguments)
-	case parsers.FunctionCallMathAtn2:
-		return r.math_Atn2(functionCall.Arguments)
-	case parsers.FunctionCallMathIntAdd:
-		return r.math_IntAdd(functionCall.Arguments)
-	case parsers.FunctionCallMathIntBitAnd:
-		return r.math_IntBitAnd(functionCall.Arguments)
-	case parsers.FunctionCallMathIntBitLeftShift:
-		return r.math_IntBitLeftShift(functionCall.Arguments)
-	case parsers.FunctionCallMathIntBitOr:
-		return r.math_IntBitOr(functionCall.Arguments)
-	case parsers.FunctionCallMathIntBitRightShift:
-		return r.math_IntBitRightShift(functionCall.Arguments)
-	case parsers.FunctionCallMathIntBitXor:
-		return r.math_IntBitXor(functionCall.Arguments)
-	case parsers.FunctionCallMathIntDiv:
-		return r.math_IntDiv(functionCall.Arguments)
-	case parsers.FunctionCallMathIntMod:
-		return r.math_IntMod(functionCall.Arguments)
-	case parsers.FunctionCallMathIntMul:
-		return r.math_IntMul(functionCall.Arguments)
-	case parsers.FunctionCallMathIntSub:
-		return r.math_IntSub(functionCall.Arguments)
-	case parsers.FunctionCallMathPower:
-		return r.math_Power(functionCall.Arguments)
-	case parsers.FunctionCallMathLog:
-		return r.math_Log(functionCall.Arguments)
-	case parsers.FunctionCallMathNumberBin:
-		return r.math_NumberBin(functionCall.Arguments)
-	case parsers.FunctionCallMathPi:
-		return r.math_Pi()
-	case parsers.FunctionCallMathRand:
-		return r.math_Rand()
-
-	case parsers.FunctionCallAggregateAvg:
-		return r.aggregate_Avg(functionCall.Arguments)
-	case parsers.FunctionCallAggregateCount:
-		return r.aggregate_Count(functionCall.Arguments)
-	case parsers.FunctionCallAggregateMax:
-		return r.aggregate_Max(functionCall.Arguments)
-	case parsers.FunctionCallAggregateMin:
-		return r.aggregate_Min(functionCall.Arguments)
-	case parsers.FunctionCallAggregateSum:
-		return r.aggregate_Sum(functionCall.Arguments)
-
-	case parsers.FunctionCallIn:
-		return r.misc_In(functionCall.Arguments)
-	}
-
-	logger.Errorf("Unknown function call type: %v", functionCall.Type)
-	return nil
-}
-
-func (r rowContext) selectItem_SelectItemTypeBinaryExpression(binaryExpression parsers.BinaryExpression) interface{} {
-	if binaryExpression.Left == nil || binaryExpression.Right == nil {
-		logger.Debug("parsers.BinaryExpression has nil Left or Right value")
-		return nil
-	}
-
-	leftValue := r.resolveSelectItem(binaryExpression.Left.(parsers.SelectItem))
-	rightValue := r.resolveSelectItem(binaryExpression.Right.(parsers.SelectItem))
-
-	if leftValue == nil || rightValue == nil {
-		return nil
-	}
-
-	leftNumber, leftIsNumber := numToFloat64(leftValue)
-	rightNumber, rightIsNumber := numToFloat64(rightValue)
-
-	if !leftIsNumber || !rightIsNumber {
-		logger.Debug("Binary expression operands are not numbers, returning nil")
-		return nil
-	}
-
-	switch binaryExpression.Operation {
-	case "+":
-		return leftNumber + rightNumber
-	case "-":
-		return leftNumber - rightNumber
-	case "*":
-		return leftNumber * rightNumber
-	case "/":
-		if rightNumber == 0 {
-			logger.Debug("Division by zero in binary expression")
-			return nil
-		}
-		return leftNumber / rightNumber
-	default:
-		return nil
-	}
-}
-
-func (r rowContext) selectItem_SelectItemTypeField(selectItem parsers.SelectItem) interface{} {
-	value := r.tables[selectItem.Path[0]]
-
-	if len(selectItem.Path) > 1 {
-		for _, pathSegment := range selectItem.Path[1:] {
-			if pathSegment[0] == '@' {
-				pathSegment = r.parameters[pathSegment].(string)
-			}
-
-			switch nestedValue := value.(type) {
-			case map[string]interface{}:
-				value = nestedValue[pathSegment]
-			case map[string]RowType:
-				value = nestedValue[pathSegment]
-			case datastore.Document:
-				value = nestedValue[pathSegment]
-			case map[string]datastore.Document:
-				value = nestedValue[pathSegment]
-			case []int, []string, []interface{}:
-				slice := reflect.ValueOf(nestedValue)
-				if arrayIndex, err := strconv.Atoi(pathSegment); err == nil && slice.Len() > arrayIndex {
-					value = slice.Index(arrayIndex).Interface()
-				} else {
-					return nil
-				}
-			default:
-				return nil
-			}
-		}
-	}
-
-	return value
-}
-
-func compareValues(val1, val2 interface{}) int {
-	// Handle nil values
-	if val1 == nil && val2 == nil {
-		return 0
-	} else if val1 == nil {
-		return -1
-	} else if val2 == nil {
-		return 1
-	}
-
-	// Handle number values
-	val1Number, val1IsNumber := numToFloat64(val1)
-	val2Number, val2IsNumber := numToFloat64(val2)
-	if val1IsNumber && val2IsNumber {
-		if val1Number < val2Number {
-			return -1
-		} else if val1Number > val2Number {
-			return 1
-		}
-		return 0
-	}
-
-	// Handle different types
-	if reflect.TypeOf(val1) != reflect.TypeOf(val2) {
-		return 1
-	}
-
-	switch val1 := val1.(type) {
-	case string:
-		val2 := val2.(string)
-		return strings.Compare(val1, val2)
-	case bool:
-		val2 := val2.(bool)
-		if val1 == val2 {
-			return 0
-		} else if val1 {
-			return 1
-		} else {
-			return -1
-		}
-	// TODO: Add more types
-	default:
-		if reflect.DeepEqual(val1, val2) {
-			return 0
-		}
-		return 1
-	}
-}
-
-func copyMap[T RowType | []RowType](originalMap map[string]T) map[string]T {
-	targetMap := make(map[string]T)
-
-	for k, v := range originalMap {
-		targetMap[k] = v
-	}
-
-	return targetMap
-}

query_executors/memory_executor/comparison_expression_test.go

@@ -1,92 +0,0 @@
-package memoryexecutor_test
-
-import (
-	"testing"
-
-	"github.com/pikami/cosmium/parsers"
-	memoryexecutor "github.com/pikami/cosmium/query_executors/memory_executor"
-	testutils "github.com/pikami/cosmium/test_utils"
-)
-
-func Test_Execute_Expressions(t *testing.T) {
-	mockData := []memoryexecutor.RowType{
-		map[string]interface{}{"id": "123", "age": 10, "isCool": true},
-		map[string]interface{}{"id": "456", "age": 20, "isCool": false},
-		map[string]interface{}{"id": "789", "age": 30, "isCool": true},
-	}
-
-	t.Run("Should execute comparison expressions in SELECT", func(t *testing.T) {
-		testQueryExecute(
-			t,
-			parsers.SelectStmt{
-				SelectItems: []parsers.SelectItem{
-					{
-						Path: []string{"c", "id"},
-						Type: parsers.SelectItemTypeField,
-					},
-					{
-						Alias: "isAdult",
-						Type:  parsers.SelectItemTypeExpression,
-						Value: parsers.ComparisonExpression{
-							Operation: ">=",
-							Left:      testutils.SelectItem_Path("c", "age"),
-							Right:     testutils.SelectItem_Constant_Int(18),
-						},
-					},
-					{
-						Alias: "isNotCool",
-						Type:  parsers.SelectItemTypeExpression,
-						Value: parsers.ComparisonExpression{
-							Operation: "!=",
-							Left:      testutils.SelectItem_Path("c", "isCool"),
-							Right:     testutils.SelectItem_Constant_Bool(true),
-						},
-					},
-				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
-			},
-			mockData,
-			[]memoryexecutor.RowType{
-				map[string]interface{}{"id": "123", "isAdult": false, "isNotCool": false},
-				map[string]interface{}{"id": "456", "isAdult": true, "isNotCool": true},
-				map[string]interface{}{"id": "789", "isAdult": true, "isNotCool": false},
-			},
-		)
-	})
-
-	t.Run("Should execute logical expressions in SELECT", func(t *testing.T) {
-		testQueryExecute(
-			t,
-			parsers.SelectStmt{
-				SelectItems: []parsers.SelectItem{
-					{
-						Path: []string{"c", "id"},
-						Type: parsers.SelectItemTypeField,
-					},
-					{
-						Alias: "isCoolAndAdult",
-						Type:  parsers.SelectItemTypeExpression,
-						Value: parsers.LogicalExpression{
-							Operation: parsers.LogicalExpressionTypeAnd,
-							Expressions: []interface{}{
-								testutils.SelectItem_Path("c", "isCool"),
-								parsers.ComparisonExpression{
-									Operation: ">=",
-									Left:      testutils.SelectItem_Path("c", "age"),
-									Right:     testutils.SelectItem_Constant_Int(18),
-								},
-							},
-						},
-					},
-				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
-			},
-			mockData,
-			[]memoryexecutor.RowType{
-				map[string]interface{}{"id": "123", "isCoolAndAdult": false},
-				map[string]interface{}{"id": "456", "isCoolAndAdult": false},
-				map[string]interface{}{"id": "789", "isCoolAndAdult": true},
-			},
-		)
-	})
-}

query_executors/memory_executor/distinct_iterator.go

@@ -1,36 +0,0 @@
-package memoryexecutor
-
-import "github.com/pikami/cosmium/internal/datastore"
-
-type distinctIterator struct {
-	documents rowTypeIterator
-	seenDocs  []RowType
-}
-
-func (di *distinctIterator) Next() (RowType, datastore.DataStoreStatus) {
-	if di.documents == nil {
-		return rowContext{}, datastore.IterEOF
-	}
-
-	for {
-		row, status := di.documents.Next()
-		if status != datastore.StatusOk {
-			di.documents = nil
-			return rowContext{}, status
-		}
-
-		if !di.seen(row) {
-			di.seenDocs = append(di.seenDocs, row)
-			return row, status
-		}
-	}
-}
-
-func (di *distinctIterator) seen(row RowType) bool {
-	for _, seenRow := range di.seenDocs {
-		if compareValues(seenRow, row) == 0 {
-			return true
-		}
-	}
-	return false
-}

query_executors/memory_executor/filter_iterator.go

@@ -1,143 +0,0 @@
-package memoryexecutor
-
-import (
-	"github.com/pikami/cosmium/internal/datastore"
-	"github.com/pikami/cosmium/internal/logger"
-	"github.com/pikami/cosmium/parsers"
-)
-
-type filterIterator struct {
-	documents rowIterator
-	filters   interface{}
-}
-
-func (fi *filterIterator) Next() (rowContext, datastore.DataStoreStatus) {
-	if fi.documents == nil {
-		return rowContext{}, datastore.IterEOF
-	}
-
-	for {
-		row, status := fi.documents.Next()
-		if status != datastore.StatusOk {
-			fi.documents = nil
-			return rowContext{}, status
-		}
-
-		if fi.evaluateFilters(row) {
-			return row, status
-		}
-	}
-}
-
-func (fi *filterIterator) evaluateFilters(row rowContext) bool {
-	if fi.filters == nil {
-		return true
-	}
-
-	switch typedFilters := fi.filters.(type) {
-	case parsers.ComparisonExpression:
-		return row.filters_ComparisonExpression(typedFilters)
-	case parsers.LogicalExpression:
-		return row.filters_LogicalExpression(typedFilters)
-	case parsers.Constant:
-		if value, ok := typedFilters.Value.(bool); ok {
-			return value
-		}
-		return false
-	case parsers.SelectItem:
-		resolvedValue := row.resolveSelectItem(typedFilters)
-		if value, ok := resolvedValue.(bool); ok {
-			if typedFilters.Invert {
-				return !value
-			}
-
-			return value
-		}
-	}
-
-	return false
-}
-
-func (r rowContext) applyFilters(filters interface{}) bool {
-	if filters == nil {
-		return true
-	}
-
-	switch typedFilters := filters.(type) {
-	case parsers.ComparisonExpression:
-		return r.filters_ComparisonExpression(typedFilters)
-	case parsers.LogicalExpression:
-		return r.filters_LogicalExpression(typedFilters)
-	case parsers.Constant:
-		if value, ok := typedFilters.Value.(bool); ok {
-			return value
-		}
-		return false
-	case parsers.SelectItem:
-		resolvedValue := r.resolveSelectItem(typedFilters)
-		if value, ok := resolvedValue.(bool); ok {
-			if typedFilters.Invert {
-				return !value
-			}
-
-			return value
-		}
-	}
-
-	return false
-}
-
-func (r rowContext) filters_ComparisonExpression(expression parsers.ComparisonExpression) bool {
-	leftExpression, leftExpressionOk := expression.Left.(parsers.SelectItem)
-	rightExpression, rightExpressionOk := expression.Right.(parsers.SelectItem)
-
-	if !leftExpressionOk || !rightExpressionOk {
-		logger.ErrorLn("ComparisonExpression has incorrect Left or Right type")
-		return false
-	}
-
-	leftValue := r.resolveSelectItem(leftExpression)
-	rightValue := r.resolveSelectItem(rightExpression)
-
-	cmp := compareValues(leftValue, rightValue)
-	switch expression.Operation {
-	case "=":
-		return cmp == 0
-	case "!=":
-		return cmp != 0
-	case "<":
-		return cmp < 0
-	case ">":
-		return cmp > 0
-	case "<=":
-		return cmp <= 0
-	case ">=":
-		return cmp >= 0
-	}
-
-	return false
-}
-
-func (r rowContext) filters_LogicalExpression(expression parsers.LogicalExpression) bool {
-	var result bool
-	for i, subExpression := range expression.Expressions {
-		expressionResult := r.applyFilters(subExpression)
-		if i == 0 {
-			result = expressionResult
-		}
-
-		switch expression.Operation {
-		case parsers.LogicalExpressionTypeAnd:
-			result = result && expressionResult
-			if !result {
-				return false
-			}
-		case parsers.LogicalExpressionTypeOr:
-			result = result || expressionResult
-			if result {
-				return true
-			}
-		}
-	}
-	return result
-}