Update dependencies

* Support single-quoted string literals in query parsing

Add single-quoted string literal support to the NoSQL query parser,
matching Cosmos DB behavior where apostrophes are escaped by doubling
them (''). Includes parser unit tests and an API integration test.

Co-authored-by: Pijus Kamandulis <pikami@users.noreply.github.com>

* Use backslash escape for apostrophes in single-quoted strings

Cosmos DB escapes apostrophes with \' rather than SQL-style doubling.
Also fix EscapeCharacter to return proper values for \', \", and \\
which were previously producing empty substitutions.

Co-authored-by: Pijus Kamandulis <pikami@users.noreply.github.com>

---------

Co-authored-by: Cursor Agent <cursoragent@cursor.com>

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

@@ -7,15 +7,18 @@ jobs:
   build:
     runs-on: ubuntu-latest
 
+    outputs:
+      artifact: shared-libraries
+
     steps:
       - name: Checkout code
-        uses: actions/checkout@v3
+        uses: actions/checkout@v6
 
       - name: Cross-Compile with xgo
-        uses: crazy-max/ghaction-xgo@e22d3c8b089adba750d5a74738b8e95d96f0c991 # v3.1.0
+        uses: crazy-max/ghaction-xgo@de82f877ff4552f03b66c146f608233849e9c3dc # v4.0.0
         with:
           xgo_version: latest
-          go_version: 1.24.0
+          go_version: 1.26.3
           dest: dist
           pkg: sharedlibrary
           prefix: cosmium
