2025-06-08 08:30:24 +01:00
137 changed files with 3603 additions and 16680 deletions
--- a/.github/workflows/compile-shared-libraries.yml
+++ b/.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/*
--- a/.github/workflows/release.yml
+++ b/.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
-
-      - 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
-
+          go-version: 1.21.6
      - 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 }}
--- a/.gitignore
+++ b/.gitignore
@ -1,7 +1,2 @@
 dist/
-sharedlibrary_dist/
 ignored/
-explorer_www/
-main
-save.json
-.vscode/
--- a/.goreleaser.yaml
+++ b/.goreleaser.yaml
@ -1,6 +1,5 @@
 builds:
  - binary: cosmium
-    main: ./cmd/server
    goos:
      - darwin
      - linux
@ -10,6 +9,11 @@ builds:
      - arm64
    env:
      - CGO_ENABLED=0
+    ignore:
+      - goos: linux
+        goarch: arm64
+      - goos: windows
+        goarch: arm64

 release:
  prerelease: auto
@ -26,32 +30,11 @@ 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
-    goos: linux
-    goarch: amd64
-    image_templates:
-    - "ghcr.io/pikami/{{ .ProjectName }}:{{ .Version }}-amd64"
+  - image_templates: ["ghcr.io/pikami/{{ .ProjectName }}:{{ .Version }}-amd64"]
    dockerfile: Dockerfile
-    use: buildx
+    use: docker
    build_flag_templates:
    - "--platform=linux/amd64"
    - "--pull"
@ -62,85 +45,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'
--- a/2
+++ b/2
@ -1,4 +1,4 @@
-FROM alpine:latest
+FROM scratch

 WORKDIR /app
 COPY cosmium /app/cosmium
--- a/Explorer.Dockerfile
+++ b/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"]
--- a/51
+++ b/51
@ -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)
-
-build-linux-arm64:
-	@echo "Building Linux ARM binary..."
-	@GOOS=linux GOARCH=arm64 $(GOBUILD) -o $(DIST_DIR)/$(BINARY_NAME)-linux-arm64 $(SERVER_LOCATION)
+	@GOOS=linux GOARCH=amd64 $(GOBUILD) -o $(DIST_DIR)/$(BINARY_NAME)-linux-amd64 .

 build-windows-amd64:
 	@echo "Building Windows x64 binary..."
-	@GOOS=windows GOARCH=amd64 $(GOBUILD) -o $(DIST_DIR)/$(BINARY_NAME)-windows-amd64.exe $(SERVER_LOCATION)
-
-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) .
+	@GOOS=windows GOARCH=amd64 $(GOBUILD) -o $(DIST_DIR)/$(BINARY_NAME)-windows-amd64.exe .

 generate-parser-nosql:
 	pigeon -o ./parsers/nosql/nosql.go ./parsers/nosql/nosql.peg
--- a/README.md
+++ b/README.md
@ -1,13 +1,11 @@
 # Cosmium

-Cosmium is a lightweight Cosmos DB emulator designed to facilitate local development and testing. While it aims to provide developers with a solution for running a local database during development, it's important to note that it's not 100% compatible with Cosmos DB. However, it serves as a convenient tool for E2E or integration tests during the CI/CD pipeline. Read more about compatibility [here](./docs/COMPATIBILITY.md).
+Cosmium is a lightweight Cosmos DB emulator designed to facilitate local development and testing. While it aims to provide developers with a solution for running a local database during development, it's important to note that it's not 100% compatible with Cosmos DB. However, it serves as a convenient tool for E2E or integration tests during the CI/CD pipeline. Read more about compatibility [here](docs/compatibility.md).

 One of Cosmium's notable features is its ability to save and load state to a single JSON file. This feature makes it easy to load different test cases or share state with other developers, enhancing collaboration and efficiency in development workflows.

 # Getting Started
-
 ### Installation via Homebrew
-
 You can install Cosmium using Homebrew by adding the `pikami/brew` tap and then installing the package.

 ```sh
@ -25,12 +23,10 @@ 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
+* **Linux**: cosmium-linux-amd64
+* **macOS**: cosmium-darwin-amd64
+* **macOS on Apple Silicon**: cosmium-darwin-arm64
+* **Windows**: cosmium-windows-amd64.exe

 ### Running Cosmium

@ -41,34 +37,25 @@ cosmium -Persist "./save.json"
 ```

 Connection String Example:
-
 ```
 AccountEndpoint=https://localhost:8081/;AccountKey=C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw==;
 ```

-### Running Cosmos DB Explorer
+###  Running Cosmos DB Explorer

 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
 docker run --rm \
-  -e COSMIUM_PERSIST=/save.json \
+  -e 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
@ -79,39 +66,24 @@ To disable SSL and run Cosmium on HTTP instead, you can use the `-DisableTls` fl

 ### Other Available Arguments

- **-AccountKey**: Account key for authentication (default "C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw==")
- **-DisableAuth**: Disable authentication
- **-Host**: Hostname (default "localhost")
- **-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)
- **-DataStore**: Allows selecting [storage backend](#data-storage-backends) (default "json")
+* **-AccountKey**: Account key for authentication (default "C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw==")
+* **-DisableAuth**: Disable authentication
+* **-Host**: Hostname (default "localhost")
+* **-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)
+* **-Debug**: Runs application in debug mode, this provides additional logging

 These arguments allow you to configure various aspects of Cosmium's behavior according to your requirements.

 All mentioned arguments can also be set using environment variables:
-
- **COSMIUM_ACCOUNTKEY** for `-AccountKey`
- **COSMIUM_DISABLEAUTH** for `-DisableAuth`
- **COSMIUM_HOST** for `-Host`
- **COSMIUM_INITIALDATA** for `-InitialData`
- **COSMIUM_PERSIST** for `-Persist`
- **COSMIUM_PORT** for `-Port`
- **COSMIUM_LOGLEVEL** for `-LogLevel`
-
-### 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.
+* **COSMIUM_ACCOUNTKEY** for `-AccountKey`
+* **COSMIUM_DISABLEAUTH** for `-DisableAuth`
+* **COSMIUM_HOST** for `-Host`
+* **COSMIUM_INITIALDATA** for `-InitialData`
+* **COSMIUM_PERSIST** for `-Persist`
+* **COSMIUM_PORT** for `-Port`
+* **COSMIUM_DEBUG** for `-Debug`

 # License
-
 This project is [MIT licensed](./LICENSE).
--- a/api/api_models/models.go
+++ b/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"`
-}
--- a/api/api_server.go
+++ b/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
-}
--- a/api/config/config.go
+++ b/api/config/config.go
@ -5,22 +5,16 @@ import (
 	"fmt"
 	"os"
 	"strings"
-
-	"github.com/pikami/cosmium/internal/logger"
 )

 const (
-	DefaultAccountKey       = "C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw=="
-	EnvPrefix               = "COSMIUM_"
-	ExplorerBaseUrlLocation = "/_explorer"
+	DefaultAccountKey = "C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw=="
+	EnvPrefix         = "COSMIUM_"
 )

-const (
-	DataStoreJson   = "json"
-	DataStoreBadger = "badger"
-)
+var Config = ServerConfig{}

-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 +25,26 @@ 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"})
-	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()))
+	debug := flag.Bool("Debug", false, "Runs application in debug mode, this provides additional logging")

 	flag.Parse()
 	setFlagsFromEnvironment()

-	config := ServerConfig{}
-	config.Host = *host
-	config.Port = *port
-	config.ExplorerPath = *explorerPath
-	config.TLS_CertificatePath = *tlsCertificatePath
-	config.TLS_CertificateKey = *tlsCertificateKey
-	config.InitialDataFilePath = *initialDataPath
-	config.PersistDataFilePath = *persistDataPath
-	config.DisableAuth = *disableAuthentication
-	config.DisableTls = *disableTls
-	config.AccountKey = *accountKey
-	config.LogLevel = logLevel.value
-	config.DataStore = dataStore.value
+	Config.Host = *host
+	Config.Port = *port
+	Config.ExplorerPath = *explorerPath
+	Config.TLS_CertificatePath = *tlsCertificatePath
+	Config.TLS_CertificateKey = *tlsCertificateKey
+	Config.InitialDataFilePath = *initialDataPath
+	Config.PersistDataFilePath = *persistDataPath
+	Config.DisableAuth = *disableAuthentication
+	Config.DisableTls = *disableTls
+	Config.Debug = *debug

-	config.PopulateCalculatedFields()
-
-	return config
-}
-
-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
-	}
+	Config.DatabaseAccount = Config.Host
+	Config.DatabaseDomain = Config.Host
+	Config.DatabaseEndpoint = fmt.Sprintf("https://%s:%d/", Config.Host, Config.Port)
+	Config.AccountKey = *accountKey
 }

 func setFlagsFromEnvironment() (err error) {
--- a/api/config/enumFlag.go
+++ b/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, ", "))
-}
--- a/api/config/models.go
+++ b/api/config/models.go
@ -1,22 +1,19 @@
 package config

 type ServerConfig struct {
-	DatabaseAccount  string `json:"databaseAccount"`
-	DatabaseDomain   string `json:"databaseDomain"`
-	DatabaseEndpoint string `json:"databaseEndpoint"`
-	AccountKey       string `json:"accountKey"`
+	DatabaseAccount  string
+	DatabaseDomain   string
+	DatabaseEndpoint string
+	AccountKey       string

-	ExplorerPath            string `json:"explorerPath"`
-	Port                    int    `json:"port"`
-	Host                    string `json:"host"`
-	TLS_CertificatePath     string `json:"tlsCertificatePath"`
-	TLS_CertificateKey      string `json:"tlsCertificateKey"`
-	InitialDataFilePath     string `json:"initialDataFilePath"`
-	PersistDataFilePath     string `json:"persistDataFilePath"`
-	DisableAuth             bool   `json:"disableAuth"`
-	DisableTls              bool   `json:"disableTls"`
-	LogLevel                string `json:"logLevel"`
-	ExplorerBaseUrlLocation string `json:"explorerBaseUrlLocation"`
-
-	DataStore string `json:"dataStore"`
+	ExplorerPath        string
+	Port                int
+	Host                string
+	TLS_CertificatePath string
+	TLS_CertificateKey  string
+	InitialDataFilePath string
+	PersistDataFilePath string
+	DisableAuth         bool
+	DisableTls          bool
+	Debug               bool
 }
--- a/api/handlers/collections.go
+++ b/api/handlers/collections.go
@ -1,22 +1,20 @@
 package handlers

 import (
-	"fmt"
 	"net/http"

 	"github.com/gin-gonic/gin"
-	"github.com/pikami/cosmium/internal/constants"
-	"github.com/pikami/cosmium/internal/datastore"
+	"github.com/pikami/cosmium/internal/repositories"
+	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)
-	if status == datastore.StatusOk {
-		database, _ := h.dataStore.GetDatabase(databaseId)
+	collections, status := repositories.GetAllCollections(databaseId)
+	if status == repositorymodels.StatusOk {
+		database, _ := repositories.GetDatabase(databaseId)

-		c.Header("x-ms-item-count", fmt.Sprintf("%d", len(collections)))
 		c.IndentedJSON(http.StatusOK, gin.H{
 			"_rid":                database.ResourceID,
 			"DocumentCollections": collections,
@ -25,48 +23,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)
-	if status == datastore.StatusOk {
+	collection, status := repositories.GetCollection(databaseId, id)
+	if status == repositorymodels.StatusOk {
 		c.IndentedJSON(http.StatusOK, collection)
 		return
 	}

-	if status == datastore.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
+	if status == repositorymodels.StatusNotFound {
+		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)
-	if status == datastore.StatusOk {
+	status := repositories.DeleteCollection(databaseId, id)
+	if status == repositorymodels.StatusOk {
 		c.Status(http.StatusNoContent)
 		return
 	}

-	if status == datastore.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
+	if status == repositorymodels.StatusNotFound {
+		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 +72,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)
-	if status == datastore.Conflict {
-		c.IndentedJSON(http.StatusConflict, constants.ConflictResponse)
+	createdCollection, status := repositories.CreateCollection(databaseId, newCollection)
+	if status == repositorymodels.Conflict {
+		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"})
 }
--- a/api/handlers/cosmium.go
+++ b/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) {
-	dataStoreState, err := h.dataStore.DumpToJson()
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		return
-	}
-
-	c.Data(http.StatusOK, "application/json", []byte(dataStoreState))
+func CosmiumExport(c *gin.Context) {
+	c.IndentedJSON(http.StatusOK, repositories.GetState())
 }
--- a/api/handlers/databases.go
+++ b/api/handlers/databases.go
@ -1,18 +1,16 @@
 package handlers

 import (
-	"fmt"
 	"net/http"

 	"github.com/gin-gonic/gin"
-	"github.com/pikami/cosmium/internal/constants"
-	"github.com/pikami/cosmium/internal/datastore"
+	"github.com/pikami/cosmium/internal/repositories"
+	repositorymodels "github.com/pikami/cosmium/internal/repository_models"
 )

-func (h *Handlers) GetAllDatabases(c *gin.Context) {
-	databases, status := h.dataStore.GetAllDatabases()
-	if status == datastore.StatusOk {
-		c.Header("x-ms-item-count", fmt.Sprintf("%d", len(databases)))
+func GetAllDatabases(c *gin.Context) {
+	databases, status := repositories.GetAllDatabases()
+	if status == repositorymodels.StatusOk {
 		c.IndentedJSON(http.StatusOK, gin.H{
 			"_rid":      "",
 			"Databases": databases,
@ -21,45 +19,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)
-	if status == datastore.StatusOk {
+	database, status := repositories.GetDatabase(id)
+	if status == repositorymodels.StatusOk {
 		c.IndentedJSON(http.StatusOK, database)
 		return
 	}

-	if status == datastore.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
+	if status == repositorymodels.StatusNotFound {
+		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)
-	if status == datastore.StatusOk {
+	status := repositories.DeleteDatabase(id)
+	if status == repositorymodels.StatusOk {
 		c.Status(http.StatusNoContent)
 		return
 	}

-	if status == datastore.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
+	if status == repositorymodels.StatusNotFound {
+		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) {
-	var newDatabase datastore.Database
+func CreateDatabase(c *gin.Context) {
+	var newDatabase repositorymodels.Database

 	if err := c.BindJSON(&newDatabase); err != nil {
 		c.JSON(http.StatusBadRequest, gin.H{"message": err.Error()})
@ -67,20 +65,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)
-	if status == datastore.Conflict {
-		c.IndentedJSON(http.StatusConflict, constants.ConflictResponse)
+	createdDatabase, status := repositories.CreateDatabase(newDatabase)
+	if status == repositorymodels.Conflict {
+		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"})
 }
--- a/api/handlers/documents.go
+++ b/api/handlers/documents.go
@ -1,32 +1,22 @@
 package handlers

 import (
-	"encoding/json"
-	"fmt"
 	"net/http"
-	"strconv"

-	jsonpatch "github.com/cosmiumdev/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/parsers/nosql"
-	memoryexecutor "github.com/pikami/cosmium/query_executors/memory_executor"
+	"github.com/pikami/cosmium/internal/repositories"
+	repositorymodels "github.com/pikami/cosmium/internal/repository_models"
 )

-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)
-	if status == datastore.StatusOk {
-		collection, _ := h.dataStore.GetCollection(databaseId, collectionId)
+	documents, status := repositories.GetAllDocuments(databaseId, collectionId)
+	if status == repositorymodels.StatusOk {
+		collection, _ := repositories.GetCollection(databaseId, collectionId)

-		c.Header("x-ms-item-count", fmt.Sprintf("%d", len(documents)))
 		c.IndentedJSON(http.StatusOK, gin.H{
 			"_rid":      collection.ID,
 			"Documents": documents,
@ -35,49 +25,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)
-	if status == datastore.StatusOk {
+	document, status := repositories.GetDocument(databaseId, collectionId, documentId)
+	if status == repositorymodels.StatusOk {
 		c.IndentedJSON(http.StatusOK, document)
 		return
 	}

-	if status == datastore.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
+	if status == repositorymodels.StatusNotFound {
+		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)
-	if status == datastore.StatusOk {
+	status := repositories.DeleteDocument(databaseId, collectionId, documentId)
+	if status == repositorymodels.StatusOk {
 		c.Status(http.StatusNoContent)
 		return
 	}

-	if status == datastore.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
+	if status == repositorymodels.StatusNotFound {
+		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
-func (h *Handlers) ReplaceDocument(c *gin.Context) {
+// TODO: Maybe move "replace" logic to repository
+func ReplaceDocument(c *gin.Context) {
 	databaseId := c.Param("databaseId")
 	collectionId := c.Param("collId")
 	documentId := c.Param("docId")
@ -88,112 +78,29 @@ func (h *Handlers) ReplaceDocument(c *gin.Context) {
 		return
 	}

-	status := h.dataStore.DeleteDocument(databaseId, collectionId, documentId)
-	if status == datastore.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
+	status := repositories.DeleteDocument(databaseId, collectionId, documentId)
+	if status == repositorymodels.StatusNotFound {
+		c.IndentedJSON(http.StatusNotFound, gin.H{"message": "NotFound"})
 		return
 	}

-	createdDocument, status := h.dataStore.CreateDocument(databaseId, collectionId, requestBody)
-	if status == datastore.Conflict {
-		c.IndentedJSON(http.StatusConflict, constants.ConflictResponse)
+	createdDocument, status := repositories.CreateDocument(databaseId, collectionId, requestBody)
+	if status == repositorymodels.Conflict {
+		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 DocumentsPost(c *gin.Context) {
 	databaseId := c.Param("databaseId")
 	collectionId := c.Param("collId")
-	documentId := c.Param("docId")
-
-	document, status := h.dataStore.GetDocument(databaseId, collectionId, documentId)
-	if status == datastore.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
-		return
-	}
-
-	var requestBody map[string]interface{}
-	if err := c.BindJSON(&requestBody); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"message": err.Error()})
-		return
-	}
-
-	operations := requestBody["operations"]
-	operationsBytes, err := json.Marshal(operations)
-	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"message": "Could not decode operations"})
-		return
-	}
-
-	patch, err := jsonpatch.DecodePatch(operationsBytes)
-	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"message": err.Error()})
-		return
-	}
-
-	currentDocumentBytes, err := json.Marshal(document)
-	if err != nil {
-		logger.ErrorLn("Failed to marshal existing document:", err)
-		c.JSON(http.StatusInternalServerError, gin.H{"message": "Failed to marshal existing document"})
-		return
-	}
-
-	modifiedDocumentBytes, err := patch.Apply(currentDocumentBytes)
-	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"message": err.Error()})
-		return
-	}
-
-	var modifiedDocument map[string]interface{}
-	err = json.Unmarshal(modifiedDocumentBytes, &modifiedDocument)
-	if err != nil {
-		logger.ErrorLn("Failed to unmarshal modified document:", err)
-		c.JSON(http.StatusInternalServerError, gin.H{"message": "Failed to unmarshal modified document"})
-		return
-	}
-
-	if modifiedDocument["id"] != document["id"] {
-		c.JSON(http.StatusUnprocessableEntity, gin.H{"message": "The ID field cannot be modified"})
-		return
-	}
-
-	status = h.dataStore.DeleteDocument(databaseId, collectionId, documentId)
-	if status == datastore.StatusNotFound {
-		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
-		return
-	}
-
-	createdDocument, status := h.dataStore.CreateDocument(databaseId, collectionId, modifiedDocument)
-	if status == datastore.Conflict {
-		c.IndentedJSON(http.StatusConflict, constants.ConflictResponse)
-		return
-	}
-
-	if status == datastore.StatusOk {
-		c.IndentedJSON(http.StatusCreated, createdDocument)
-		return
-	}
-
-	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
-}
-
-func (h *Handlers) 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 {
@ -203,32 +110,49 @@ 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.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))
-	}
-
-	createdDocument, status := h.dataStore.CreateDocument(databaseId, collectionId, requestBody)
-	if status == datastore.Conflict {
-		c.IndentedJSON(http.StatusConflict, constants.ConflictResponse)
+	createdDocument, status := repositories.CreateDocument(databaseId, collectionId, requestBody)
+	if status == repositorymodels.Conflict {
+		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 +166,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
-}
--- a/api/handlers/explorer.go
+++ b/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) {
-	explorer := router.Group(h.config.ExplorerBaseUrlLocation)
+func RegisterExplorerHandlers(router *gin.Engine) {
+	explorer := router.Group("/_explorer")
 	{
 		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 != "" {
-			explorer.Static("/", h.config.ExplorerPath)
+		if config.Config.ExplorerPath != "" {
+			explorer.Static("/", config.Config.ExplorerPath)
 		}
 	}
 }
--- a/api/handlers/handlers.go
+++ b/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,
-	}
-}
--- a/api/handlers/middleware/authentication.go
+++ b/api/handlers/middleware/authentication.go
@ -10,22 +10,44 @@ 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 ||
-			strings.HasPrefix(requestUrl, config.ExplorerBaseUrlLocation) ||
+		if config.Config.DisableAuth ||
+			strings.HasPrefix(requestUrl, "/_explorer") ||
 			strings.HasPrefix(requestUrl, "/cosmium") {
 			return
 		}

-		resourceType := urlToResourceType(requestUrl)
-		resourceId := requestToResourceId(c)
+		var resourceType string
+		parts := strings.Split(requestUrl, "/")
+		switch len(parts) {
+		case 2, 3:
+			resourceType = parts[1]
+		case 4, 5:
+			resourceType = parts[3]
+		case 6, 7:
+			resourceType = parts[5]
+		}
+
+		databaseId, _ := c.Params.Get("databaseId")
+		collId, _ := c.Params.Get("collId")
+		docId, _ := c.Params.Get("docId")
+		var resourceId string
+		if databaseId != "" {
+			resourceId += "dbs/" + databaseId
+		}
+		if collId != "" {
+			resourceId += "/colls/" + collId
+		}
+		if docId != "" {
+			resourceId += "/docs/" + docId
+		}

 		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)
@ -40,43 +62,3 @@ func Authentication(config *config.ServerConfig) gin.HandlerFunc {
 		}
 	}
 }
-
-func urlToResourceType(requestUrl string) string {
-	var resourceType string
-	parts := strings.Split(requestUrl, "/")
-	switch len(parts) {
-	case 2, 3:
-		resourceType = parts[1]
-	case 4, 5:
-		resourceType = parts[3]
-	case 6, 7:
-		resourceType = parts[5]
-	}
-
-	return resourceType
-}
-
-func requestToResourceId(c *gin.Context) string {
-	databaseId, _ := c.Params.Get("databaseId")
-	collId, _ := c.Params.Get("collId")
-	docId, _ := c.Params.Get("docId")
-	resourceType := urlToResourceType(c.Request.URL.String())
-
-	var resourceId string
-	if databaseId != "" {
-		resourceId += "dbs/" + databaseId
-	}
-	if collId != "" {
-		resourceId += "/colls/" + collId
-	}
-	if docId != "" {
-		resourceId += "/docs/" + docId
-	}
-
-	isFeed := c.Request.Header.Get("A-Im") == "Incremental Feed"
-	if resourceType == "pkranges" && isFeed {
-		resourceId = collId
-	}
-
-	return resourceId
-}
--- a/api/handlers/middleware/loggers.go
+++ b/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
--- a/api/handlers/middleware/strip_trailing_slashes.go
+++ b/api/handlers/middleware/strip_trailing_slashes.go
@ -1,21 +0,0 @@
-package middleware
-
-import (
-	"strings"
-
-	"github.com/gin-gonic/gin"
-	"github.com/pikami/cosmium/api/config"
-)
-
-func StripTrailingSlashes(r *gin.Engine, config *config.ServerConfig) 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) {
-			c.Request.URL.Path = path[:len(path)-1]
-			r.HandleContext(c)
-			c.Abort()
-			return
-		}
-		c.Next()
-	}
-}
--- a/api/handlers/offers.go
+++ b/api/handlers/offers.go
@ -7,7 +7,6 @@ import (
 )

 func GetOffers(c *gin.Context) {
-	c.Header("x-ms-item-count", "0")
 	c.IndentedJSON(http.StatusOK, gin.H{
 		"_rid":   "",
 		"_count": 0,
--- a/api/handlers/partition_key_ranges.go
+++ b/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/datastore"
-	"github.com/pikami/cosmium/internal/resourceid"
+	"github.com/pikami/cosmium/internal/repositories"
+	repositorymodels "github.com/pikami/cosmium/internal/repository_models"
 )

-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)
-	if status == datastore.StatusOk {
+	partitionKeyRanges, status := repositories.GetPartitionKeyRanges(databaseId, collectionId)
+	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 {
-		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
+	if status == repositorymodels.StatusNotFound {
+		c.IndentedJSON(http.StatusNotFound, gin.H{"message": "NotFound"})
 		return
 	}

-	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
+	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
 }
--- a/api/handlers/server_info.go
+++ b/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,
-		"_rid":      fmt.Sprintf("%s.%s", h.config.DatabaseAccount, h.config.DatabaseDomain),
+		"id":        config.Config.DatabaseAccount,
+		"_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,
+		"enableMultipleWriteLocations": false,
 		"userReplicationPolicy": map[string]interface{}{
 			"asyncReplication":  false,
 			"minReplicaSetSize": 1,
--- a/api/handlers/stored_procedures.go
+++ b/api/handlers/stored_procedures.go
@ -1,119 +1,23 @@
 package handlers

 import (
-	"fmt"
 	"net/http"

 	"github.com/gin-gonic/gin"
-	"github.com/pikami/cosmium/internal/constants"
-	"github.com/pikami/cosmium/internal/datastore"
+	"github.com/pikami/cosmium/internal/repositories"
+	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 {
-		c.Header("x-ms-item-count", fmt.Sprintf("%d", len(sps)))
+	if status == repositorymodels.StatusOk {
 		c.IndentedJSON(http.StatusOK, gin.H{"_rid": "", "StoredProcedures": sps, "_count": len(sps)})
 		return
 	}

-	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
-}
-
-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)
+	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
 }
--- a/api/handlers/triggers.go
+++ b/api/handlers/triggers.go
@ -1,119 +1,23 @@
 package handlers

 import (
-	"fmt"
 	"net/http"

 	"github.com/gin-gonic/gin"
-	"github.com/pikami/cosmium/internal/constants"
-	"github.com/pikami/cosmium/internal/datastore"
+	"github.com/pikami/cosmium/internal/repositories"
+	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 {
-		c.Header("x-ms-item-count", fmt.Sprintf("%d", len(triggers)))
+	if status == repositorymodels.StatusOk {
 		c.IndentedJSON(http.StatusOK, gin.H{"_rid": "", "Triggers": triggers, "_count": len(triggers)})
 		return
 	}

-	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
-}
-
-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)
+	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
 }
--- a/api/handlers/user_defined_functions.go
+++ b/api/handlers/user_defined_functions.go
@ -1,119 +1,23 @@
 package handlers

 import (
-	"fmt"
 	"net/http"

 	"github.com/gin-gonic/gin"
-	"github.com/pikami/cosmium/internal/constants"
-	"github.com/pikami/cosmium/internal/datastore"
+	"github.com/pikami/cosmium/internal/repositories"
+	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 {
-		c.Header("x-ms-item-count", fmt.Sprintf("%d", len(udfs)))
+	if status == repositorymodels.StatusOk {
 		c.IndentedJSON(http.StatusOK, gin.H{"_rid": "", "UserDefinedFunctions": udfs, "_count": len(udfs)})
 		return
 	}

-	c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
-}
-
-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)
+	c.IndentedJSON(http.StatusInternalServerError, gin.H{"message": "Unknown error"})
 }
--- a/api/router.go
+++ b/api/router.go
@ -1,144 +1,94 @@
 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 {
+	router := gin.Default()

-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.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.GET("/dbs/:databaseId/colls/:collId/docs", routeHandlers.GetAllDocuments)
-	router.GET("/dbs/:databaseId/colls/:collId/docs/:docId", routeHandlers.GetDocument)
-	router.PUT("/dbs/:databaseId/colls/:collId/docs/:docId", routeHandlers.ReplaceDocument)
-	router.PATCH("/dbs/:databaseId/colls/:collId/docs/:docId", routeHandlers.PatchDocument)
-	router.DELETE("/dbs/:databaseId/colls/:collId/docs/:docId", routeHandlers.DeleteDocument)
+	router.POST("/dbs/:databaseId/colls/:collId/docs", handlers.DocumentsPost)
+	router.GET("/dbs/:databaseId/colls/:collId/docs", handlers.GetAllDocuments)
+	router.GET("/dbs/:databaseId/colls/:collId/docs/:docId", handlers.GetDocument)
+	router.PUT("/dbs/:databaseId/colls/:collId/docs/:docId", handlers.ReplaceDocument)
+	router.DELETE("/dbs/:databaseId/colls/:collId/docs/:docId", handlers.DeleteDocument)

-	router.POST("/dbs/:databaseId/colls", routeHandlers.CreateCollection)
-	router.GET("/dbs/:databaseId/colls", routeHandlers.GetAllCollections)
-	router.GET("/dbs/:databaseId/colls/:collId", routeHandlers.GetCollection)
-	router.DELETE("/dbs/:databaseId/colls/:collId", routeHandlers.DeleteCollection)
+	router.POST("/dbs/:databaseId/colls", handlers.CreateCollection)
+	router.GET("/dbs/:databaseId/colls", handlers.GetAllCollections)
+	router.GET("/dbs/:databaseId/colls/:collId", handlers.GetCollection)
+	router.DELETE("/dbs/:databaseId/colls/:collId", handlers.DeleteCollection)

-	router.POST("/dbs", routeHandlers.CreateDatabase)
-	router.GET("/dbs", routeHandlers.GetAllDatabases)
-	router.GET("/dbs/:databaseId", routeHandlers.GetDatabase)
-	router.DELETE("/dbs/:databaseId", routeHandlers.DeleteDatabase)
+	router.POST("/dbs", handlers.CreateDatabase)
+	router.GET("/dbs", handlers.GetAllDatabases)
+	router.GET("/dbs/:databaseId", handlers.GetDatabase)
+	router.DELETE("/dbs/:databaseId", handlers.DeleteDatabase)

-	router.POST("/dbs/:databaseId/colls/:collId/triggers", routeHandlers.CreateTrigger)
-	router.GET("/dbs/:databaseId/colls/:collId/triggers", routeHandlers.GetAllTriggers)
-	router.GET("/dbs/:databaseId/colls/:collId/triggers/:triggerId", routeHandlers.GetTrigger)
-	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("/dbs/:databaseId/colls/:collId/udfs", handlers.GetAllUserDefinedFunctions)
+	router.GET("/dbs/:databaseId/colls/:collId/sprocs", handlers.GetAllStoredProcedures)
+	router.GET("/dbs/:databaseId/colls/:collId/triggers", handlers.GetAllTriggers)

 	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 {
-	listenAddress := fmt.Sprintf(":%d", s.config.Port)
-	s.isActive = true
-
-	server := &http.Server{
-		Addr:    listenAddress,
-		Handler: s.router.Handler(),
+func StartAPI() {
+	if !config.Config.Debug {
+		gin.SetMode(gin.ReleaseMode)
 	}

-	errChan := make(chan error, 1)
+	router := CreateRouter()
+	listenAddress := fmt.Sprintf(":%d", config.Config.Port)

-	go func() {
-		<-s.stopServer
-		logger.InfoLn("Shutting down server...")
-		err := server.Shutdown(context.TODO())
+	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.ErrorLn("Failed to shutdown 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("", "")
+			logger.Error("Failed to start HTTPS server:", err)
 		}

-		if err != nil && err != http.ErrServerClosed {
-			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
+		return
 	}
+
+	if config.Config.DisableTls {
+		router.Run(listenAddress)
+	}
+
+	tlsConfig := tlsprovider.GetDefaultTlsConfig()
+	server := &http.Server{
+		Addr:      listenAddress,
+		Handler:   router.Handler(),
+		TLSConfig: tlsConfig,
+	}
+
+	logger.Infof("Listening and serving HTTPS on %s\n", server.Addr)
+	err := server.ListenAndServeTLS("", "")
+	if err != nil {
+		logger.Error("Failed to start HTTPS server:", err)
+	}
+
+	router.Run()
 }
--- a/api/tests/authentication_test.go
+++ b/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) {
-		ts.DataStore.DeleteDatabase(testDatabaseName)
+	t.Run("Should get 200 when wrong account key is used, but authentication is dissabled", func(t *testing.T) {
+		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)
-}
--- a/api/tests/collections_test.go
+++ b/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 {
-		ts.DataStore.CreateDatabase(datastore.Database{ID: testDatabaseName})
-		databaseClient, err := client.NewDatabase(testDatabaseName)
-		assert.Nil(t, err)
+	client, err := azcosmos.NewClientFromConnectionString(
+		fmt.Sprintf("AccountEndpoint=%s;AccountKey=%s", ts.URL, config.Config.AccountKey),
+		&azcosmos.ClientOptions{},
+	)
+	assert.Nil(t, err)

-		return databaseClient
-	}
-
-	runTestsWithPresets(t, "Collection Create", presets, func(t *testing.T, ts *TestServer, client *azcosmos.Client) {
-		databaseClient := setUp(ts, client)
+	repositories.CreateDatabase(repositorymodels.Database{ID: testDatabaseName})
+	databaseClient, err := client.NewDatabase(testDatabaseName)
+	assert.Nil(t, err)

+	t.Run("Collection Create", func(t *testing.T) {
 		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) {
-		databaseClient := setUp(ts, client)
-
+	t.Run("Collection Read", func(t *testing.T) {
 		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) {
-		databaseClient := setUp(ts, client)
-
+	t.Run("Collection Delete", func(t *testing.T) {
 		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)
--- a/api/tests/config_test.go
+++ b/api/tests/config_test.go
@ -1,64 +1,17 @@
 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 {
-	Server    *httptest.Server
-	DataStore datastore.DataStore
-	URL       string
-}
+func runTestServer() *httptest.Server {
+	config.Config.AccountKey = config.DefaultAccountKey
+	config.Config.ExplorerPath = "/tmp/nothing"

-func getDefaultTestServerConfig() *config.ServerConfig {
-	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)
+	return httptest.NewServer(api.CreateRouter())
 }

 const (
@ -66,47 +19,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)
-	}
-}
--- a/api/tests/databases_test.go
+++ b/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)
--- a/api/tests/documents_test.go
+++ b/api/tests/documents_test.go
@ -3,18 +3,14 @@ package tests_test
 import (
 	"context"
 	"encoding/json"
-	"errors"
 	"fmt"
-	"net/http"
 	"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 +49,9 @@ func testCosmosQuery(t *testing.T,
 	}
 }

-func documents_InitializeDb(t *testing.T, ts *TestServer) *azcosmos.ContainerClient {
-	ts.DataStore.CreateDatabase(datastore.Database{ID: testDatabaseName})
-	ts.DataStore.CreateCollection(testDatabaseName, datastore.Collection{
+func Test_Documents(t *testing.T) {
+	repositories.CreateDatabase(repositorymodels.Database{ID: testDatabaseName})
+	repositories.CreateCollection(testDatabaseName, repositorymodels.Collection{
 		ID: testCollectionName,
 		PartitionKey: struct {
 			Paths   []string "json:\"paths\""
@ -65,11 +61,14 @@ 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}})
-	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": "12345", "pk": "123", "isCool": false})
+	repositories.CreateDocument(testDatabaseName, testCollectionName, map[string]interface{}{"id": "67890", "pk": "456", "isCool": true})
+
+	ts := runTestServer()
+	defer ts.Close()

 	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,439 +76,64 @@ func documents_InitializeDb(t *testing.T, ts *TestServer) *azcosmos.ContainerCli
 	collectionClient, err := client.NewContainer(testDatabaseName, testCollectionName)
 	assert.Nil(t, err)

-	return collectionClient
-}
-
-func Test_Documents(t *testing.T) {
-	presets := []testPreset{PresetJsonStore, PresetBadgerStore}
-
-	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,
-				"SELECT c.id, c[\"pk\"] FROM c ORDER BY c.id",
-				nil,
-				[]interface{}{
-					map[string]interface{}{"id": "12345", "pk": "123"},
-					map[string]interface{}{"id": "67890", "pk": "456"},
-				},
-			)
-		})
-
-		t.Run("Should query VALUE array", func(t *testing.T) {
-			testCosmosQuery(t, collectionClient,
-				"SELECT VALUE [c.id, c[\"pk\"]] FROM c ORDER BY c.id",
-				nil,
-				[]interface{}{
-					[]interface{}{"12345", "123"},
-					[]interface{}{"67890", "456"},
-				},
-			)
-		})
-
-		t.Run("Should query VALUE object", func(t *testing.T) {
-			testCosmosQuery(t, collectionClient,
-				"SELECT VALUE { id: c.id, _pk: c.pk } FROM c ORDER BY c.id",
-				nil,
-				[]interface{}{
-					map[string]interface{}{"id": "12345", "_pk": "123"},
-					map[string]interface{}{"id": "67890", "_pk": "456"},
-				},
-			)
-		})
-
-		t.Run("Should query document with single WHERE condition", func(t *testing.T) {
-			testCosmosQuery(t, collectionClient,
-				`select c.id
-				FROM c
-				WHERE c.isCool=true
-				ORDER BY c.id`,
-				nil,
-				[]interface{}{
-					map[string]interface{}{"id": "67890"},
-				},
-			)
-		})
-
-		t.Run("Should query document with query parameters", func(t *testing.T) {
-			testCosmosQuery(t, collectionClient,
-				`select c.id
-				FROM c
-				WHERE c.id=@param_id
-				ORDER BY c.id`,
-				[]azcosmos.QueryParameter{
-					{Name: "@param_id", Value: "67890"},
-				},
-				[]interface{}{
-					map[string]interface{}{"id": "67890"},
-				},
-			)
-		})
-
-		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,
-					c["arr"][0] AS arr0,
-					c["arr"][1] AS arr1,
-					c["arr"][2] AS arr2,
-					c["arr"][3] AS arr3
-				FROM c ORDER BY c.id`,
-				nil,
-				[]interface{}{
-					map[string]interface{}{"id": "12345", "arr0": 1.0, "arr1": 2.0, "arr2": 3.0, "arr3": nil},
-					map[string]interface{}{"id": "67890", "arr0": 6.0, "arr1": 7.0, "arr2": 8.0, "arr3": nil},
-				},
-			)
-		})
-
-		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)
-				defer cancel()
-
-				_, 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)
-				}
-			}
-		})
+	t.Run("Should query document", func(t *testing.T) {
+		testCosmosQuery(t, collectionClient,
+			"SELECT c.id, c[\"pk\"] FROM c ORDER BY c.id",
+			nil,
+			[]interface{}{
+				map[string]interface{}{"id": "12345", "pk": "123"},
+				map[string]interface{}{"id": "67890", "pk": "456"},
+			},
+		)
 	})

-	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"}
-
-			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,
-				azcosmos.PartitionKey{},
-				"67890",
-				patch,
-				&azcosmos.ItemOptions{
-					EnableContentResponseOnWrite: false,
-				},
-			)
-			assert.Nil(t, err)
-
-			var itemResponseBody map[string]interface{}
-			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) {
-			context := context.TODO()
-
-			patch := azcosmos.PatchOperations{}
-			patch.AppendReplace("/id", "newValue")
-
-			_, err := collectionClient.PatchItem(
-				context,
-				azcosmos.PartitionKey{},
-				"67890",
-				patch,
-				&azcosmos.ItemOptions{
-					EnableContentResponseOnWrite: false,
-				},
-			)
-			assert.NotNil(t, err)
-
-			var respErr *azcore.ResponseError
-			if errors.As(err, &respErr) {
-				assert.Equal(t, http.StatusUnprocessableEntity, respErr.StatusCode)
-			} else {
-				panic(err)
-			}
-		})
-
-		t.Run("CreateItem", func(t *testing.T) {
-			context := context.TODO()
-
-			item := map[string]interface{}{
-				"Id":       "6789011",
-				"pk":       "456",
-				"newField": "newValue2",
-			}
-			bytes, err := json.Marshal(item)
-			assert.Nil(t, err)
-
-			r, err2 := collectionClient.CreateItem(
-				context,
-				azcosmos.PartitionKey{},
-				bytes,
-				&azcosmos.ItemOptions{
-					EnableContentResponseOnWrite: false,
-				},
-			)
-			assert.NotNil(t, r)
-			assert.Nil(t, err2)
-		})
-
-		t.Run("CreateItem that already exists", func(t *testing.T) {
-			context := context.TODO()
-
-			item := map[string]interface{}{"id": "12345", "pk": "123", "isCool": false, "arr": []int{1, 2, 3}}
-			bytes, err := json.Marshal(item)
-			assert.Nil(t, err)
-
-			r, err := collectionClient.CreateItem(
-				context,
-				azcosmos.PartitionKey{},
-				bytes,
-				&azcosmos.ItemOptions{
-					EnableContentResponseOnWrite: false,
-				},
-			)
-			assert.NotNil(t, r)
-			assert.NotNil(t, err)
-
-			var respErr *azcore.ResponseError
-			if errors.As(err, &respErr) {
-				assert.Equal(t, http.StatusConflict, respErr.StatusCode)
-			} else {
-				panic(err)
-			}
-		})
-
-		t.Run("UpsertItem new", func(t *testing.T) {
-			context := context.TODO()
-
-			item := map[string]interface{}{"id": "123456", "pk": "1234", "isCool": false, "arr": []int{1, 2, 3}}
-			bytes, err := json.Marshal(item)
-			assert.Nil(t, err)
-
-			r, err2 := collectionClient.UpsertItem(
-				context,
-				azcosmos.PartitionKey{},
-				bytes,
-				&azcosmos.ItemOptions{
-					EnableContentResponseOnWrite: false,
-				},
-			)
-			assert.NotNil(t, r)
-			assert.Nil(t, err2)
-		})
-
-		t.Run("UpsertItem that already exists", func(t *testing.T) {
-			context := context.TODO()
-
-			item := map[string]interface{}{"id": "12345", "pk": "123", "isCool": false, "arr": []int{1, 2, 3, 4}}
-			bytes, err := json.Marshal(item)
-			assert.Nil(t, err)
-
-			r, err2 := collectionClient.UpsertItem(
-				context,
-				azcosmos.PartitionKey{},
-				bytes,
-				&azcosmos.ItemOptions{
-					EnableContentResponseOnWrite: false,
-				},
-			)
-			assert.NotNil(t, r)
-			assert.Nil(t, err2)
-		})
+	t.Run("Should query VALUE array", func(t *testing.T) {
+		testCosmosQuery(t, collectionClient,
+			"SELECT VALUE [c.id, c[\"pk\"]] FROM c ORDER BY c.id",
+			nil,
+			[]interface{}{
+				[]interface{}{"12345", "123"},
+				[]interface{}{"67890", "456"},
+			},
+		)
 	})

-	runTestsWithPresets(t, "Test_Documents_TransactionalBatch", presets, func(t *testing.T, ts *TestServer, client *azcosmos.Client) {
-		collectionClient := documents_InitializeDb(t, ts)
+	t.Run("Should query VALUE object", func(t *testing.T) {
+		testCosmosQuery(t, collectionClient,
+			"SELECT VALUE { id: c.id, _pk: c.pk } FROM c ORDER BY c.id",
+			nil,
+			[]interface{}{
+				map[string]interface{}{"id": "12345", "_pk": "123"},
+				map[string]interface{}{"id": "67890", "_pk": "456"},
+			},
+		)
+	})

-		t.Run("Should execute CREATE transactional batch", func(t *testing.T) {
-			context := context.TODO()
-			batch := collectionClient.NewTransactionalBatch(azcosmos.NewPartitionKeyString("pk"))
+	t.Run("Should query document with single WHERE condition", func(t *testing.T) {
+		testCosmosQuery(t, collectionClient,
+			`select c.id
+			FROM c
+			WHERE c.isCool=true
+			ORDER BY c.id`,
+			nil,
+			[]interface{}{
+				map[string]interface{}{"id": "67890"},
+			},
+		)
+	})

-			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"])
-		})
+	t.Run("Should query document with query parameters", func(t *testing.T) {
+		testCosmosQuery(t, collectionClient,
+			`select c.id
+			FROM c
+			WHERE c.id=@param_id
+			ORDER BY c.id`,
+			[]azcosmos.QueryParameter{
+				{Name: "@param_id", Value: "67890"},
+			},
+			[]interface{}{
+				map[string]interface{}{"id": "67890"},
+			},
+		)
 	})
 }
--- a/api/tests/documents_trailingslash_test.go
+++ b/api/tests/documents_trailingslash_test.go
@ -1,42 +0,0 @@
-package tests_test
-
-import (
-	"fmt"
-	"net/http"
-	"net/url"
-	"testing"
-	"time"
-
-	"github.com/pikami/cosmium/api/config"
-	"github.com/pikami/cosmium/internal/authentication"
-	"github.com/stretchr/testify/assert"
-)
-
-// Request document with trailing slash like python cosmosdb client does.
-func Test_Documents_Read_Trailing_Slash(t *testing.T) {
-	ts := runTestServer()
-	documents_InitializeDb(t, ts)
-	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)
-		httpClient := &http.Client{}
-		req, _ := http.NewRequest("GET", testUrl, nil)
-		req.Header.Add("x-ms-date", date)
-		req.Header.Add("authorization", "sig="+url.QueryEscape(signature))
-		res, err := httpClient.Do(req)
-
-		assert.Nil(t, err)
-
-		if res != nil {
-			defer res.Body.Close()
-			assert.Equal(t, http.StatusOK, res.StatusCode, "Expected HTTP status 200 OK")
-		} else {
-			t.FailNow()
-		}
-	})
-}
--- a/cmd/server/server.go
+++ b/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()
-}
--- a/docs/COMPATIBILITY.md
+++ b/docs/COMPATIBILITY.md
@ -15,11 +15,10 @@ Cosmium strives to support the core features of Cosmos DB, including:
 ## Compatibility Matrix

 ### Features
-
 | Feature                       | Implemented |
-| ----------------------------- | ----------- |
-| Subqueries                    | Yes         |
-| Joins                         | Yes         |
+|-------------------------------|-------------|
+| Subqueries                    | No          |
+| Joins                         | No          |
 | Computed properties           | No          |
 | Coalesce operators            | No          |
 | Bitwise operators             | No          |
@ -30,9 +29,8 @@ Cosmium strives to support the core features of Cosmos DB, including:
 | User-defined functions (UDFs) | No          |

 ### Clauses
-
 | Clause       | Implemented |
-| ------------ | ----------- |
+|--------------|-------------|
 | SELECT       | Yes         |
 | FROM         | Yes         |
 | WHERE        | Yes         |
@ -41,9 +39,8 @@ Cosmium strives to support the core features of Cosmos DB, including:
 | OFFSET LIMIT | Yes         |

 ### Keywords
-
 | Keyword  | Implemented |
-| -------- | ----------- |
+|----------|-------------|
 | BETWEEN  | No          |
 | DISTINCT | Yes         |
 | LIKE     | No          |
@ -51,9 +48,8 @@ Cosmium strives to support the core features of Cosmos DB, including:
 | TOP      | Yes         |

 ### Aggregate Functions
-
 | Function | Implemented |
-| -------- | ----------- |
+|----------|-------------|
 | AVG      | Yes         |
 | COUNT    | Yes         |
 | MAX      | Yes         |
@ -61,30 +57,25 @@ Cosmium strives to support the core features of Cosmos DB, including:
 | SUM      | Yes         |

 ### Array Functions
-
-| Function           | Implemented |
-| ------------------ | ----------- |
-| ARRAY_CONCAT       | Yes         |
-| ARRAY_CONTAINS     | Yes         |
-| ARRAY_CONTAINS_ANY | Yes         |
-| ARRAY_CONTAINS_ALL | Yes         |
-| ARRAY_LENGTH       | Yes         |
-| ARRAY_SLICE        | Yes         |
-| CHOOSE             | No          |
-| ObjectToArray      | No          |
-| SetIntersect       | Yes         |
-| SetUnion           | Yes         |
+| Function       | Implemented |
+|----------------|-------------|
+| ARRAY_CONCAT   | Yes         |
+| ARRAY_CONTAINS | No          |
+| ARRAY_LENGTH   | Yes         |
+| ARRAY_SLICE    | Yes         |
+| CHOOSE         | No          |
+| ObjectToArray  | No          |
+| SetIntersect   | Yes         |
+| SetUnion       | Yes         |

 ### Conditional Functions
-
 | Function | Implemented |
-| -------- | ----------- |
-| IIF      | Yes         |
+|----------|-------------|
+| IIF      | No          |

 ### Date and time Functions
-
 | Function                  | Implemented |
-| ------------------------- | ----------- |
+|---------------------------|-------------|
 | DateTimeAdd               | No          |
 | DateTimeBin               | No          |
 | DateTimeDiff              | No          |
@ -102,56 +93,53 @@ Cosmium strives to support the core features of Cosmos DB, including:
 | TimestampToDateTime       | No          |

 ### Item Functions
-
 | Function   | Implemented |
-| ---------- | ----------- |
+|------------|-------------|
 | DocumentId | No          |

 ### Mathematical Functions
-
 | Function         | Implemented |
-| ---------------- | ----------- |
-| ABS              | Yes         |
-| ACOS             | Yes         |
-| ASIN             | Yes         |
-| ATAN             | Yes         |
-| ATN2             | Yes         |
-| CEILING          | Yes         |
-| COS              | Yes         |
-| COT              | Yes         |
-| DEGREES          | Yes         |
-| EXP              | Yes         |
-| FLOOR            | Yes         |
-| IntAdd           | Yes         |
-| IntBitAnd        | Yes         |
-| IntBitLeftShift  | Yes         |
-| IntBitNot        | Yes         |
-| IntBitOr         | Yes         |
-| IntBitRightShift | Yes         |
-| IntBitXor        | Yes         |
-| IntDiv           | Yes         |
-| IntMod           | Yes         |
-| IntMul           | Yes         |
-| IntSub           | Yes         |
-| LOG              | Yes         |
-| LOG10            | Yes         |
-| NumberBin        | Yes         |
-| PI               | Yes         |
-| POWER            | Yes         |
-| RADIANS          | Yes         |
-| RAND             | Yes         |
-| ROUND            | Yes         |
-| SIGN             | Yes         |
-| SIN              | Yes         |
-| SQRT             | Yes         |
-| SQUARE           | Yes         |
-| TAN              | Yes         |
-| TRUNC            | Yes         |
+|------------------|-------------|
+| ABS              | No          |
+| ACOS             | No          |
+| ASIN             | No          |
+| ATAN             | No          |
+| ATN2             | No          |
+| CEILING          | No          |
+| COS              | No          |
+| COT              | No          |
+| DEGREES          | No          |
+| EXP              | No          |
+| FLOOR            | No          |
+| IntAdd           | No          |
+| IntBitAnd        | No          |
+| IntBitLeftShift  | No          |
+| IntBitNot        | No          |
+| IntBitOr         | No          |
+| IntBitRightShift | No          |
+| IntBitXor        | No          |
+| IntDiv           | No          |
+| IntMod           | No          |
+| IntMul           | No          |
+| IntSub           | No          |
+| LOG              | No          |
+| LOG10            | No          |
+| NumberBin        | No          |
+| PI               | No          |
+| POWER            | No          |
+| RADIANS          | No          |
+| RAND             | No          |
+| ROUND            | No          |
+| SIGN             | No          |
+| SIN              | No          |
+| SQRT             | No          |
+| SQUARE           | No          |
+| TAN              | No          |
+| TRUNC            | No          |

 ### Spatial Functions
-
 | Function           | Implemented |
-| ------------------ | ----------- |
+|--------------------|-------------|
 | ST_AREA            | No          |
 | ST_DISTANCE        | No          |
 | ST_WITHIN          | No          |
@ -160,9 +148,8 @@ Cosmium strives to support the core features of Cosmos DB, including:
 | ST_ISVALIDDETAILED | No          |

 ### String Functions
-
 | Function        | Implemented |
-| --------------- | ----------- |
+|-----------------|-------------|
 | CONCAT          | Yes         |
 | CONTAINS        | Yes         |
 | ENDSWITH        | Yes         |
@ -190,9 +177,8 @@ Cosmium strives to support the core features of Cosmos DB, including:
 | UPPER           | Yes         |

 ### Type checking Functions
-
 | Function         | Implemented |
-| ---------------- | ----------- |
+|------------------|-------------|
 | IS_ARRAY         | Yes         |
 | IS_BOOL          | Yes         |
 | IS_DEFINED       | Yes         |
@ -204,19 +190,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:
--- a/go.mod
+++ b/go.mod
@ -1,60 +1,43 @@
 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/data/azcosmos v1.4.0
-	github.com/cosmiumdev/json-patch/v5 v5.9.11
-	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/vmihailenco/msgpack/v5 v5.4.1
-	golang.org/x/exp v0.0.0-20250506013437-ce4c2cf36ca6
+	github.com/Azure/azure-sdk-for-go/sdk/azcore v1.9.2
+	github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos v0.3.6
+	github.com/gin-gonic/gin v1.9.1
+	github.com/google/uuid v1.1.1
+	github.com/stretchr/testify v1.8.4
+	golang.org/x/exp v0.0.0-20240222234643-814bf88cf225
 )

 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/bytedance/sonic v1.13.2 // indirect
-	github.com/bytedance/sonic/loader v0.2.4 // indirect
-	github.com/cespare/xxhash/v2 v2.3.0 // indirect
-	github.com/cloudwego/base64x v0.1.5 // indirect
+	github.com/Azure/azure-sdk-for-go/sdk/internal v1.5.2 // indirect
+	github.com/bytedance/sonic v1.9.1 // indirect
+	github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/dgraph-io/ristretto/v2 v2.2.0 // indirect
-	github.com/dustin/go-humanize v1.0.1 // 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/gabriel-vasile/mimetype v1.4.2 // indirect
+	github.com/gin-contrib/sse v0.1.0 // 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/goccy/go-json v0.10.5 // indirect
-	github.com/google/flatbuffers v25.2.10+incompatible // indirect
+	github.com/go-playground/validator/v10 v10.14.0 // indirect
+	github.com/goccy/go-json v0.10.2 // 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.10 // indirect
-	github.com/leodido/go-urn v1.4.0 // indirect
-	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.4 // indirect
+	github.com/leodido/go-urn v1.2.4 // indirect
+	github.com/mattn/go-isatty v0.0.19 // 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/pkg/errors v0.9.1 // indirect
+	github.com/pelletier/go-toml/v2 v2.0.8 // 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
-	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
-	go.opentelemetry.io/otel v1.35.0 // indirect
-	go.opentelemetry.io/otel/metric v1.35.0 // indirect
-	go.opentelemetry.io/otel/trace v1.35.0 // indirect
-	golang.org/x/arch v0.17.0 // 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
+	github.com/ugorji/go/codec v1.2.11 // indirect
+	golang.org/x/arch v0.3.0 // indirect
+	golang.org/x/crypto v0.18.0 // indirect
+	golang.org/x/net v0.20.0 // indirect
+	golang.org/x/sys v0.16.0 // indirect
+	golang.org/x/text v0.14.0 // indirect
+	google.golang.org/protobuf v1.30.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
--- a/go.sum
+++ b/go.sum
@ -1,186 +1,109 @@
 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.17.0/go.mod h1:XCW7KnZet0Opnr7HccfUw1PLc4CjHqpcaxW8DHklNkQ=
-github.com/Azure/azure-sdk-for-go/sdk/azcore v1.18.0 h1:Gt0j3wceWMwPmiazCa8MzMA0MfhmPIz0Qp0FJ6qcM0U=
-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.8.0 h1:B/dfvscEQtew9dVuoxqxrUKKv8Ih2f55PydknDamU+g=
-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/azidentity v1.8.2 h1:F0gBpfdPLGsw+nsgk6aqqkZS1jiixa5WwFe3fk/T3Ys=
-github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos v1.3.0 h1:RGcdpSElvcXCwxydI0xzOBu1Gvp88OoiTGfbtO/z1m0=
-github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos v1.3.0/go.mod h1:YwUyrNUtcZcibA99JcfCP6UUp95VVQKO2MJfBzgJDwA=
-github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos v1.4.0 h1:TSaH6Lj0m8bDr4vX1+LC1KLQTnLzZb3tOxrx/PLqw+c=
-github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos v1.4.0/go.mod h1:Krtog/7tz27z75TwM5cIS8bxEH4dcBUezcq+kGVeZEo=
-github.com/Azure/azure-sdk-for-go/sdk/internal v1.10.0 h1:ywEEhmNahHBihViHepv3xPBn1663uRv2t2q/ESv9seY=
-github.com/Azure/azure-sdk-for-go/sdk/internal v1.10.0/go.mod h1:iZDifYGJTIgIIkYRNWPENUnqx6bJ2xnSDFI2tjwZNuY=
-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/bytedance/sonic/loader v0.2.4/go.mod h1:N8A3vUdtUebEY2/VQC0MyhYeKUFosQU6FxH2JmUe6VI=
-github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
-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/Azure/azure-sdk-for-go/sdk/azcore v1.9.2 h1:c4k2FIYIh4xtwqrQwV0Ct1v5+ehlNXj5NI/MWVsiTkQ=
+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/azidentity v1.0.0 h1:Yoicul8bnVdQrhDMTHxdEckRGX01XvwXDHUT9zYZ3k0=
+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/data/azcosmos v0.3.6 h1:oBqQLSI1pZwGOdXJAoJJSzmff9tlfD4KroVfjQQmd0g=
+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/internal v1.5.2 h1:LqbJ/WzJUwBf8UiaSzgX7aMclParm9/5Vgp+TY51uBQ=
+github.com/Azure/azure-sdk-for-go/sdk/internal v1.5.2/go.mod h1:yInRyqWXAuaPrgI7p70+lDDgh3mlBohis29jGMISnmc=
+github.com/AzureAD/microsoft-authentication-library-for-go v0.4.0 h1:WVsrXCnHlDDX8ls+tootqRE87/hL9S/g4ewig9RsD/c=
+github.com/AzureAD/microsoft-authentication-library-for-go v0.4.0/go.mod h1:Vt9sXTKwMyGcOxSmLDMnGPgqsUg7m8pe215qMLrDXw4=
+github.com/bytedance/sonic v1.5.0/go.mod h1:ED5hyg4y6t3/9Ku1R6dU/4KyJ48DZ4jPhfY1O2AihPM=
+github.com/bytedance/sonic v1.9.1 h1:6iJ6NqdoxCDr6mbY8h18oSO+cShGSMRGCEo7F2h0x8s=
+github.com/bytedance/sonic v1.9.1/go.mod h1:i736AoUSYt75HyZLoJW9ERYxcy6eaN6h4BZXU064P/U=
+github.com/chenzhuoyu/base64x v0.0.0-20211019084208-fb5309c8db06/go.mod h1:DH46F32mSOjUmXrMHnKwZdA8wcEefY7UVqBKYGjpdQY=
+github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 h1:qSGYFH7+jGhDF8vLC+iwCD4WpbV1EBDSzWkJODFLams=
+github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311/go.mod h1:b583jCggY9gE99b6G5LEC39OIiVsWj+R97kbl5odCEk=
 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/dgraph-io/badger/v4 v4.6.0/go.mod h1:KSJ5VTuZNC3Sd+YhvVjk2nYua9UZnnTr/SkXvdtiPgI=
-github.com/dgraph-io/badger/v4 v4.7.0 h1:Q+J8HApYAY7UMpL8d9owqiB+odzEc0zn/aqOD9jhc6Y=
-github.com/dgraph-io/badger/v4 v4.7.0/go.mod h1:He7TzG3YBy3j4f5baj5B7Zl2XyfNe5bl4Udl0aPemVA=
-github.com/dgraph-io/ristretto/v2 v2.1.0 h1:59LjpOJLNDULHh8MC4UaegN52lC4JnO2dITsie/Pa8I=
-github.com/dgraph-io/ristretto/v2 v2.1.0/go.mod h1:uejeqfYXpUomfse0+lO+13ATz4TypQYLJZzBSAemuB4=
-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/gabriel-vasile/mimetype v1.4.2 h1:w5qFW6JKBz9Y393Y4q372O9A7cUSequkh1Q7OhCmWKU=
+github.com/gabriel-vasile/mimetype v1.4.2/go.mod h1:zApsH/mKG4w07erKIaJPFiX0Tsq9BFQgN3qGY5GnNgA=
+github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
+github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
+github.com/gin-gonic/gin v1.9.1 h1:4idEAncQnU5cB7BeOkPtxjfCSye0AAm1R0RVIqJ+Jmg=
+github.com/gin-gonic/gin v1.9.1/go.mod h1:hPrL7YrpYKXt5YId3A/Tnip5kqbEAP+KLuI3SUcPTeU=
 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.25.0/go.mod h1:GGzBIJMuE98Ic/kJsBXbz1x/7cByt++cQ+YOuDM5wus=
-github.com/go-playground/validator/v10 v10.26.0 h1:SP05Nqhjcvz81uJaRfEV0YBSSSGMc/iMaVtFbr3Sw2k=
-github.com/go-playground/validator/v10 v10.26.0/go.mod h1:I5QpIEbmr8On7W0TktmJAumgzX4CA1XNl4ZmDuVHKKo=
-github.com/goccy/go-json v0.10.5 h1:Fq85nIqj+gXn/S5ahsiTlK3TmC85qgirsdTP/+DeaC4=
-github.com/goccy/go-json v0.10.5/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
-github.com/golang-jwt/jwt/v5 v5.2.1 h1:OuVbFODueb089Lh128TAcimifWaLhJwVflnrgM17wHk=
-github.com/golang-jwt/jwt/v5 v5.2.1/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk=
-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/go-playground/validator/v10 v10.14.0 h1:vgvQWe3XCz3gIeFDm/HnTIbj6UGmg/+t63MyGU2n5js=
+github.com/go-playground/validator/v10 v10.14.0/go.mod h1:9iXMNT7sEkjXb0I+enO7QXmzG6QCsPWY4zveKFVRSyU=
+github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
+github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
+github.com/golang-jwt/jwt v3.2.1+incompatible h1:73Z+4BJcrTC+KczS6WvTPvRGOp1WmfEP4Q1lOd9Z/+c=
+github.com/golang-jwt/jwt v3.2.1+incompatible/go.mod h1:8pz2t5EyA70fFQQSrl6XZXzqecmYZeUEB8OUGHkxJ+I=
+github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.8 h1:e6P7q2lk1O+qJJb4BtCQXlK8vWEO8V1ZeuEdJNOqZyg=
+github.com/google/go-cmp v0.5.8/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 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/google/uuid v1.1.1 h1:Gkbcsh/GbpXz7lPftLA3P6TYMwjCLYm83jiFQZF/3gY=
+github.com/google/uuid v1.1.1/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.10/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
-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/klauspost/cpuid/v2 v2.2.4 h1:acbojRNwl3o09bUq+yDCtZFc1aiwaAAxtcn8YkZXnvk=
+github.com/klauspost/cpuid/v2 v2.2.4/go.mod h1:RVVoqg1df56z8g3pUjL/3lE5UfnlrJX8tyFgg4nqhuY=
 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=
-github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI=
-github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
-github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/leodido/go-urn v1.2.4 h1:XlAE/cm/ms7TE/VMVoduSpNBoyc2dOxHs5MZSwAN63Q=
+github.com/leodido/go-urn v1.2.4/go.mod h1:7ZrI8mTSeBSHl/UaRyKQW1qZeMgak41ANeCNaVckg+4=
+github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA=
+github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
 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.3/go.mod h1:MfCQTFTvCcUyyvvwm1+G6H/jORL20Xlb6rzQu9GuUkc=
-github.com/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0t5Ec4=
-github.com/pelletier/go-toml/v2 v2.2.4/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY=
-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/pelletier/go-toml/v2 v2.0.8 h1:0ctb6s9mE31h0/lhu+J6OPmVeDxJn+kYnJc2jZR9tGQ=
+github.com/pelletier/go-toml/v2 v2.0.8/go.mod h1:vuYfssBdrU2XDZ9bYydBu6t+6a6PYNcZljzZR9VXg+4=
+github.com/pkg/browser v0.0.0-20210115035449-ce105d075bb4 h1:Qj1ukM4GlMWXNdMBuXcXfz/Kw9s1qm0CLY32QxuSImI=
+github.com/pkg/browser v0.0.0-20210115035449-ce105d075bb4/go.mod h1:N6UoU20jOqggOuDwUaBQpluzLNDqif3kq9z2wpdYEfQ=
 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=
-github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 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.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/stretchr/testify v1.8.3/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
 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.10.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=
-github.com/vmihailenco/msgpack/v5 v5.4.1/go.mod h1:GaZTsDaehaPpQVyxrf5mtQlH+pc21PIudVV/E3rRQok=
-github.com/vmihailenco/tagparser/v2 v2.0.0 h1:y09buUbR+b5aycVFQs/g70pqKVZNBmxwAhO7/IwNM9g=
-github.com/vmihailenco/tagparser/v2 v2.0.0/go.mod h1:Wri+At7QHww0WTrCBeu4J6bNtoV6mEfg5OIWRZA9qds=
-go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
-go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
-go.opentelemetry.io/otel v1.35.0 h1:xKWKPxrxB6OtMCbmMY021CqC45J+3Onta9MqjhnusiQ=
-go.opentelemetry.io/otel v1.35.0/go.mod h1:UEqy8Zp11hpkUrL73gSlELM0DupHoiq72dR+Zqel/+Y=
-go.opentelemetry.io/otel/metric v1.35.0 h1:0znxYu2SNyuMSQT4Y9WDWej0VpcsxkuklLa4/siN90M=
-go.opentelemetry.io/otel/metric v1.35.0/go.mod h1:nKVFgxBZ2fReX6IlyW28MgZojkoAkJGaE8CpgeAU3oE=
-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=
+github.com/ugorji/go/codec v1.2.11 h1:BMaWp1Bb6fHwEtbplGBGJ498wD+LKlNSl25MjdZY4dU=
+github.com/ugorji/go/codec v1.2.11/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
+golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
+golang.org/x/arch v0.3.0 h1:02VY4/ZcO/gBOH6PUaoiptASxtXU10jazRCP865E97k=
+golang.org/x/arch v0.3.0/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
+golang.org/x/crypto v0.18.0 h1:PGVlW0xEltQnzFZ55hkuX5+KLyrMYhHld1YHO4AKcdc=
+golang.org/x/crypto v0.18.0/go.mod h1:R0j02AL6hcrfOiy9T4ZYp/rcWeMxM3L6QYxlOuEG1mg=
+golang.org/x/exp v0.0.0-20240222234643-814bf88cf225 h1:LfspQV/FYTatPTr/3HzIcmiUFH7PGP+OQ6mgDYo3yuQ=
+golang.org/x/exp v0.0.0-20240222234643-814bf88cf225/go.mod h1:CxmFvTBINI24O/j8iY7H1xHzx2i4OsyguNBmN/uPtqc=
+golang.org/x/net v0.20.0 h1:aCL9BSgETF1k+blQaYUBx9hJ9LOGP3gAVemcZlf1Kpo=
+golang.org/x/net v0.20.0/go.mod h1:z8BVo6PvndSri0LbOE3hAn0apkU+1YvI6E70E9jsnvY=
+golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 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.31.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
-golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/text v0.23.0 h1:D71I7dUrlY+VX0gQShAThNGHFxZ13dGLBHQLVl1mJlY=
-golang.org/x/text v0.23.0/go.mod h1:/BLNzu4aZCJ1+kcD0DNRotWKage4q2rGVAg4o22unh4=
-golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
-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=
+golang.org/x/sys v0.16.0 h1:xWw16ngr6ZMtmxDyKyIgsE93KNKz5HKmMa3b8ALHidU=
+golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
+golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
+google.golang.org/protobuf v1.30.0 h1:kPPoIgf3TsEvrm0PFe15JQ+570QVxYzEvvHqChK+cng=
+google.golang.org/protobuf v1.30.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 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=
--- a/internal/authentication/authentication.go
+++ b/internal/authentication/authentication.go
@ -10,11 +10,6 @@ import (

 // https://learn.microsoft.com/en-us/rest/api/cosmos-db/access-control-on-cosmosdb-resources
 func GenerateSignature(verb string, resourceType string, resourceId string, date string, masterKey string) string {
-	isNameBased := resourceId != "" && ((len(resourceId) > 4 && resourceId[3] == '/') || strings.HasPrefix(strings.ToLower(resourceId), "interopusers"))
-	if !isNameBased {
-		resourceId = strings.ToLower(resourceId)
-	}
-
 	payload := fmt.Sprintf(
 		"%s\n%s\n%s\n%s\n%s\n",
 		strings.ToLower(verb),
--- a/internal/authentication/authentication_test.go
+++ b/internal/authentication/authentication_test.go
@ -27,14 +27,4 @@ func Test_GenerateSignature(t *testing.T) {
 		signature := authentication.GenerateSignature("DELETE", "dbs", "dbs/Test Database", testDate, config.DefaultAccountKey)
 		assert.Equal(t, "LcuXXg0TcXxZG0kUCj9tZIWRy2yCzim3oiqGiHpRqGs=", signature)
 	})
-
-	t.Run("Should generate PKRANGES signature", func(t *testing.T) {
-		signature := authentication.GenerateSignature("GET", "pkranges", "m4d+xG08uVM=", testDate, config.DefaultAccountKey)
-		assert.Equal(t, "6S5ceZsl2EXWB3Jo5bJcK7zv8NxXnsxWPWD9TH3nNMo=", signature)
-	})
-
-	t.Run("Should generate PATCH signature", func(t *testing.T) {
-		signature := authentication.GenerateSignature("PATCH", "docs", "dbs/test-db/colls/test-coll/docs/67890", testDate, config.DefaultAccountKey)
-		assert.Equal(t, "VR1ddfxKBXnoaT+b3WkhyYVc9JmGNpTnaRmyDM44398=", signature)
-	})
 }
--- a/internal/constants/responses.go
+++ b/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"}
--- a/internal/converters/document_to_rowtype.go
+++ b/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()
-}
--- a/internal/datastore/badger_datastore/badger_datastore.go
+++ b/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
-		}
-	}
-}
--- a/internal/datastore/badger_datastore/badger_logger.go
+++ b/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...)
-}
--- a/internal/datastore/badger_datastore/collections.go
+++ b/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
-}
--- a/internal/datastore/badger_datastore/databases.go
+++ b/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
-}
--- a/internal/datastore/badger_datastore/db_abstractions.go
+++ b/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
-}
--- a/internal/datastore/badger_datastore/document_iterator.go
+++ b/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()
-}
--- a/internal/datastore/badger_datastore/documents.go
+++ b/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
-}
--- a/internal/datastore/badger_datastore/partition_key_ranges.go
+++ b/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
-}
--- a/internal/datastore/badger_datastore/stored_procedures.go
+++ b/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
-}
--- a/internal/datastore/badger_datastore/triggers.go
+++ b/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
-}
--- a/internal/datastore/badger_datastore/user_defined_functions.go
+++ b/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
-}
--- a/internal/datastore/datastore.go
+++ b/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()
-}
--- a/internal/datastore/json_datastore/array_document_iterator.go
+++ b/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{}
-}
--- a/internal/datastore/json_datastore/collections.go
+++ b/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
-}
--- a/internal/datastore/json_datastore/databases.go
+++ b/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
-}
--- a/internal/datastore/json_datastore/documents.go
+++ b/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
-}
--- a/internal/datastore/json_datastore/map_datastore.go
+++ b/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
-}
--- a/internal/datastore/json_datastore/state.go
+++ b/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)
-			}
-		}
-	}
-}
--- a/internal/datastore/json_datastore/stored_procedures.go
+++ b/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
-}
--- a/internal/datastore/json_datastore/triggers.go
+++ b/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
-}
--- a/internal/datastore/json_datastore/user_defined_functions.go
+++ b/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
-}
--- a/internal/logger/logger.go
+++ b/internal/logger/logger.go
@ -1,140 +1,40 @@
 package logger

 import (
-	"fmt"
 	"log"
 	"os"
-	"runtime"
-	"strings"
-	"sync"
+
+	"github.com/pikami/cosmium/api/config"
 )

-type LogLevelType int
-
-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 DebugLogger = log.New(os.Stdout, "", log.Ldate|log.Ltime|log.Lshortfile)
 var InfoLogger = log.New(os.Stdout, "", log.Ldate|log.Ltime)
-var ErrorLogger = log.New(os.Stderr, "", log.Ldate|log.Ltime)
-
-func DebugLn(v ...any) {
-	if GetLogLevel() <= LogLevelDebug {
-		prefix := getCallerPrefix()
-		DebugLogger.Println(append([]interface{}{prefix}, v...)...)
-	}
-}
+var ErrorLogger = log.New(os.Stderr, "", log.Ldate|log.Ltime|log.Lshortfile)

 func Debug(v ...any) {
-	if GetLogLevel() <= LogLevelDebug {
-		prefix := getCallerPrefix()
-		DebugLogger.Println(append([]interface{}{prefix}, v...)...)
+	if config.Config.Debug {
+		DebugLogger.Println(v...)
 	}
 }

 func Debugf(format string, v ...any) {
-	if GetLogLevel() <= LogLevelDebug {
-		prefix := getCallerPrefix()
-		DebugLogger.Printf(prefix+format, v...)
-	}
-}
-
-func InfoLn(v ...any) {
-	if GetLogLevel() <= LogLevelInfo {
-		InfoLogger.Println(v...)
+	if config.Config.Debug {
+		DebugLogger.Printf(format, v...)
 	}
 }

 func Info(v ...any) {
-	if GetLogLevel() <= LogLevelInfo {
-		InfoLogger.Print(v...)
-	}
+	InfoLogger.Println(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...)...)
-	}
+	InfoLogger.Printf(format, v...)
 }

 func Error(v ...any) {
-	if GetLogLevel() <= LogLevelError {
-		prefix := getCallerPrefix()
-		ErrorLogger.Print(append([]interface{}{prefix}, v...)...)
-	}
+	ErrorLogger.Println(v...)
 }

 func Errorf(format string, v ...any) {
-	if GetLogLevel() <= LogLevelError {
-		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 ""
+	ErrorLogger.Printf(format, v...)
 }
--- a/internal/repositories/collections.go
+++ b/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
+}
--- a/internal/repositories/databases.go
+++ b/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
+}
--- a/internal/repositories/documents.go
+++ b/internal/repositories/documents.go
@ -0,0 +1,117 @@
+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 == "" {
+		return repositorymodels.Document{}, repositorymodels.BadRequest
+	}
+
+	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
+}
--- a/internal/datastore/json_datastore/partition_key_ranges.go
+++ b/internal/datastore/json_datastore/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) {
-	r.storeState.RLock()
-	defer r.storeState.RUnlock()
-
+func GetPartitionKeyRanges(databaseId string, collectionId string) ([]repositorymodels.PartitionKeyRange, repositorymodels.RepositoryStatus) {
 	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
 }
--- a/internal/repositories/state.go
+++ b/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)
+				}
+			}
+		}
+	}
+}
--- a/internal/repositories/stored_procedures.go
+++ b/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
+}
--- a/internal/repositories/triggers.go
+++ b/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
+}
--- a/internal/repositories/user_defined_functions.go
+++ b/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
+}
--- a/internal/repository_models/models.go
+++ b/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"`
-	TriggerType      TriggerType      `json:"triggerType"`
-	ResourceID       string           `json:"_rid"`
-	TimeStamp        int64            `json:"_ts"`
-	Self             string           `json:"_self"`
-	ETag             string           `json:"_etag"`
+	Body             string `json:"body"`
+	ID               string `json:"id"`
+	TriggerOperation string `json:"triggerOperation"`
+	TriggerType      string `json:"triggerType"`
+	ResourceID       string `json:"_rid"`
+	TimeStamp        int    `json:"_ts"`
+	Self             string `json:"_self"`
+	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"`
+}
--- a/internal/resourceid/resourceid.go
+++ b/internal/resourceid/resourceid.go
@ -2,77 +2,26 @@ 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 strings.ReplaceAll(encoded, "/", "-")
+	return base64.StdEncoding.EncodeToString(idBytes)
 }

 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 strings.ReplaceAll(encoded, "/", "-")
+	return base64.StdEncoding.EncodeToString(combinedIdBytes)
 }

 func uintToBytes(id uint32) []byte {
@ -83,13 +32,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
-}
--- a/internal/struct_hidrators/collection_defaults.go
+++ b/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{
-	IndexingPolicy: datastore.CollectionIndexingPolicy{
+var defaultCollection repositorymodels.Collection = repositorymodels.Collection{
+	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,
--- a/internal/struct_hidrators/hidrate.go
+++ b/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
--- a/internal/tls_provider/tls_provider.go
+++ b/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{}
 	}

--- a/main.go
+++ b/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)
+	}
+}
--- a/parsers/models.go
+++ b/parsers/models.go
@ -3,9 +3,7 @@ package parsers
 type SelectStmt struct {
 	SelectItems      []SelectItem
 	Table            Table
-	JoinItems        []JoinItem
 	Filters          interface{}
-	Exists           bool
 	Distinct         bool
 	Count            int
 	Offset           int
@ -15,14 +13,7 @@ type SelectStmt struct {
 }

 type Table struct {
-	Value      string
-	SelectItem SelectItem
-	IsInSelect bool
-}
-
-type JoinItem struct {
-	Table      Table
-	SelectItem SelectItem
+	Value string
 }

 type SelectItemType int
@ -33,9 +24,6 @@ const (
 	SelectItemTypeArray
 	SelectItemTypeConstant
 	SelectItemTypeFunctionCall
-	SelectItemTypeSubQuery
-	SelectItemTypeExpression
-	SelectItemTypeBinaryExpression
 )

 type SelectItem struct {
@ -44,7 +32,6 @@ type SelectItem struct {
 	SelectItems []SelectItem
 	Type        SelectItemType
 	Value       interface{}
-	Invert      bool
 	IsTopLevel  bool
 }

@ -66,12 +53,6 @@ type ComparisonExpression struct {
 	Operation string
 }

-type BinaryExpression struct {
-	Left      interface{}
-	Right     interface{}
-	Operation string
-}
-
 type ConstantType int

 const (
@ -133,53 +114,11 @@ const (
 	FunctionCallIsPrimitive    FunctionCallType = "IsPrimitive"
 	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"
-	FunctionCallMathAtan             FunctionCallType = "MathAtan"
-	FunctionCallMathAtn2             FunctionCallType = "MathAtn2"
-	FunctionCallMathCeiling          FunctionCallType = "MathCeiling"
-	FunctionCallMathCos              FunctionCallType = "MathCos"
-	FunctionCallMathCot              FunctionCallType = "MathCot"
-	FunctionCallMathDegrees          FunctionCallType = "MathDegrees"
-	FunctionCallMathExp              FunctionCallType = "MathExp"
-	FunctionCallMathFloor            FunctionCallType = "MathFloor"
-	FunctionCallMathIntAdd           FunctionCallType = "MathIntAdd"
-	FunctionCallMathIntBitAnd        FunctionCallType = "MathIntBitAnd"
-	FunctionCallMathIntBitLeftShift  FunctionCallType = "MathIntBitLeftShift"
-	FunctionCallMathIntBitNot        FunctionCallType = "MathIntBitNot"
-	FunctionCallMathIntBitOr         FunctionCallType = "MathIntBitOr"
-	FunctionCallMathIntBitRightShift FunctionCallType = "MathIntBitRightShift"
-	FunctionCallMathIntBitXor        FunctionCallType = "MathIntBitXor"
-	FunctionCallMathIntDiv           FunctionCallType = "MathIntDiv"
-	FunctionCallMathIntMod           FunctionCallType = "MathIntMod"
-	FunctionCallMathIntMul           FunctionCallType = "MathIntMul"
-	FunctionCallMathIntSub           FunctionCallType = "MathIntSub"
-	FunctionCallMathLog              FunctionCallType = "MathLog"
-	FunctionCallMathLog10            FunctionCallType = "MathLog10"
-	FunctionCallMathNumberBin        FunctionCallType = "MathNumberBin"
-	FunctionCallMathPi               FunctionCallType = "MathPi"
-	FunctionCallMathPower            FunctionCallType = "MathPower"
-	FunctionCallMathRadians          FunctionCallType = "MathRadians"
-	FunctionCallMathRand             FunctionCallType = "MathRand"
-	FunctionCallMathRound            FunctionCallType = "MathRound"
-	FunctionCallMathSign             FunctionCallType = "MathSign"
-	FunctionCallMathSin              FunctionCallType = "MathSin"
-	FunctionCallMathSqrt             FunctionCallType = "MathSqrt"
-	FunctionCallMathSquare           FunctionCallType = "MathSquare"
-	FunctionCallMathTan              FunctionCallType = "MathTan"
-	FunctionCallMathTrunc            FunctionCallType = "MathTrunc"
+	FunctionCallArrayConcat  FunctionCallType = "ArrayConcat"
+	FunctionCallArrayLength  FunctionCallType = "ArrayLength"
+	FunctionCallArraySlice   FunctionCallType = "ArraySlice"
+	FunctionCallSetIntersect FunctionCallType = "SetIntersect"
+	FunctionCallSetUnion     FunctionCallType = "SetUnion"

 	FunctionCallAggregateAvg   FunctionCallType = "AggregateAvg"
 	FunctionCallAggregateCount FunctionCallType = "AggregateCount"
--- a/parsers/nosql/aggregate_functions_test.go
+++ b/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"},
 			},
 		)
 	})
--- a/parsers/nosql/arithmetics_test.go
+++ b/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),
-				},
-			},
-		)
-	})
-}
--- a/parsers/nosql/array_functions_test.go
+++ b/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")},
-			},
-		)
-	})
-
-	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")},
+				Table: parsers.Table{Value: "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),
-								testutils.SelectItem_Constant_Int(2),
+								parsers.SelectItem{
+									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"},
 			},
 		)
 	})
--- a/parsers/nosql/join_test.go
+++ b/parsers/nosql/join_test.go
@ -1,58 +0,0 @@
-package nosql_test
-
-import (
-	"testing"
-
-	"github.com/pikami/cosmium/parsers"
-	testutils "github.com/pikami/cosmium/test_utils"
-)
-
-func Test_Parse_Join(t *testing.T) {
-
-	t.Run("Should parse simple JOIN", func(t *testing.T) {
-		testQueryParse(
-			t,
-			`SELECT c.id, c["pk"] FROM c JOIN cc IN c["tags"]`,
-			parsers.SelectStmt{
-				SelectItems: []parsers.SelectItem{
-					{Path: []string{"c", "id"}},
-					{Path: []string{"c", "pk"}},
-				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
-				JoinItems: []parsers.JoinItem{
-					{
-						Table: parsers.Table{
-							Value: "cc",
-						},
-						SelectItem: parsers.SelectItem{
-							Path: []string{"c", "tags"},
-						},
-					},
-				},
-			},
-		)
-	})
-
-	t.Run("Should parse JOIN VALUE", func(t *testing.T) {
-		testQueryParse(
-			t,
-			`SELECT VALUE cc FROM c JOIN cc IN c["tags"]`,
-			parsers.SelectStmt{
-				SelectItems: []parsers.SelectItem{
-					{Path: []string{"cc"}, IsTopLevel: true},
-				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
-				JoinItems: []parsers.JoinItem{
-					{
-						Table: parsers.Table{
-							Value: "cc",
-						},
-						SelectItem: parsers.SelectItem{
-							Path: []string{"c", "tags"},
-						},
-					},
-				},
-			},
-		)
-	})
-}
--- a/parsers/nosql/math_functions_test.go
+++ b/parsers/nosql/math_functions_test.go
@ -1,651 +0,0 @@
-package nosql_test
-
-import (
-	"testing"
-
-	"github.com/pikami/cosmium/parsers"
-	testutils "github.com/pikami/cosmium/test_utils"
-)
-
-func Test_Execute_MathFunctions(t *testing.T) {
-	t.Run("Should parse function ABS(ex)", func(t *testing.T) {
-		testMathFunctionParse(
-			t,
-			`SELECT ABS(c.value) FROM c`,
-			parsers.FunctionCallMathAbs,
-			[]interface{}{
-				parsers.SelectItem{
-					Path: []string{"c", "value"},
-					Type: parsers.SelectItemTypeField,
-				},
-			},
-			"c",
-		)
-	})
-
-	t.Run("Should parse function ACOS(ex)", func(t *testing.T) {
-		testMathFunctionParse(
-			t,
-			`SELECT ACOS(c.value) FROM c`,
-			parsers.FunctionCallMathAcos,
-			[]interface{}{
-				parsers.SelectItem{
-					Path: []string{"c", "value"},
-					Type: parsers.SelectItemTypeField,
-				},
-			},
-			"c",
-		)
-	})
-
-	t.Run("Should parse function ASIN(ex)", func(t *testing.T) {
-		testMathFunctionParse(
-			t,
-			`SELECT ASIN(c.value) FROM c`,
-			parsers.FunctionCallMathAsin,
-			[]interface{}{
-				parsers.SelectItem{
-					Path: []string{"c", "value"},
-					Type: parsers.SelectItemTypeField,
-				},
-			},
-			"c",
-		)
-	})
-
-	t.Run("Should parse function ATAN(ex)", func(t *testing.T) {
-		testMathFunctionParse(
-			t,
-			`SELECT ATAN(c.value) FROM c`,
-			parsers.FunctionCallMathAtan,
-			[]interface{}{
-				parsers.SelectItem{
-					Path: []string{"c", "value"},
-					Type: parsers.SelectItemTypeField,
-				},
-			},
-			"c",
-		)
-	})
-
-	t.Run("Should parse function CEILING(ex)", func(t *testing.T) {
-		testMathFunctionParse(
-			t,
-			`SELECT CEILING(c.value) FROM c`,
-			parsers.FunctionCallMathCeiling,
-			[]interface{}{
-				parsers.SelectItem{
-					Path: []string{"c", "value"},
-					Type: parsers.SelectItemTypeField,
-				},
-			},
-			"c",
-		)
-	})
-
-	t.Run("Should parse function COS(ex)", func(t *testing.T) {
-		testMathFunctionParse(
-			t,
-			`SELECT COS(c.value) FROM c`,
-			parsers.FunctionCallMathCos,
-			[]interface{}{
-				parsers.SelectItem{
-					Path: []string{"c", "value"},
-					Type: parsers.SelectItemTypeField,
-				},
-			},
-			"c",
-		)
-	})
-
-	t.Run("Should parse function COT(ex)", func(t *testing.T) {
-		testMathFunctionParse(
-			t,
-			`SELECT COT(c.value) FROM c`,
-			parsers.FunctionCallMathCot,
-			[]interface{}{
-				parsers.SelectItem{
-					Path: []string{"c", "value"},
-					Type: parsers.SelectItemTypeField,
-				},
-			},
-			"c",
-		)
-	})
-
-	t.Run("Should parse function DEGREES(ex)", func(t *testing.T) {
-		testMathFunctionParse(
-			t,
-			`SELECT DEGREES(c.value) FROM c`,
-			parsers.FunctionCallMathDegrees,
-			[]interface{}{
-				parsers.SelectItem{
-					Path: []string{"c", "value"},
-					Type: parsers.SelectItemTypeField,
-				},
-			},
-			"c",
-		)
-	})
-
-	t.Run("Should parse function EXP(ex)", func(t *testing.T) {
-		testMathFunctionParse(
-			t,
-			`SELECT EXP(c.value) FROM c`,
-			parsers.FunctionCallMathExp,
-			[]interface{}{
-				parsers.SelectItem{
-					Path: []string{"c", "value"},
-					Type: parsers.SelectItemTypeField,
-				},
-			},
-			"c",
-		)
-	})
-
-	t.Run("Should parse function FLOOR(ex)", func(t *testing.T) {
-		testMathFunctionParse(
-			t,
-			`SELECT FLOOR(c.value) FROM c`,
-			parsers.FunctionCallMathFloor,
-			[]interface{}{
-				parsers.SelectItem{
-					Path: []string{"c", "value"},
-					Type: parsers.SelectItemTypeField,
-				},
-			},
-			"c",
-		)
-	})
-
-	t.Run("Should parse function IntBitNot(ex)", func(t *testing.T) {
-		testMathFunctionParse(
-			t,
-			`SELECT IntBitNot(c.value) FROM c`,
-			parsers.FunctionCallMathIntBitNot,
-			[]interface{}{
-				parsers.SelectItem{
-					Path: []string{"c", "value"},
-					Type: parsers.SelectItemTypeField,
-				},
-			},
-			"c",
-		)
-	})
-
-	t.Run("Should parse function LOG10(ex)", func(t *testing.T) {
-		testMathFunctionParse(
-			t,
-			`SELECT LOG10(c.value) FROM c`,
-			parsers.FunctionCallMathLog10,
-			[]interface{}{
-				parsers.SelectItem{
-					Path: []string{"c", "value"},
-					Type: parsers.SelectItemTypeField,
-				},
-			},
-			"c",
-		)
-	})
-
-	t.Run("Should parse function RADIANS(ex)", func(t *testing.T) {
-		testMathFunctionParse(
-			t,
-			`SELECT RADIANS(c.value) FROM c`,
-			parsers.FunctionCallMathRadians,
-			[]interface{}{
-				parsers.SelectItem{
-					Path: []string{"c", "value"},
-					Type: parsers.SelectItemTypeField,
-				},
-			},
-			"c",
-		)
-	})
-
-	t.Run("Should parse function ROUND(ex)", func(t *testing.T) {
-		testMathFunctionParse(
-			t,
-			`SELECT ROUND(c.value) FROM c`,
-			parsers.FunctionCallMathRound,
-			[]interface{}{
-				parsers.SelectItem{
-					Path: []string{"c", "value"},
-					Type: parsers.SelectItemTypeField,
-				},
-			},
-			"c",
-		)
-	})
-
-	t.Run("Should parse function SIGN(ex)", func(t *testing.T) {
-		testMathFunctionParse(
-			t,
-			`SELECT SIGN(c.value) FROM c`,
-			parsers.FunctionCallMathSign,
-			[]interface{}{
-				parsers.SelectItem{
-					Path: []string{"c", "value"},
-					Type: parsers.SelectItemTypeField,
-				},
-			},
-			"c",
-		)
-	})
-
-	t.Run("Should parse function SIN(ex)", func(t *testing.T) {
-		testMathFunctionParse(
-			t,
-			`SELECT SIN(c.value) FROM c`,
-			parsers.FunctionCallMathSin,
-			[]interface{}{
-				parsers.SelectItem{
-					Path: []string{"c", "value"},
-					Type: parsers.SelectItemTypeField,
-				},
-			},
-			"c",
-		)
-	})
-
-	t.Run("Should parse function SQRT(ex)", func(t *testing.T) {
-		testMathFunctionParse(
-			t,
-			`SELECT SQRT(c.value) FROM c`,
-			parsers.FunctionCallMathSqrt,
-			[]interface{}{
-				parsers.SelectItem{
-					Path: []string{"c", "value"},
-					Type: parsers.SelectItemTypeField,
-				},
-			},
-			"c",
-		)
-	})
-
-	t.Run("Should parse function SQUARE(ex)", func(t *testing.T) {
-		testMathFunctionParse(
-			t,
-			`SELECT SQUARE(c.value) FROM c`,
-			parsers.FunctionCallMathSquare,
-			[]interface{}{
-				parsers.SelectItem{
-					Path: []string{"c", "value"},
-					Type: parsers.SelectItemTypeField,
-				},
-			},
-			"c",
-		)
-	})
-
-	t.Run("Should parse function TAN(ex)", func(t *testing.T) {
-		testMathFunctionParse(
-			t,
-			`SELECT TAN(c.value) FROM c`,
-			parsers.FunctionCallMathTan,
-			[]interface{}{
-				parsers.SelectItem{
-					Path: []string{"c", "value"},
-					Type: parsers.SelectItemTypeField,
-				},
-			},
-			"c",
-		)
-	})
-
-	t.Run("Should parse function TRUNC(ex)", func(t *testing.T) {
-		testMathFunctionParse(
-			t,
-			`SELECT TRUNC(c.value) FROM c`,
-			parsers.FunctionCallMathTrunc,
-			[]interface{}{
-				parsers.SelectItem{
-					Path: []string{"c", "value"},
-					Type: parsers.SelectItemTypeField,
-				},
-			},
-			"c",
-		)
-	})
-
-	t.Run("Should parse function ATN2(ex1, ex2)", func(t *testing.T) {
-		testMathFunctionParse(
-			t,
-			`SELECT ATN2(c.value, c.secondValue) FROM c`,
-			parsers.FunctionCallMathAtn2,
-			[]interface{}{
-				parsers.SelectItem{
-					Path: []string{"c", "value"},
-					Type: parsers.SelectItemTypeField,
-				},
-				parsers.SelectItem{
-					Path: []string{"c", "secondValue"},
-					Type: parsers.SelectItemTypeField,
-				},
-			},
-			"c",
-		)
-	})
-
-	t.Run("Should parse function IntAdd(ex1, ex2)", func(t *testing.T) {
-		testMathFunctionParse(
-			t,
-			`SELECT IntAdd(c.value, c.secondValue) FROM c`,
-			parsers.FunctionCallMathIntAdd,
-			[]interface{}{
-				parsers.SelectItem{
-					Path: []string{"c", "value"},
-					Type: parsers.SelectItemTypeField,
-				},
-				parsers.SelectItem{
-					Path: []string{"c", "secondValue"},
-					Type: parsers.SelectItemTypeField,
-				},
-			},
-			"c",
-		)
-	})
-
-	t.Run("Should parse function IntBitAnd(ex1, ex2)", func(t *testing.T) {
-		testMathFunctionParse(
-			t,
-			`SELECT IntBitAnd(c.value, c.secondValue) FROM c`,
-			parsers.FunctionCallMathIntBitAnd,
-			[]interface{}{
-				parsers.SelectItem{
-					Path: []string{"c", "value"},
-					Type: parsers.SelectItemTypeField,
-				},
-				parsers.SelectItem{
-					Path: []string{"c", "secondValue"},
-					Type: parsers.SelectItemTypeField,
-				},
-			},
-			"c",
-		)
-	})
-
-	t.Run("Should parse function IntBitLeftShift(ex1, ex2)", func(t *testing.T) {
-		testMathFunctionParse(
-			t,
-			`SELECT IntBitLeftShift(c.value, c.secondValue) FROM c`,
-			parsers.FunctionCallMathIntBitLeftShift,
-			[]interface{}{
-				parsers.SelectItem{
-					Path: []string{"c", "value"},
-					Type: parsers.SelectItemTypeField,
-				},
-				parsers.SelectItem{
-					Path: []string{"c", "secondValue"},
-					Type: parsers.SelectItemTypeField,
-				},
-			},
-			"c",
-		)
-	})
-
-	t.Run("Should parse function IntBitOr(ex1, ex2)", func(t *testing.T) {
-		testMathFunctionParse(
-			t,
-			`SELECT IntBitOr(c.value, c.secondValue) FROM c`,
-			parsers.FunctionCallMathIntBitOr,
-			[]interface{}{
-				parsers.SelectItem{
-					Path: []string{"c", "value"},
-					Type: parsers.SelectItemTypeField,
-				},
-				parsers.SelectItem{
-					Path: []string{"c", "secondValue"},
-					Type: parsers.SelectItemTypeField,
-				},
-			},
-			"c",
-		)
-	})
-
-	t.Run("Should parse function IntBitRightShift(ex1, ex2)", func(t *testing.T) {
-		testMathFunctionParse(
-			t,
-			`SELECT IntBitRightShift(c.value, c.secondValue) FROM c`,
-			parsers.FunctionCallMathIntBitRightShift,
-			[]interface{}{
-				parsers.SelectItem{
-					Path: []string{"c", "value"},
-					Type: parsers.SelectItemTypeField,
-				},
-				parsers.SelectItem{
-					Path: []string{"c", "secondValue"},
-					Type: parsers.SelectItemTypeField,
-				},
-			},
-			"c",
-		)
-	})
-
-	t.Run("Should parse function IntBitXor(ex1, ex2)", func(t *testing.T) {
-		testMathFunctionParse(
-			t,
-			`SELECT IntBitXor(c.value, c.secondValue) FROM c`,
-			parsers.FunctionCallMathIntBitXor,
-			[]interface{}{
-				parsers.SelectItem{
-					Path: []string{"c", "value"},
-					Type: parsers.SelectItemTypeField,
-				},
-				parsers.SelectItem{
-					Path: []string{"c", "secondValue"},
-					Type: parsers.SelectItemTypeField,
-				},
-			},
-			"c",
-		)
-	})
-
-	t.Run("Should parse function IntDiv(ex1, ex2)", func(t *testing.T) {
-		testMathFunctionParse(
-			t,
-			`SELECT IntDiv(c.value, c.secondValue) FROM c`,
-			parsers.FunctionCallMathIntDiv,
-			[]interface{}{
-				parsers.SelectItem{
-					Path: []string{"c", "value"},
-					Type: parsers.SelectItemTypeField,
-				},
-				parsers.SelectItem{
-					Path: []string{"c", "secondValue"},
-					Type: parsers.SelectItemTypeField,
-				},
-			},
-			"c",
-		)
-	})
-
-	t.Run("Should parse function IntMod(ex1, ex2)", func(t *testing.T) {
-		testMathFunctionParse(
-			t,
-			`SELECT IntMod(c.value, c.secondValue) FROM c`,
-			parsers.FunctionCallMathIntMod,
-			[]interface{}{
-				parsers.SelectItem{
-					Path: []string{"c", "value"},
-					Type: parsers.SelectItemTypeField,
-				},
-				parsers.SelectItem{
-					Path: []string{"c", "secondValue"},
-					Type: parsers.SelectItemTypeField,
-				},
-			},
-			"c",
-		)
-	})
-
-	t.Run("Should parse function IntMul(ex1, ex2)", func(t *testing.T) {
-		testMathFunctionParse(
-			t,
-			`SELECT IntMul(c.value, c.secondValue) FROM c`,
-			parsers.FunctionCallMathIntMul,
-			[]interface{}{
-				parsers.SelectItem{
-					Path: []string{"c", "value"},
-					Type: parsers.SelectItemTypeField,
-				},
-				parsers.SelectItem{
-					Path: []string{"c", "secondValue"},
-					Type: parsers.SelectItemTypeField,
-				},
-			},
-			"c",
-		)
-	})
-
-	t.Run("Should parse function IntSub(ex1, ex2)", func(t *testing.T) {
-		testMathFunctionParse(
-			t,
-			`SELECT IntSub(c.value, c.secondValue) FROM c`,
-			parsers.FunctionCallMathIntSub,
-			[]interface{}{
-				parsers.SelectItem{
-					Path: []string{"c", "value"},
-					Type: parsers.SelectItemTypeField,
-				},
-				parsers.SelectItem{
-					Path: []string{"c", "secondValue"},
-					Type: parsers.SelectItemTypeField,
-				},
-			},
-			"c",
-		)
-	})
-
-	t.Run("Should parse function POWER(ex1, ex2)", func(t *testing.T) {
-		testMathFunctionParse(
-			t,
-			`SELECT POWER(c.value, c.secondValue) FROM c`,
-			parsers.FunctionCallMathPower,
-			[]interface{}{
-				parsers.SelectItem{
-					Path: []string{"c", "value"},
-					Type: parsers.SelectItemTypeField,
-				},
-				parsers.SelectItem{
-					Path: []string{"c", "secondValue"},
-					Type: parsers.SelectItemTypeField,
-				},
-			},
-			"c",
-		)
-	})
-
-	t.Run("Should parse function LOG(ex)", func(t *testing.T) {
-		testMathFunctionParse(
-			t,
-			`SELECT LOG(c.value) FROM c`,
-			parsers.FunctionCallMathLog,
-			[]interface{}{
-				parsers.SelectItem{
-					Path: []string{"c", "value"},
-					Type: parsers.SelectItemTypeField,
-				},
-			},
-			"c",
-		)
-	})
-
-	t.Run("Should parse function LOG(ex1, ex2)", func(t *testing.T) {
-		testMathFunctionParse(
-			t,
-			`SELECT LOG(c.value, c.secondValue) FROM c`,
-			parsers.FunctionCallMathLog,
-			[]interface{}{
-				parsers.SelectItem{
-					Path: []string{"c", "value"},
-					Type: parsers.SelectItemTypeField,
-				},
-				parsers.SelectItem{
-					Path: []string{"c", "secondValue"},
-					Type: parsers.SelectItemTypeField,
-				},
-			},
-			"c",
-		)
-	})
-
-	t.Run("Should parse function NumberBin(ex)", func(t *testing.T) {
-		testMathFunctionParse(
-			t,
-			`SELECT NumberBin(c.value) FROM c`,
-			parsers.FunctionCallMathNumberBin,
-			[]interface{}{
-				parsers.SelectItem{
-					Path: []string{"c", "value"},
-					Type: parsers.SelectItemTypeField,
-				},
-			},
-			"c",
-		)
-	})
-
-	t.Run("Should parse function NumberBin(ex1, ex2)", func(t *testing.T) {
-		testMathFunctionParse(
-			t,
-			`SELECT NumberBin(c.value, c.secondValue) FROM c`,
-			parsers.FunctionCallMathNumberBin,
-			[]interface{}{
-				parsers.SelectItem{
-					Path: []string{"c", "value"},
-					Type: parsers.SelectItemTypeField,
-				},
-				parsers.SelectItem{
-					Path: []string{"c", "secondValue"},
-					Type: parsers.SelectItemTypeField,
-				},
-			},
-			"c",
-		)
-	})
-
-	t.Run("Should parse function PI()", func(t *testing.T) {
-		testMathFunctionParse(
-			t,
-			`SELECT PI() FROM c`,
-			parsers.FunctionCallMathPi,
-			[]interface{}{},
-			"c",
-		)
-	})
-
-	t.Run("Should parse function RAND()", func(t *testing.T) {
-		testMathFunctionParse(
-			t,
-			`SELECT RAND() FROM c`,
-			parsers.FunctionCallMathRand,
-			[]interface{}{},
-			"c",
-		)
-	})
-}
-
-func testMathFunctionParse(
-	t *testing.T,
-	query string,
-	expectedFunctionType parsers.FunctionCallType,
-	expectedArguments []interface{},
-	expectedTable string,
-) {
-	testQueryParse(
-		t,
-		query,
-		parsers.SelectStmt{
-			SelectItems: []parsers.SelectItem{
-				{
-					Type: parsers.SelectItemTypeFunctionCall,
-					Value: parsers.FunctionCall{
-						Type:      expectedFunctionType,
-						Arguments: expectedArguments,
-					},
-				},
-			},
-			Table: parsers.Table{SelectItem: testutils.SelectItem_Path(expectedTable)},
-		},
-	)
-}
--- a/parsers/nosql/misc_test.go
+++ b/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,86 +102,23 @@ 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,
-								Value: parsers.FunctionCall{
-									Type: parsers.FunctionCallToString,
-									Arguments: []interface{}{
-										testutils.SelectItem_Path("c", "id"),
-									},
+								Type: parsers.SelectItemTypeConstant,
+								Value: parsers.Constant{
+									Type:  parsers.ConstantTypeString,
+									Value: "123",
 								},
 							},
-							testutils.SelectItem_Constant_String("123"),
-							testutils.SelectItem_Constant_String("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"),
+							parsers.SelectItem{
+								Type: parsers.SelectItemTypeConstant,
+								Value: parsers.Constant{
+									Type:  parsers.ConstantTypeString,
+									Value: "456",
+								},
 							},
 						},
 					},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
 			},
 		)
 	})
--- a/parsers/nosql/nosql.go
+++ b/parsers/nosql/nosql.go
--- a/parsers/nosql/nosql.peg
+++ b/parsers/nosql/nosql.peg
@ -4,137 +4,112 @@ package nosql
 import "github.com/pikami/cosmium/parsers"

 func makeSelectStmt(
-    columns, fromClause, joinItems,
-    whereClause interface{}, distinctClause interface{},
-    count interface{}, groupByClause interface{}, orderList interface{},
-    offsetClause interface{},
+	columns, table,
+	whereClause interface{}, distinctClause interface{},
+	count interface{}, groupByClause interface{}, orderList interface{},
+	offsetClause interface{},
 ) (parsers.SelectStmt, error) {
-    selectStmt := parsers.SelectStmt{
-        SelectItems: columns.([]parsers.SelectItem),
-    }
+	selectStmt := parsers.SelectStmt{
+		SelectItems: columns.([]parsers.SelectItem),
+		Table:       table.(parsers.Table),
+	}

-    if fromTable, ok := fromClause.(parsers.Table); ok {
-        selectStmt.Table = fromTable
-    }
+	switch v := whereClause.(type) {
+	case parsers.ComparisonExpression, parsers.LogicalExpression, parsers.Constant, parsers.SelectItem:
+		selectStmt.Filters = v
+	}

-    if joinItemsArray, ok := joinItems.([]interface{}); ok && len(joinItemsArray) > 0 {
-        selectStmt.JoinItems = make([]parsers.JoinItem, len(joinItemsArray))
-        for i, joinItem := range joinItemsArray {
-            selectStmt.JoinItems[i] = joinItem.(parsers.JoinItem)
-        }
-    }
+	if distinctClause != nil {
+		selectStmt.Distinct = true
+	}

-    switch v := whereClause.(type) {
-    case parsers.ComparisonExpression, parsers.LogicalExpression, parsers.Constant, parsers.SelectItem:
-        selectStmt.Filters = v
-    }
+	if n, ok := count.(int); ok {
+		selectStmt.Count = n
+	}

-    if distinctClause != nil {
-        selectStmt.Distinct = true
-    }
+	if offsetArr, ok := offsetClause.([]interface{}); ok && len(offsetArr) == 2 {
+		if n, ok := offsetArr[0].(int); ok {
+			selectStmt.Offset = n
+		}

-    if n, ok := count.(int); ok {
-        selectStmt.Count = n
-    }
+		if n, ok := offsetArr[1].(int); ok {
+			selectStmt.Count = n
+		}
+	}

-    if offsetArr, ok := offsetClause.([]interface{}); ok && len(offsetArr) == 2 {
-        if n, ok := offsetArr[0].(int); ok {
-            selectStmt.Offset = n
-        }
+	if orderExpressions, ok := orderList.([]parsers.OrderExpression); ok {
+		selectStmt.OrderExpressions = orderExpressions
+	}

-        if n, ok := offsetArr[1].(int); ok {
-            selectStmt.Count = n
-        }
-    }
+	if groupByClause != nil {
+		selectStmt.GroupBy = groupByClause.([]parsers.SelectItem)
+	}

-    if orderExpressions, ok := orderList.([]parsers.OrderExpression); ok {
-        selectStmt.OrderExpressions = orderExpressions
-    }
-
-    if groupByClause != nil {
-        selectStmt.GroupBy = groupByClause.([]parsers.SelectItem)
-    }
-
-    return selectStmt, nil
-}
-
-func makeJoin(table interface{}, column interface{}) (parsers.JoinItem, error) {
-    joinItem := parsers.JoinItem{}
-
-    if selectItem, isSelectItem := column.(parsers.SelectItem); isSelectItem {
-        joinItem.SelectItem = selectItem
-        joinItem.Table.Value = selectItem.Alias
-    }
-
-    if tableTyped, isTable := table.(parsers.Table); isTable {
-        joinItem.Table = tableTyped
-    }
-
-    return joinItem, nil
+	return selectStmt, nil
 }

 func makeSelectItem(name interface{}, path interface{}, selectItemType parsers.SelectItemType) (parsers.SelectItem, error) {
-    ps := path.([]interface{})
+	ps := path.([]interface{})

-    paths := make([]string, 1)
+	paths := make([]string, 1)
    paths[0] = name.(string)
-    for _, p := range ps {
+	for _, p := range ps {
        paths = append(paths, p.(string))
-    }
+	}

-    return parsers.SelectItem{Path: paths, Type: selectItemType}, nil
+	return parsers.SelectItem{Path: paths, Type: selectItemType}, nil
 }

 func makeColumnList(column interface{}, other_columns interface{}) ([]parsers.SelectItem, error) {
    collsAsArray := other_columns.([]interface{})
-    columnList := make([]parsers.SelectItem, len(collsAsArray) + 1)
-    columnList[0] = column.(parsers.SelectItem)
+	columnList := make([]parsers.SelectItem, len(collsAsArray) + 1)
+	columnList[0] = column.(parsers.SelectItem)

-    for i, v := range collsAsArray {
+	for i, v := range collsAsArray {
        if col, ok := v.(parsers.SelectItem); ok {
-            columnList[i+1] = col
+			columnList[i+1] = col
        }
    }

-    return columnList, nil
+	return columnList, nil
 }

 func makeSelectArray(columns interface{}) (parsers.SelectItem, error) {
-    return parsers.SelectItem{
-        SelectItems: columns.([]parsers.SelectItem),
-        Type:        parsers.SelectItemTypeArray,
-    }, nil
+	return parsers.SelectItem{
+		SelectItems: columns.([]parsers.SelectItem),
+		Type:        parsers.SelectItemTypeArray,
+	}, nil
 }

 func makeSelectObject(field interface{}, other_fields interface{}) (parsers.SelectItem, error) {
    fieldsAsArray := other_fields.([]interface{})
-    fieldsList := make([]parsers.SelectItem, len(fieldsAsArray)+1)
-    fieldsList[0] = field.(parsers.SelectItem)
+	fieldsList := make([]parsers.SelectItem, len(fieldsAsArray)+1)
+	fieldsList[0] = field.(parsers.SelectItem)

-    for i, v := range fieldsAsArray {
-        if col, ok := v.(parsers.SelectItem); ok {
-            fieldsList[i+1] = col
-        }
-    }
+	for i, v := range fieldsAsArray {
+		if col, ok := v.(parsers.SelectItem); ok {
+			fieldsList[i+1] = col
+		}
+	}

-    return parsers.SelectItem{
-        SelectItems: fieldsList,
-        Type:        parsers.SelectItemTypeObject,
-    }, nil
+	return parsers.SelectItem{
+		SelectItems: fieldsList,
+		Type:        parsers.SelectItemTypeObject,
+	}, nil
 }

 func makeOrderByClause(ex1 interface{}, others interface{}) ([]parsers.OrderExpression, error) {
    othersArray := others.([]interface{})
-    orderList := make([]parsers.OrderExpression, len(othersArray)+1)
-    orderList[0] = ex1.(parsers.OrderExpression)
+	orderList := make([]parsers.OrderExpression, len(othersArray)+1)
+	orderList[0] = ex1.(parsers.OrderExpression)

-    for i, v := range othersArray {
-        if col, ok := v.(parsers.OrderExpression); ok {
-            orderList[i+1] = col
-        }
-    }
+	for i, v := range othersArray {
+		if col, ok := v.(parsers.OrderExpression); ok {
+			orderList[i+1] = col
+		}
+	}

-    return orderList, nil
+	return orderList, nil
 }

 func makeOrderExpression(field interface{}, order interface{}) (parsers.OrderExpression, error) {
@ -144,8 +119,8 @@ func makeOrderExpression(field interface{}, order interface{}) (parsers.OrderExp
    }

    if orderValue, ok := order.(parsers.OrderDirection); ok {
-        value.Direction = orderValue
-    }
+		value.Direction = orderValue
+	}

    return value, nil
 }
@ -169,39 +144,13 @@ func joinStrings(array []interface{}) string {

 func combineExpressions(ex1 interface{}, exs interface{}, operation parsers.LogicalExpressionType) (interface{}, error) {
    if exs == nil || len(exs.([]interface{})) < 1 {
-        return ex1, nil
-    }
+		return ex1, nil
+	}

-    return parsers.LogicalExpression{
-        Expressions: append([]interface{}{ex1}, exs.([]interface{})...),
-        Operation:   operation,
-    }, 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
+	return parsers.LogicalExpression{
+		Expressions: append([]interface{}{ex1}, exs.([]interface{})...),
+		Operation:   operation,
+	}, nil
 }

 }
@ -212,15 +161,13 @@ Input <- selectStmt:SelectStmt {

 SelectStmt <- Select ws
    distinctClause:DistinctClause? ws
-    topClause:TopClause? ws
-    columns:Selection ws
-    fromClause:FromClause? ws
-    joinClauses:(ws join:JoinClause { return join, nil })* ws
+    topClause:TopClause? ws columns:Selection ws
+    From ws table:TableName 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 })?
-    offsetClause:(ws offset:OffsetClause { return offset, nil })? {
-    return makeSelectStmt(columns, fromClause, joinClauses, whereClause,
+    orderByClause:OrderByClause?
+    offsetClause:OffsetClause? {
+    return makeSelectStmt(columns, table, whereClause,
        distinctClause, topClause, groupByClause, orderByClause, offsetClause)
 }

@ -230,60 +177,7 @@ TopClause <- Top ws count:Integer {
    return count, nil
 }

-FromClause <- From ws table:TableName selectItem:(ws In ws column:SelectItemWithAlias { return column, nil }) {
-    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
 }

@ -291,40 +185,17 @@ Selection <- SelectValueSpec / ColumnList / SelectAsterisk

 SelectAsterisk <- "*" {
    selectItem, _ := makeSelectItem("c", make([]interface{}, 0), parsers.SelectItemTypeField)
-    selectItem.IsTopLevel = true
+	selectItem.IsTopLevel = true
    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? {
-    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 {
+SelectValueSpec <- "VALUE"i ws column:SelectItem {
    selectItem := column.(parsers.SelectItem)
-    selectItem.IsTopLevel = true
+	selectItem.IsTopLevel = true
    return makeColumnList(selectItem, make([]interface{}, 0))
 }

@ -338,32 +209,19 @@ 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 {
    item := selectItem.(parsers.SelectItem)
-    item.Alias = name.(string)
-    return item, nil
+	item.Alias = name.(string)
+	return item, nil
 }

 SelectProperty <- name:Identifier path:(DotFieldAccess / ArrayFieldAccess)* {
    return makeSelectItem(name, path, parsers.SelectItemTypeField)
 }

-SelectItemWithAlias <- selectItem:SelectItem 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) {
+SelectItem <- selectItem:(Literal / FunctionCall / SelectArray / SelectObject / SelectProperty) asClause:AsClause? {
    var itemResult parsers.SelectItem
    switch typedValue := selectItem.(type) {
    case parsers.SelectItem:
@ -380,22 +238,22 @@ SelectItem <- selectItem:(SubQuerySelectItem / Literal / FunctionCall / SelectAr
        }
    }

-    return itemResult, nil
+	if aliasValue, ok := asClause.(string); ok {
+		itemResult.Alias = aliasValue
+	}
+
+	return itemResult, nil
 }

-AsClause <- (ws As)? ws !ExcludedKeywords alias:Identifier {
-    return alias, nil
-}
-
-ExcludedKeywords <- Select / Top / As / From / In / Join / Exists / Where / And / Or / Not / GroupBy / OrderBy / Offset
+AsClause <- ws As ws alias:Identifier { return alias, nil }

 DotFieldAccess <- "." id:Identifier {
    return id, nil
 }

-ArrayFieldAccess <- "[\"" id:Identifier "\"]" { return id, nil }
-  / "[" id:Integer "]" { return strconv.Itoa(id.(int)), nil }
-  / "[" id:ParameterConstant "]" { return id.(parsers.Constant).Value.(string), nil }
+ArrayFieldAccess <- "[\"" id:Identifier "\"]" {
+    return id, nil
+}

 Identifier <- [a-zA-Z_][a-zA-Z0-9_]* {
    return string(c.text), nil
@ -413,27 +271,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)
@ -445,10 +287,10 @@ OrderExpression <- field:SelectProperty ws order:OrderDirection? {

 OrderDirection <- ("ASC"i / "DESC"i) {
    if strings.EqualFold(string(c.text), "DESC") {
-        return parsers.OrderDirectionDesc, nil
+		return parsers.OrderDirectionDesc, nil
    }

-    return parsers.OrderDirectionAsc, nil
+	return parsers.OrderDirectionAsc, nil
 }

 Select <- "SELECT"i
@ -459,34 +301,20 @@ 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
-
-Not <- "NOT"i
+Or <- "OR"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,10 +342,8 @@ BooleanLiteral <- ("true"i / "false"i) {
 FunctionCall <- StringFunctions
    / TypeCheckingFunctions
    / ArrayFunctions
-    / ConditionalFunctions
    / InFunction
    / AggregateFunctions
-    / MathFunctions

 StringFunctions <- StringEqualsExpression
    / ToStringExpression
@ -554,53 +380,11 @@ AggregateFunctions <- AvgAggregateExpression
    / SumAggregateExpression

 ArrayFunctions <- ArrayConcatExpression
-    / ArrayContainsExpression
-    / ArrayContainsAnyExpression
-    / ArrayContainsAllExpression
    / ArrayLengthExpression
    / ArraySliceExpression
    / SetIntersectExpression
    / SetUnionExpression

-ConditionalFunctions <- IifExpression
-
-MathFunctions <- MathAbsExpression
-    / MathAcosExpression
-    / MathAsinExpression
-    / MathAtanExpression
-    / MathCeilingExpression
-    / MathCosExpression
-    / MathCotExpression
-    / MathDegreesExpression
-    / MathExpExpression
-    / MathFloorExpression
-    / MathIntBitNotExpression
-    / MathLog10Expression
-    / MathRadiansExpression
-    / MathRoundExpression
-    / MathSignExpression
-    / MathSinExpression
-    / MathSqrtExpression
-    / MathSquareExpression
-    / MathTanExpression
-    / MathTruncExpression
-    / MathAtn2Expression
-    / MathIntAddExpression
-    / MathIntBitAndExpression
-    / MathIntBitLeftShiftExpression
-    / MathIntBitOrExpression
-    / MathIntBitRightShiftExpression
-    / MathIntBitXorExpression
-    / MathIntDivExpression
-    / MathIntModExpression
-    / MathIntMulExpression
-    / MathIntSubExpression
-    / MathPowerExpression
-    / MathLogExpression
-    / MathNumberBinExpression
-    / MathPiExpression
-    / MathRandExpression
-
 UpperExpression <- "UPPER"i ws "(" ex:SelectItem ")" {
    return createFunctionCall(parsers.FunctionCallUpper, []interface{}{ex})
 }
@ -728,18 +512,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,56 +528,7 @@ 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}) }
-MathAtanExpression <- "ATAN"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathAtan, []interface{}{ex}) }
-MathCeilingExpression <- "CEILING"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathCeiling, []interface{}{ex}) }
-MathCosExpression <- "COS"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathCos, []interface{}{ex}) }
-MathCotExpression <- "COT"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathCot, []interface{}{ex}) }
-MathDegreesExpression <- "DEGREES"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathDegrees, []interface{}{ex}) }
-MathExpExpression <- "EXP"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathExp, []interface{}{ex}) }
-MathFloorExpression <- "FLOOR"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathFloor, []interface{}{ex}) }
-MathIntBitNotExpression <- "IntBitNot"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathIntBitNot, []interface{}{ex}) }
-MathLog10Expression <- "LOG10"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathLog10, []interface{}{ex}) }
-MathRadiansExpression <- "RADIANS"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathRadians, []interface{}{ex}) }
-MathRoundExpression <- "ROUND"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathRound, []interface{}{ex}) }
-MathSignExpression <- "SIGN"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathSign, []interface{}{ex}) }
-MathSinExpression <- "SIN"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathSin, []interface{}{ex}) }
-MathSqrtExpression <- "SQRT"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathSqrt, []interface{}{ex}) }
-MathSquareExpression <- "SQUARE"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathSquare, []interface{}{ex}) }
-MathTanExpression <- "TAN"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathTan, []interface{}{ex}) }
-MathTruncExpression <- "TRUNC"i ws "(" ws ex:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathTrunc, []interface{}{ex}) }
-
-MathAtn2Expression <- "ATN2"i ws "(" ws set1:SelectItem ws "," ws set2:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathAtn2, []interface{}{set1, set2}) }
-MathIntAddExpression <- "IntAdd"i ws "(" ws set1:SelectItem ws "," ws set2:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathIntAdd, []interface{}{set1, set2}) }
-MathIntBitAndExpression <- "IntBitAnd"i ws "(" ws set1:SelectItem ws "," ws set2:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathIntBitAnd, []interface{}{set1, set2}) }
-MathIntBitLeftShiftExpression <- "IntBitLeftShift"i ws "(" ws set1:SelectItem ws "," ws set2:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathIntBitLeftShift, []interface{}{set1, set2}) }
-MathIntBitOrExpression <- "IntBitOr"i ws "(" ws set1:SelectItem ws "," ws set2:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathIntBitOr, []interface{}{set1, set2}) }
-MathIntBitRightShiftExpression <- "IntBitRightShift"i ws "(" ws set1:SelectItem ws "," ws set2:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathIntBitRightShift, []interface{}{set1, set2}) }
-MathIntBitXorExpression <- "IntBitXor"i ws "(" ws set1:SelectItem ws "," ws set2:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathIntBitXor, []interface{}{set1, set2}) }
-MathIntDivExpression <- "IntDiv"i ws "(" ws set1:SelectItem ws "," ws set2:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathIntDiv, []interface{}{set1, set2}) }
-MathIntModExpression <- "IntMod"i ws "(" ws set1:SelectItem ws "," ws set2:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathIntMod, []interface{}{set1, set2}) }
-MathIntMulExpression <- "IntMul"i ws "(" ws set1:SelectItem ws "," ws set2:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathIntMul, []interface{}{set1, set2}) }
-MathIntSubExpression <- "IntSub"i ws "(" ws set1:SelectItem ws "," ws set2:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathIntSub, []interface{}{set1, set2}) }
-MathPowerExpression <- "POWER"i ws "(" ws set1:SelectItem ws "," ws set2:SelectItem ws ")" { return createFunctionCall(parsers.FunctionCallMathPower, []interface{}{set1, set2}) }
-
-MathLogExpression <- "LOG"i ws "(" ws ex1:SelectItem others:(ws "," ws ex:SelectItem { return ex, nil })* ws ")" {
-    return createFunctionCall(parsers.FunctionCallMathLog, append([]interface{}{ex1}, others.([]interface{})...))
-}
-MathNumberBinExpression <- "NumberBin"i ws "(" ws ex1:SelectItem others:(ws "," ws ex:SelectItem { return ex, nil })* ws ")" {
-    return createFunctionCall(parsers.FunctionCallMathNumberBin, append([]interface{}{ex1}, others.([]interface{})...))
-}
-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 ")" {
-    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 ")" {
+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{})...))
 }

@ -852,6 +575,4 @@ non_escape_character <- !(escape_character) char:.

 ws <- [ \t\n\r]*

-wss <- [ \t\n\r]+
-
 EOF <- !.
--- a/parsers/nosql/select_test.go
+++ b/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")},
-			},
-		)
-	})
-
-	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")},
+				Table: parsers.Table{Value: "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")},
-			},
-		)
-	})
-
-	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")},
+				Table: parsers.Table{Value: "c"},
 			},
 		)
 	})
@ -134,27 +106,7 @@ func Test_Parse_Select(t *testing.T) {
 						},
 					},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("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"}},
-				},
+				Table: parsers.Table{Value: "c"},
 			},
 		)
 	})
@ -174,93 +126,7 @@ func Test_Parse_Select(t *testing.T) {
 						},
 					},
 				},
-				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("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")},
+				Table: parsers.Table{Value: "c"},
 			},
 		)
 	})
--- a/parsers/nosql/string_functions_test.go
+++ b/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"),
-								testutils.SelectItem_Constant_Bool(true),
+								parsers.SelectItem{
+									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"),
-								testutils.SelectItem_Constant_Bool(true),
+								parsers.SelectItem{
+									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"),
-								testutils.SelectItem_Constant_Bool(true),
+								parsers.SelectItem{
+									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"),
-								testutils.SelectItem_Constant_Bool(true),
+								parsers.SelectItem{
+									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"),
-								testutils.SelectItem_Constant_Int(1),
+								parsers.SelectItem{
+									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"),
-								testutils.SelectItem_Constant_String("new"),
+								parsers.SelectItem{
+									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),
-								testutils.SelectItem_Constant_Int(5),
+								parsers.SelectItem{
+									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"},
 			},
 		)
 	})
--- a/parsers/nosql/subquery_test.go
+++ b/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"},
-				},
-			},
-		)
-	})
-}
--- a/parsers/nosql/type_checking_functions_test.go
+++ b/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{
--- a/parsers/nosql/were_test.go
+++ b/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),
+							Left: parsers.SelectItem{Path: []string{"c", "boolean"}},
+							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),
+							Left: parsers.SelectItem{Path: []string{"c", "integer"}},
+							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),
+							Left: parsers.SelectItem{Path: []string{"c", "float"}},
+							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"),
+							Left: parsers.SelectItem{Path: []string{"c", "string"}},
+							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"),
+							Left: parsers.SelectItem{Path: []string{"c", "param"}},
+							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,
-				},
-			},
-		)
-	})
 }
--- a/query_executors/memory_executor/aggregate_functions.go
+++ b/query_executors/memory_executor/aggregate_functions.go
@ -6,19 +6,21 @@ 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 {
-		value := item.resolveSelectItem(selectExpression)
-		if numericValue, ok := value.(float64); ok {
-			sum += numericValue
-			count++
-		} else if numericValue, ok := value.(int); ok {
-			sum += float64(numericValue)
-			count++
+	if array, isArray := row.([]RowType); isArray {
+		for _, item := range array {
+			value := c.getFieldValue(selectExpression, item)
+			if numericValue, ok := value.(float64); ok {
+				sum += numericValue
+				count++
+			} else if numericValue, ok := value.(int); ok {
+				sum += float64(numericValue)
+				count++
+			}
 		}
 	}

@ -29,37 +31,41 @@ 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 {
-		value := item.resolveSelectItem(selectExpression)
-		if value != nil {
-			count++
+	if array, isArray := row.([]RowType); isArray {
+		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 {
-		value := item.resolveSelectItem(selectExpression)
-		if numericValue, ok := value.(float64); ok {
-			if numericValue > max {
-				max = numericValue
+	if array, isArray := row.([]RowType); isArray {
+		for _, item := range array {
+			value := c.getFieldValue(selectExpression, item)
+			if numericValue, ok := value.(float64); ok {
+				if numericValue > max {
+					max = numericValue
+				}
+				count++
+			} else if numericValue, ok := value.(int); ok {
+				if float64(numericValue) > max {
+					max = float64(numericValue)
+				}
+				count++
 			}
-			count++
-		} else if numericValue, ok := value.(int); ok {
-			if float64(numericValue) > max {
-				max = float64(numericValue)
-			}
-			count++
 		}
 	}

@ -70,23 +76,25 @@ 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 {
-		value := item.resolveSelectItem(selectExpression)
-		if numericValue, ok := value.(float64); ok {
-			if numericValue < min {
-				min = numericValue
+	if array, isArray := row.([]RowType); isArray {
+		for _, item := range array {
+			value := c.getFieldValue(selectExpression, item)
+			if numericValue, ok := value.(float64); ok {
+				if numericValue < min {
+					min = numericValue
+				}
+				count++
+			} else if numericValue, ok := value.(int); ok {
+				if float64(numericValue) < min {
+					min = float64(numericValue)
+				}
+				count++
 			}
-			count++
-		} else if numericValue, ok := value.(int); ok {
-			if float64(numericValue) < min {
-				min = float64(numericValue)
-			}
-			count++
 		}
 	}

@ -97,19 +105,21 @@ 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 {
-		value := item.resolveSelectItem(selectExpression)
-		if numericValue, ok := value.(float64); ok {
-			sum += numericValue
-			count++
-		} else if numericValue, ok := value.(int); ok {
-			sum += float64(numericValue)
-			count++
+	if array, isArray := row.([]RowType); isArray {
+		for _, item := range array {
+			value := c.getFieldValue(selectExpression, item)
+			if numericValue, ok := value.(float64); ok {
+				sum += numericValue
+				count++
+			} else if numericValue, ok := value.(int); ok {
+				sum += float64(numericValue)
+				count++
+			}
 		}
 	}

--- a/query_executors/memory_executor/aggregate_functions_test.go
+++ b/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{
--- a/query_executors/memory_executor/arithmetics_test.go
+++ b/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},
-			},
-		)
-	})
-}
--- a/query_executors/memory_executor/array_functions.go
+++ b/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 {
-	array := r.parseArray(arguments[0])
-	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])
+func (c memoryExecutorContext) array_Length(arguments []interface{}, row RowType) int {
+	array := c.parseArray(arguments[0], row)
 	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])
-	startEx := r.resolveSelectItem(arguments[1].(parsers.SelectItem))
+	array := c.parseArray(arguments[0], row)
+	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{} {
-	set1 := r.parseArray(arguments[0])
-	set2 := r.parseArray(arguments[1])
+func (c memoryExecutorContext) set_Intersect(arguments []interface{}, row RowType) []interface{} {
+	set1 := c.parseArray(arguments[0], row)
+	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{} {
-	set1 := r.parseArray(arguments[0])
-	set2 := r.parseArray(arguments[1])
+func (c memoryExecutorContext) set_Union(arguments []interface{}, row RowType) []interface{} {
+	set1 := c.parseArray(arguments[0], row)
+	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
-}
--- a/query_executors/memory_executor/array_functions_test.go
+++ b/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),
-								testutils.SelectItem_Constant_Int(2),
+								parsers.SelectItem{
+									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{
--- a/query_executors/memory_executor/array_iterator.go
+++ b/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
-}
--- a/query_executors/memory_executor/common.go
+++ b/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
-}
--- a/Show More
+++ b/Show More