@@ -25,7 +28,62 @@ jobs:
           buildvcs: true
 
       - name: Upload artifact
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v7
         with:
           name: shared-libraries
           path: dist/*
+
+  test:
+    needs: build
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-latest
+            lib_ext: amd64.so
+          - os: windows-latest
+            lib_ext: amd64.dll
+          - os: macos-latest
+            lib_ext: arm64.dylib
+
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Download shared libraries
+        uses: actions/download-artifact@v8
+        with:
+          name: shared-libraries
+          path: libs
+
+      - name: Install MinGW (GCC) on Windows
+        if: runner.os == 'Windows'
+        run: choco install mingw --no-progress
+
+      - name: Build test loader (Windows)
+        if: runner.os == 'Windows'
+        run: |
+          mkdir build
+          gcc -Wall -o build/test_loader.exe sharedlibrary/tests/*.c
+
+      - name: Build test loader (Unix)
+        if: runner.os != 'Windows'
+        run: |
+          mkdir build
+          gcc -Wall -ldl -o build/test_loader sharedlibrary/tests/*.c
+
+      - name: Run test (Unix)
+        if: runner.os != 'Windows'
+        run: |
+          LIB=$(ls libs/*${{ matrix.lib_ext }} | head -n 1)
+          echo "Testing library: $LIB"
+          chmod +x build/test_loader
+          ./build/test_loader "$LIB"
+
+      - name: Run test (Windows)
+        if: runner.os == 'Windows'
+        shell: pwsh
+        run: |
+          $lib = Get-ChildItem "libs/*${{ matrix.lib_ext }}" | Select-Object -First 1
+          Write-Host "Testing library: $($lib.FullName)"
+          .\build\test_loader.exe $lib.FullName

.github/workflows/release.yml

@@ -3,7 +3,7 @@ name: goreleaser
 on:
   push:
     tags:
-      - '*'
+      - "*"
 
 permissions:
   contents: write
@@ -14,20 +14,20 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
         with:
           fetch-depth: 0
 
       - name: Set up Go
         uses: actions/setup-go@v5
         with:
-          go-version: 1.24.0
+          go-version: 1.26.3
 
       - name: Cross-Compile with xgo
-        uses: crazy-max/ghaction-xgo@e22d3c8b089adba750d5a74738b8e95d96f0c991 # v3.1.0
+        uses: crazy-max/ghaction-xgo@de82f877ff4552f03b66c146f608233849e9c3dc # v4.0.0
         with:
           xgo_version: latest
-          go_version: 1.24.0
+          go_version: 1.26.3
           dest: sharedlibrary_dist
           pkg: sharedlibrary
           prefix: cosmium

Makefile

@@ -9,7 +9,7 @@ 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
+GOVERSION=1.26.3
 
 DIST_DIR=dist
 

README.md

@@ -64,7 +64,8 @@ There are two docker tags available:
 If you wan to run the application using docker, configure it using environment variables see example:
 
 ```sh
-docker run --rm \
+# Ensure save.json exists so Docker volume mounts correctly
+[ -f save.json ] || echo '{}' > save.json && docker run --rm \
   -e COSMIUM_PERSIST=/save.json \
   -v ./save.json:/save.json \
   -p 8081:8081 \
@@ -104,10 +105,10 @@ All mentioned arguments can also be set using environment variables:
 
 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                       |
+| Backend  | Storage Location         | Write Behavior           | Memory Usage         |
+|----------|--------------------------|--------------------------|----------------------|
+| `json` (default) | JSON file on disk 📄 | On application exit ⏳ | 🛑 More than Badger |
+| `badger`  | BadgerDB database on disk ⚡ | Immediately on write 🚀 | ✅ Less than JSON  |
 
 
 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.

api/config/config.go

@@ -23,6 +23,7 @@ const (
 func ParseFlags() ServerConfig {
 	host := flag.String("Host", "localhost", "Hostname")
 	port := flag.Int("Port", 8081, "Listen port")
+	rntbdPort := flag.Int("RntbdPort", 10000, "RNTBD listen port")
 	explorerPath := flag.String("ExplorerDir", "", "Path to cosmos-explorer files")
 	tlsCertificatePath := flag.String("Cert", "", "Hostname")
 	tlsCertificateKey := flag.String("CertKey", "", "Hostname")
@@ -35,6 +36,7 @@ func ParseFlags() ServerConfig {
 	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()))
+	enableRntbd := flag.Bool("ExperimentalEnableRntbd", false, "EXPERIMENTAL: Enable RNTBD (CosmosDB Direct Connection Mode)")
 
 	flag.Parse()
 	setFlagsFromEnvironment()
@@ -42,6 +44,7 @@ func ParseFlags() ServerConfig {
 	config := ServerConfig{}
 	config.Host = *host
 	config.Port = *port
+	config.RntbdPort = *rntbdPort
 	config.ExplorerPath = *explorerPath
 	config.TLS_CertificatePath = *tlsCertificatePath
 	config.TLS_CertificateKey = *tlsCertificateKey
@@ -52,6 +55,7 @@ func ParseFlags() ServerConfig {
 	config.AccountKey = *accountKey
 	config.LogLevel = logLevel.value
 	config.DataStore = dataStore.value
+	config.EnableRntbd = *enableRntbd
 
 	config.PopulateCalculatedFields()
 
@@ -62,6 +66,7 @@ func (c *ServerConfig) PopulateCalculatedFields() {
 	c.DatabaseAccount = c.Host
 	c.DatabaseDomain = c.Host
 	c.DatabaseEndpoint = fmt.Sprintf("https://%s:%d/", c.Host, c.Port)
+	c.RntbdEndpoint = fmt.Sprintf("rntbd://%s:%d/", c.Host, c.RntbdPort)
 	c.ExplorerBaseUrlLocation = ExplorerBaseUrlLocation
 
 	switch c.LogLevel {
@@ -94,11 +99,6 @@ func (c *ServerConfig) PopulateCalculatedFields() {
 			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() {

api/config/models.go

@@ -4,10 +4,12 @@ type ServerConfig struct {
 	DatabaseAccount  string `json:"databaseAccount"`
 	DatabaseDomain   string `json:"databaseDomain"`
 	DatabaseEndpoint string `json:"databaseEndpoint"`
+	RntbdEndpoint    string `json:"rntbdEndpoint"`
 	AccountKey       string `json:"accountKey"`
 
 	ExplorerPath            string `json:"explorerPath"`
 	Port                    int    `json:"port"`
+	RntbdPort               int    `json:"rntbdPort"`
 	Host                    string `json:"host"`
 	TLS_CertificatePath     string `json:"tlsCertificatePath"`
 	TLS_CertificateKey      string `json:"tlsCertificateKey"`
@@ -17,6 +19,7 @@ type ServerConfig struct {
 	DisableTls              bool   `json:"disableTls"`
 	LogLevel                string `json:"logLevel"`
 	ExplorerBaseUrlLocation string `json:"explorerBaseUrlLocation"`
+	EnableRntbd             bool   `json:"enableRntbd"`
 
 	DataStore string `json:"dataStore"`
 }

api/handlers/collections.go

@@ -5,6 +5,7 @@ import (
 	"net/http"
 
 	"github.com/gin-gonic/gin"
+	"github.com/pikami/cosmium/api/headers"
 	"github.com/pikami/cosmium/internal/constants"
 	"github.com/pikami/cosmium/internal/datastore"
 )
@@ -16,7 +17,7 @@ func (h *Handlers) GetAllCollections(c *gin.Context) {
 	if status == datastore.StatusOk {
 		database, _ := h.dataStore.GetDatabase(databaseId)
 
-		c.Header("x-ms-item-count", fmt.Sprintf("%d", len(collections)))
+		c.Header(headers.ItemCount, fmt.Sprintf("%d", len(collections)))
 		c.IndentedJSON(http.StatusOK, gin.H{
 			"_rid":                database.ResourceID,
 			"DocumentCollections": collections,

api/handlers/databases.go

@@ -5,6 +5,7 @@ import (
 	"net/http"
 
 	"github.com/gin-gonic/gin"
+	"github.com/pikami/cosmium/api/headers"
 	"github.com/pikami/cosmium/internal/constants"
 	"github.com/pikami/cosmium/internal/datastore"
 )
@@ -12,7 +13,7 @@ import (
 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)))
+		c.Header(headers.ItemCount, fmt.Sprintf("%d", len(databases)))
 		c.IndentedJSON(http.StatusOK, gin.H{
 			"_rid":      "",
 			"Databases": databases,

api/handlers/documents.go

@@ -9,7 +9,9 @@ import (
 	jsonpatch "github.com/cosmiumdev/json-patch/v5"
 	"github.com/gin-gonic/gin"
 	apimodels "github.com/pikami/cosmium/api/api_models"
+	"github.com/pikami/cosmium/api/headers"
 	"github.com/pikami/cosmium/internal/constants"
+	continuationtoken "github.com/pikami/cosmium/internal/continuation_token"
 	"github.com/pikami/cosmium/internal/converters"
 	"github.com/pikami/cosmium/internal/datastore"
 	"github.com/pikami/cosmium/internal/logger"
@@ -26,7 +28,7 @@ func (h *Handlers) GetAllDocuments(c *gin.Context) {
 	if status == datastore.StatusOk {
 		collection, _ := h.dataStore.GetCollection(databaseId, collectionId)
 
-		c.Header("x-ms-item-count", fmt.Sprintf("%d", len(documents)))
+		c.Header(headers.ItemCount, fmt.Sprintf("%d", len(documents)))
 		c.IndentedJSON(http.StatusOK, gin.H{
 			"_rid":      collection.ID,
 			"Documents": documents,
@@ -45,6 +47,9 @@ func (h *Handlers) GetDocument(c *gin.Context) {
 
 	document, status := h.dataStore.GetDocument(databaseId, collectionId, documentId)
 	if status == datastore.StatusOk {
+		if etag, ok := document["_etag"].(string); ok {
+			c.Header(headers.ETag, etag)
+		}
 		c.IndentedJSON(http.StatusOK, document)
 		return
 	}
@@ -88,7 +93,25 @@ func (h *Handlers) ReplaceDocument(c *gin.Context) {
 		return
 	}
 
-	status := h.dataStore.DeleteDocument(databaseId, collectionId, documentId)
+	existingDocument, status := h.dataStore.GetDocument(databaseId, collectionId, documentId)
+	if status == datastore.StatusNotFound {
+		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
+		return
+	}
+	if status != datastore.StatusOk {
+		c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
+		return
+	}
+
+	if ifMatch := c.GetHeader(headers.IfMatch); ifMatch != "" {
+		if existingDocument["_etag"] != ifMatch {
+			c.Header(headers.ErrorCode, "PreconditionFailed")
+			c.JSON(http.StatusPreconditionFailed, constants.PreconditionFailedResponse)
+			return
+		}
+	}
+
+	status = h.dataStore.DeleteDocument(databaseId, collectionId, documentId)
 	if status == datastore.StatusNotFound {
 		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
 		return
@@ -189,7 +212,7 @@ func (h *Handlers) DocumentsPost(c *gin.Context) {
 	collectionId := c.Param("collId")
 
 	// Handle batch requests
-	isBatchRequest, _ := strconv.ParseBool(c.GetHeader("x-ms-cosmos-is-batch-request"))
+	isBatchRequest, _ := strconv.ParseBool(c.GetHeader(headers.IsBatchRequest))
 	if isBatchRequest {
 		h.handleBatchRequest(c)
 		return
@@ -201,8 +224,17 @@ func (h *Handlers) DocumentsPost(c *gin.Context) {
 		return
 	}
 
-	query := requestBody["query"]
-	if query != nil {
+	// Handle query plan requests
+	isQueryPlanRequest, _ := strconv.ParseBool(c.GetHeader(headers.IsQueryPlanRequest))
+	if isQueryPlanRequest {
+		c.IndentedJSON(http.StatusOK, constants.QueryPlanResponse)
+		return
+	}
+
+	// Handle query requests
+	isQueryRequest, _ := strconv.ParseBool(c.GetHeader(headers.IsQuery))
+	isQueryRequestAltHeader, _ := strconv.ParseBool(c.GetHeader(headers.Query))
+	if isQueryRequest || isQueryRequestAltHeader {
 		h.handleDocumentQuery(c, requestBody)
 		return
 	}
@@ -212,7 +244,7 @@ func (h *Handlers) DocumentsPost(c *gin.Context) {
 		return
 	}
 
-	isUpsert, _ := strconv.ParseBool(c.GetHeader("x-ms-documentdb-is-upsert"))
+	isUpsert, _ := strconv.ParseBool(c.GetHeader(headers.IsUpsert))
 	if isUpsert {
 		h.dataStore.DeleteDocument(databaseId, collectionId, requestBody["id"].(string))
 	}
@@ -247,30 +279,55 @@ func (h *Handlers) handleDocumentQuery(c *gin.Context, requestBody map[string]in
 	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)
 	}
 
+	collection, collectionStatus := h.dataStore.GetCollection(databaseId, collectionId)
+	if collectionStatus == datastore.StatusNotFound {
+		c.IndentedJSON(http.StatusNotFound, constants.NotFoundResponse)
+		return
+	}
+
+	if collectionStatus != datastore.StatusOk {
+		c.IndentedJSON(http.StatusInternalServerError, constants.UnknownErrorResponse)
+		return
+	}
+
+	continuationToken := continuationtoken.GenerateDefault(collection.ResourceID)
+	continuationTokenHeader := c.GetHeader(headers.ContinuationToken)
+	if continuationTokenHeader != "" {
+		continuationToken = continuationtoken.FromString(continuationTokenHeader)
+	}
+
+	pageMaxItemCount, maxItemCountError := strconv.Atoi(c.GetHeader(headers.MaxItemCount))
+	if maxItemCountError != nil {
+		pageMaxItemCount = 1000
+	}
+
 	queryText := requestBody["query"].(string)
-	docs, status := h.executeQueryDocuments(databaseId, collectionId, queryText, queryParameters)
+	executeQueryResult, status := h.executeQueryDocuments(
+		databaseId, collectionId, queryText, queryParameters, pageMaxItemCount, continuationToken.Token.TotalResults)
 	if status != datastore.StatusOk {
 		// TODO: Currently we return everything if the query fails
+		logger.Infof("Query failed: %s", queryText)
 		h.GetAllDocuments(c)
 		return
 	}
 
-	collection, _ := h.dataStore.GetCollection(databaseId, collectionId)
-	c.Header("x-ms-item-count", fmt.Sprintf("%d", len(docs)))
+	resultCount := len(executeQueryResult.Rows)
+	if executeQueryResult.HasMorePages {
+		nextContinuationToken := continuationtoken.Generate(
+			collection.ResourceID, continuationToken.Token.PageIndex+1, continuationToken.Token.TotalResults+resultCount)
+		c.Header(headers.ContinuationToken, nextContinuationToken.ToString())
+	}
+
+	c.Header(headers.ItemCount, fmt.Sprintf("%d", resultCount))
 	c.IndentedJSON(http.StatusOK, gin.H{
 		"_rid":      collection.ResourceID,
-		"Documents": docs,
-		"_count":    len(docs),
+		"Documents": executeQueryResult.Rows,
+		"_count":    resultCount,
 	})
 }
 
@@ -372,16 +429,23 @@ func dataStoreStatusToResponseCode(status datastore.DataStoreStatus) int {
 	}
 }
 
-func (h *Handlers) executeQueryDocuments(databaseId string, collectionId string, query string, queryParameters map[string]interface{}) ([]memoryexecutor.RowType, datastore.DataStoreStatus) {
+func (h *Handlers) executeQueryDocuments(
+	databaseId string,
+	collectionId string,
+	query string,
+	queryParameters map[string]interface{},
+	pageMaxItemCount int,
+	pageCursor int,
+) (memoryexecutor.ExecuteQueryResult, 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
+		return memoryexecutor.ExecuteQueryResult{}, datastore.BadRequest
 	}
 
 	allDocumentsIterator, status := h.dataStore.GetDocumentIterator(databaseId, collectionId)
 	if status != datastore.StatusOk {
-		return nil, status
+		return memoryexecutor.ExecuteQueryResult{}, status
 	}
 	defer allDocumentsIterator.Close()
 
@@ -389,8 +453,8 @@ func (h *Handlers) executeQueryDocuments(databaseId string, collectionId string,
 
 	if typedQuery, ok := parsedQuery.(parsers.SelectStmt); ok {
 		typedQuery.Parameters = queryParameters
-		return memoryexecutor.ExecuteQuery(typedQuery, rowsIterator), datastore.StatusOk
+		return memoryexecutor.ExecuteQuery(typedQuery, rowsIterator, pageCursor, pageMaxItemCount), datastore.StatusOk
 	}
 
-	return nil, datastore.BadRequest
+	return memoryexecutor.ExecuteQueryResult{}, datastore.BadRequest
 }

api/handlers/middleware/authentication.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/gin-gonic/gin"
 	"github.com/pikami/cosmium/api/config"
+	"github.com/pikami/cosmium/api/headers"
 	"github.com/pikami/cosmium/internal/authentication"
 	"github.com/pikami/cosmium/internal/logger"
 )
@@ -22,8 +23,8 @@ func Authentication(config *config.ServerConfig) gin.HandlerFunc {
 		resourceType := urlToResourceType(requestUrl)
 		resourceId := requestToResourceId(c)
 
-		authHeader := c.Request.Header.Get("authorization")
-		date := c.Request.Header.Get("x-ms-date")
+		authHeader := c.Request.Header.Get(headers.Authorization)
+		date := c.Request.Header.Get(headers.XDate)
 		expectedSignature := authentication.GenerateSignature(
 			c.Request.Method, resourceType, resourceId, date, config.AccountKey)
 
@@ -60,6 +61,9 @@ func requestToResourceId(c *gin.Context) string {
 	databaseId, _ := c.Params.Get("databaseId")
 	collId, _ := c.Params.Get("collId")
 	docId, _ := c.Params.Get("docId")
+	triggerId, _ := c.Params.Get("triggerId")
+	sprocId, _ := c.Params.Get("sprocId")
+	udfId, _ := c.Params.Get("udfId")
 	resourceType := urlToResourceType(c.Request.URL.String())
 
 	var resourceId string
@@ -72,8 +76,17 @@ func requestToResourceId(c *gin.Context) string {
 	if docId != "" {
 		resourceId += "/docs/" + docId
 	}
+	if triggerId != "" {
+		resourceId += "/triggers/" + triggerId
+	}
+	if sprocId != "" {
+		resourceId += "/sprocs/" + sprocId
+	}
+	if udfId != "" {
+		resourceId += "/udfs/" + udfId
+	}
 
-	isFeed := c.Request.Header.Get("A-Im") == "Incremental Feed"
+	isFeed := c.Request.Header.Get(headers.AIM) == "Incremental Feed"
 	if resourceType == "pkranges" && isFeed {
 		resourceId = collId
 	}

api/handlers/offers.go

@@ -4,10 +4,11 @@ import (
 	"net/http"
 
 	"github.com/gin-gonic/gin"
+	"github.com/pikami/cosmium/api/headers"
 )
 
 func GetOffers(c *gin.Context) {
-	c.Header("x-ms-item-count", "0")
+	c.Header(headers.ItemCount, "0")
 	c.IndentedJSON(http.StatusOK, gin.H{
 		"_rid":   "",
 		"_count": 0,

api/handlers/partition_key_ranges.go

@@ -5,6 +5,7 @@ import (
 	"net/http"
 
 	"github.com/gin-gonic/gin"
+	"github.com/pikami/cosmium/api/headers"
 	"github.com/pikami/cosmium/internal/constants"
 	"github.com/pikami/cosmium/internal/datastore"
 	"github.com/pikami/cosmium/internal/resourceid"
@@ -14,18 +15,18 @@ func (h *Handlers) GetPartitionKeyRanges(c *gin.Context) {
 	databaseId := c.Param("databaseId")
 	collectionId := c.Param("collId")
 
-	if c.Request.Header.Get("if-none-match") != "" {
+	if c.Request.Header.Get(headers.IfNoneMatch) != "" {
 		c.AbortWithStatus(http.StatusNotModified)
 		return
 	}
 
 	partitionKeyRanges, status := h.dataStore.GetPartitionKeyRanges(databaseId, collectionId)
 	if status == datastore.StatusOk {
-		c.Header("etag", "\"420\"")
-		c.Header("lsn", "420")
-		c.Header("x-ms-cosmos-llsn", "420")
-		c.Header("x-ms-global-committed-lsn", "420")
-		c.Header("x-ms-item-count", fmt.Sprintf("%d", len(partitionKeyRanges)))
+		c.Header(headers.ETag, "\"420\"")
+		c.Header(headers.LSN, "420")
+		c.Header(headers.CosmosLsn, "420")
+		c.Header(headers.GlobalCommittedLsn, "420")
+		c.Header(headers.ItemCount, fmt.Sprintf("%d", len(partitionKeyRanges)))
 
 		collectionRid := collectionId
 		collection, _ := h.dataStore.GetCollection(databaseId, collectionId)

api/handlers/server_info.go

@@ -3,6 +3,7 @@ package handlers
 import (
 	"fmt"
 	"net/http"
+	"strings"
 
 	"github.com/gin-gonic/gin"
 )
@@ -41,3 +42,46 @@ func (h *Handlers) GetServerInfo(c *gin.Context) {
 		"queryEngineConfiguration": "{\"allowNewKeywords\":true,\"maxJoinsPerSqlQuery\":10,\"maxQueryRequestTimeoutFraction\":0.9,\"maxSqlQueryInputLength\":524288,\"maxUdfRefPerSqlQuery\":10,\"queryMaxInMemorySortDocumentCount\":-1000,\"spatialMaxGeometryPointCount\":256,\"sqlAllowNonFiniteNumbers\":false,\"sqlDisableOptimizationFlags\":0,\"enableSpatialIndexing\":true,\"maxInExpressionItemsCount\":2147483647,\"maxLogicalAndPerSqlQuery\":2147483647,\"maxLogicalOrPerSqlQuery\":2147483647,\"maxSpatialQueryCells\":2147483647,\"sqlAllowAggregateFunctions\":true,\"sqlAllowGroupByClause\":true,\"sqlAllowLike\":true,\"sqlAllowSubQuery\":true,\"sqlAllowScalarSubQuery\":true,\"sqlAllowTop\":true}",
 	})
 }
+
+type Address struct {
+	IsPrimary                     bool   `json:"isPrimary"`
+	PhyscialUri                   string `json:"physcialUri"`
+	IsAuxiliary                   bool   `json:"isAuxiliary"`
+	PartitionTargetReplicaSetSize int    `json:"partitionTargetReplicaSetSize"`
+	Protocol                      string `json:"protocol"`
+	PartitionKeyRangeId           string `json:"partitionKeyRangeId"`
+	PartitionIndex                string `json:"partitionIndex"`
+}
+
+func (h *Handlers) GetAddresses(c *gin.Context) {
+	addresses := []Address{}
+
+	if h.config.EnableRntbd {
+		addresses = append(addresses, Address{
+			IsPrimary:                     true,
+			PhyscialUri:                   h.config.RntbdEndpoint,
+			IsAuxiliary:                   false,
+			PartitionTargetReplicaSetSize: 1,
+			Protocol:                      "rntbd",
+			PartitionKeyRangeId:           "0",
+			PartitionIndex:                "0@0",
+		})
+	}
+
+	if !strings.Contains(c.Request.RequestURI, "protocol%20eq%20rntbd") {
+		addresses = append(addresses, Address{
+			IsPrimary:                     true,
+			PhyscialUri:                   h.config.DatabaseEndpoint,
+			IsAuxiliary:                   false,
+			PartitionTargetReplicaSetSize: 1,
+			Protocol:                      "https",
+			PartitionKeyRangeId:           "0",
+			PartitionIndex:                "0@0",
+		})
+	}
+
+	c.IndentedJSON(http.StatusOK, gin.H{
+		"Addresss": addresses,
+		"_count":   len(addresses),
+	})
+}

api/handlers/stored_procedures.go

@@ -5,6 +5,7 @@ import (
 	"net/http"
 
 	"github.com/gin-gonic/gin"
+	"github.com/pikami/cosmium/api/headers"
 	"github.com/pikami/cosmium/internal/constants"
 	"github.com/pikami/cosmium/internal/datastore"
 )
@@ -16,7 +17,7 @@ func (h *Handlers) GetAllStoredProcedures(c *gin.Context) {
 	sps, status := h.dataStore.GetAllStoredProcedures(databaseId, collectionId)
 
 	if status == datastore.StatusOk {
-		c.Header("x-ms-item-count", fmt.Sprintf("%d", len(sps)))
+		c.Header(headers.ItemCount, fmt.Sprintf("%d", len(sps)))
 		c.IndentedJSON(http.StatusOK, gin.H{"_rid": "", "StoredProcedures": sps, "_count": len(sps)})
 		return
 	}

api/handlers/triggers.go

@@ -5,6 +5,7 @@ import (
 	"net/http"
 
 	"github.com/gin-gonic/gin"
+	"github.com/pikami/cosmium/api/headers"
 	"github.com/pikami/cosmium/internal/constants"
 	"github.com/pikami/cosmium/internal/datastore"
 )
@@ -16,7 +17,7 @@ func (h *Handlers) GetAllTriggers(c *gin.Context) {
 	triggers, status := h.dataStore.GetAllTriggers(databaseId, collectionId)
 
 	if status == datastore.StatusOk {
-		c.Header("x-ms-item-count", fmt.Sprintf("%d", len(triggers)))
+		c.Header(headers.ItemCount, fmt.Sprintf("%d", len(triggers)))
 		c.IndentedJSON(http.StatusOK, gin.H{"_rid": "", "Triggers": triggers, "_count": len(triggers)})
 		return
 	}

api/handlers/user_defined_functions.go

@@ -5,6 +5,7 @@ import (
 	"net/http"
 
 	"github.com/gin-gonic/gin"
+	"github.com/pikami/cosmium/api/headers"
 	"github.com/pikami/cosmium/internal/constants"
 	"github.com/pikami/cosmium/internal/datastore"
 )
@@ -16,7 +17,7 @@ func (h *Handlers) GetAllUserDefinedFunctions(c *gin.Context) {
 	udfs, status := h.dataStore.GetAllUserDefinedFunctions(databaseId, collectionId)
 
 	if status == datastore.StatusOk {
-		c.Header("x-ms-item-count", fmt.Sprintf("%d", len(udfs)))
+		c.Header(headers.ItemCount, fmt.Sprintf("%d", len(udfs)))
 		c.IndentedJSON(http.StatusOK, gin.H{"_rid": "", "UserDefinedFunctions": udfs, "_count": len(udfs)})
 		return
 	}

api/headers/headers.go

@@ -0,0 +1,30 @@
+package headers
+
+const (
+	AIM                = "A-Im"
+	Authorization      = "authorization"
+	CosmosLsn          = "x-ms-cosmos-llsn"
+	ErrorCode          = "x-ms-error-code"
+	ETag               = "etag"
+	GlobalCommittedLsn = "x-ms-global-committed-lsn"
+	IfMatch            = "if-match"
+	IfNoneMatch        = "if-none-match"
+	IsBatchRequest     = "x-ms-cosmos-is-batch-request"
+	IsQueryPlanRequest = "x-ms-cosmos-is-query-plan-request"
+	IsUpsert           = "x-ms-documentdb-is-upsert"
+	ItemCount          = "x-ms-item-count"
+	LSN                = "lsn"
+	XDate              = "x-ms-date"
+	MaxItemCount       = "x-ms-max-item-count"
+	ContinuationToken  = "x-ms-continuation"
+
+	// Kinda retarded, but what can I do ¯\_(ツ)_/¯
+	IsQuery = "x-ms-documentdb-isquery" // Sent from python sdk and web explorer
+	Query   = "x-ms-documentdb-query"   // Sent from Go sdk
+
+	// I kinda don't use these, but I've seen them in the wild xd
+	SupportedCapabilities     = "x-ms-cosmos-sdk-supportedcapabilities"
+	ClientRetryAttemptCount   = "x-ms-client-retry-attempt-count"
+	RemainingTimeInMsOnClient = "x-ms-remaining-time-in-ms-on-client"
+	ConsistencyLevel          = "x-ms-consistency-level"
+)

api/router.go

@@ -31,6 +31,7 @@ func (s *ApiServer) CreateRouter(dataStore datastore.DataStore) {
 
 	router := gin.Default(func(e *gin.Engine) {
 		e.RedirectTrailingSlash = false
+		e.RemoveExtraSlash = true
 	})
 
 	if s.config.LogLevel == "debug" {
@@ -79,6 +80,7 @@ func (s *ApiServer) CreateRouter(dataStore datastore.DataStore) {
 
 	router.GET("/offers", handlers.GetOffers)
 	router.GET("/", routeHandlers.GetServerInfo)
+	router.GET("//addresses", routeHandlers.GetAddresses)
 
 	router.GET("/cosmium/export", routeHandlers.CosmiumExport)
 

api/tests/collections_test.go

@@ -121,5 +121,26 @@ func Test_Collections(t *testing.T) {
 				panic(err)
 			}
 		})
+
+		t.Run("Should delete collection with exactly matching name", func(t *testing.T) {
+			ts.DataStore.CreateCollection(testDatabaseName, datastore.Collection{
+				ID: testCollectionName + "extra",
+			})
+			ts.DataStore.CreateCollection(testDatabaseName, datastore.Collection{
+				ID: testCollectionName,
+			})
+
+			collectionResponse, err := databaseClient.NewContainer(testCollectionName)
+			assert.Nil(t, err)
+
+			readResponse, err := collectionResponse.Delete(context.TODO(), &azcosmos.DeleteContainerOptions{})
+			assert.Nil(t, err)
+			assert.Equal(t, readResponse.RawResponse.StatusCode, http.StatusNoContent)
+
+			collections, status := ts.DataStore.GetAllCollections(testDatabaseName)
+			assert.Equal(t, status, datastore.StatusOk)
+			assert.Len(t, collections, 1)
+			assert.Equal(t, collections[0].ID, testCollectionName+"extra")
+		})
 	})
 }

api/tests/databases_test.go

@@ -109,5 +109,26 @@ func Test_Databases(t *testing.T) {
 				panic(err)
 			}
 		})
+
+		t.Run("Should delete database with exactly matching name", func(t *testing.T) {
+			ts.DataStore.CreateDatabase(datastore.Database{
+				ID: testDatabaseName + "extra",
+			})
+			ts.DataStore.CreateDatabase(datastore.Database{
+				ID: testDatabaseName,
+			})
+
+			databaseResponse, err := client.NewDatabase(testDatabaseName)
+			assert.Nil(t, err)
+
+			readResponse, err := databaseResponse.Delete(context.TODO(), &azcosmos.DeleteDatabaseOptions{})
+			assert.Nil(t, err)
+			assert.Equal(t, readResponse.RawResponse.StatusCode, http.StatusNoContent)
+
+			dbs, status := ts.DataStore.GetAllDatabases()
+			assert.Equal(t, status, datastore.StatusOk)
+			assert.Len(t, dbs, 1)
+			assert.Equal(t, dbs[0].ID, testDatabaseName+"extra")
+		})
 	})
 }

api/tests/documents_array_functions_test.go

@@ -0,0 +1,47 @@
+package tests_test
+
+import (
+	"testing"
+
+	"github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos"
+)
+
+func Test_Documents_ArrayContains(t *testing.T) {
+	presets := []testPreset{PresetJsonStore, PresetBadgerStore}
+
+	runTestsWithPresets(t, "Test_Documents_ArrayContains", presets, func(t *testing.T, ts *TestServer, client *azcosmos.Client) {
+		collectionClient := documents_InitializeDb(t, ts)
+
+		t.Run("Should execute ARRAY_CONTAINS() without partial match argument", func(t *testing.T) {
+			testCosmosQuery(t, collectionClient,
+				`SELECT VALUE ARRAY_CONTAINS(["apple", "banana", "cherry"], "banana") FROM c ORDER BY c.id`,
+				nil,
+				[]interface{}{true, true},
+			)
+		})
+
+		t.Run("Should execute ARRAY_CONTAINS() returning false for missing item", func(t *testing.T) {
+			testCosmosQuery(t, collectionClient,
+				`SELECT VALUE ARRAY_CONTAINS(["apple", "banana", "cherry"], "grape") FROM c ORDER BY c.id`,
+				nil,
+				[]interface{}{false, false},
+			)
+		})
+
+		t.Run("Should execute ARRAY_CONTAINS() with object full match", func(t *testing.T) {
+			testCosmosQuery(t, collectionClient,
+				`SELECT VALUE ARRAY_CONTAINS([{"name": "apple", "color": "red"}], {"name": "apple"}) FROM c ORDER BY c.id`,
+				nil,
+				[]interface{}{false, false},
+			)
+		})
+
+		t.Run("Should execute ARRAY_CONTAINS() with object partial match", func(t *testing.T) {
+			testCosmosQuery(t, collectionClient,
+				`SELECT VALUE ARRAY_CONTAINS([{"name": "apple", "color": "red"}], {"name": "apple"}, true) FROM c ORDER BY c.id`,
+				nil,
+				[]interface{}{true, true},
+			)
+		})
+	})
+}

api/tests/documents_string_functions_test.go

@@ -0,0 +1,73 @@
+package tests_test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos"
+	"github.com/pikami/cosmium/api/config"
+	"github.com/pikami/cosmium/internal/datastore"
+	"github.com/stretchr/testify/assert"
+)
+
+func documents_InitializeSingleDocumentDb(t *testing.T, ts *TestServer) *azcosmos.ContainerClient {
+	ts.DataStore.CreateDatabase(datastore.Database{ID: testDatabaseName})
+	ts.DataStore.CreateCollection(testDatabaseName, datastore.Collection{
+		ID: testCollectionName,
+		PartitionKey: struct {
+			Paths   []string "json:\"paths\""
+			Kind    string   "json:\"kind\""
+			Version int      "json:\"Version\""
+		}{
+			Paths: []string{"/pk"},
+		},
+	})
+	ts.DataStore.CreateDocument(testDatabaseName, testCollectionName, map[string]interface{}{"id": "regexmatch-test", "pk": "regexmatch-test"})
+
+	client, err := azcosmos.NewClientFromConnectionString(
+		fmt.Sprintf("AccountEndpoint=%s;AccountKey=%s", ts.URL, config.DefaultAccountKey),
+		&azcosmos.ClientOptions{},
+	)
+	assert.Nil(t, err)
+
+	collectionClient, err := client.NewContainer(testDatabaseName, testCollectionName)
+	assert.Nil(t, err)
+
+	return collectionClient
+}
+
+func Test_Documents_RegexMatch(t *testing.T) {
+	presets := []testPreset{PresetJsonStore, PresetBadgerStore}
+
+	runTestsWithPresets(t, "Test_Documents_RegexMatch", presets, func(t *testing.T, ts *TestServer, client *azcosmos.Client) {
+		collectionClient := documents_InitializeSingleDocumentDb(t, ts)
+
+		t.Run("Should execute REGEXMATCH()", func(t *testing.T) {
+			testCosmosQuery(t, collectionClient,
+				`SELECT VALUE {
+					noModifiers: REGEXMATCH("abcd", "ABC"),
+					caseInsensitive: REGEXMATCH("abcd", "ABC", "i"),
+					wildcardCharacter: REGEXMATCH("abcd", "ab.", ""),
+					ignoreWhiteSpace: REGEXMATCH("abcd", "ab c", "x"),
+					caseInsensitiveAndIgnoreWhiteSpace: REGEXMATCH("abcd", "aB c", "ix"),
+					containNumberBetweenZeroAndNine: REGEXMATCH("03a", "[0-9]"),
+					containPrefix: REGEXMATCH("salt3824908", "salt{1}"),
+					containsFiveLetterWordStartingWithS: REGEXMATCH("shame", "s....", "i")
+				}`,
+				nil,
+				[]interface{}{
+					map[string]interface{}{
+						"noModifiers":                         false,
+						"caseInsensitive":                     true,
+						"wildcardCharacter":                   true,
+						"ignoreWhiteSpace":                    true,
+						"caseInsensitiveAndIgnoreWhiteSpace":  true,
+						"containNumberBetweenZeroAndNine":     true,
+						"containPrefix":                       true,
+						"containsFiveLetterWordStartingWithS": true,
+					},
+				},
+			)
+		})
+	})
+}

api/tests/documents_test.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"io"
 	"net/http"
 	"reflect"
 	"sync"
@@ -14,6 +15,7 @@ import (
 	"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"
+	continuationtoken "github.com/pikami/cosmium/internal/continuation_token"
 	"github.com/pikami/cosmium/internal/datastore"
 	"github.com/stretchr/testify/assert"
 )
@@ -97,6 +99,17 @@ func Test_Documents(t *testing.T) {
 			)
 		})
 
+		t.Run("Should query document with 'orderByItems' alias", func(t *testing.T) {
+			testCosmosQuery(t, collectionClient,
+				`SELECT c.id, c["pk"] AS orderByItems FROM c ORDER BY c.id`,
+				nil,
+				[]interface{}{
+					map[string]interface{}{"id": "12345", "orderByItems": "123"},
+					map[string]interface{}{"id": "67890", "orderByItems": "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",
@@ -132,6 +145,19 @@ func Test_Documents(t *testing.T) {
 			)
 		})
 
+		t.Run("Should query document with single-quoted string literal", func(t *testing.T) {
+			testCosmosQuery(t, collectionClient,
+				`select c.id
+				FROM c
+				WHERE c.id='67890'
+				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
@@ -227,6 +253,21 @@ func Test_Documents(t *testing.T) {
 				}
 			}
 		})
+
+		t.Run("Should query document with escaped single-quoted string literal", func(t *testing.T) {
+			ts.DataStore.CreateDocument(testDatabaseName, testCollectionName, map[string]interface{}{"id": "apostrophe-doc", "pk": "ap", "name": "it's"})
+
+			testCosmosQuery(t, collectionClient,
+				`select c.id
+				FROM c
+				WHERE c.name='it\'s'
+				ORDER BY c.id`,
+				nil,
+				[]interface{}{
+					map[string]interface{}{"id": "apostrophe-doc"},
+				},
+			)
+		})
 	})
 
 	runTestsWithPresets(t, "Test_Documents_Patch", presets, func(t *testing.T, ts *TestServer, client *azcosmos.Client) {
@@ -378,6 +419,80 @@ func Test_Documents(t *testing.T) {
 		})
 	})
 
+	runTestsWithPresets(t, "Test_Documents_ETag_OptimisticConcurrency", presets, func(t *testing.T, ts *TestServer, client *azcosmos.Client) {
+		collectionClient := documents_InitializeDb(t, ts)
+
+		t.Run("Should fail replace with incorrect etag", func(t *testing.T) {
+			context := context.TODO()
+
+			item := map[string]interface{}{"id": "12345", "pk": "123", "isCool": true}
+			bytes, err := json.Marshal(item)
+			assert.Nil(t, err)
+
+			wrongETag := azcore.ETag("\"incorrect-etag\"")
+			_, err = collectionClient.ReplaceItem(
+				context,
+				azcosmos.PartitionKey{},
+				"12345",
+				bytes,
+				&azcosmos.ItemOptions{IfMatchEtag: &wrongETag},
+			)
+			assert.NotNil(t, err)
+
+			var respErr *azcore.ResponseError
+			if errors.As(err, &respErr) {
+				assert.Equal(t, http.StatusPreconditionFailed, respErr.StatusCode)
+				assert.Equal(t, "PreconditionFailed", respErr.RawResponse.Header.Get("x-ms-error-code"))
+
+				responseBody, readErr := io.ReadAll(respErr.RawResponse.Body)
+				assert.Nil(t, readErr)
+				assert.JSONEq(t,
+					`{"code":"PreconditionFailed","message":"Operation cannot be performed because one of the specified precondition is not met."}`,
+					string(responseBody),
+				)
+			} else {
+				panic(err)
+			}
+
+			document, status := ts.DataStore.GetDocument(testDatabaseName, testCollectionName, "12345")
+			assert.Equal(t, datastore.StatusOk, status)
+			assert.Equal(t, false, document["isCool"])
+		})
+
+		t.Run("Should replace with correct etag", func(t *testing.T) {
+			context := context.TODO()
+
+			readResponse, err := collectionClient.ReadItem(context, azcosmos.PartitionKey{}, "12345", nil)
+			assert.Nil(t, err)
+			assert.NotEmpty(t, readResponse.ETag)
+
+			var item map[string]interface{}
+			err = json.Unmarshal(readResponse.Value, &item)
+			assert.Nil(t, err)
+			assert.Equal(t, string(readResponse.ETag), item["_etag"])
+
+			item["pk"] = "999"
+			item["isCool"] = true
+			bytes, err := json.Marshal(item)
+			assert.Nil(t, err)
+
+			etag := readResponse.ETag
+			_, err = collectionClient.ReplaceItem(
+				context,
+				azcosmos.PartitionKey{},
+				"12345",
+				bytes,
+				&azcosmos.ItemOptions{IfMatchEtag: &etag},
+			)
+			assert.Nil(t, err)
+
+			document, status := ts.DataStore.GetDocument(testDatabaseName, testCollectionName, "12345")
+			assert.Equal(t, datastore.StatusOk, status)
+			assert.Equal(t, "999", document["pk"])
+			assert.Equal(t, true, document["isCool"])
+		})
+	})
+
 	runTestsWithPresets(t, "Test_Documents_TransactionalBatch", presets, func(t *testing.T, ts *TestServer, client *azcosmos.Client) {
 		collectionClient := documents_InitializeDb(t, ts)
 
@@ -425,7 +540,7 @@ func Test_Documents(t *testing.T) {
 			assert.Equal(t, int32(http.StatusNoContent), operationResponse.StatusCode)
 
 			_, status := ts.DataStore.GetDocument(testDatabaseName, testCollectionName, "12345")
-			assert.Equal(t, datastore.StatusNotFound, int(status))
+			assert.Equal(t, datastore.StatusNotFound, status)
 		})
 
 		t.Run("Should execute REPLACE transactional batch", func(t *testing.T) {
@@ -512,4 +627,46 @@ func Test_Documents(t *testing.T) {
 			assert.Equal(t, "67890", itemResponseBody["id"])
 		})
 	})
+
+	runTestsWithPresets(t, "Test_Documents_With_Continuation_Token", presets, func(t *testing.T, ts *TestServer, client *azcosmos.Client) {
+		collectionClient := documents_InitializeDb(t, ts)
+
+		t.Run("Should query document with continuation token", func(t *testing.T) {
+			context := context.TODO()
+			pager := collectionClient.NewQueryItemsPager(
+				"SELECT c.id, c[\"pk\"] FROM c ORDER BY c.id",
+				azcosmos.PartitionKey{},
+				&azcosmos.QueryOptions{
+					PageSizeHint: 1,
+				})
+
+			assert.True(t, pager.More())
+
+			firstResponse, err := pager.NextPage(context)
+			assert.Nil(t, err)
+			assert.Equal(t, 1, len(firstResponse.Items))
+			var firstItem map[string]interface{}
+			err = json.Unmarshal(firstResponse.Items[0], &firstItem)
+			assert.Nil(t, err)
+			assert.Equal(t, "12345", firstItem["id"])
+			assert.Equal(t, "123", firstItem["pk"])
+
+			firstContinuationToken := continuationtoken.FromString(*firstResponse.ContinuationToken)
+			assert.Equal(t, 1, firstContinuationToken.Token.PageIndex)
+			assert.Equal(t, 1, firstContinuationToken.Token.TotalResults)
+
+			assert.True(t, pager.More())
+			secondResponse, err := pager.NextPage(context)
+			assert.Nil(t, err)
+			assert.Equal(t, 1, len(secondResponse.Items))
+			var secondItem map[string]interface{}
+			err = json.Unmarshal(secondResponse.Items[0], &secondItem)
+			assert.Nil(t, err)
+			assert.Equal(t, "67890", secondItem["id"])
+			assert.Equal(t, "456", secondItem["pk"])
+			assert.Nil(t, secondResponse.ContinuationToken)
+
+			assert.False(t, pager.More())
+		})
+	})
 }

api/tests/documents_trailingslash_test.go

@@ -8,6 +8,7 @@ import (
 	"time"
 
 	"github.com/pikami/cosmium/api/config"
+	"github.com/pikami/cosmium/api/headers"
 	"github.com/pikami/cosmium/internal/authentication"
 	"github.com/stretchr/testify/assert"
 )
@@ -26,8 +27,8 @@ func Test_Documents_Read_Trailing_Slash(t *testing.T) {
 		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))
+		req.Header.Add(headers.XDate, date)
+		req.Header.Add(headers.Authorization, "sig="+url.QueryEscape(signature))
 		res, err := httpClient.Do(req)
 
 		assert.Nil(t, err)

cmd/rntbd_parser/rntbd_parser.go

@@ -0,0 +1,63 @@
+package main
+
+import (
+	"encoding/hex"
+	"encoding/json"
+	"flag"
+	"fmt"
+
+	"github.com/pikami/cosmium/internal/rntbd"
+)
+
+func main() {
+	input := flag.String("input", "", "Input hex string")
+	isResponse := flag.Bool("response", false, "Is response")
+	flag.Parse()
+
+	data, err := hex.DecodeString(*input)
+	if err != nil {
+		fmt.Printf("Error decoding hex string: %v\n", err)
+		return
+	}
+
+	frame, err := rntbd.ParseFrame(data, *isResponse)
+	if err != nil {
+		fmt.Printf("Error parsing frame: %v\n", err)
+		return
+	}
+
+	fmt.Printf("Activity ID: %s\n", hex.EncodeToString(frame.ActivityId))
+	fmt.Printf("Resource Type: %s\n", frame.ResourceType.String())
+	fmt.Printf("Operation Type: %s\n", frame.OperationType.String())
+
+	if len(frame.RequestHeaders) > 0 {
+		fmt.Printf("=== Request Headers ===\n")
+		for header, value := range frame.RequestHeaders {
+			fmt.Printf("%s: %v\n", header.String(), value)
+		}
+	}
+
+	if len(frame.ResponseHeaders) > 0 {
+		fmt.Printf("=== Response Headers ===\n")
+		for header, value := range frame.ResponseHeaders {
+			fmt.Printf("%s: %v\n", header.String(), value)
+		}
+	}
+
+	if len(frame.ContextHeaders) > 0 {
+		fmt.Printf("=== Context Headers ===\n")
+		for header, value := range frame.ContextHeaders {
+			fmt.Printf("%s: %v\n", header.String(), value)
+		}
+	}
+
+	if len(frame.Payload) > 0 {
+		var jsonObj any
+		err := json.Unmarshal(frame.Payload, &jsonObj)
+		if err != nil {
+			fmt.Printf("Payload: %s\n", hex.EncodeToString(frame.Payload))
+		} else {
+			fmt.Printf("Payload: %+v\n", jsonObj)
+		}
+	}
+}

cmd/server/server.go

@@ -11,6 +11,7 @@ import (
 	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/pikami/cosmium/internal/rntbd"
 )
 
 func main() {
@@ -20,6 +21,7 @@ func main() {
 	switch configuration.DataStore {
 	case config.DataStoreBadger:
 		dataStore = badgerdatastore.NewBadgerDataStore(badgerdatastore.BadgerDataStoreOptions{
+			InitialDataFilePath: configuration.InitialDataFilePath,
 			PersistDataFilePath: configuration.PersistDataFilePath,
 		})
 		logger.InfoLn("Using Badger data store")
@@ -37,6 +39,15 @@ func main() {
 		panic(err)
 	}
 
+	if configuration.EnableRntbd {
+		rntbdServer := rntbd.NewRntbdServer(configuration.RntbdPort, server)
+		err = rntbdServer.Start()
+		if err != nil {
+			panic(err)
+		}
+		defer rntbdServer.Stop()
+	}
+
 	waitForExit(server, dataStore)
 }
 
@@ -49,6 +60,5 @@ func waitForExit(server *api.ApiServer, dataStore datastore.DataStore) {
 
 	// Stop the server
 	server.Stop()
-
 	dataStore.Close()
 }

go.mod

@@ -1,60 +1,63 @@
 module github.com/pikami/cosmium
 
-go 1.24.0
+go 1.26.3
 
 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/Azure/azure-sdk-for-go/sdk/azcore v1.22.0
+	github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos v1.5.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/dgraph-io/badger/v4 v4.9.6
+	github.com/gin-gonic/gin v1.12.0
 	github.com/google/uuid v1.6.0
-	github.com/stretchr/testify v1.10.0
+	github.com/stretchr/testify v1.11.1
 	github.com/vmihailenco/msgpack/v5 v5.4.1
-	golang.org/x/exp v0.0.0-20250506013437-ce4c2cf36ca6
+	golang.org/x/exp v0.0.0-20260727155853-b88d891fe743
 )
 
 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/Azure/azure-sdk-for-go/sdk/internal v1.12.0 // indirect
+	github.com/bytedance/gopkg v0.1.4 // indirect
+	github.com/bytedance/sonic v1.15.2 // indirect
+	github.com/bytedance/sonic/loader v0.5.2 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
-	github.com/cloudwego/base64x v0.1.5 // indirect
+	github.com/cloudwego/base64x v0.1.7 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/dgraph-io/ristretto/v2 v2.2.0 // indirect
+	github.com/dgraph-io/ristretto/v2 v2.4.2 // 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/gabriel-vasile/mimetype v1.4.15 // indirect
+	github.com/gin-contrib/sse v1.1.1 // indirect
+	github.com/go-logr/logr v1.4.4 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
 	github.com/go-playground/locales v0.14.1 // indirect
 	github.com/go-playground/universal-translator v0.18.1 // indirect
-	github.com/go-playground/validator/v10 v10.26.0 // indirect
-	github.com/goccy/go-json v0.10.5 // indirect
-	github.com/google/flatbuffers v25.2.10+incompatible // indirect
+	github.com/go-playground/validator/v10 v10.30.3 // indirect
+	github.com/goccy/go-json v0.10.6 // indirect
+	github.com/goccy/go-yaml v1.19.2 // indirect
+	github.com/google/flatbuffers v25.12.19+incompatible // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
-	github.com/klauspost/compress v1.18.0 // indirect
-	github.com/klauspost/cpuid/v2 v2.2.10 // indirect
-	github.com/leodido/go-urn v1.4.0 // indirect
-	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/klauspost/compress v1.19.1 // indirect
+	github.com/klauspost/cpuid/v2 v2.4.0 // indirect
+	github.com/leodido/go-urn v1.5.0 // indirect
+	github.com/mattn/go-isatty v0.0.24 // 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.4.3 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/quic-go/qpack v0.6.0 // indirect
+	github.com/quic-go/quic-go v0.61.0 // indirect
 	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
-	github.com/ugorji/go/codec v1.2.12 // indirect
+	github.com/ugorji/go/codec v1.3.2 // 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
+	go.mongodb.org/mongo-driver/v2 v2.8.0 // indirect
+	go.opentelemetry.io/auto/sdk v1.2.1 // indirect
+	go.opentelemetry.io/otel v1.45.0 // indirect
+	go.opentelemetry.io/otel/metric v1.45.0 // indirect
+	go.opentelemetry.io/otel/trace v1.45.0 // indirect
+	golang.org/x/arch v0.29.0 // indirect
+	golang.org/x/crypto v0.54.0 // indirect
+	golang.org/x/net v0.57.0 // indirect
+	golang.org/x/sys v0.47.0 // indirect
+	golang.org/x/text v0.40.0 // indirect
+	google.golang.org/protobuf v1.36.11 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -1,66 +1,45 @@
-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/Azure/azure-sdk-for-go/sdk/azcore v1.22.0 h1:aokoqcHvaGjiM3VpjKDfMMnF/8epJ+Q1HLJ7CudztqE=
+github.com/Azure/azure-sdk-for-go/sdk/azcore v1.22.0/go.mod h1:/WYEx9pcM9Y+Dd/APJaNlSvVSvzl54rrMdZT5+Oi2LM=
+github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.13.1 h1:Hk5QBxZQC1jb2Fwj6mpzme37xbCDdNTxU7O9eb5+LB4=
+github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.13.1/go.mod h1:IYus9qsFobWIc2YVwe/WPjcnyCkPKtnHAqUYeebc8z0=
+github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos v1.5.0 h1:wtCn7MemMD9eo4/NdpJ6S/MFD2BV2CDwoEfvl5th2vM=
+github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos v1.5.0/go.mod h1:MIyTWizpwnsX4LS9/tW1II9JL+D25Ypzj6URaT9NcgQ=
+github.com/Azure/azure-sdk-for-go/sdk/internal v1.12.0 h1:fhqpLE3UEXi9lPaBRpQ6XuRW0nU7hgg4zlmZZa+a9q4=
+github.com/Azure/azure-sdk-for-go/sdk/internal v1.12.0/go.mod h1:7dCRMLwisfRH3dBupKeNCioWYUZ4SS09Z14H+7i8ZoY=
+github.com/AzureAD/microsoft-authentication-library-for-go v1.7.0 h1:4iB+IesclUXdP0ICgAabvq2FYLXrJWKx1fJQ+GxSo3Y=
+github.com/AzureAD/microsoft-authentication-library-for-go v1.7.0/go.mod h1:HKpQxkWaGLJ+D/5H8QRpyQXA1eKjxkFlOMwck5+33Jk=
+github.com/bytedance/gopkg v0.1.4 h1:oZnQwnX82KAIWb7033bEwtxvTqXcYMxDBaQxo5JJHWM=
+github.com/bytedance/gopkg v0.1.4/go.mod h1:v1zWfPm21Fb+OsyXN2VAHdL6TBb2L88anLQgdyje6R4=
+github.com/bytedance/sonic v1.15.2 h1:90H+rcF/FwLXwfB1cudOLq/je83n683Utf4Cbp0xHCo=
+github.com/bytedance/sonic v1.15.2/go.mod h1:mT2NbXunuaEbnZ+mRIX/vYqKISmgEuHFDI4UzmKx2SA=
+github.com/bytedance/sonic/loader v0.5.2 h1:0QtP1gevc1OZ6/H8Lb9BRZiCXd1Ftjd3OKuj1T1lBIo=
+github.com/bytedance/sonic/loader v0.5.2/go.mod h1:AR4NYCk5DdzZizZ5djGqQ92eEhCCcdf5x77udYiSJRo=
 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/cloudwego/base64x v0.1.7 h1:NppS+Fgzg5ovhn4NkUXaDT3x9jldgH5ToMCqzBSi2zI=
+github.com/cloudwego/base64x v0.1.7/go.mod h1:Cu1PV9zfrSf7ET2tIbWbbEy7jO7HHJ13q4X2SQ8aWYg=
 github.com/cosmiumdev/json-patch/v5 v5.9.11 h1:WD2Wqaz/vO987z2FFdqgkj15HgYZ/Y5TpqE3I4T/iOQ=
 github.com/cosmiumdev/json-patch/v5 v5.9.11/go.mod h1:YPZmckmv4ZY+oxKIOjgq3sIudHVB6VEMcicCS9LtVLM=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/dgraph-io/badger/v4 v4.6.0 h1:acOwfOOZ4p1dPRnYzvkVm7rUk2Y21TgPVepCy5dJdFQ=
-github.com/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/dgraph-io/badger/v4 v4.9.6 h1:IQqMPVGLNCQr1b4Mu8lHkYm/xyqFRsyKaFEtyLi9CCQ=
+github.com/dgraph-io/badger/v4 v4.9.6/go.mod h1:Xa9dAupjbwAacupWFCpa6YEn9E1PjBXkfZYr2I/8aWg=
+github.com/dgraph-io/ristretto/v2 v2.4.2 h1:x0cvjmUKxt764Yxdk2nr94we1AvPPAMh1rh5TQ+Jo80=
+github.com/dgraph-io/ristretto/v2 v2.4.2/go.mod h1:0KsrXtXvnv0EqnzyowllbVJB8yBonswa2lTCK2gGo9E=
 github.com/dgryski/go-farm v0.0.0-20240924180020-3414d57e47da h1:aIftn67I1fkbMa512G+w+Pxci9hJPB8oMnkcP3iZF38=
+github.com/dgryski/go-farm v0.0.0-20240924180020-3414d57e47da/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw=
 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/gabriel-vasile/mimetype v1.4.15 h1:05iP/CYtZ/w455R/KZM6rZ5ieAdh99UPtd+d3YzLmaI=
+github.com/gabriel-vasile/mimetype v1.4.15/go.mod h1:azpTcoLcDZRNgFou5j+APrqQx9HqVPWa6ijYQIIVswQ=
+github.com/gin-contrib/sse v1.1.1 h1:uGYpNwTacv5R68bSGMapo62iLTRa9l5zxGCps4hK6ko=
+github.com/gin-contrib/sse v1.1.1/go.mod h1:QXzuVkA0YO7o/gun03UI1Q+FTI8ZV/n5t03kIQAI89s=
+github.com/gin-gonic/gin v1.12.0 h1:b3YAbrZtnf8N//yjKeU2+MQsh2mY5htkZidOM7O0wG8=
+github.com/gin-gonic/gin v1.12.0/go.mod h1:VxccKfsSllpKshkBWgVgRniFFAzFb9csfngsqANjnLc=
 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/logr v1.4.4 h1:tG4xh9yMsRCAiodLVTxyrkzSZ9+o0L1Kg/+cPVcbP/8=
+github.com/go-logr/logr v1.4.4/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
 github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
 github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
 github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
@@ -69,17 +48,16 @@ github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/o
 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/go-playground/validator/v10 v10.30.3 h1:4MU6YkEwx7GbcPJOZxrtbu+QfF3pJLJuaYTeAH0DYy8=
+github.com/go-playground/validator/v10 v10.30.3/go.mod h1:4Axh7oCNGcoGkqLoE4YWt6n20mcEIsPRlB7vPk3lpyc=
+github.com/goccy/go-json v0.10.6 h1:p8HrPJzOakx/mn/bQtjgNjdTcN+/S6FcG2CTtQOrHVU=
+github.com/goccy/go-json v0.10.6/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
+github.com/goccy/go-yaml v1.19.2 h1:PmFC1S6h8ljIz6gMRBopkjP1TVT7xuwrButHID66PoM=
+github.com/goccy/go-yaml v1.19.2/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA=
+github.com/golang-jwt/jwt/v5 v5.3.1 h1:kYf81DTWFe7t+1VvL7eS+jKFVWaUnK9cB1qbwn63YCY=
+github.com/golang-jwt/jwt/v5 v5.3.1/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE=
+github.com/google/flatbuffers v25.12.19+incompatible h1:haMV2JRRJCe1998HeW/p0X9UaMTK6SDo0ffLn2+DbLs=
+github.com/google/flatbuffers v25.12.19+incompatible/go.mod h1:1AeVuKshWv4vARoZatz6mlQ0JxURH0Kv5+zNeJKJCa8=
 github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
@@ -87,100 +65,87 @@ github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
 github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
-github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo=
-github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ=
-github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
-github.com/klauspost/cpuid/v2 v2.2.10 h1:tBs3QSyvjDyFTq3uoc/9xFpCuOsJQFNPiAhYdw2skhE=
-github.com/klauspost/cpuid/v2 v2.2.10/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
-github.com/knz/go-libedit v1.10.1/go.mod h1:MZTVkCWyz0oBc7JOWP3wNAzd002ZbM/5hgShxwh4x8M=
+github.com/klauspost/compress v1.19.1 h1:VsB4HPswih7mmZ8WleSFQ75c/Ui1M4trX5oAsJnhSlk=
+github.com/klauspost/compress v1.19.1/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ=
+github.com/klauspost/cpuid/v2 v2.4.0 h1:S6Hrbc7+ywsr0r+RLapfGBHfyefhCTwEh3A0tV913Dw=
+github.com/klauspost/cpuid/v2 v2.4.0/go.mod h1:19jmZ9mjzoF//ddRSUsv0zfBTJWh3QJh9FNxZTMrGxU=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
 github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
-github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ=
-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.5.0 h1:pLqT2kq1zpHW/1D18QMjMpdtX7cekxqtJJjg5ANyWw0=
+github.com/leodido/go-urn v1.5.0/go.mod h1:9BORnCDhdPBJNDEX+w1bJisa8yOKYi116VeO96s4ifE=
+github.com/mattn/go-isatty v0.0.24 h1:tGZZoVgT/KiqK1c8ocVLeDS8BSWMRd47J3Lbz7vsReI=
+github.com/mattn/go-isatty v0.0.24/go.mod h1:nMCL3Zebbrt45jsMDgnfIwz6ydEQApk5oEI3HqDio6A=
 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/pelletier/go-toml/v2 v2.4.3 h1:GTRvJQutkOSftxIFD5xw9aepkYNuPWmVJpffdDPYVpY=
+github.com/pelletier/go-toml/v2 v2.4.3/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/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/quic-go/go-ossfuzz-seeds v0.1.0 h1:APacT+iIaNF6fd8AGEiN3bT/Jtkd2jz4v4TzM7MFjy0=
+github.com/quic-go/go-ossfuzz-seeds v0.1.0/go.mod h1:3IOHRbJIc+L6YKMwfDtJAM9Vj9k0YY4muhuyUYk5tbk=
+github.com/quic-go/qpack v0.6.0 h1:g7W+BMYynC1LbYLSqRt8PBg5Tgwxn214ZZR34VIOjz8=
+github.com/quic-go/qpack v0.6.0/go.mod h1:lUpLKChi8njB4ty2bFLX2x4gzDqXwUpaO1DP9qMDZII=
+github.com/quic-go/quic-go v0.61.0 h1:ui88A53s8MSVYLC56en0KQ17HARk+9986Dn0SBfKNvA=
+github.com/quic-go/quic-go v0.61.0/go.mod h1:9So2anK4Tp22URSQq00k+Vo2PNkle96ycDPDHL4s9vs=
+github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
+github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
 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.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/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 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/ugorji/go/codec v1.3.2 h1:zkEASHHyEClGeURfgNT9PJZVfAbs9oEX9QXggwWNJbc=
+github.com/ugorji/go/codec v1.3.2/go.mod h1:pRBVtBSKl77K30Bv8R2P+cLSGaTtex6fsA2Wjqmfxj4=
 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=
-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=
+go.mongodb.org/mongo-driver/v2 v2.8.0 h1:CxWDGQYY8QQwNjAl/aq2sfWakdnWZynnqJ9F4DhHbP8=
+go.mongodb.org/mongo-driver/v2 v2.8.0/go.mod h1:yOI9kBsufol30iFsl1slpdq1I0eHPzybRWdyYUs8K/0=
+go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64=
+go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y=
+go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU=
+go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ=
+go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M=
+go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s=
+go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag=
+go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc=
+go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y=
+go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU=
+golang.org/x/arch v0.29.0 h1:8sSET5wB0+exBm0FGmOtdHMqjlRdV2DRD3/IV6OZgho=
+golang.org/x/arch v0.29.0/go.mod h1:0X+GdSIP+kL5wPmpK7sdkEVTt2XoYP0cSjQSbZBwOi8=
+golang.org/x/crypto v0.54.0 h1:YLIA59K4fiNzHzjnZt2tUJQjQtUWfWbeHBqKtk3eScw=
+golang.org/x/crypto v0.54.0/go.mod h1:KWL8ny2AZdGR2cWmzeHrp2azQPGogOv+HeQaVEXC2dk=
+golang.org/x/exp v0.0.0-20260727155853-b88d891fe743 h1:ex206bKw+v3K0dm3andkrIF+ijyQKJG1pLgwQ2PYdQM=
+golang.org/x/exp v0.0.0-20260727155853-b88d891fe743/go.mod h1:EdfpwwqSu+0Li0mzskwHU6FWDV3t9Q+RZDo3QMUtL3Q=
+golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE=
+golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU=
+golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs=
+golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/text v0.40.0 h1:Ub2Z6/xjgF1WrYQz2nuITOEegKFtiIy+rieRJ5lHZKs=
+golang.org/x/text v0.40.0/go.mod h1:hpnzDAfGV753zIKo+wk3u1bVKCGPbrnF7+7LBF/UHVY=
+google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=
+google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
 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=

internal/constants/responses.go

@@ -35,3 +35,7 @@ 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"}
+var PreconditionFailedResponse = gin.H{
+	"code":    "PreconditionFailed",
+	"message": "Operation cannot be performed because one of the specified precondition is not met.",
+}

internal/continuation_token/continuation_token.go

@@ -0,0 +1,145 @@
+package continuationtoken
+
+import (
+	"encoding/json"
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/pikami/cosmium/internal/logger"
+)
+
+type ContinuationTokenExternal struct {
+	Token string `json:"token"`
+	Range struct {
+		Min string `json:"min"`
+		Max string `json:"max"`
+	} `json:"range"`
+}
+
+type ContinuationToken struct {
+	Token struct {
+		ResourceId   string // RID
+		PageIndex    int    // RT
+		TotalResults int    // TRC
+		ISV          int    // ISV
+		IEO          int    // IEO
+		QCF          int    // QCF
+		LR           int    // LR
+	}
+	Range struct {
+		Min string
+		Max string
+	}
+}
+
+func Generate(resourceid string, pageIndex int, totalResults int) ContinuationToken {
+	ct := ContinuationToken{}
+	ct.Token.ResourceId = resourceid
+	ct.Token.PageIndex = pageIndex
+	ct.Token.TotalResults = totalResults
+	ct.Token.ISV = 2
+	ct.Token.IEO = 65567
+	ct.Token.QCF = 8
+	ct.Token.LR = 1
+	ct.Range.Min = ""
+	ct.Range.Max = "FF"
+
+	return ct
+}
+
+func GenerateDefault(resourceid string) ContinuationToken {
+	return Generate(resourceid, 0, 0)
+}
+
+func (ct *ContinuationToken) ToString() string {
+	token := fmt.Sprintf(
+		"-RID:~%s#RT:%d#TRC:%d#ISV:%d#IEO:%d#QCF:%d#LR:%d",
+		ct.Token.ResourceId,
+		ct.Token.PageIndex,
+		ct.Token.TotalResults,
+		ct.Token.ISV,
+		ct.Token.IEO,
+		ct.Token.QCF,
+		ct.Token.LR,
+	)
+
+	ect := ContinuationTokenExternal{}
+	ect.Token = token
+	ect.Range.Min = ct.Range.Min
+	ect.Range.Max = ct.Range.Max
+
+	json, err := json.Marshal(ect)
+	if err != nil {
+		logger.Error(err, "failed to marshal continuation token")
+		return ""
+	}
+
+	return string(json)
+}
+
+func FromString(token string) ContinuationToken {
+	ect := ContinuationTokenExternal{}
+	err := json.Unmarshal([]byte(token), &ect)
+	if err != nil {
+		logger.Error(err, "failed to unmarshal continuation token")
+		return ContinuationToken{}
+	}
+
+	ct, err := parseContinuationToken(ect.Token, ect.Range.Min, ect.Range.Max)
+	if err != nil {
+		logger.Error(err, "failed to parse continuation token")
+		return ContinuationToken{}
+	}
+
+	return *ct
+}
+
+func parseContinuationToken(token string, minRange string, maxRange string) (*ContinuationToken, error) {
+	const prefix = "-RID:~"
+	if !strings.HasPrefix(token, prefix) {
+		return nil, fmt.Errorf("invalid token prefix")
+	}
+
+	parts := strings.Split(token[len(prefix):], "#")
+	if len(parts) != 7 {
+		return nil, fmt.Errorf("invalid token format: expected 7 fields, got %d", len(parts))
+	}
+
+	ct := &ContinuationToken{}
+
+	ct.Token.ResourceId = parts[0]
+
+	parseIntField := func(part, key string) (int, error) {
+		if !strings.HasPrefix(part, key+":") {
+			return 0, fmt.Errorf("expected %s field", key)
+		}
+		return strconv.Atoi(strings.TrimPrefix(part, key+":"))
+	}
+
+	var err error
+
+	if ct.Token.PageIndex, err = parseIntField(parts[1], "RT"); err != nil {
+		return nil, err
+	}
+	if ct.Token.TotalResults, err = parseIntField(parts[2], "TRC"); err != nil {
+		return nil, err
+	}
+	if ct.Token.ISV, err = parseIntField(parts[3], "ISV"); err != nil {
+		return nil, err
+	}
+	if ct.Token.IEO, err = parseIntField(parts[4], "IEO"); err != nil {
+		return nil, err
+	}
+	if ct.Token.QCF, err = parseIntField(parts[5], "QCF"); err != nil {
+		return nil, err
+	}
+	if ct.Token.LR, err = parseIntField(parts[6], "LR"); err != nil {
+		return nil, err
+	}
+
+	ct.Range.Min = minRange
+	ct.Range.Max = maxRange
+
+	return ct, nil
+}

internal/continuation_token/continuation_token_test.go

@@ -0,0 +1,35 @@
+package continuationtoken
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_Generate(t *testing.T) {
+	token := Generate("test-resource-id", 1, 100)
+
+	assert.Equal(t, "test-resource-id", token.Token.ResourceId)
+	assert.Equal(t, 1, token.Token.PageIndex)
+	assert.Equal(t, 100, token.Token.TotalResults)
+}
+
+func Test_FromString(t *testing.T) {
+	token := FromString("{\"token\":\"-RID:~test-resource-id#RT:1#TRC:100#ISV:2#IEO:65567#QCF:8#LR:1\",\"range\":{\"min\":\"\",\"max\":\"FF\"}}")
+
+	assert.Equal(t, "test-resource-id", token.Token.ResourceId)
+	assert.Equal(t, 1, token.Token.PageIndex)
+	assert.Equal(t, 100, token.Token.TotalResults)
+}
+
+func Test_ToString(t *testing.T) {
+	token := Generate("test-resource-id", 1, 100)
+	assert.Equal(t, "{\"token\":\"-RID:~test-resource-id#RT:1#TRC:100#ISV:2#IEO:65567#QCF:8#LR:1\",\"range\":{\"min\":\"\",\"max\":\"FF\"}}", token.ToString())
+}
+
+func Test_GenerateDefault(t *testing.T) {
+	token := GenerateDefault("test-resource-id")
+	assert.Equal(t, "test-resource-id", token.Token.ResourceId)
+	assert.Equal(t, 0, token.Token.PageIndex)
+	assert.Equal(t, 0, token.Token.TotalResults)
+}

internal/datastore/badger_datastore/badger_datastore.go

@@ -1,18 +1,25 @@
 package badgerdatastore
 
 import (
+	"encoding/json"
+	"log"
+	"os"
 	"time"
 
 	"github.com/dgraph-io/badger/v4"
+	"github.com/pikami/cosmium/internal/datastore"
 	"github.com/pikami/cosmium/internal/logger"
 )
 
 type BadgerDataStore struct {
-	db       *badger.DB
-	gcTicker *time.Ticker
+	db        *badger.DB
+	gcTicker  *time.Ticker
+	gcDone    chan struct{}
+	gcStopped chan struct{}
 }
 
 type BadgerDataStoreOptions struct {
+	InitialDataFilePath string
 	PersistDataFilePath string
 }
 
@@ -31,10 +38,14 @@ func NewBadgerDataStore(options BadgerDataStoreOptions) *BadgerDataStore {
 	gcTicker := time.NewTicker(5 * time.Minute)
 
 	ds := &BadgerDataStore{
-		db:       db,
-		gcTicker: gcTicker,
+		db:        db,
+		gcTicker:  gcTicker,
+		gcDone:    make(chan struct{}),
+		gcStopped: make(chan struct{}),
 	}
 
+	ds.initializeDataStore(options.InitialDataFilePath)
+
 	go ds.runGarbageCollector()
 
 	return ds
@@ -43,7 +54,8 @@ func NewBadgerDataStore(options BadgerDataStoreOptions) *BadgerDataStore {
 func (r *BadgerDataStore) Close() {
 	if r.gcTicker != nil {
 		r.gcTicker.Stop()
-		r.gcTicker = nil
+		close(r.gcDone)
+		<-r.gcStopped
 	}
 
 	r.db.Close()
@@ -56,11 +68,69 @@ func (r *BadgerDataStore) DumpToJson() (string, error) {
 }
 
 func (r *BadgerDataStore) runGarbageCollector() {
-	for range r.gcTicker.C {
-	again:
-		err := r.db.RunValueLogGC(0.7)
-		if err == nil {
-			goto again
+	defer close(r.gcStopped)
+
+	for {
+		select {
+		case <-r.gcTicker.C:
+			for {
+				err := r.db.RunValueLogGC(0.7)
+				if err != nil {
+					break
+				}
+			}
+		case <-r.gcDone:
+			return
+		}
+	}
+}
+
+func (r *BadgerDataStore) initializeDataStore(initialDataFilePath string) {
+	if initialDataFilePath == "" {
+		return
+	}
+
+	stat, err := os.Stat(initialDataFilePath)
+	if err != nil {
+		panic(err)
+	}
+
+	if stat.IsDir() {
+		logger.ErrorLn("Argument '-Persist' must be a path to file, not a directory.")
+		os.Exit(1)
+	}
+
+	jsonData, err := os.ReadFile(initialDataFilePath)
+	if err != nil {
+		log.Fatalf("Error reading state JSON file: %v", err)
+		return
+	}
+
+	var state datastore.InitialDataModel
+	if err := json.Unmarshal([]byte(jsonData), &state); err != nil {
+		log.Fatalf("Error parsing state JSON file: %v", err)
+		return
+	}
+
+	for dbName, dbModel := range state.Databases {
+		r.CreateDatabase(dbModel)
+		for colName, colModel := range state.Collections[dbName] {
+			r.CreateCollection(dbName, colModel)
+			for _, docModel := range state.Documents[dbName][colName] {
+				r.CreateDocument(dbName, colName, docModel)
+			}
+
+			for _, triggerModel := range state.Triggers[dbName][colName] {
+				r.CreateTrigger(dbName, colName, triggerModel)
+			}
+
+			for _, spModel := range state.StoredProcedures[dbName][colName] {
+				r.CreateStoredProcedure(dbName, colName, spModel)
+			}
+
+			for _, udfModel := range state.UserDefinedFunctions[dbName][colName] {
+				r.CreateUserDefinedFunction(dbName, colName, udfModel)
+			}
 		}
 	}
 }

internal/datastore/badger_datastore/collections.go

@@ -22,7 +22,8 @@ func (r *BadgerDataStore) GetAllCollections(databaseId string) ([]datastore.Coll
 		return nil, datastore.StatusNotFound
 	}
 
-	colls, status := listByPrefix[datastore.Collection](r.db, generateKey(resourceid.ResourceTypeCollection, databaseId, "", ""))
+	prefix := generateKey(resourceid.ResourceTypeCollection, databaseId, "", "") + "/"
+	colls, status := listByPrefix[datastore.Collection](r.db, prefix)
 	if status == datastore.StatusOk {
 		return colls, datastore.StatusOk
 	}
@@ -49,11 +50,10 @@ func (r *BadgerDataStore) DeleteCollection(databaseId string, collectionId strin
 	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,
+		generateKey(resourceid.ResourceTypeDocument, databaseId, collectionId, "") + "/",
+		generateKey(resourceid.ResourceTypeTrigger, databaseId, collectionId, "") + "/",
+		generateKey(resourceid.ResourceTypeStoredProcedure, databaseId, collectionId, "") + "/",
+		generateKey(resourceid.ResourceTypeUserDefinedFunction, databaseId, collectionId, "") + "/",
 	}
 	for _, prefix := range prefixes {
 		if err := deleteKeysByPrefix(txn, prefix); err != nil {
@@ -61,6 +61,8 @@ func (r *BadgerDataStore) DeleteCollection(databaseId string, collectionId strin
 		}
 	}
 
+	deleteKey(txn, collectionKey)
+
 	err := txn.Commit()
 	if err != nil {
 		logger.ErrorLn("Error while committing transaction:", err)

internal/datastore/badger_datastore/databases.go

@@ -38,12 +38,11 @@ func (r *BadgerDataStore) DeleteDatabase(id string) datastore.DataStoreStatus {
 	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,
+		generateKey(resourceid.ResourceTypeCollection, id, "", "") + "/",
+		generateKey(resourceid.ResourceTypeDocument, id, "", "") + "/",
+		generateKey(resourceid.ResourceTypeTrigger, id, "", "") + "/",
+		generateKey(resourceid.ResourceTypeStoredProcedure, id, "", "") + "/",
+		generateKey(resourceid.ResourceTypeUserDefinedFunction, id, "", "") + "/",
 	}
 	for _, prefix := range prefixes {
 		if err := deleteKeysByPrefix(txn, prefix); err != nil {
@@ -51,6 +50,8 @@ func (r *BadgerDataStore) DeleteDatabase(id string) datastore.DataStoreStatus {
 		}
 	}
 
+	deleteKey(txn, databaseKey)
+
 	err := txn.Commit()
 	if err != nil {
 		logger.ErrorLn("Error while committing transaction:", err)

internal/datastore/badger_datastore/db_abstractions.go

@@ -202,3 +202,22 @@ func deleteKeysByPrefix(txn *badger.Txn, prefix string) error {
 
 	return nil
 }
+
+func deleteKey(txn *badger.Txn, key string) error {
+	_, err := txn.Get([]byte(key))
+	if err == badger.ErrKeyNotFound {
+		return nil
+	}
+	if err != nil {
+		logger.ErrorLn("Error while checking if key exists:", err)
+		return err
+	}
+
+	err = txn.Delete([]byte(key))
+	if err != nil {
+		logger.ErrorLn("Error while deleting key:", err)
+		return err
+	}
+
+	return nil
+}

internal/datastore/badger_datastore/documents.go

@@ -24,7 +24,8 @@ func (r *BadgerDataStore) GetAllDocuments(databaseId string, collectionId string
 		return nil, datastore.StatusNotFound
 	}
 
-	docs, status := listByPrefix[datastore.Document](r.db, generateKey(resourceid.ResourceTypeDocument, databaseId, collectionId, ""))
+	prefix := generateKey(resourceid.ResourceTypeDocument, databaseId, collectionId, "") + "/"
+	docs, status := listByPrefix[datastore.Document](r.db, prefix)
 	if status == datastore.StatusOk {
 		return docs, datastore.StatusOk
 	}
@@ -45,7 +46,8 @@ func (r *BadgerDataStore) GetDocumentIterator(databaseId string, collectionId st
 		return nil, datastore.StatusNotFound
 	}
 
-	iter := NewBadgerDocumentIterator(txn, generateKey(resourceid.ResourceTypeDocument, databaseId, collectionId, ""))
+	prefix := generateKey(resourceid.ResourceTypeDocument, databaseId, collectionId, "") + "/"
+	iter := NewBadgerDocumentIterator(txn, prefix)
 	return iter, datastore.StatusOk
 }
 

internal/datastore/badger_datastore/stored_procedures.go

@@ -24,7 +24,8 @@ func (r *BadgerDataStore) GetAllStoredProcedures(databaseId string, collectionId
 		return nil, datastore.StatusNotFound
 	}
 
-	storedProcedures, status := listByPrefix[datastore.StoredProcedure](r.db, generateKey(resourceid.ResourceTypeStoredProcedure, databaseId, collectionId, ""))
+	prefix := generateKey(resourceid.ResourceTypeStoredProcedure, databaseId, collectionId, "") + "/"
+	storedProcedures, status := listByPrefix[datastore.StoredProcedure](r.db, prefix)
 	if status == datastore.StatusOk {
 		return storedProcedures, datastore.StatusOk
 	}

internal/datastore/badger_datastore/triggers.go

@@ -24,7 +24,8 @@ func (r *BadgerDataStore) GetAllTriggers(databaseId string, collectionId string)
 		return nil, datastore.StatusNotFound
 	}
 
-	triggers, status := listByPrefix[datastore.Trigger](r.db, generateKey(resourceid.ResourceTypeTrigger, databaseId, collectionId, ""))
+	prefix := generateKey(resourceid.ResourceTypeTrigger, databaseId, collectionId, "") + "/"
+	triggers, status := listByPrefix[datastore.Trigger](r.db, prefix)
 	if status == datastore.StatusOk {
 		return triggers, datastore.StatusOk
 	}

internal/datastore/badger_datastore/user_defined_functions.go

@@ -24,7 +24,8 @@ func (r *BadgerDataStore) GetAllUserDefinedFunctions(databaseId string, collecti
 		return nil, datastore.StatusNotFound
 	}
 
-	udfs, status := listByPrefix[datastore.UserDefinedFunction](r.db, generateKey(resourceid.ResourceTypeUserDefinedFunction, databaseId, collectionId, ""))
+	prefix := generateKey(resourceid.ResourceTypeUserDefinedFunction, databaseId, collectionId, "") + "/"
+	udfs, status := listByPrefix[datastore.UserDefinedFunction](r.db, prefix)
 	if status == datastore.StatusOk {
 		return udfs, datastore.StatusOk
 	}

internal/datastore/initial_data.go

@@ -0,0 +1,21 @@
+package datastore
+
+type InitialDataModel 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"`
+
+	// Map databaseId -> collectionId -> triggerId -> Trigger
+	Triggers map[string]map[string]map[string]Trigger `json:"triggers"`
+
+	// Map databaseId -> collectionId -> spId -> StoredProcedure
+	StoredProcedures map[string]map[string]map[string]StoredProcedure `json:"sprocs"`
+
+	// Map databaseId -> collectionId -> udfId -> UserDefinedFunction
+	UserDefinedFunctions map[string]map[string]map[string]UserDefinedFunction `json:"udfs"`
+}

internal/datastore/models.go

@@ -11,12 +11,12 @@ type Database struct {
 type DataStoreStatus int
 
 const (
-	StatusOk       = 1
-	StatusNotFound = 2
-	Conflict       = 3
-	BadRequest     = 4
-	IterEOF        = 5
-	Unknown        = 6
+	StatusOk       DataStoreStatus = 1
+	StatusNotFound DataStoreStatus = 2
+	Conflict       DataStoreStatus = 3
+	BadRequest     DataStoreStatus = 4
+	IterEOF        DataStoreStatus = 5
+	Unknown        DataStoreStatus = 6
 )
 
 type TriggerOperation string

internal/rntbd/builder.go

@@ -0,0 +1,138 @@
+package rntbd
+
+import (
+	"bytes"
+	"encoding/binary"
+)
+
+type RntbdResponseFrame struct {
+	StatusCode      uint16
+	ResourceType    RntbdResourceType
+	ActivityId      []byte
+	ResponseHeaders []RntbdResponseHeader
+	Payload         []byte
+}
+
+type RntbdResponseHeader struct {
+	HeaderId   uint16
+	TokenType  RntbdTokenType
+	TokenValue any
+}
+
+type RntbdResponseFrameBuilder struct {
+	frame RntbdResponseFrame
+}
+
+func (b *RntbdResponseFrameBuilder) AddHeader(headerId uint16, tokenType RntbdTokenType, tokenValue any) {
+	b.frame.ResponseHeaders = append(b.frame.ResponseHeaders, RntbdResponseHeader{
+		HeaderId:   headerId,
+		TokenType:  tokenType,
+		TokenValue: tokenValue,
+	})
+}
+
+func (b *RntbdResponseFrameBuilder) AddPayload(payload []byte) {
+	b.frame.Payload = payload
+}
+
+func (b *RntbdResponseFrameBuilder) SetStatusCode(statusCode uint16) {
+	b.frame.StatusCode = statusCode
+}
+
+func (b *RntbdResponseFrameBuilder) SetResourceType(resourceType RntbdResourceType) {
+	b.frame.ResourceType = resourceType
+}
+
+func (b *RntbdResponseFrameBuilder) SetActivityId(activityId []byte) {
+	b.frame.ActivityId = activityId
+}
+
+func (b *RntbdResponseFrameBuilder) Build() *RntbdResponseFrame {
+	return &b.frame
+}
+
+func (f *RntbdResponseFrame) ToBytes() []byte {
+	var buffer bytes.Buffer
+
+	binary.Write(&buffer, binary.LittleEndian, f.StatusCode)
+	binary.Write(&buffer, binary.LittleEndian, uint16(f.ResourceType))
+	binary.Write(&buffer, binary.LittleEndian, f.ActivityId)
+
+	for _, header := range f.ResponseHeaders {
+		binary.Write(&buffer, binary.LittleEndian, header.HeaderId)
+		binary.Write(&buffer, binary.LittleEndian, uint8(header.TokenType))
+
+		switch header.TokenType {
+		case RntbdTokenTypeByte:
+			buffer.Write(header.TokenValue.([]byte))
+		case RntbdTokenTypeUShort:
+			binary.Write(&buffer, binary.LittleEndian, header.TokenValue.(uint16))
+		case RntbdTokenTypeULong:
+			binary.Write(&buffer, binary.LittleEndian, header.TokenValue.(uint32))
+		case RntbdTokenTypeLong:
+			binary.Write(&buffer, binary.LittleEndian, header.TokenValue.(int32))
+		case RntbdTokenTypeULongLong:
+			binary.Write(&buffer, binary.LittleEndian, header.TokenValue.(uint64))
+		case RntbdTokenTypeLongLong:
+			binary.Write(&buffer, binary.LittleEndian, header.TokenValue.(int64))
+		case RntbdTokenTypeGuid:
+			buffer.Write(header.TokenValue.([]byte))
+
+		case RntbdTokenTypeSmallString:
+			binary.Write(&buffer, binary.LittleEndian, uint8(len(header.TokenValue.(string))))
+			buffer.WriteString(header.TokenValue.(string))
+		case RntbdTokenTypeString:
+			binary.Write(&buffer, binary.LittleEndian, uint16(len(header.TokenValue.(string))))
+			buffer.WriteString(header.TokenValue.(string))
+		case RntbdTokenTypeULongString:
+			binary.Write(&buffer, binary.LittleEndian, uint32(len(header.TokenValue.(string))))
+			buffer.WriteString(header.TokenValue.(string))
+		case RntbdTokenTypeSmallBytes:
+			binary.Write(&buffer, binary.LittleEndian, uint8(len(header.TokenValue.([]byte))))
+			buffer.Write(header.TokenValue.([]byte))
+		case RntbdTokenTypeBytes:
+			binary.Write(&buffer, binary.LittleEndian, uint16(len(header.TokenValue.([]byte))))
+			buffer.Write(header.TokenValue.([]byte))
+		case RntbdTokenTypeULongBytes:
+			binary.Write(&buffer, binary.LittleEndian, uint32(len(header.TokenValue.([]byte))))
+			buffer.Write(header.TokenValue.([]byte))
+		case RntbdTokenTypeFloat:
+			binary.Write(&buffer, binary.LittleEndian, header.TokenValue.(float32))
+		case RntbdTokenTypeDouble:
+			binary.Write(&buffer, binary.LittleEndian, header.TokenValue.(float64))
+		case RntbdTokenTypeInvalid:
+			panic("invalid token type")
+		default:
+			panic("invalid token type")
+		}
+	}
+
+	payloadSize := uint32(0)
+	if len(f.Payload) > 0 {
+		payloadSize = uint32(len(f.Payload)) + 4
+	}
+
+	frameSize := uint32(buffer.Len()) + 4
+	result := make([]byte, frameSize+payloadSize)
+	binary.LittleEndian.PutUint32(result, frameSize)
+	copy(result[4:], buffer.Bytes())
+
+	if len(f.Payload) > 0 {
+		binary.LittleEndian.PutUint32(result[frameSize:], payloadSize-4)
+		copy(result[frameSize+4:], f.Payload)
+	}
+
+	return result
+}
+
+func buildContextFrame(requestFrame *RntbdFrame) []byte {
+	builder := RntbdResponseFrameBuilder{}
+	builder.SetStatusCode(200)
+	builder.SetResourceType(RntbdResourceTypeConnection)
+	builder.SetActivityId(requestFrame.ActivityId)
+	builder.AddHeader(uint16(RntbdContextHeaderServerAgent), RntbdTokenTypeSmallString, "DocumentDB Server")
+	builder.AddHeader(uint16(RntbdContextHeaderServerVersion), RntbdTokenTypeSmallString, " version=2.14.0.0")
+	builder.AddHeader(uint16(RntbdContextHeaderIdleTimeoutInSeconds), RntbdTokenTypeULong, uint32(120))
+	builder.AddHeader(uint16(RntbdContextHeaderUnauthenticatedTimeoutInSeconds), RntbdTokenTypeULong, uint32(25))
+	return builder.Build().ToBytes()
+}

internal/rntbd/constants.go

@@ -0,0 +1,746 @@
+package rntbd
+
+import (
+	"fmt"
+
+	"github.com/pikami/cosmium/api/headers"
+)
+
+type RntbdOperationType uint16
+
+const (
+	RntbdOperationTypeConnection                       RntbdOperationType = 0x0000
+	RntbdOperationTypeCreate                           RntbdOperationType = 0x0001
+	RntbdOperationTypeUpdate                           RntbdOperationType = 0x0002
+	RntbdOperationTypeRead                             RntbdOperationType = 0x0003
+	RntbdOperationTypeReadFeed                         RntbdOperationType = 0x0004
+	RntbdOperationTypeDelete                           RntbdOperationType = 0x0005
+	RntbdOperationTypeReplace                          RntbdOperationType = 0x0006
+	RntbdOperationTypeExecuteJavaScript                RntbdOperationType = 0x0008
+	RntbdOperationTypeSQLQuery                         RntbdOperationType = 0x0009
+	RntbdOperationTypePause                            RntbdOperationType = 0x000A
+	RntbdOperationTypeResume                           RntbdOperationType = 0x000B
+	RntbdOperationTypeStop                             RntbdOperationType = 0x000C
+	RntbdOperationTypeRecycle                          RntbdOperationType = 0x000D
+	RntbdOperationTypeCrash                            RntbdOperationType = 0x000E
+	RntbdOperationTypeQuery                            RntbdOperationType = 0x000F
+	RntbdOperationTypeForceConfigRefresh               RntbdOperationType = 0x0010
+	RntbdOperationTypeHead                             RntbdOperationType = 0x0011
+	RntbdOperationTypeHeadFeed                         RntbdOperationType = 0x0012
+	RntbdOperationTypeUpsert                           RntbdOperationType = 0x0013
+	RntbdOperationTypeRecreate                         RntbdOperationType = 0x0014
+	RntbdOperationTypeThrottle                         RntbdOperationType = 0x0015
+	RntbdOperationTypeGetSplitPoint                    RntbdOperationType = 0x0016
+	RntbdOperationTypePreCreateValidation              RntbdOperationType = 0x0017
+	RntbdOperationTypeBatchApply                       RntbdOperationType = 0x0018
+	RntbdOperationTypeAbortSplit                       RntbdOperationType = 0x0019
+	RntbdOperationTypeCompleteSplit                    RntbdOperationType = 0x001A
+	RntbdOperationTypeOfferUpdateOperation             RntbdOperationType = 0x001B
+	RntbdOperationTypeOfferPreGrowValidation           RntbdOperationType = 0x001C
+	RntbdOperationTypeBatchReportThroughputUtilization RntbdOperationType = 0x001D
+	RntbdOperationTypeCompletePartitionMigration       RntbdOperationType = 0x001E
+	RntbdOperationTypeAbortPartitionMigration          RntbdOperationType = 0x001F
+	RntbdOperationTypePreReplaceValidation             RntbdOperationType = 0x0020
+	RntbdOperationTypeAddComputeGatewayRequestCharges  RntbdOperationType = 0x0021
+	RntbdOperationTypeMigratePartition                 RntbdOperationType = 0x0022
+)
+
+type RntbdResourceType uint16
+
+const (
+	RntbdResourceTypeConnection              RntbdResourceType = 0x0000
+	RntbdResourceTypeDatabase                RntbdResourceType = 0x0001
+	RntbdResourceTypeCollection              RntbdResourceType = 0x0002
+	RntbdResourceTypeDocument                RntbdResourceType = 0x0003
+	RntbdResourceTypeAttachment              RntbdResourceType = 0x0004
+	RntbdResourceTypeUser                    RntbdResourceType = 0x0005
+	RntbdResourceTypePermission              RntbdResourceType = 0x0006
+	RntbdResourceTypeStoredProcedure         RntbdResourceType = 0x0007
+	RntbdResourceTypeConflict                RntbdResourceType = 0x0008
+	RntbdResourceTypeTrigger                 RntbdResourceType = 0x0009
+	RntbdResourceTypeUserDefinedFunction     RntbdResourceType = 0x000A
+	RntbdResourceTypeModule                  RntbdResourceType = 0x000B
+	RntbdResourceTypeReplica                 RntbdResourceType = 0x000C
+	RntbdResourceTypeModuleCommand           RntbdResourceType = 0x000D
+	RntbdResourceTypeRecord                  RntbdResourceType = 0x000E
+	RntbdResourceTypeOffer                   RntbdResourceType = 0x000F
+	RntbdResourceTypePartitionSetInformation RntbdResourceType = 0x0010
+	RntbdResourceTypeXPReplicatorAddress     RntbdResourceType = 0x0011
+	RntbdResourceTypeMasterPartition         RntbdResourceType = 0x0012
+	RntbdResourceTypeServerPartition         RntbdResourceType = 0x0013
+	RntbdResourceTypeDatabaseAccount         RntbdResourceType = 0x0014
+	RntbdResourceTypeTopology                RntbdResourceType = 0x0015
+	RntbdResourceTypePartitionKeyRange       RntbdResourceType = 0x0016
+	RntbdResourceTypeSchema                  RntbdResourceType = 0x0018
+	RntbdResourceTypeBatchApply              RntbdResourceType = 0x0019
+	RntbdResourceTypeRestoreMetadata         RntbdResourceType = 0x001A
+	RntbdResourceTypeComputeGatewayCharges   RntbdResourceType = 0x001B
+	RntbdResourceTypeRidRange                RntbdResourceType = 0x001C
+	RntbdResourceTypeUserDefinedType         RntbdResourceType = 0x001D
+)
+
+type RntbdRequestHeader uint16
+
+const (
+	RntbdRequestHeaderResourceId                                RntbdRequestHeader = 0x0000 // RntbdTokenType.Bytes, required = false
+	RntbdRequestHeaderAuthorizationToken                        RntbdRequestHeader = 0x0001 // RntbdTokenType.String, required = false
+	RntbdRequestHeaderPayloadPresent                            RntbdRequestHeader = 0x0002 // RntbdTokenType.Byte, required = true
+	RntbdRequestHeaderDate                                      RntbdRequestHeader = 0x0003 // RntbdTokenType.SmallString, required = false
+	RntbdRequestHeaderPageSize                                  RntbdRequestHeader = 0x0004 // RntbdTokenType.ULong, required = false
+	RntbdRequestHeaderSessionToken                              RntbdRequestHeader = 0x0005 // RntbdTokenType.String, required = false
+	RntbdRequestHeaderContinuationToken                         RntbdRequestHeader = 0x0006 // RntbdTokenType.String, required = false
+	RntbdRequestHeaderIndexingDirective                         RntbdRequestHeader = 0x0007 // RntbdTokenType.Byte, required = false
+	RntbdRequestHeaderMatch                                     RntbdRequestHeader = 0x0008 // RntbdTokenType.String, required = false
+	RntbdRequestHeaderPreTriggerInclude                         RntbdRequestHeader = 0x0009 // RntbdTokenType.String, required = false
+	RntbdRequestHeaderPostTriggerInclude                        RntbdRequestHeader = 0x000A // RntbdTokenType.String, required = false
+	RntbdRequestHeaderIsFanout                                  RntbdRequestHeader = 0x000B // RntbdTokenType.Byte, required = false
+	RntbdRequestHeaderCollectionPartitionIndex                  RntbdRequestHeader = 0x000C // RntbdTokenType.ULong, required = false
+	RntbdRequestHeaderCollectionServiceIndex                    RntbdRequestHeader = 0x000D // RntbdTokenType.ULong, required = false
+	RntbdRequestHeaderPreTriggerExclude                         RntbdRequestHeader = 0x000E // RntbdTokenType.String, required = false
+	RntbdRequestHeaderPostTriggerExclude                        RntbdRequestHeader = 0x000F // RntbdTokenType.String, required = false
+	RntbdRequestHeaderConsistencyLevel                          RntbdRequestHeader = 0x0010 // RntbdTokenType.Byte, required = false
+	RntbdRequestHeaderEntityId                                  RntbdRequestHeader = 0x0011 // RntbdTokenType.String, required = false
+	RntbdRequestHeaderResourceSchemaName                        RntbdRequestHeader = 0x0012 // RntbdTokenType.SmallString, required = false
+	RntbdRequestHeaderReplicaPath                               RntbdRequestHeader = 0x0013 // RntbdTokenType.String, required = true
+	RntbdRequestHeaderResourceTokenExpiry                       RntbdRequestHeader = 0x0014 // RntbdTokenType.ULong, required = false
+	RntbdRequestHeaderDatabaseName                              RntbdRequestHeader = 0x0015 // RntbdTokenType.String, required = false
+	RntbdRequestHeaderCollectionName                            RntbdRequestHeader = 0x0016 // RntbdTokenType.String, required = false
+	RntbdRequestHeaderDocumentName                              RntbdRequestHeader = 0x0017 // RntbdTokenType.String, required = false
+	RntbdRequestHeaderAttachmentName                            RntbdRequestHeader = 0x0018 // RntbdTokenType.String, required = false
+	RntbdRequestHeaderUserName                                  RntbdRequestHeader = 0x0019 // RntbdTokenType.String, required = false
+	RntbdRequestHeaderPermissionName                            RntbdRequestHeader = 0x001A // RntbdTokenType.String, required = false
+	RntbdRequestHeaderStoredProcedureName                       RntbdRequestHeader = 0x001B // RntbdTokenType.String, required = false
+	RntbdRequestHeaderUserDefinedFunctionName                   RntbdRequestHeader = 0x001C // RntbdTokenType.String, required = false
+	RntbdRequestHeaderTriggerName                               RntbdRequestHeader = 0x001D // RntbdTokenType.String, required = false
+	RntbdRequestHeaderEnableScanInQuery                         RntbdRequestHeader = 0x001E // RntbdTokenType.Byte, required = false
+	RntbdRequestHeaderEmitVerboseTracesInQuery                  RntbdRequestHeader = 0x001F // RntbdTokenType.Byte, required = false
+	RntbdRequestHeaderConflictName                              RntbdRequestHeader = 0x0020 // RntbdTokenType.String, required = false
+	RntbdRequestHeaderBindReplicaDirective                      RntbdRequestHeader = 0x0021 // RntbdTokenType.String, required = false
+	RntbdRequestHeaderPrimaryMasterKey                          RntbdRequestHeader = 0x0022 // RntbdTokenType.String, required = false
+	RntbdRequestHeaderSecondaryMasterKey                        RntbdRequestHeader = 0x0023 // RntbdTokenType.String, required = false
+	RntbdRequestHeaderPrimaryReadonlyKey                        RntbdRequestHeader = 0x0024 // RntbdTokenType.String, required = false
+	RntbdRequestHeaderSecondaryReadonlyKey                      RntbdRequestHeader = 0x0025 // RntbdTokenType.String, required = false
+	RntbdRequestHeaderProfileRequest                            RntbdRequestHeader = 0x0026 // RntbdTokenType.Byte, required = false
+	RntbdRequestHeaderEnableLowPrecisionOrderBy                 RntbdRequestHeader = 0x0027 // RntbdTokenType.Byte, required = false
+	RntbdRequestHeaderClientVersion                             RntbdRequestHeader = 0x0028 // RntbdTokenType.SmallString, required = false
+	RntbdRequestHeaderCanCharge                                 RntbdRequestHeader = 0x0029 // RntbdTokenType.Byte, required = false
+	RntbdRequestHeaderCanThrottle                               RntbdRequestHeader = 0x002A // RntbdTokenType.Byte, required = false
+	RntbdRequestHeaderPartitionKey                              RntbdRequestHeader = 0x002B // RntbdTokenType.String, required = false
+	RntbdRequestHeaderPartitionKeyRangeId                       RntbdRequestHeader = 0x002C // RntbdTokenType.String, required = false
+	RntbdRequestHeaderNotUsed2D                                 RntbdRequestHeader = 0x002D // RntbdTokenType.Invalid, required = false
+	RntbdRequestHeaderNotUsed2E                                 RntbdRequestHeader = 0x002E // RntbdTokenType.Invalid, required = false
+	RntbdRequestHeaderNotUsed2F                                 RntbdRequestHeader = 0x002F // RntbdTokenType.Invalid, required = false
+	RntbdRequestHeaderMigrateCollectionDirective                RntbdRequestHeader = 0x0031 // RntbdTokenType.Byte, required = false
+	RntbdRequestHeaderNotUsed32                                 RntbdRequestHeader = 0x0032 // RntbdTokenType.Invalid, required = false
+	RntbdRequestHeaderSupportSpatialLegacyCoordinates           RntbdRequestHeader = 0x0033 // RntbdTokenType.Byte, required = false
+	RntbdRequestHeaderPartitionCount                            RntbdRequestHeader = 0x0034 // RntbdTokenType.ULong, required = false
+	RntbdRequestHeaderCollectionRid                             RntbdRequestHeader = 0x0035 // RntbdTokenType.String, required = false
+	RntbdRequestHeaderPartitionKeyRangeName                     RntbdRequestHeader = 0x0036 // RntbdTokenType.String, required = false
+	RntbdRequestHeaderSchemaName                                RntbdRequestHeader = 0x003A // RntbdTokenType.String, required = false
+	RntbdRequestHeaderFilterBySchemaRid                         RntbdRequestHeader = 0x003B // RntbdTokenType.String, required = false
+	RntbdRequestHeaderUsePolygonsSmallerThanAHemisphere         RntbdRequestHeader = 0x003C // RntbdTokenType.Byte, required = false
+	RntbdRequestHeaderGatewaySignature                          RntbdRequestHeader = 0x003D // RntbdTokenType.String, required = false
+	RntbdRequestHeaderEnableLogging                             RntbdRequestHeader = 0x003E // RntbdTokenType.Byte, required = false
+	RntbdRequestHeaderAIM                                       RntbdRequestHeader = 0x003F // RntbdTokenType.String, required = false
+	RntbdRequestHeaderPopulateQuotaInfo                         RntbdRequestHeader = 0x0040 // RntbdTokenType.Byte, required = false
+	RntbdRequestHeaderDisableRUPerMinuteUsage                   RntbdRequestHeader = 0x0041 // RntbdTokenType.Byte, required = false
+	RntbdRequestHeaderPopulateQueryMetrics                      RntbdRequestHeader = 0x0042 // RntbdTokenType.Byte, required = false
+	RntbdRequestHeaderResponseContinuationTokenLimitInKb        RntbdRequestHeader = 0x0043 // RntbdTokenType.ULong, required = false
+	RntbdRequestHeaderPopulatePartitionStatistics               RntbdRequestHeader = 0x0044 // RntbdTokenType.Byte, required = false
+	RntbdRequestHeaderRemoteStorageType                         RntbdRequestHeader = 0x0045 // RntbdTokenType.Byte, required = false
+	RntbdRequestHeaderCollectionRemoteStorageSecurityIdentifier RntbdRequestHeader = 0x0046 // RntbdTokenType.String, required = false
+	RntbdRequestHeaderIfModifiedSince                           RntbdRequestHeader = 0x0047 // RntbdTokenType.String, required = false
+	RntbdRequestHeaderPopulateCollectionThroughputInfo          RntbdRequestHeader = 0x0048 // RntbdTokenType.Byte, required = false
+	RntbdRequestHeaderRemainingTimeInMsOnClientRequest          RntbdRequestHeader = 0x0049 // RntbdTokenType.ULong, required = false
+	RntbdRequestHeaderClientRetryAttemptCount                   RntbdRequestHeader = 0x004A // RntbdTokenType.ULong, required = false
+	RntbdRequestHeaderTargetLsn                                 RntbdRequestHeader = 0x004B // RntbdTokenType.LongLong, required = false
+	RntbdRequestHeaderTargetGlobalCommittedLsn                  RntbdRequestHeader = 0x004C // RntbdTokenType.LongLong, required = false
+	RntbdRequestHeaderTransportRequestID                        RntbdRequestHeader = 0x004D // RntbdTokenType.ULong, required = false
+	RntbdRequestHeaderRestoreMetadaFilter                       RntbdRequestHeader = 0x004E // RntbdTokenType.String, required = false
+	RntbdRequestHeaderRestoreParams                             RntbdRequestHeader = 0x004F // RntbdTokenType.String, required = false
+	RntbdRequestHeaderShareThroughput                           RntbdRequestHeader = 0x0050 // RntbdTokenType.Byte, required = false
+	RntbdRequestHeaderPartitionResourceFilter                   RntbdRequestHeader = 0x0051 // RntbdTokenType.String, required = false
+	RntbdRequestHeaderIsReadOnlyScript                          RntbdRequestHeader = 0x0052 // RntbdTokenType.Byte, required = false
+	RntbdRequestHeaderIsAutoScaleRequest                        RntbdRequestHeader = 0x0053 // RntbdTokenType.Byte, required = false
+	RntbdRequestHeaderForceQueryScan                            RntbdRequestHeader = 0x0054 // RntbdTokenType.Byte, required = false
+	RntbdRequestHeaderCanOfferReplaceComplete                   RntbdRequestHeader = 0x0056 // RntbdTokenType.Byte, required = false
+	RntbdRequestHeaderExcludeSystemProperties                   RntbdRequestHeader = 0x0057 // RntbdTokenType.Byte, required = false
+	RntbdRequestHeaderBinaryId                                  RntbdRequestHeader = 0x0058 // RntbdTokenType.Bytes, required = false
+	RntbdRequestHeaderTimeToLiveInSeconds                       RntbdRequestHeader = 0x0059 // RntbdTokenType.Long, required = false
+	RntbdRequestHeaderEffectivePartitionKey                     RntbdRequestHeader = 0x005A // RntbdTokenType.Bytes, required = false
+	RntbdRequestHeaderBinaryPassthroughRequest                  RntbdRequestHeader = 0x005B // RntbdTokenType.Byte, required = false
+	RntbdRequestHeaderUserDefinedTypeName                       RntbdRequestHeader = 0x005C // RntbdTokenType.String, required = false
+	RntbdRequestHeaderEnableDynamicRidRangeAllocation           RntbdRequestHeader = 0x005D // RntbdTokenType.Byte, required = false
+	RntbdRequestHeaderEnumerationDirection                      RntbdRequestHeader = 0x005E // RntbdTokenType.Byte, required = false
+	RntbdRequestHeaderStartId                                   RntbdRequestHeader = 0x005F // RntbdTokenType.Bytes, required = false
+	RntbdRequestHeaderEndId                                     RntbdRequestHeader = 0x0060 // RntbdTokenType.Bytes, required = false
+	RntbdRequestHeaderFanoutOperationState                      RntbdRequestHeader = 0x0061 // RntbdTokenType.Byte, required = false
+	RntbdRequestHeaderStartEpk                                  RntbdRequestHeader = 0x0062 // RntbdTokenType.Bytes, required = false
+	RntbdRequestHeaderEndEpk                                    RntbdRequestHeader = 0x0063 // RntbdTokenType.Bytes, required = false
+	RntbdRequestHeaderReadFeedKeyType                           RntbdRequestHeader = 0x0064 // RntbdTokenType.Byte, required = false
+	RntbdRequestHeaderContentSerializationFormat                RntbdRequestHeader = 0x0065 // RntbdTokenType.Byte, required = false
+	RntbdRequestHeaderAllowTentativeWrites                      RntbdRequestHeader = 0x0066 // RntbdTokenType.Byte, required = false
+	RntbdRequestHeaderIsUserRequest                             RntbdRequestHeader = 0x0067 // RntbdTokenType.Byte, required = false
+	RntbdRequestHeaderSharedOfferThroughput                     RntbdRequestHeader = 0x0068 // RntbdTokenType.ULong, required = false
+
+	RntbdRequestHeaderSDKSupportedCapabilities RntbdRequestHeader = 0x00A2 // RntbdTokenType.ULong, required = ?
+)
+
+type RntbdResponseHeaderType uint16
+
+const (
+	RntbdResponseHeaderPayloadPresent               RntbdResponseHeaderType = 0x0000 // RntbdTokenType.Byte, required = true
+	RntbdResponseHeaderLastStateChangeDateTime      RntbdResponseHeaderType = 0x0002 // RntbdTokenType.SmallString, required = false
+	RntbdResponseHeaderContinuationToken            RntbdResponseHeaderType = 0x0003 // RntbdTokenType.String, required = false
+	RntbdResponseHeaderETag                         RntbdResponseHeaderType = 0x0004 // RntbdTokenType.String, required = false
+	RntbdResponseHeaderReadsPerformed               RntbdResponseHeaderType = 0x0007 // RntbdTokenType.ULong, required = false
+	RntbdResponseHeaderWritesPerformed              RntbdResponseHeaderType = 0x0008 // RntbdTokenType.ULong, required = false
+	RntbdResponseHeaderQueriesPerformed             RntbdResponseHeaderType = 0x0009 // RntbdTokenType.ULong, required = false
+	RntbdResponseHeaderIndexTermsGenerated          RntbdResponseHeaderType = 0x000A // RntbdTokenType.ULong, required = false
+	RntbdResponseHeaderScriptsExecuted              RntbdResponseHeaderType = 0x000B // RntbdTokenType.ULong, required = false
+	RntbdResponseHeaderRetryAfterMilliseconds       RntbdResponseHeaderType = 0x000C // RntbdTokenType.ULong, required = false
+	RntbdResponseHeaderIndexingDirective            RntbdResponseHeaderType = 0x000D // RntbdTokenType.Byte, required = false
+	RntbdResponseHeaderStorageMaxResoureQuota       RntbdResponseHeaderType = 0x000E // RntbdTokenType.String, required = false
+	RntbdResponseHeaderStorageResourceQuotaUsage    RntbdResponseHeaderType = 0x000F // RntbdTokenType.String, required = false
+	RntbdResponseHeaderSchemaVersion                RntbdResponseHeaderType = 0x0010 // RntbdTokenType.SmallString, required = false
+	RntbdResponseHeaderCollectionPartitionIndex     RntbdResponseHeaderType = 0x0011 // RntbdTokenType.ULong, required = false
+	RntbdResponseHeaderCollectionServiceIndex       RntbdResponseHeaderType = 0x0012 // RntbdTokenType.ULong, required = false
+	RntbdResponseHeaderLSN                          RntbdResponseHeaderType = 0x0013 // RntbdTokenType.LongLong, required = false
+	RntbdResponseHeaderItemCount                    RntbdResponseHeaderType = 0x0014 // RntbdTokenType.ULong, required = false
+	RntbdResponseHeaderRequestCharge                RntbdResponseHeaderType = 0x0015 // RntbdTokenType.Double, required = false
+	RntbdResponseHeaderOwnerFullName                RntbdResponseHeaderType = 0x0017 // RntbdTokenType.String, required = false
+	RntbdResponseHeaderOwnerId                      RntbdResponseHeaderType = 0x0018 // RntbdTokenType.String, required = false
+	RntbdResponseHeaderDatabaseAccountId            RntbdResponseHeaderType = 0x0019 // RntbdTokenType.String, required = false
+	RntbdResponseHeaderQuorumAckedLSN               RntbdResponseHeaderType = 0x001A // RntbdTokenType.LongLong, required = false
+	RntbdResponseHeaderRequestValidationFailure     RntbdResponseHeaderType = 0x001B // RntbdTokenType.Byte, required = false
+	RntbdResponseHeaderSubStatus                    RntbdResponseHeaderType = 0x001C // RntbdTokenType.ULong, required = false
+	RntbdResponseHeaderCollectionUpdateProgress     RntbdResponseHeaderType = 0x001D // RntbdTokenType.ULong, required = false
+	RntbdResponseHeaderCurrentWriteQuorum           RntbdResponseHeaderType = 0x001E // RntbdTokenType.ULong, required = false
+	RntbdResponseHeaderCurrentReplicaSetSize        RntbdResponseHeaderType = 0x001F // RntbdTokenType.ULong, required = false
+	RntbdResponseHeaderCollectionLazyIndexProgress  RntbdResponseHeaderType = 0x0020 // RntbdTokenType.ULong, required = false
+	RntbdResponseHeaderPartitionKeyRangeId          RntbdResponseHeaderType = 0x0021 // RntbdTokenType.String, required = false
+	RntbdResponseHeaderLogResults                   RntbdResponseHeaderType = 0x0025 // RntbdTokenType.String, required = false
+	RntbdResponseHeaderXPRole                       RntbdResponseHeaderType = 0x0026 // RntbdTokenType.ULong, required = false
+	RntbdResponseHeaderIsRUPerMinuteUsed            RntbdResponseHeaderType = 0x0027 // RntbdTokenType.Byte, required = false
+	RntbdResponseHeaderQueryMetrics                 RntbdResponseHeaderType = 0x0028 // RntbdTokenType.String, required = false
+	RntbdResponseHeaderGlobalCommittedLSN           RntbdResponseHeaderType = 0x0029 // RntbdTokenType.LongLong, required = false
+	RntbdResponseHeaderNumberOfReadRegions          RntbdResponseHeaderType = 0x0030 // RntbdTokenType.ULong, required = false
+	RntbdResponseHeaderOfferReplacePending          RntbdResponseHeaderType = 0x0031 // RntbdTokenType.Byte, required = false
+	RntbdResponseHeaderItemLSN                      RntbdResponseHeaderType = 0x0032 // RntbdTokenType.LongLong, required = false
+	RntbdResponseHeaderRestoreState                 RntbdResponseHeaderType = 0x0033 // RntbdTokenType.String, required = false
+	RntbdResponseHeaderCollectionSecurityIdentifier RntbdResponseHeaderType = 0x0034 // RntbdTokenType.String, required = false
+	RntbdResponseHeaderTransportRequestID           RntbdResponseHeaderType = 0x0035 // RntbdTokenType.ULong, required = false
+	RntbdResponseHeaderShareThroughput              RntbdResponseHeaderType = 0x0036 // RntbdTokenType.Byte, required = false
+	RntbdResponseHeaderDisableRntbdChannel          RntbdResponseHeaderType = 0x0038 // RntbdTokenType.Byte, required = false
+	RntbdResponseHeaderServerDateTimeUtc            RntbdResponseHeaderType = 0x0039 // RntbdTokenType.SmallString, required = false
+	RntbdResponseHeaderLocalLSN                     RntbdResponseHeaderType = 0x003A // RntbdTokenType.LongLong, required = false
+	RntbdResponseHeaderQuorumAckedLocalLSN          RntbdResponseHeaderType = 0x003B // RntbdTokenType.LongLong, required = false
+	RntbdResponseHeaderItemLocalLSN                 RntbdResponseHeaderType = 0x003C // RntbdTokenType.LongLong, required = false
+	RntbdResponseHeaderHasTentativeWrites           RntbdResponseHeaderType = 0x003D // RntbdTokenType.Byte, required = false
+	RntbdResponseHeaderSessionToken                 RntbdResponseHeaderType = 0x003E // RntbdTokenType.String, required = false
+)
+
+type RntbdContextHeader uint16
+
+const (
+	RntbdContextHeaderProtocolVersion                 RntbdContextHeader = 0x0000 // RntbdTokenType.ULong, required = false
+	RntbdContextHeaderClientVersion                   RntbdContextHeader = 0x0001 // RntbdTokenType.SmallString, required = false
+	RntbdContextHeaderServerAgent                     RntbdContextHeader = 0x0002 // RntbdTokenType.SmallString, required = true
+	RntbdContextHeaderServerVersion                   RntbdContextHeader = 0x0003 // RntbdTokenType.SmallString, required = true
+	RntbdContextHeaderIdleTimeoutInSeconds            RntbdContextHeader = 0x0004 // RntbdTokenType.ULong, required = false
+	RntbdContextHeaderUnauthenticatedTimeoutInSeconds RntbdContextHeader = 0x0005 // RntbdTokenType.ULong, required = false
+)
+
+type RntbdTokenType uint8
+
+const (
+	RntbdTokenTypeByte        RntbdTokenType = 0x00 // 8bit boolean
+	RntbdTokenTypeUShort      RntbdTokenType = 0x01 // 16bit unsigned integer
+	RntbdTokenTypeULong       RntbdTokenType = 0x02 // 32bit unsigned integer
+	RntbdTokenTypeLong        RntbdTokenType = 0x03 // 32bit signed integer
+	RntbdTokenTypeULongLong   RntbdTokenType = 0x04 // 64bit unsigned integer
+	RntbdTokenTypeLongLong    RntbdTokenType = 0x05 // 64bit signed integer
+	RntbdTokenTypeGuid        RntbdTokenType = 0x06 // 128bit GUID
+	RntbdTokenTypeSmallString RntbdTokenType = 0x07 // 8bit len + string
+	RntbdTokenTypeString      RntbdTokenType = 0x08 // 16bit len + string
+	RntbdTokenTypeULongString RntbdTokenType = 0x09 // 32bit len + string
+	RntbdTokenTypeSmallBytes  RntbdTokenType = 0x0A // 8bit len + bytes
+	RntbdTokenTypeBytes       RntbdTokenType = 0x0B // 16bit len + bytes
+	RntbdTokenTypeULongBytes  RntbdTokenType = 0x0C // 32bit len + bytes
+	RntbdTokenTypeFloat       RntbdTokenType = 0x0D // 32bit float
+	RntbdTokenTypeDouble      RntbdTokenType = 0x0E // 64bit double
+	RntbdTokenTypeInvalid     RntbdTokenType = 0x0F // Invalid token type
+)
+
+func (h RntbdRequestHeader) String() string {
+	switch h {
+	case RntbdRequestHeaderResourceId:
+		return "RntbdRequestHeaderResourceId"
+	case RntbdRequestHeaderAuthorizationToken:
+		return headers.Authorization
+	case RntbdRequestHeaderPayloadPresent:
+		return "RntbdRequestHeaderPayloadPresent"
+	case RntbdRequestHeaderDate:
+		return headers.XDate
+	case RntbdRequestHeaderPageSize:
+		return "RntbdRequestHeaderPageSize"
+	case RntbdRequestHeaderSessionToken:
+		return "RntbdRequestHeaderSessionToken"
+	case RntbdRequestHeaderContinuationToken:
+		return "RntbdRequestHeaderContinuationToken"
+	case RntbdRequestHeaderIndexingDirective:
+		return "RntbdRequestHeaderIndexingDirective"
+	case RntbdRequestHeaderMatch:
+		return "RntbdRequestHeaderMatch"
+	case RntbdRequestHeaderPreTriggerInclude:
+		return "RntbdRequestHeaderPreTriggerInclude"
+	case RntbdRequestHeaderPostTriggerInclude:
+		return "RntbdRequestHeaderPostTriggerInclude"
+	case RntbdRequestHeaderIsFanout:
+		return "RntbdRequestHeaderIsFanout"
+	case RntbdRequestHeaderCollectionPartitionIndex:
+		return "RntbdRequestHeaderCollectionPartitionIndex"
+	case RntbdRequestHeaderCollectionServiceIndex:
+		return "RntbdRequestHeaderCollectionServiceIndex"
+	case RntbdRequestHeaderPreTriggerExclude:
+		return "RntbdRequestHeaderPreTriggerExclude"
+	case RntbdRequestHeaderPostTriggerExclude:
+		return "RntbdRequestHeaderPostTriggerExclude"
+	case RntbdRequestHeaderConsistencyLevel:
+		return headers.ConsistencyLevel
+	case RntbdRequestHeaderEntityId:
+		return "RntbdRequestHeaderEntityId"
+	case RntbdRequestHeaderResourceSchemaName:
+		return "RntbdRequestHeaderResourceSchemaName"
+	case RntbdRequestHeaderReplicaPath:
+		return "RntbdRequestHeaderReplicaPath"
+	case RntbdRequestHeaderResourceTokenExpiry:
+		return "RntbdRequestHeaderResourceTokenExpiry"
+	case RntbdRequestHeaderDatabaseName:
+		return "RntbdRequestHeaderDatabaseName"
+	case RntbdRequestHeaderCollectionName:
+		return "RntbdRequestHeaderCollectionName"
+	case RntbdRequestHeaderDocumentName:
+		return "RntbdRequestHeaderDocumentName"
+	case RntbdRequestHeaderAttachmentName:
+		return "RntbdRequestHeaderAttachmentName"
+	case RntbdRequestHeaderUserName:
+		return "RntbdRequestHeaderUserName"
+	case RntbdRequestHeaderPermissionName:
+		return "RntbdRequestHeaderPermissionName"
+	case RntbdRequestHeaderStoredProcedureName:
+		return "RntbdRequestHeaderStoredProcedureName"
+	case RntbdRequestHeaderUserDefinedFunctionName:
+		return "RntbdRequestHeaderUserDefinedFunctionName"
+	case RntbdRequestHeaderTriggerName:
+		return "RntbdRequestHeaderTriggerName"
+	case RntbdRequestHeaderEnableScanInQuery:
+		return "RntbdRequestHeaderEnableScanInQuery"
+	case RntbdRequestHeaderEmitVerboseTracesInQuery:
+		return "RntbdRequestHeaderEmitVerboseTracesInQuery"
+	case RntbdRequestHeaderConflictName:
+		return "RntbdRequestHeaderConflictName"
+	case RntbdRequestHeaderBindReplicaDirective:
+		return "RntbdRequestHeaderBindReplicaDirective"
+	case RntbdRequestHeaderPrimaryMasterKey:
+		return "RntbdRequestHeaderPrimaryMasterKey"
+	case RntbdRequestHeaderSecondaryMasterKey:
+		return "RntbdRequestHeaderSecondaryMasterKey"
+	case RntbdRequestHeaderPrimaryReadonlyKey:
+		return "RntbdRequestHeaderPrimaryReadonlyKey"
+	case RntbdRequestHeaderSecondaryReadonlyKey:
+		return "RntbdRequestHeaderSecondaryReadonlyKey"
+	case RntbdRequestHeaderProfileRequest:
+		return "RntbdRequestHeaderProfileRequest"
+	case RntbdRequestHeaderEnableLowPrecisionOrderBy:
+		return "RntbdRequestHeaderEnableLowPrecisionOrderBy"
+	case RntbdRequestHeaderClientVersion:
+		return "RntbdRequestHeaderClientVersion"
+	case RntbdRequestHeaderCanCharge:
+		return "RntbdRequestHeaderCanCharge"
+	case RntbdRequestHeaderCanThrottle:
+		return "RntbdRequestHeaderCanThrottle"
+	case RntbdRequestHeaderPartitionKey:
+		return "RntbdRequestHeaderPartitionKey"
+	case RntbdRequestHeaderPartitionKeyRangeId:
+		return "RntbdRequestHeaderPartitionKeyRangeId"
+	case RntbdRequestHeaderNotUsed2D:
+		return "RntbdRequestHeaderNotUsed2D"
+	case RntbdRequestHeaderNotUsed2E:
+		return "RntbdRequestHeaderNotUsed2E"
+	case RntbdRequestHeaderNotUsed2F:
+		return "RntbdRequestHeaderNotUsed2F"
+	case RntbdRequestHeaderMigrateCollectionDirective:
+		return "RntbdRequestHeaderMigrateCollectionDirective"
+	case RntbdRequestHeaderNotUsed32:
+		return "RntbdRequestHeaderNotUsed32"
+	case RntbdRequestHeaderSupportSpatialLegacyCoordinates:
+		return "RntbdRequestHeaderSupportSpatialLegacyCoordinates"
+	case RntbdRequestHeaderPartitionCount:
+		return "RntbdRequestHeaderPartitionCount"
+	case RntbdRequestHeaderCollectionRid:
+		return "RntbdRequestHeaderCollectionRid"
+	case RntbdRequestHeaderPartitionKeyRangeName:
+		return "RntbdRequestHeaderPartitionKeyRangeName"
+	case RntbdRequestHeaderSchemaName:
+		return "RntbdRequestHeaderSchemaName"
+	case RntbdRequestHeaderFilterBySchemaRid:
+		return "RntbdRequestHeaderFilterBySchemaRid"
+	case RntbdRequestHeaderUsePolygonsSmallerThanAHemisphere:
+		return "RntbdRequestHeaderUsePolygonsSmallerThanAHemisphere"
+	case RntbdRequestHeaderGatewaySignature:
+		return "RntbdRequestHeaderGatewaySignature"
+	case RntbdRequestHeaderEnableLogging:
+		return "RntbdRequestHeaderEnableLogging"
+	case RntbdRequestHeaderAIM:
+		return headers.AIM
+	case RntbdRequestHeaderPopulateQuotaInfo:
+		return "RntbdRequestHeaderPopulateQuotaInfo"
+	case RntbdRequestHeaderDisableRUPerMinuteUsage:
+		return "RntbdRequestHeaderDisableRUPerMinuteUsage"
+	case RntbdRequestHeaderPopulateQueryMetrics:
+		return "RntbdRequestHeaderPopulateQueryMetrics"
+	case RntbdRequestHeaderResponseContinuationTokenLimitInKb:
+		return "RntbdRequestHeaderResponseContinuationTokenLimitInKb"
+	case RntbdRequestHeaderPopulatePartitionStatistics:
+		return "RntbdRequestHeaderPopulatePartitionStatistics"
+	case RntbdRequestHeaderRemoteStorageType:
+		return "RntbdRequestHeaderRemoteStorageType"
+	case RntbdRequestHeaderCollectionRemoteStorageSecurityIdentifier:
+		return "RntbdRequestHeaderCollectionRemoteStorageSecurityIdentifier"
+	case RntbdRequestHeaderIfModifiedSince:
+		return "RntbdRequestHeaderIfModifiedSince"
+	case RntbdRequestHeaderPopulateCollectionThroughputInfo:
+		return "RntbdRequestHeaderPopulateCollectionThroughputInfo"
+	case RntbdRequestHeaderRemainingTimeInMsOnClientRequest:
+		return headers.RemainingTimeInMsOnClient
+	case RntbdRequestHeaderClientRetryAttemptCount:
+		return headers.ClientRetryAttemptCount
+	case RntbdRequestHeaderTargetLsn:
+		return "RntbdRequestHeaderTargetLsn"
+	case RntbdRequestHeaderTargetGlobalCommittedLsn:
+		return "RntbdRequestHeaderTargetGlobalCommittedLsn"
+	case RntbdRequestHeaderTransportRequestID:
+		return "RntbdRequestHeaderTransportRequestID"
+	case RntbdRequestHeaderRestoreMetadaFilter:
+		return "RntbdRequestHeaderRestoreMetadaFilter"
+	case RntbdRequestHeaderRestoreParams:
+		return "RntbdRequestHeaderRestoreParams"
+	case RntbdRequestHeaderShareThroughput:
+		return "RntbdRequestHeaderShareThroughput"
+	case RntbdRequestHeaderPartitionResourceFilter:
+		return "RntbdRequestHeaderPartitionResourceFilter"
+	case RntbdRequestHeaderIsReadOnlyScript:
+		return "RntbdRequestHeaderIsReadOnlyScript"
+	case RntbdRequestHeaderIsAutoScaleRequest:
+		return "RntbdRequestHeaderIsAutoScaleRequest"
+	case RntbdRequestHeaderForceQueryScan:
+		return "RntbdRequestHeaderForceQueryScan"
+	case RntbdRequestHeaderCanOfferReplaceComplete:
+		return "RntbdRequestHeaderCanOfferReplaceComplete"
+	case RntbdRequestHeaderExcludeSystemProperties:
+		return "RntbdRequestHeaderExcludeSystemProperties"
+	case RntbdRequestHeaderBinaryId:
+		return "RntbdRequestHeaderBinaryId"
+	case RntbdRequestHeaderTimeToLiveInSeconds:
+		return "RntbdRequestHeaderTimeToLiveInSeconds"
+	case RntbdRequestHeaderEffectivePartitionKey:
+		return "RntbdRequestHeaderEffectivePartitionKey"
+	case RntbdRequestHeaderBinaryPassthroughRequest:
+		return "RntbdRequestHeaderBinaryPassthroughRequest"
+	case RntbdRequestHeaderUserDefinedTypeName:
+		return "RntbdRequestHeaderUserDefinedTypeName"
+	case RntbdRequestHeaderEnableDynamicRidRangeAllocation:
+		return "RntbdRequestHeaderEnableDynamicRidRangeAllocation"
+	case RntbdRequestHeaderEnumerationDirection:
+		return "RntbdRequestHeaderEnumerationDirection"
+	case RntbdRequestHeaderStartId:
+		return "RntbdRequestHeaderStartId"
+	case RntbdRequestHeaderEndId:
+		return "RntbdRequestHeaderEndId"
+	case RntbdRequestHeaderFanoutOperationState:
+		return "RntbdRequestHeaderFanoutOperationState"
+	case RntbdRequestHeaderStartEpk:
+		return "RntbdRequestHeaderStartEpk"
+	case RntbdRequestHeaderEndEpk:
+		return "RntbdRequestHeaderEndEpk"
+	case RntbdRequestHeaderReadFeedKeyType:
+		return "RntbdRequestHeaderReadFeedKeyType"
+	case RntbdRequestHeaderContentSerializationFormat:
+		return "RntbdRequestHeaderContentSerializationFormat"
+	case RntbdRequestHeaderAllowTentativeWrites:
+		return "RntbdRequestHeaderAllowTentativeWrites"
+	case RntbdRequestHeaderIsUserRequest:
+		return "RntbdRequestHeaderIsUserRequest"
+	case RntbdRequestHeaderSharedOfferThroughput:
+		return "RntbdRequestHeaderSharedOfferThroughput"
+	case RntbdRequestHeaderSDKSupportedCapabilities:
+		return headers.SupportedCapabilities
+	}
+
+	return fmt.Sprintf("RntbdRequestHeader(%d)", h)
+}
+
+func (h RntbdContextHeader) String() string {
+	switch h {
+	case RntbdContextHeaderProtocolVersion:
+		return "RntbdContextHeaderProtocolVersion"
+	case RntbdContextHeaderClientVersion:
+		return "RntbdContextHeaderClientVersion"
+	case RntbdContextHeaderServerAgent:
+		return "RntbdContextHeaderServerAgent"
+	case RntbdContextHeaderServerVersion:
+		return "RntbdContextHeaderServerVersion"
+	case RntbdContextHeaderIdleTimeoutInSeconds:
+		return "RntbdContextHeaderIdleTimeoutInSeconds"
+	case RntbdContextHeaderUnauthenticatedTimeoutInSeconds:
+		return "RntbdContextHeaderUnauthenticatedTimeoutInSeconds"
+	}
+
+	return fmt.Sprintf("RntbdContextHeader(%d)", h)
+}
+
+func (h RntbdResponseHeaderType) String() string {
+	switch h {
+	case RntbdResponseHeaderPayloadPresent:
+		return "PayloadPresent"
+	case RntbdResponseHeaderLastStateChangeDateTime:
+		return "LastStateChangeDateTime"
+	case RntbdResponseHeaderContinuationToken:
+		return "ContinuationToken"
+	case RntbdResponseHeaderETag:
+		return "ETag"
+	case RntbdResponseHeaderReadsPerformed:
+		return "ReadsPerformed"
+	case RntbdResponseHeaderWritesPerformed:
+		return "WritesPerformed"
+	case RntbdResponseHeaderQueriesPerformed:
+		return "QueriesPerformed"
+	case RntbdResponseHeaderIndexTermsGenerated:
+		return "IndexTermsGenerated"
+	case RntbdResponseHeaderScriptsExecuted:
+		return "ScriptsExecuted"
+	case RntbdResponseHeaderRetryAfterMilliseconds:
+		return "RetryAfterMilliseconds"
+	case RntbdResponseHeaderIndexingDirective:
+		return "IndexingDirective"
+	case RntbdResponseHeaderStorageMaxResoureQuota:
+		return "StorageMaxResoureQuota"
+	case RntbdResponseHeaderStorageResourceQuotaUsage:
+		return "StorageResourceQuotaUsage"
+	case RntbdResponseHeaderSchemaVersion:
+		return "SchemaVersion"
+	case RntbdResponseHeaderCollectionPartitionIndex:
+		return "CollectionPartitionIndex"
+	case RntbdResponseHeaderCollectionServiceIndex:
+		return "CollectionServiceIndex"
+	case RntbdResponseHeaderLSN:
+		return "LSN"
+	case RntbdResponseHeaderItemCount:
+		return "ItemCount"
+	case RntbdResponseHeaderRequestCharge:
+		return "RequestCharge"
+	case RntbdResponseHeaderOwnerFullName:
+		return "OwnerFullName"
+	case RntbdResponseHeaderOwnerId:
+		return "OwnerId"
+	case RntbdResponseHeaderDatabaseAccountId:
+		return "DatabaseAccountId"
+	case RntbdResponseHeaderQuorumAckedLSN:
+		return "QuorumAckedLSN"
+	case RntbdResponseHeaderRequestValidationFailure:
+		return "RequestValidationFailure"
+	case RntbdResponseHeaderSubStatus:
+		return "SubStatus"
+	case RntbdResponseHeaderCollectionUpdateProgress:
+		return "CollectionUpdateProgress"
+	case RntbdResponseHeaderCurrentWriteQuorum:
+		return "CurrentWriteQuorum"
+	case RntbdResponseHeaderCurrentReplicaSetSize:
+		return "CurrentReplicaSetSize"
+	case RntbdResponseHeaderCollectionLazyIndexProgress:
+		return "CollectionLazyIndexProgress"
+	case RntbdResponseHeaderPartitionKeyRangeId:
+		return "PartitionKeyRangeId"
+	case RntbdResponseHeaderLogResults:
+		return "LogResults"
+	case RntbdResponseHeaderXPRole:
+		return "XPRole"
+	case RntbdResponseHeaderIsRUPerMinuteUsed:
+		return "IsRUPerMinuteUsed"
+	case RntbdResponseHeaderQueryMetrics:
+		return "QueryMetrics"
+	case RntbdResponseHeaderGlobalCommittedLSN:
+		return "GlobalCommittedLSN"
+	case RntbdResponseHeaderNumberOfReadRegions:
+		return "NumberOfReadRegions"
+	case RntbdResponseHeaderOfferReplacePending:
+		return "OfferReplacePending"
+	case RntbdResponseHeaderItemLSN:
+		return "ItemLSN"
+	case RntbdResponseHeaderRestoreState:
+		return "RestoreState"
+	case RntbdResponseHeaderCollectionSecurityIdentifier:
+		return "CollectionSecurityIdentifier"
+	case RntbdResponseHeaderTransportRequestID:
+		return "TransportRequestID"
+	case RntbdResponseHeaderShareThroughput:
+		return "ShareThroughput"
+	case RntbdResponseHeaderDisableRntbdChannel:
+		return "DisableRntbdChannel"
+	case RntbdResponseHeaderServerDateTimeUtc:
+		return "ServerDateTimeUtc"
+	case RntbdResponseHeaderLocalLSN:
+		return "LocalLSN"
+	case RntbdResponseHeaderQuorumAckedLocalLSN:
+		return "QuorumAckedLocalLSN"
+	case RntbdResponseHeaderItemLocalLSN:
+		return "ItemLocalLSN"
+	case RntbdResponseHeaderHasTentativeWrites:
+		return "HasTentativeWrites"
+	case RntbdResponseHeaderSessionToken:
+		return "SessionToken"
+	}
+
+	return fmt.Sprintf("RntbdResponseHeaderType(%d)", h)
+}
+
+func (r RntbdResourceType) String() string {
+	switch r {
+	case RntbdResourceTypeConnection:
+		return "Connection"
+	case RntbdResourceTypeDatabase:
+		return "Database"
+	case RntbdResourceTypeCollection:
+		return "Collection"
+	case RntbdResourceTypeDocument:
+		return "Document"
+	case RntbdResourceTypeAttachment:
+		return "Attachment"
+	case RntbdResourceTypeUser:
+		return "User"
+	case RntbdResourceTypePermission:
+		return "Permission"
+	case RntbdResourceTypeStoredProcedure:
+		return "StoredProcedure"
+	case RntbdResourceTypeConflict:
+		return "Conflict"
+	case RntbdResourceTypeTrigger:
+		return "Trigger"
+	case RntbdResourceTypeUserDefinedFunction:
+		return "UserDefinedFunction"
+	case RntbdResourceTypeModule:
+		return "Module"
+	case RntbdResourceTypeReplica:
+		return "Replica"
+	case RntbdResourceTypeModuleCommand:
+		return "ModuleCommand"
+	case RntbdResourceTypeRecord:
+		return "Record"
+	case RntbdResourceTypeOffer:
+		return "Offer"
+	case RntbdResourceTypePartitionSetInformation:
+		return "PartitionSetInformation"
+	case RntbdResourceTypeXPReplicatorAddress:
+		return "XPReplicatorAddress"
+	case RntbdResourceTypeMasterPartition:
+		return "MasterPartition"
+	case RntbdResourceTypeServerPartition:
+		return "ServerPartition"
+	case RntbdResourceTypeDatabaseAccount:
+		return "DatabaseAccount"
+	case RntbdResourceTypeTopology:
+		return "Topology"
+	case RntbdResourceTypePartitionKeyRange:
+		return "PartitionKeyRange"
+	case RntbdResourceTypeSchema:
+		return "Schema"
+	case RntbdResourceTypeBatchApply:
+		return "BatchApply"
+	case RntbdResourceTypeRestoreMetadata:
+		return "RestoreMetadata"
+	case RntbdResourceTypeComputeGatewayCharges:
+		return "ComputeGatewayCharges"
+	case RntbdResourceTypeRidRange:
+		return "RidRange"
+	case RntbdResourceTypeUserDefinedType:
+		return "UserDefinedType"
+	}
+
+	return fmt.Sprintf("RntbdResourceType(%d)", r)
+}
+
+func (o RntbdOperationType) String() string {
+	switch o {
+	case RntbdOperationTypeConnection:
+		return "Connection"
+	case RntbdOperationTypeCreate:
+		return "Create"
+	case RntbdOperationTypeUpdate:
+		return "Update"
+	case RntbdOperationTypeRead:
+		return "Read"
+	case RntbdOperationTypeReadFeed:
+		return "ReadFeed"
+	case RntbdOperationTypeDelete:
+		return "Delete"
+	case RntbdOperationTypeReplace:
+		return "Replace"
+	case RntbdOperationTypeExecuteJavaScript:
+		return "ExecuteJavaScript"
+	case RntbdOperationTypeSQLQuery:
+		return "SQLQuery"
+	case RntbdOperationTypePause:
+		return "Pause"
+	case RntbdOperationTypeResume:
+		return "Resume"
+	case RntbdOperationTypeStop:
+		return "Stop"
+	case RntbdOperationTypeRecycle:
+		return "Recycle"
+	case RntbdOperationTypeCrash:
+		return "Crash"
+	case RntbdOperationTypeQuery:
+		return "Query"
+	case RntbdOperationTypeForceConfigRefresh:
+		return "ForceConfigRefresh"
+	case RntbdOperationTypeHead:
+		return "Head"
+	case RntbdOperationTypeHeadFeed:
+		return "HeadFeed"
+	case RntbdOperationTypeUpsert:
+		return "Upsert"
+	case RntbdOperationTypeRecreate:
+		return "Recreate"
+	case RntbdOperationTypeThrottle:
+		return "Throttle"
+	case RntbdOperationTypeGetSplitPoint:
+		return "GetSplitPoint"
+	case RntbdOperationTypePreCreateValidation:
+		return "PreCreateValidation"
+	case RntbdOperationTypeBatchApply:
+		return "BatchApply"
+	case RntbdOperationTypeAbortSplit:
+		return "AbortSplit"
+	case RntbdOperationTypeCompleteSplit:
+		return "CompleteSplit"
+	case RntbdOperationTypeOfferUpdateOperation:
+		return "OfferUpdateOperation"
+	case RntbdOperationTypeOfferPreGrowValidation:
+		return "OfferPreGrowValidation"
+	case RntbdOperationTypeBatchReportThroughputUtilization:
+		return "BatchReportThroughputUtilization"
+	case RntbdOperationTypeCompletePartitionMigration:
+		return "CompletePartitionMigration"
+	case RntbdOperationTypeAbortPartitionMigration:
+		return "AbortPartitionMigration"
+	case RntbdOperationTypePreReplaceValidation:
+		return "PreReplaceValidation"
+	case RntbdOperationTypeAddComputeGatewayRequestCharges:
+		return "AddComputeGatewayRequestCharges"
+	case RntbdOperationTypeMigratePartition:
+		return "MigratePartition"
+	}
+
+	return fmt.Sprintf("RntbdOperationType(%d)", o)
+}

internal/rntbd/converter.go

@@ -0,0 +1,128 @@
+package rntbd
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"strconv"
+
+	"github.com/pikami/cosmium/api/headers"
+)
+
+func (f *RntbdFrame) ToHttpRequest() *http.Request {
+	req := &http.Request{
+		Method: operationTypeToHttpMethod(f.OperationType),
+		URL:    &url.URL{Path: frameToPath(f)},
+		Body:   io.NopCloser(bytes.NewReader(f.Payload)),
+		Header: http.Header{},
+	}
+
+	switch f.OperationType {
+	case RntbdOperationTypeQuery, RntbdOperationTypeSQLQuery:
+		req.Header.Set(headers.Query, "true")
+	case RntbdOperationTypeUpsert:
+		req.Header.Set(headers.IsUpsert, "true")
+	}
+
+	if ifMatch, ok := f.RequestHeaders[RntbdRequestHeaderMatch]; ok {
+		if ifMatchString, ok := ifMatch.(string); ok {
+			req.Header.Set(headers.IfMatch, ifMatchString)
+		}
+	}
+
+	if continuationToken, ok := f.RequestHeaders[RntbdRequestHeaderContinuationToken]; ok {
+		if continuationTokenString, ok := continuationToken.(string); ok {
+			req.Header.Set(headers.ContinuationToken, continuationTokenString)
+		}
+	}
+
+	if maxItemCount, ok := f.RequestHeaders[RntbdRequestHeaderPageSize]; ok {
+		if maxItemCountString, ok := maxItemCount.(uint64); ok {
+			req.Header.Set(headers.MaxItemCount, fmt.Sprintf("%d", maxItemCountString))
+		}
+	}
+
+	return req
+}
+
+func ToRntbdResponseFrame(responseWriter *httptest.ResponseRecorder) *RntbdResponseFrameBuilder {
+	builder := &RntbdResponseFrameBuilder{}
+	builder.SetStatusCode(uint16(responseWriter.Code))
+
+	if responseWriter.Header().Get(headers.ETag) != "" {
+		builder.AddHeader(uint16(RntbdResponseHeaderETag), RntbdTokenTypeString, responseWriter.Header().Get(headers.ETag))
+	}
+
+	if responseWriter.Header().Get(headers.ContinuationToken) != "" {
+		builder.AddHeader(uint16(RntbdResponseHeaderContinuationToken), RntbdTokenTypeString, responseWriter.Header().Get(headers.ContinuationToken))
+	}
+
+	if responseWriter.Header().Get(headers.ItemCount) != "" {
+		itemCount, err := strconv.ParseUint(responseWriter.Header().Get(headers.ItemCount), 10, 32)
+		if err != nil {
+			panic(err)
+		}
+
+		builder.AddHeader(uint16(RntbdResponseHeaderItemCount), RntbdTokenTypeULong, uint32(itemCount))
+	}
+
+	if responseWriter.Body.Len() > 0 {
+		builder.AddHeader(uint16(RntbdResponseHeaderPayloadPresent), RntbdTokenTypeByte, []byte{1})
+		builder.AddPayload(responseWriter.Body.Bytes())
+	} else {
+		builder.AddHeader(uint16(RntbdResponseHeaderPayloadPresent), RntbdTokenTypeByte, []byte{0})
+	}
+
+	return builder
+}
+
+func operationTypeToHttpMethod(operationType RntbdOperationType) string {
+	switch operationType {
+	case RntbdOperationTypeRead,
+		RntbdOperationTypeReadFeed:
+		return http.MethodGet
+	case RntbdOperationTypeCreate,
+		RntbdOperationTypeUpsert,
+		RntbdOperationTypeQuery,
+		RntbdOperationTypeSQLQuery:
+		return http.MethodPost
+	case RntbdOperationTypeUpdate,
+		RntbdOperationTypeReplace:
+		return http.MethodPut
+	case RntbdOperationTypeDelete:
+		return http.MethodDelete
+	}
+
+	panic(fmt.Sprintf("Unknown operation type: %d", operationType))
+}
+
+func frameToPath(frame *RntbdFrame) string {
+	databaseName, databaseOk := frame.RequestHeaders[RntbdRequestHeaderDatabaseName]
+	collectionName, collectionOk := frame.RequestHeaders[RntbdRequestHeaderCollectionName]
+	documentName, documentOk := frame.RequestHeaders[RntbdRequestHeaderDocumentName]
+
+	urlPath := ""
+
+	if databaseOk {
+		urlPath += fmt.Sprintf("/dbs/%s", databaseName)
+	} else if frame.ResourceType == RntbdResourceTypeDatabase {
+		urlPath += "/dbs"
+	}
+
+	if collectionOk {
+		urlPath += fmt.Sprintf("/colls/%s", collectionName)
+	} else if frame.ResourceType == RntbdResourceTypeCollection {
+		urlPath += "/colls"
+	}
+
+	if documentOk {
+		urlPath += fmt.Sprintf("/docs/%s", documentName)
+	} else if frame.ResourceType == RntbdResourceTypeDocument {
+		urlPath += "/docs"
+	}
+
+	return urlPath
+}

internal/rntbd/parser.go

@@ -0,0 +1,212 @@
+package rntbd
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/binary"
+	"encoding/hex"
+	"fmt"
+	"io"
+	"os"
+
+	"github.com/pikami/cosmium/internal/logger"
+)
+
+type RntbdFrame struct {
+	ResourceType    RntbdResourceType
+	OperationType   RntbdOperationType
+	ActivityId      []byte
+	RequestHeaders  map[RntbdRequestHeader]any
+	ResponseHeaders map[RntbdResponseHeaderType]any
+	ContextHeaders  map[RntbdContextHeader]any
+	Payload         []byte
+}
+
+func ReadFrame(reader *bufio.Reader) (*RntbdFrame, error) {
+	sizeBytes := readBytes(reader, 4)
+	size := binary.LittleEndian.Uint32(sizeBytes)
+
+	payload := readBytes(reader, int(size)-4)
+
+	frame, err := parseFrame_Int(payload, false)
+	if err != nil {
+		return nil, err
+	}
+
+	if payloadPresent, ok := frame.RequestHeaders[RntbdRequestHeaderPayloadPresent]; ok && payloadPresent.([]byte)[0] == 1 {
+		payloadSize := binary.LittleEndian.Uint32(readBytes(reader, 4))
+		payload := readBytes(reader, int(payloadSize))
+		frame.Payload = payload
+	}
+
+	if payloadPresent, ok := frame.ResponseHeaders[RntbdResponseHeaderPayloadPresent]; ok && payloadPresent.([]byte)[0] == 1 {
+		payloadSize := binary.LittleEndian.Uint32(readBytes(reader, 4))
+		payload := readBytes(reader, int(payloadSize))
+		frame.Payload = payload
+	}
+
+	return frame, nil
+}
+
+func ParseFrame(data []byte, isResponse bool) (*RntbdFrame, error) {
+	if len(data) < 4 {
+		return nil, fmt.Errorf("data too short")
+	}
+
+	reader := bufio.NewReader(bytes.NewReader(data))
+	sizeBytes := readBytes(reader, 4)
+	size := binary.LittleEndian.Uint32(sizeBytes)
+
+	payload := readBytes(reader, int(size)-4)
+	frame, err := parseFrame_Int(payload, isResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	if payloadPresent, ok := frame.RequestHeaders[RntbdRequestHeaderPayloadPresent]; ok && payloadPresent.([]byte)[0] == 1 {
+		payloadSize := binary.LittleEndian.Uint32(readBytes(reader, 4))
+		payload := readBytes(reader, int(payloadSize))
+		frame.Payload = payload
+	}
+
+	if payloadPresent, ok := frame.ResponseHeaders[RntbdResponseHeaderPayloadPresent]; ok && payloadPresent.([]byte)[0] == 1 {
+		payloadSize := binary.LittleEndian.Uint32(readBytes(reader, 4))
+		payload := readBytes(reader, int(payloadSize))
+		frame.Payload = payload
+	}
+
+	leftOverBytes, err := io.ReadAll(reader)
+	if err != nil {
+		logger.ErrorLn("Error reading leftOverBytes:", err)
+	}
+
+	if len(leftOverBytes) > 0 {
+		logger.ErrorLn("Left over bytes:", hex.EncodeToString(leftOverBytes))
+	}
+
+	return frame, nil
+}
+
+func parseFrame_Int(data []byte, isResponse bool) (*RntbdFrame, error) {
+	payloadReader := bufio.NewReader(bytes.NewReader(data))
+
+	resourceTypeBytes := readBytes(payloadReader, 2)
+	resourceType := binary.LittleEndian.Uint16(resourceTypeBytes)
+
+	operationTypeBytes := readBytes(payloadReader, 2)
+	operationType := RntbdOperationType(binary.LittleEndian.Uint16(operationTypeBytes))
+
+	activityIdBytes := readBytes(payloadReader, 16)
+
+	requestHeaders := make(map[RntbdRequestHeader]any)
+	responseHeaders := make(map[RntbdResponseHeaderType]any)
+	contextHeaders := make(map[RntbdContextHeader]any)
+	for {
+		if _, err := payloadReader.Peek(1); err != nil {
+			break
+		}
+
+		headerIdBytes := readBytes(payloadReader, 2)
+		headerId := binary.LittleEndian.Uint16(headerIdBytes)
+
+		token, err := parseRntbdToken(payloadReader)
+		if err != nil {
+			return nil, err
+		}
+
+		if resourceType == uint16(RntbdResourceTypeConnection) {
+			contextHeaders[RntbdContextHeader(headerId)] = token
+		} else if isResponse {
+			responseHeaders[RntbdResponseHeaderType(headerId)] = token
+		} else {
+			requestHeaders[RntbdRequestHeader(headerId)] = token
+		}
+	}
+
+	return &RntbdFrame{
+		ResourceType:    RntbdResourceType(resourceType),
+		OperationType:   RntbdOperationType(operationType),
+		ActivityId:      activityIdBytes,
+		RequestHeaders:  requestHeaders,
+		ResponseHeaders: responseHeaders,
+		ContextHeaders:  contextHeaders,
+	}, nil
+}
+
+func parseRntbdToken(reader *bufio.Reader) (any, error) {
+	tokenTypeBytes := readBytes(reader, 1)
+	tokenType := RntbdTokenType(tokenTypeBytes[0])
+
+	switch tokenType {
+	case RntbdTokenTypeByte:
+		token := readBytes(reader, 1)
+		return token, nil
+	case RntbdTokenTypeUShort:
+		token := binary.LittleEndian.Uint16(readBytes(reader, 2))
+		return token, nil
+	case RntbdTokenTypeULong:
+		token := binary.LittleEndian.Uint32(readBytes(reader, 4))
+		return token, nil
+	case RntbdTokenTypeLong:
+		token := int32(binary.LittleEndian.Uint32(readBytes(reader, 4)))
+		return token, nil
+	case RntbdTokenTypeULongLong:
+		token := binary.LittleEndian.Uint64(readBytes(reader, 8))
+		return token, nil
+	case RntbdTokenTypeLongLong:
+		token := int64(binary.LittleEndian.Uint64(readBytes(reader, 8)))
+		return token, nil
+	case RntbdTokenTypeGuid:
+		token := readBytes(reader, 16)
+		return token, nil
+	case RntbdTokenTypeSmallString:
+		lengthBytes := readBytes(reader, 1)
+		length := uint8(lengthBytes[0])
+		token := readBytes(reader, int(length))
+		return string(token), nil
+	case RntbdTokenTypeString:
+		length := binary.LittleEndian.Uint16(readBytes(reader, 2))
+		token := readBytes(reader, int(length))
+		return string(token), nil
+	case RntbdTokenTypeULongString:
+		length := binary.LittleEndian.Uint32(readBytes(reader, 4))
+		token := readBytes(reader, int(length))
+		return string(token), nil
+	case RntbdTokenTypeSmallBytes:
+		lengthBytes := readBytes(reader, 1)
+		length := uint8(lengthBytes[0])
+		token := readBytes(reader, int(length))
+		return token, nil
+	case RntbdTokenTypeBytes:
+		length := binary.LittleEndian.Uint16(readBytes(reader, 2))
+		token := readBytes(reader, int(length))
+		return token, nil
+	case RntbdTokenTypeULongBytes:
+		length := binary.LittleEndian.Uint32(readBytes(reader, 4))
+		token := readBytes(reader, int(length))
+		return token, nil
+	case RntbdTokenTypeFloat:
+		// I can't be bothered to implement this, let's just return a byte array
+		token := readBytes(reader, 4)
+		return token, nil
+	case RntbdTokenTypeDouble:
+		// I can't be bothered to implement this, let's just return a byte array
+		token := readBytes(reader, 8)
+		return token, nil
+	case RntbdTokenTypeInvalid:
+		return nil, fmt.Errorf("invalid token type")
+	}
+
+	return nil, fmt.Errorf("invalid token type")
+}
+
+func readBytes(reader *bufio.Reader, n int) []byte {
+	bytes := make([]byte, n)
+	_, err := io.ReadFull(reader, bytes)
+	if err != nil {
+		logger.ErrorLn("Error reading bytes:", err)
+		os.Exit(0)
+	}
+
+	return bytes
+}

internal/rntbd/server.go

@@ -0,0 +1,120 @@
+package rntbd
+
+import (
+	"bufio"
+	"crypto/tls"
+	"fmt"
+	"net"
+	"net/http/httptest"
+
+	"github.com/pikami/cosmium/api"
+	"github.com/pikami/cosmium/internal/logger"
+	tlsprovider "github.com/pikami/cosmium/internal/tls_provider"
+)
+
+type RntbdServer struct {
+	port      int
+	listener  net.Listener
+	apiServer *api.ApiServer
+}
+
+func NewRntbdServer(port int, apiServer *api.ApiServer) *RntbdServer {
+	return &RntbdServer{port: port, apiServer: apiServer}
+}
+
+func (s *RntbdServer) Start() error {
+	tlsConfig := tlsprovider.GetDefaultTlsConfig()
+	listener, err := tls.Listen("tcp", fmt.Sprintf(":%d", s.port), tlsConfig)
+	if err != nil {
+		return fmt.Errorf("failed to listen on port %d: %w", s.port, err)
+	}
+	s.listener = listener
+
+	go func() {
+		for {
+			conn, err := s.listener.Accept()
+			if err != nil {
+				logger.ErrorLn("Failed to accept connection:", err)
+				continue
+			}
+
+			go s.handleConnection(conn)
+		}
+	}()
+
+	return nil
+}
+
+func (s *RntbdServer) Stop() error {
+	return s.listener.Close()
+}
+
+func (s *RntbdServer) handleConnection(conn net.Conn) {
+	defer conn.Close()
+
+	reader := bufio.NewReader(conn)
+	writer := bufio.NewWriter(conn)
+
+	for {
+		_, err := reader.Peek(4)
+		if err != nil {
+			return
+		}
+
+		frame, err := ReadFrame(reader)
+		if err != nil {
+			logger.ErrorLn("Failed to read frame:", err)
+			continue
+		}
+
+		if frame.ResourceType == RntbdResourceTypeConnection {
+			responseFrame := buildContextFrame(frame)
+			_, err := writer.Write(responseFrame)
+			writer.Flush()
+			if err != nil {
+				logger.ErrorLn("Failed to write response frame:", err)
+				continue
+			}
+			continue
+		} else if frame.ResourceType == RntbdResourceTypeDatabase ||
+			frame.ResourceType == RntbdResourceTypeCollection ||
+			frame.ResourceType == RntbdResourceTypeDocument {
+			responseFrameBytes := s.passToApiServer(frame)
+			_, err := writer.Write(responseFrameBytes)
+			writer.Flush()
+			if err != nil {
+				logger.ErrorLn("Failed to write response frame:", err)
+				continue
+			}
+			continue
+		} else {
+			logger.Errorf("Received Unhandled RNTBD request from: %s with resource type: %s\n", conn.RemoteAddr(), frame.ResourceType.String())
+		}
+	}
+}
+
+func (s *RntbdServer) passToApiServer(frame *RntbdFrame) []byte {
+	req := frame.ToHttpRequest()
+	responseWriter := httptest.NewRecorder()
+	s.apiServer.GetRouter().ServeHTTP(responseWriter, req)
+
+	responseFrameBuilder := ToRntbdResponseFrame(responseWriter)
+	responseFrameBuilder.SetActivityId(frame.ActivityId)
+	if transportRequestId, ok := frame.RequestHeaders[RntbdRequestHeaderTransportRequestID]; ok {
+		responseFrameBuilder.AddHeader(uint16(RntbdResponseHeaderTransportRequestID), RntbdTokenTypeULong, transportRequestId)
+	}
+
+	responseFrameBuilder.AddHeader(uint16(RntbdResponseHeaderItemLSN), RntbdTokenTypeLongLong, int64(420))
+	responseFrameBuilder.AddHeader(uint16(RntbdResponseHeaderLocalLSN), RntbdTokenTypeLongLong, int64(420))
+	responseFrameBuilder.AddHeader(uint16(RntbdResponseHeaderGlobalCommittedLSN), RntbdTokenTypeLongLong, int64(420))
+	responseFrameBuilder.AddHeader(uint16(RntbdResponseHeaderItemLocalLSN), RntbdTokenTypeLongLong, int64(420))
+	responseFrameBuilder.AddHeader(uint16(RntbdResponseHeaderLSN), RntbdTokenTypeLongLong, int64(420))
+	responseFrameBuilder.AddHeader(uint16(RntbdResponseHeaderQuorumAckedLSN), RntbdTokenTypeLongLong, int64(420))
+	responseFrameBuilder.AddHeader(uint16(RntbdResponseHeaderQuorumAckedLocalLSN), RntbdTokenTypeLongLong, int64(420))
+	responseFrameBuilder.AddHeader(uint16(RntbdResponseHeaderCurrentReplicaSetSize), RntbdTokenTypeULong, uint32(1))
+
+	responseFrame := responseFrameBuilder.Build()
+	responseFrameBytes := responseFrame.ToBytes()
+
+	return responseFrameBytes
+}

parsers/models.go

@@ -107,6 +107,7 @@ const (
 	FunctionCallContains     FunctionCallType = "Contains"
 	FunctionCallEndsWith     FunctionCallType = "EndsWith"
 	FunctionCallStartsWith   FunctionCallType = "StartsWith"
+	FunctionCallRegexMatch   FunctionCallType = "RegexMatch"
 	FunctionCallIndexOf      FunctionCallType = "IndexOf"
 	FunctionCallToString     FunctionCallType = "ToString"
 	FunctionCallUpper        FunctionCallType = "Upper"

parsers/nosql/misc_test.go

@@ -112,6 +112,65 @@ func Test_Parse(t *testing.T) {
 		)
 	})
 
+	t.Run("Should parse NOT IN function", func(t *testing.T) {
+		testQueryParse(
+			t,
+			`SELECT c.id FROM c WHERE c.id NOT IN ("123", "456")`,
+			parsers.SelectStmt{
+				SelectItems: []parsers.SelectItem{
+					{
+						Path: []string{"c", "id"},
+						Type: parsers.SelectItemTypeField,
+					},
+				},
+				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Filters: parsers.SelectItem{
+					Type:   parsers.SelectItemTypeFunctionCall,
+					Invert: true,
+					Value: parsers.FunctionCall{
+						Type: parsers.FunctionCallIn,
+						Arguments: []interface{}{
+							parsers.SelectItem{
+								Path: []string{"c", "id"},
+								Type: parsers.SelectItemTypeField,
+							},
+							testutils.SelectItem_Constant_String("123"),
+							testutils.SelectItem_Constant_String("456"),
+						},
+					},
+				},
+			},
+		)
+	})
+
+	t.Run("Should parse NOT with parentheses", func(t *testing.T) {
+		testQueryParse(
+			t,
+			`SELECT c.id FROM c WHERE NOT (c.id IN ("123", "456"))`,
+			parsers.SelectStmt{
+				SelectItems: []parsers.SelectItem{
+					{Path: []string{"c", "id"}, Type: parsers.SelectItemTypeField},
+				},
+				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Filters: parsers.SelectItem{
+					Type:   parsers.SelectItemTypeFunctionCall,
+					Invert: true,
+					Value: parsers.FunctionCall{
+						Type: parsers.FunctionCallIn,
+						Arguments: []interface{}{
+							parsers.SelectItem{
+								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,

parsers/nosql/nosql.peg

@@ -387,7 +387,11 @@ 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
+ExcludedKeywords <- (
+    Select / Top / As / From / In / Join / Exists / Where / And / Or / Not / Offset /
+    ("GROUP"i wss "BY"i) /
+    ("ORDER"i wss "BY"i)
+) ![a-zA-Z0-9_]
 
 DotFieldAccess <- "." id:Identifier {
     return id, nil
@@ -425,7 +429,15 @@ MulDivExpression <- left:SelectItemWithParentheses operations:(ws op:MultiplyOrD
     return makeMathExpression(left, operations)
 }
 
-SelectItemWithParentheses <- "(" ws ex:OrExpression ws ")" { return ex, nil }
+SelectItemWithParentheses <- inv:(Not ws)? "(" ws ex:OrExpression ws ")" {
+    if inv != nil {
+        if ex1, ok := ex.(parsers.SelectItem); ok {
+            ex1.Invert = true
+            return ex1, nil
+        }
+    }
+    return ex, nil
+}
     / inv:(Not ws)? ex:SelectItem {
     if inv != nil {
         ex1 := ex.(parsers.SelectItem)
@@ -501,6 +513,8 @@ IntegerLiteral <- number:Integer {
 }
 StringLiteral <- "\"" chars:StringCharacter* "\"" {
     return parsers.Constant{Type: parsers.ConstantTypeString,Value: joinStrings(chars.([]interface{}))}, nil
+} / "'" chars:SingleQuotedStringCharacter* "'" {
+    return parsers.Constant{Type: parsers.ConstantTypeString,Value: joinStrings(chars.([]interface{}))}, nil
 }
 FloatLiteral <- [0-9]+"."[0-9]+ {
     floatValue, _ := strconv.ParseFloat(string(c.text), 64)
@@ -673,6 +687,8 @@ ThreeArgumentStringFunctionExpression <- function:ThreeArgumentStringFunction ws
         functionType = parsers.FunctionCallEndsWith
     case "STARTSWITH":
         functionType = parsers.FunctionCallStartsWith
+    case "REGEXMATCH":
+        functionType = parsers.FunctionCallRegexMatch
     case "INDEX_OF":
         functionType = parsers.FunctionCallIndexOf
     }
@@ -680,7 +696,7 @@ ThreeArgumentStringFunctionExpression <- function:ThreeArgumentStringFunction ws
     return createFunctionCall(functionType, []interface{}{ex1, ex2, ignoreCase})
 }
 
-ThreeArgumentStringFunction <- ("CONTAINS"i / "ENDSWITH"i / "STARTSWITH"i / "INDEX_OF"i) {
+ThreeArgumentStringFunction <- ("CONTAINS"i / "ENDSWITH"i / "STARTSWITH"i / "REGEXMATCH"i / "INDEX_OF"i) {
     return string(c.text), nil
 }
 
@@ -803,10 +819,33 @@ MathNumberBinExpression <- "NumberBin"i ws "(" ws ex1:SelectItem others:(ws ","
 MathPiExpression <- "PI"i ws "(" ws ")" { return createFunctionCall(parsers.FunctionCallMathPi, []interface{}{}) }
 MathRandExpression <- "RAND"i ws "(" ws ")" { return createFunctionCall(parsers.FunctionCallMathRand, []interface{}{}) }
 
-InFunction <- ex1:SelectProperty ws In ws "(" ws ex2:SelectItem others:(ws "," ws ex:SelectItem { return ex, nil })* ws ")" {
-    return createFunctionCall(parsers.FunctionCallIn, append([]interface{}{ex1, ex2}, others.([]interface{})...))
-} / "(" ws ex1:SelectItem ws In ws "(" ws ex2:SelectItem others:(ws "," ws ex:SelectItem { return ex, nil })* ws ")" ws ")" {
-    return createFunctionCall(parsers.FunctionCallIn, append([]interface{}{ex1, ex2}, others.([]interface{})...))
+InFunction <- ex1:SelectProperty ws notIn:("NOT"i ws)? In ws "(" ws ex2:SelectItem others:(ws "," ws ex:SelectItem { return ex, nil })* ws ")" {
+    arguments := append([]interface{}{ex1, ex2}, others.([]interface{})...)
+    functionCall, _ := createFunctionCall(parsers.FunctionCallIn, arguments)
+    
+    if notIn != nil {
+        return parsers.SelectItem{
+            Type: parsers.SelectItemTypeFunctionCall,
+            Value: functionCall,
+            Invert: true,
+        }, nil
+    }
+    
+    return functionCall, nil
+}
+/ "(" ws ex1:SelectItem ws notIn:("NOT"i ws)? In ws "(" ws ex2:SelectItem others:(ws "," ws ex:SelectItem { return ex, nil })* ws ")" ws ")" {
+    arguments := append([]interface{}{ex1, ex2}, others.([]interface{})...)
+    functionCall, _ := createFunctionCall(parsers.FunctionCallIn, arguments)
+
+    if notIn != nil {
+        return parsers.SelectItem{
+            Type: parsers.SelectItemTypeFunctionCall,
+            Value: functionCall,
+            Invert: true,
+        }, nil
+    }
+    
+    return functionCall, nil
 }
 
 AvgAggregateExpression   <- "AVG"i "(" ws ex:SelectItem  ws ")" {
@@ -836,11 +875,14 @@ Integer <- [0-9]+ {
 StringCharacter <- !('"' / "\\") . { return string(c.text), nil }
   / "\\" seq:EscapeSequenceCharacter { return seq, nil }
 
+SingleQuotedStringCharacter <- !("'" / "\\") . { return string(c.text), nil }
+  / "\\" seq:EscapeSequenceCharacter { return seq, nil }
+
 EscapeSequenceCharacter <- char:EscapeCharacter
 
-EscapeCharacter <- "'"
-  / '"'
-  / "\\"
+EscapeCharacter <- "'" { return "'", nil }
+  / '"' { return "\"", nil }
+  / "\\" { return "\\", nil }
   / "b" { return "\b", nil }
   / "f" { return "\f", nil }
   / "n" { return "\n", nil }

parsers/nosql/select_test.go

@@ -159,6 +159,26 @@ func Test_Parse_Select(t *testing.T) {
 		)
 	})
 
+	t.Run("Should parse SELECT with orderByItems alias", func(t *testing.T) {
+		testQueryParse(
+			t,
+			`SELECT c.id, c["pk"] AS orderByItems FROM c ORDER BY c.id`,
+			parsers.SelectStmt{
+				SelectItems: []parsers.SelectItem{
+					{Path: []string{"c", "id"}},
+					{Alias: "orderByItems", Path: []string{"c", "pk"}},
+				},
+				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				OrderExpressions: []parsers.OrderExpression{
+					{
+						SelectItem: testutils.SelectItem_Path("c", "id"),
+						Direction:  parsers.OrderDirectionAsc,
+					},
+				},
+			},
+		)
+	})
+
 	t.Run("Should parse SELECT object", func(t *testing.T) {
 		testQueryParse(
 			t,

parsers/nosql/string_functions_test.go

@@ -168,6 +168,32 @@ func Test_Execute_StringFunctions(t *testing.T) {
 		)
 	})
 
+	t.Run("Should parse function REGEXMATCH()", func(t *testing.T) {
+		testQueryParse(
+			t,
+			`SELECT REGEXMATCH(c.id, "aB c", "ix") FROM c`,
+			parsers.SelectStmt{
+				SelectItems: []parsers.SelectItem{
+					{
+						Type: parsers.SelectItemTypeFunctionCall,
+						Value: parsers.FunctionCall{
+							Type: parsers.FunctionCallRegexMatch,
+							Arguments: []interface{}{
+								parsers.SelectItem{
+									Path: []string{"c", "id"},
+									Type: parsers.SelectItemTypeField,
+								},
+								testutils.SelectItem_Constant_String("aB c"),
+								testutils.SelectItem_Constant_String("ix"),
+							},
+						},
+					},
+				},
+				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+			},
+		)
+	})
+
 	t.Run("Should parse function INDEX_OF()", func(t *testing.T) {
 		testQueryParse(
 			t,

parsers/nosql/were_test.go

@@ -149,6 +149,32 @@ func Test_Parse_Were(t *testing.T) {
 		)
 	})
 
+	t.Run("Should correctly parse single-quoted string literals", func(t *testing.T) {
+		testQueryParse(
+			t,
+			`SELECT c.id FROM c WHERE c.id = '12345' AND c.string = 'it\'s'`,
+			parsers.SelectStmt{
+				SelectItems: []parsers.SelectItem{{Path: []string{"c", "id"}}},
+				Table:       parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Filters: parsers.LogicalExpression{
+					Operation: parsers.LogicalExpressionTypeAnd,
+					Expressions: []interface{}{
+						parsers.ComparisonExpression{
+							Operation: "=",
+							Left:      parsers.SelectItem{Path: []string{"c", "id"}},
+							Right:     testutils.SelectItem_Constant_String("12345"),
+						},
+						parsers.ComparisonExpression{
+							Operation: "=",
+							Left:      parsers.SelectItem{Path: []string{"c", "string"}},
+							Right:     testutils.SelectItem_Constant_String("it's"),
+						},
+					},
+				},
+			},
+		)
+	})
+
 	t.Run("Should correctly parse NOT conditions", func(t *testing.T) {
 		testQueryParse(
 			t,

query_executors/memory_executor/array_functions.go

@@ -25,7 +25,7 @@ func (r rowContext) array_Contains(arguments []interface{}) bool {
 	exprToSearch := r.resolveSelectItem(arguments[1].(parsers.SelectItem))
 
 	partialSearch := false
-	if len(arguments) > 2 {
+	if len(arguments) > 2 && arguments[2] != nil {
 		boolExpr := r.resolveSelectItem(arguments[2].(parsers.SelectItem))
 		if boolValue, ok := boolExpr.(bool); ok {
 			partialSearch = boolValue

query_executors/memory_executor/common.go

@@ -162,6 +162,8 @@ func (r rowContext) selectItem_SelectItemTypeFunctionCall(functionCall parsers.F
 		return r.strings_EndsWith(functionCall.Arguments)
 	case parsers.FunctionCallStartsWith:
 		return r.strings_StartsWith(functionCall.Arguments)
+	case parsers.FunctionCallRegexMatch:
+		return r.strings_RegexMatch(functionCall.Arguments)
 	case parsers.FunctionCallConcat:
 		return r.strings_Concat(functionCall.Arguments)
 	case parsers.FunctionCallIndexOf:

query_executors/memory_executor/memory_executor.go

@@ -5,18 +5,46 @@ import (
 	"github.com/pikami/cosmium/parsers"
 )
 
-func ExecuteQuery(query parsers.SelectStmt, documents rowTypeIterator) []RowType {
+type ExecuteQueryResult struct {
+	Rows         []RowType
+	HasMorePages bool
+}
+
+func ExecuteQuery(
+	query parsers.SelectStmt,
+	documents rowTypeIterator,
+	offset int,
+	limit int,
+) ExecuteQueryResult {
 	resultIter := executeQuery(query, &rowTypeToRowContextIterator{documents: documents, query: query})
-	result := make([]RowType, 0)
-	for {
+
+	result := &ExecuteQueryResult{
+		Rows:         make([]RowType, 0),
+		HasMorePages: false,
+	}
+
+	for i := 0; i < offset; i++ {
+		_, status := resultIter.Next()
+		if status != datastore.StatusOk {
+			break
+		}
+	}
+
+	for i := 0; i < limit; i++ {
 		row, status := resultIter.Next()
 		if status != datastore.StatusOk {
 			break
 		}
 
-		result = append(result, row)
+		result.Rows = append(result.Rows, row)
 	}
-	return result
+
+	_, status := resultIter.Next()
+	if status == datastore.StatusOk {
+		result.HasMorePages = true
+	}
+
+	return *result
 }
 
 func executeQuery(query parsers.SelectStmt, documents rowIterator) rowTypeIterator {

query_executors/memory_executor/misc_test.go

@@ -38,10 +38,10 @@ func testQueryExecute(
 	expectedData []memoryexecutor.RowType,
 ) {
 	iter := NewTestDocumentIterator(data)
-	result := memoryexecutor.ExecuteQuery(query, iter)
+	result := memoryexecutor.ExecuteQuery(query, iter, 0, 1000)
 
-	if !reflect.DeepEqual(result, expectedData) {
-		t.Errorf("execution result does not match expected data.\nExpected: %+v\nGot: %+v", expectedData, result)
+	if !reflect.DeepEqual(result.Rows, expectedData) {
+		t.Errorf("execution result does not match expected data.\nExpected: %+v\nGot: %+v", expectedData, result.Rows)
 	}
 }
 
@@ -149,6 +149,41 @@ func Test_Execute(t *testing.T) {
 		)
 	})
 
+	t.Run("Should execute NOT IN function", func(t *testing.T) {
+		testQueryExecute(
+			t,
+			parsers.SelectStmt{
+				SelectItems: []parsers.SelectItem{
+					{
+						Path: []string{"c", "id"},
+						Type: parsers.SelectItemTypeField,
+					},
+				},
+				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+				Filters: parsers.SelectItem{
+					Type:   parsers.SelectItemTypeFunctionCall,
+					Invert: true,
+					Value: parsers.FunctionCall{
+						Type: parsers.FunctionCallIn,
+						Arguments: []interface{}{
+							parsers.SelectItem{
+								Path: []string{"c", "id"},
+								Type: parsers.SelectItemTypeField,
+							},
+							testutils.SelectItem_Constant_String("123"),
+							testutils.SelectItem_Constant_String("456"),
+						},
+					},
+				},
+			},
+			mockData,
+			[]memoryexecutor.RowType{
+				map[string]interface{}{"id": "12345"},
+				map[string]interface{}{"id": "67890"},
+			},
+		)
+	})
+
 	t.Run("Should execute IN function with function call", func(t *testing.T) {
 		testQueryExecute(
 			t,

query_executors/memory_executor/string_functions.go

@@ -2,6 +2,7 @@ package memoryexecutor
 
 import (
 	"fmt"
+	"regexp"
 	"strings"
 
 	"github.com/pikami/cosmium/internal/logger"
@@ -75,6 +76,46 @@ func (r rowContext) strings_StartsWith(arguments []interface{}) bool {
 	return strings.HasPrefix(str1, str2)
 }
 
+func (r rowContext) strings_RegexMatch(arguments []interface{}) bool {
+	value, valueOk := r.parseString(arguments[0])
+	pattern, patternOk := r.parseString(arguments[1])
+	if !valueOk || !patternOk {
+		return false
+	}
+
+	modifiers, ok := r.getStringFlag(arguments)
+	if !ok {
+		return false
+	}
+
+	regexPattern := pattern
+	if strings.Contains(modifiers, "x") {
+		regexPattern = stripRegexIgnoredWhitespace(regexPattern)
+	}
+
+	var flags strings.Builder
+	if strings.Contains(modifiers, "i") {
+		flags.WriteByte('i')
+	}
+	if strings.Contains(modifiers, "m") {
+		flags.WriteByte('m')
+	}
+	if strings.Contains(modifiers, "s") {
+		flags.WriteByte('s')
+	}
+	if flags.Len() > 0 {
+		regexPattern = "(?" + flags.String() + ")" + regexPattern
+	}
+
+	matched, err := regexp.MatchString(regexPattern, value)
+	if err != nil {
+		logger.Errorf("strings_RegexMatch - invalid pattern %q: %v", pattern, err)
+		return false
+	}
+
+	return matched
+}
+
 func (r rowContext) strings_Concat(arguments []interface{}) string {
 	result := ""
 
@@ -318,6 +359,20 @@ func (r rowContext) getBoolFlag(arguments []interface{}) bool {
 	return ignoreCase
 }
 
+func (r rowContext) getStringFlag(arguments []interface{}) (string, bool) {
+	if len(arguments) <= 2 || arguments[2] == nil {
+		return "", true
+	}
+
+	flagItem := arguments[2].(parsers.SelectItem)
+	if value, ok := r.resolveSelectItem(flagItem).(string); ok {
+		return value, true
+	}
+
+	logger.ErrorLn("getStringFlag - got parameters of wrong type")
+	return "", false
+}
+
 func (r rowContext) parseString(argument interface{}) (value string, ok bool) {
 	exItem := argument.(parsers.SelectItem)
 	ex := r.resolveSelectItem(exItem)
@@ -329,6 +384,41 @@ func (r rowContext) parseString(argument interface{}) (value string, ok bool) {
 	return "", false
 }
 
+func stripRegexIgnoredWhitespace(pattern string) string {
+	var result strings.Builder
+	inCharClass := false
+	escaped := false
+
+	for _, r := range pattern {
+		if escaped {
+			result.WriteRune(r)
+			escaped = false
+			continue
+		}
+
+		if r == '\\' {
+			result.WriteRune(r)
+			escaped = true
+			continue
+		}
+
+		switch r {
+		case '[':
+			inCharClass = true
+		case ']':
+			inCharClass = false
+		}
+
+		if !inCharClass && (r == ' ' || r == '\t' || r == '\n' || r == '\r' || r == '\f') {
+			continue
+		}
+
+		result.WriteRune(r)
+	}
+
+	return result.String()
+}
+
 func convertToString(value interface{}) string {
 	switch v := value.(type) {
 	case string:

query_executors/memory_executor/string_functions_test.go

@@ -231,6 +231,42 @@ func Test_Execute_StringFunctions(t *testing.T) {
 		)
 	})
 
+	t.Run("Should execute function REGEXMATCH()", func(t *testing.T) {
+		testQueryExecute(
+			t,
+			parsers.SelectStmt{
+				SelectItems: []parsers.SelectItem{
+					{
+						Path: []string{"c", "id"},
+						Type: parsers.SelectItemTypeField,
+					},
+					{
+						Alias: "regexMatch",
+						Type:  parsers.SelectItemTypeFunctionCall,
+						Value: parsers.FunctionCall{
+							Type: parsers.FunctionCallRegexMatch,
+							Arguments: []interface{}{
+								parsers.SelectItem{
+									Path: []string{"c", "str"},
+									Type: parsers.SelectItemTypeField,
+								},
+								testutils.SelectItem_Constant_String("COOL WORLD"),
+								testutils.SelectItem_Constant_String("i"),
+							},
+						},
+					},
+				},
+				Table: parsers.Table{SelectItem: testutils.SelectItem_Path("c")},
+			},
+			mockData,
+			[]memoryexecutor.RowType{
+				map[string]interface{}{"id": "123", "regexMatch": false},
+				map[string]interface{}{"id": "456", "regexMatch": false},
+				map[string]interface{}{"id": "789", "regexMatch": true},
+			},
+		)
+	})
+
 	t.Run("Should execute function INDEX_OF()", func(t *testing.T) {
 		testQueryExecute(
 			t,

sharedlibrary/sharedlibrary.go

@@ -38,6 +38,7 @@ func CreateServerInstance(serverName *C.char, configurationJSON *C.char) int {
 	switch configuration.DataStore {
 	case config.DataStoreBadger:
 		dataStore = badgerdatastore.NewBadgerDataStore(badgerdatastore.BadgerDataStoreOptions{
+			InitialDataFilePath: configuration.InitialDataFilePath,
 			PersistDataFilePath: configuration.PersistDataFilePath,
 		})
 	default:

sharedlibrary/tests/main.c

@@ -7,6 +7,9 @@ int test_Databases();
 
 int main(int argc, char *argv[])
 {
+    /* Disable stdout buffering for CI environments without a real terminal */
+    setvbuf(stdout, NULL, _IONBF, 0);
+
     if (argc < 2)
     {
         fprintf(stderr, "Usage: %s <path_to_shared_library>\n", argv[0]);
@@ -14,13 +17,20 @@ int main(int argc, char *argv[])
     }
 
     const char *libPath = argv[1];
-    handle = dlopen(libPath, RTLD_LAZY);
+    handle = load_library(libPath);
     if (!handle)
     {
-        fprintf(stderr, "Failed to load shared library: %s\n", dlerror());
+        fprintf(stderr, "Failed to load shared library: %s\n", get_load_error());
         return EXIT_FAILURE;
     }
 
+    /* give the loaded library a short time to initialize */
+#ifdef _WIN32
+    Sleep(1000);
+#else
+    sleep(1);
+#endif
+
     printf("Running tests for library: %s\n", libPath);
     int results[] = {
         test_CreateServerInstance(),
@@ -41,6 +51,15 @@ int main(int argc, char *argv[])
 
     printf("Tests passed: %d/%d\n", numPassed, numTests);
 
-    dlclose(handle);
-    return EXIT_SUCCESS;
+    /* Exit explicitly before unloading the library.
+       Go runtime cleanup during FreeLibrary can set a non-zero exit code on Windows. */
+    int exitCode = (numPassed == numTests) ? EXIT_SUCCESS : EXIT_FAILURE;
+
+#ifdef _WIN32
+    ExitProcess(exitCode);
+#else
+    close_library(handle);
+#endif
+
+    return exitCode;
 }

sharedlibrary/tests/shared.c

@@ -1,13 +1,50 @@
 #include "shared.h"
 
-void *handle = NULL;
+lib_handle_t handle = NULL;
+
+char *get_load_error(void)
+{
+#ifdef _WIN32
+    DWORD error = GetLastError();
+    static char buf[256];
+    FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
+                   NULL, error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+                   buf, sizeof(buf), NULL);
+    return buf;
+#else
+    return dlerror();
+#endif
+}
+
+lib_handle_t load_library(const char *path)
+{
+#ifdef _WIN32
+    return LoadLibraryA(path);
+#else
+    return dlopen(path, RTLD_LAZY);
+#endif
+}
+
+void close_library(lib_handle_t handle)
+{
+#ifdef _WIN32
+    FreeLibrary(handle);
+#else
+    dlclose(handle);
+#endif
+}
 
 void *load_function(const char *func_name)
 {
+#ifdef _WIN32
+    void *func = (void *)GetProcAddress(handle, func_name);
+#else
     void *func = dlsym(handle, func_name);
+#endif
+    
     if (!func)
     {
-        fprintf(stderr, "Failed to load function %s: %s\n", func_name, dlerror());
+        fprintf(stderr, "Failed to load function %s: %s\n", func_name, get_load_error());
     }
     return func;
 }

sharedlibrary/tests/shared.h

@@ -3,13 +3,24 @@
 
 #include <stdio.h>
 #include <stdlib.h>
-#include <dlfcn.h>
 #include <string.h>
 #include <ctype.h>
 
-extern void *handle;
+#ifdef _WIN32
+    #include <unistd.h>
+    #include <windows.h>
+    typedef HMODULE lib_handle_t;
+#else
+    #include <dlfcn.h>
+    typedef void* lib_handle_t;
+#endif
+
+extern lib_handle_t handle;
 
 void *load_function(const char *func_name);
 char *compact_json(const char *json);
+char *get_load_error(void);
+lib_handle_t load_library(const char *path);
+void close_library(lib_handle_t handle);
 
 #endif

sharedlibrary/tests/test_databases.c

@@ -2,6 +2,16 @@
 
 int test_Databases()
 {
+    /* Load FreeMemory function - must use this to free memory allocated by the DLL
+       because the DLL may use a different C runtime heap than the test loader */
+    typedef void (*FreeMemoryFn)(char *);
+    FreeMemoryFn FreeMemory = (FreeMemoryFn)load_function("FreeMemory");
+    if (!FreeMemory)
+    {
+        fprintf(stderr, "Failed to find FreeMemory function\n");
+        return 0;
+    }
+
     typedef int (*CreateDatabaseFn)(char *, char *);
     CreateDatabaseFn CreateDatabase = (CreateDatabaseFn)load_function("CreateDatabase");
     if (!CreateDatabase)
@@ -36,6 +46,7 @@ int test_Databases()
     if (database)
     {
         printf("GetDatabase: SUCCESS (database = %s)\n", database);
+        FreeMemory(database);
     }
     else
     {

sharedlibrary/tests/test_instance_state.c

@@ -2,6 +2,16 @@
 
 int test_ServerInstanceStateMethods()
 {
+    /* Load FreeMemory function - must use this to free memory allocated by the DLL
+       because the DLL may use a different C runtime heap than the test loader */
+    typedef void (*FreeMemoryFn)(char *);
+    FreeMemoryFn FreeMemory = (FreeMemoryFn)load_function("FreeMemory");
+    if (!FreeMemory)
+    {
+        fprintf(stderr, "Failed to find FreeMemory function\n");
+        return 0;
+    }
+
     typedef int (*LoadServerInstanceStateFn)(char *, char *);
     LoadServerInstanceStateFn LoadServerInstanceState = (LoadServerInstanceStateFn)load_function("LoadServerInstanceState");
     if (!LoadServerInstanceState)
@@ -46,7 +56,7 @@ int test_ServerInstanceStateMethods()
     char *compact_state = compact_json(state);
     if (!compact_state)
     {
-        free(state);
+        FreeMemory(state);
         return 0;
     }
 
@@ -59,10 +69,12 @@ int test_ServerInstanceStateMethods()
         printf("GetServerInstanceState: State does not match expected value.\n");
         printf("Expected: %s\n", expected_state);
         printf("Actual:   %s\n", compact_state);
+        FreeMemory(state);
+        free(compact_state);
         return 0;
     }
 
-    free(state);
+    FreeMemory(state);
     free(compact_state);
     return 1;
 }