bun-sqlite-for-rxdb 1.4.0 → 1.5.0

package/README.md

@@ -4,33 +4,29 @@
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-## Features
+RxDB storage adapter that translates Mango queries directly to bun:sqlite (except of $regex), bypassing slow in-memory filtering.
 
-- ✅ Uses Bun's native SQLite
-- ✅ **260/260 tests passing** (138 local + 122 official RxDB tests)
-- ✅ Full RxDB storage interface implementation
+## Features
+- ✅ **17 Mango operators** directly using SQL ($eq, $ne, $gt, $gte, $lt, $lte, $in, $nin, $or, $and, $exists, $elemMatch, $not, $nor, $type, $size, $mod)
+- ✅ **1 Mango operator optimized in memory** (complex $regex)
+- ✅ **Smart regex** - converts simple patterns to SQL LIKE (uses indexes)
 - ✅ **Attachments support** (base64 storage with digest validation)
-- ✅ **Query builder LRU cache** (5.2-57.9x speedup for repeated queries)
-- ✅ **18 Mango operators** ($eq, $ne, $gt, $gte, $lt, $lte, $in, $nin, $or, $and, $exists, $regex, $elemMatch, $not, $nor, $type, $size, $mod)
+
 - ✅ **Multi-instance support** with connection pooling
-- ✅ **1.06-1.68x faster than better-sqlite3** (with WAL mode)
+- ✅ **Dual LRU caching** - prepared statements + query AST parsing
+- ✅ **Property-based testing** with fast-check (3000+ assertions vs Mingo and Sift.js)
 - ✅ MIT licensed
 
 ## Performance
 
+### Database Performance
 Benchmarked against better-sqlite3 (1M documents, WAL mode + PRAGMA synchronous = 1):
 
 | Operation | Bun SQLite | better-sqlite3 | Speedup |
 |-----------|------------|----------------|---------|
 | Bulk INSERT (1M docs) | 7.42s | 7.90s | **1.06x faster** |
 | SELECT by ID (10K lookups) | 170ms | 170ms | Equal |
-| Complex WHERE query | 484ms | 814ms | **1.68x faster** |
-
-**Requirements for optimal performance:**
-```typescript
-db.run("PRAGMA journal_mode = WAL");
-db.run("PRAGMA synchronous = 1");
-``` 
+| Complex WHERE query | 484ms | 814ms | **1.68x faster** | 
 
 ## Installation
 
@@ -66,14 +62,6 @@ bun test
 bun run typecheck
 ```
 
-## Architecture
-
-**Key components:**
-- `RxStorage` factory
-- `RxStorageInstance` implementation (11 required methods)
-- Mango query → SQL translator
-- Change stream observables
-
 ## License
 
 MIT © adam2am

package/dist/index.js

@@ -4,25 +4,43 @@ var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: () => mod[key],
+        get: __accessProp.bind(mod, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod, to);
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 
@@ -12213,12 +12231,23 @@ var import_rxjs2 = __toESM(require_cjs(), 1);
 // src/query/regex-matcher.ts
 var REGEX_CACHE = new Map;
 var MAX_REGEX_CACHE_SIZE = 100;
+function isValidRegexOptions(options) {
+  for (let i = 0;i < options.length; i++) {
+    const c = options[i];
+    if (c !== "i" && c !== "m" && c !== "s" && c !== "x" && c !== "u")
+      return false;
+  }
+  return true;
+}
 function compileRegex(pattern, options) {
   const cacheKey = `${pattern}::${options || ""}`;
   const cached = REGEX_CACHE.get(cacheKey);
   if (cached) {
     return cached.regex;
   }
+  if (options && !isValidRegexOptions(options)) {
+    throw new Error(`Invalid regex options: "${options}". Valid options are: i, m, s, x, u`);
+  }
   const regex = new RegExp(pattern, options);
   if (REGEX_CACHE.size >= MAX_REGEX_CACHE_SIZE) {
     const firstKey = REGEX_CACHE.keys().next().value;
@@ -12302,6 +12331,14 @@ function hasExpressionIndex(fieldName, schema) {
   INDEX_CACHE.set(cacheKey, hasLowerIndex);
   return hasLowerIndex;
 }
+function isValidRegexOptions2(options) {
+  for (let i = 0;i < options.length; i++) {
+    const c = options[i];
+    if (c !== "i" && c !== "m" && c !== "s" && c !== "x" && c !== "u")
+      return false;
+  }
+  return true;
+}
 function isComplexRegex(pattern) {
   return /[*+?()[\]{}|]/.test(pattern.replace(/\\\./g, ""));
 }
@@ -12311,6 +12348,9 @@ function escapeForLike(str) {
 function smartRegexToLike(field, pattern, options, schema, fieldName) {
   if (typeof pattern !== "string")
     return null;
+  if (options && !isValidRegexOptions2(options)) {
+    throw new Error(`Invalid regex options: "${options}". Valid options are: i, m, s, x, u`);
+  }
   const caseInsensitive = options?.includes("i") ?? false;
   const hasLowerIndex = hasExpressionIndex(fieldName, schema);
   const startsWithAnchor = pattern.startsWith("^");
@@ -12349,6 +12389,18 @@ function smartRegexToLike(field, pattern, options, schema, fieldName) {
 }
 
 // src/query/operators.ts
+function normalizeValueForSQLite(value) {
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (value instanceof RegExp) {
+    return JSON.stringify({ source: value.source, flags: value.flags });
+  }
+  if (value === undefined) {
+    return null;
+  }
+  return value;
+}
 function translateEq(field, value, schema, actualFieldName) {
   if (value === null) {
     return { sql: `${field} IS NULL`, args: [] };
@@ -12358,11 +12410,11 @@ function translateEq(field, value, schema, actualFieldName) {
     if (field !== "value" && columnInfo.type === "array") {
       return {
         sql: `EXISTS (SELECT 1 FROM jsonb_each(${field}) WHERE value = ?)`,
-        args: [value]
+        args: [normalizeValueForSQLite(value)]
       };
     }
   }
-  return { sql: `${field} = ?`, args: [value] };
+  return { sql: `${field} = ?`, args: [normalizeValueForSQLite(value)] };
 }
 function translateNe(field, value, schema, actualFieldName) {
   if (value === null) {
@@ -12373,11 +12425,11 @@ function translateNe(field, value, schema, actualFieldName) {
     if (field !== "value" && columnInfo.type === "array") {
       return {
         sql: `NOT EXISTS (SELECT 1 FROM jsonb_each(${field}) WHERE value = ?)`,
-        args: [value]
+        args: [normalizeValueForSQLite(value)]
       };
     }
   }
-  return { sql: `(${field} <> ? OR ${field} IS NULL)`, args: [value] };
+  return { sql: `(${field} <> ? OR ${field} IS NULL)`, args: [normalizeValueForSQLite(value)] };
 }
 function translateGt(field, value, schema, actualFieldName) {
   if (schema && actualFieldName) {
@@ -12385,11 +12437,11 @@ function translateGt(field, value, schema, actualFieldName) {
     if (field !== "value" && columnInfo.type === "array") {
       return {
         sql: `EXISTS (SELECT 1 FROM jsonb_each(${field}) WHERE value > ?)`,
-        args: [value]
+        args: [normalizeValueForSQLite(value)]
       };
     }
   }
-  return { sql: `${field} > ?`, args: [value] };
+  return { sql: `${field} > ?`, args: [normalizeValueForSQLite(value)] };
 }
 function translateGte(field, value, schema, actualFieldName) {
   if (schema && actualFieldName) {
@@ -12397,11 +12449,11 @@ function translateGte(field, value, schema, actualFieldName) {
     if (field !== "value" && columnInfo.type === "array") {
       return {
         sql: `EXISTS (SELECT 1 FROM jsonb_each(${field}) WHERE value >= ?)`,
-        args: [value]
+        args: [normalizeValueForSQLite(value)]
       };
     }
   }
-  return { sql: `${field} >= ?`, args: [value] };
+  return { sql: `${field} >= ?`, args: [normalizeValueForSQLite(value)] };
 }
 function translateLt(field, value, schema, actualFieldName) {
   if (schema && actualFieldName) {
@@ -12409,11 +12461,11 @@ function translateLt(field, value, schema, actualFieldName) {
     if (field !== "value" && columnInfo.type === "array") {
       return {
         sql: `EXISTS (SELECT 1 FROM jsonb_each(${field}) WHERE value < ?)`,
-        args: [value]
+        args: [normalizeValueForSQLite(value)]
       };
     }
   }
-  return { sql: `${field} < ?`, args: [value] };
+  return { sql: `${field} < ?`, args: [normalizeValueForSQLite(value)] };
 }
 function translateLte(field, value, schema, actualFieldName) {
   if (schema && actualFieldName) {
@@ -12421,18 +12473,18 @@ function translateLte(field, value, schema, actualFieldName) {
     if (field !== "value" && columnInfo.type === "array") {
       return {
         sql: `EXISTS (SELECT 1 FROM jsonb_each(${field}) WHERE value <= ?)`,
-        args: [value]
+        args: [normalizeValueForSQLite(value)]
       };
     }
   }
-  return { sql: `${field} <= ?`, args: [value] };
+  return { sql: `${field} <= ?`, args: [normalizeValueForSQLite(value)] };
 }
 function translateIn(field, values, schema, actualFieldName) {
   if (!Array.isArray(values) || values.length === 0) {
     return { sql: "1=0", args: [] };
   }
   const hasNull = values.includes(null);
-  const nonNullValues = values.filter((v) => v !== null);
+  const nonNullValues = values.filter((v) => v !== null).map((v) => normalizeValueForSQLite(v));
   if (nonNullValues.length === 0) {
     return { sql: `${field} IS NULL`, args: [] };
   }
@@ -12465,7 +12517,7 @@ function translateNin(field, values, schema, actualFieldName) {
     return { sql: "1=1", args: [] };
   }
   const hasNull = values.includes(null);
-  const nonNullValues = values.filter((v) => v !== null);
+  const nonNullValues = values.filter((v) => v !== null).map((v) => normalizeValueForSQLite(v));
   if (nonNullValues.length === 0) {
     return { sql: `${field} IS NOT NULL`, args: [] };
   }
@@ -12480,7 +12532,7 @@ function translateNin(field, values, schema, actualFieldName) {
           args: args2
         };
       }
-      return { sql: ninClause2, args: args2 };
+      return { sql: `(${field} IS NULL OR ${ninClause2})`, args: args2 };
     }
   }
   const ninClause = `${field} NOT IN (SELECT value FROM json_each(?))`;
@@ -12491,7 +12543,7 @@ function translateNin(field, values, schema, actualFieldName) {
       args
     };
   }
-  return { sql: ninClause, args };
+  return { sql: `(${field} IS NULL OR ${ninClause})`, args };
 }
 function translateExists(field, exists) {
   return {
@@ -12505,21 +12557,107 @@ function translateRegex(field, pattern, options, schema, fieldName) {
     return smartResult;
   return null;
 }
+var LOGICAL_OPERATORS = new Set(["$and", "$or", "$nor", "$not"]);
+var LEAF_OPERATORS = new Set(["$eq", "$ne", "$gt", "$gte", "$lt", "$lte", "$in", "$nin", "$exists", "$regex", "$type", "$size", "$mod", "$elemMatch"]);
+function isLogicalOperator(key) {
+  return LOGICAL_OPERATORS.has(key);
+}
+function isOperatorObject(obj) {
+  let hasKeys = false;
+  for (const k in obj) {
+    hasKeys = true;
+    if (!k.startsWith("$"))
+      return false;
+  }
+  return hasKeys;
+}
+function handleLogicalOperator(operator, value, schema, baseFieldName) {
+  if (operator === "$not") {
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      const innerFragment = buildElemMatchConditions(value, schema, baseFieldName);
+      if (!innerFragment)
+        return null;
+      return { sql: `NOT (${innerFragment.sql})`, args: innerFragment.args };
+    }
+    return { sql: "1=1", args: [] };
+  }
+  if (!Array.isArray(value))
+    return { sql: "1=0", args: [] };
+  const nestedConditions = value.map((cond) => buildElemMatchConditions(cond, schema, baseFieldName));
+  if (nestedConditions.some((f) => f === null))
+    return null;
+  const joiner = operator === "$and" ? " AND " : operator === "$or" ? " OR " : " AND NOT ";
+  const sql = nestedConditions.map((f) => `(${f.sql})`).join(joiner);
+  return {
+    sql: `(${sql})`,
+    args: nestedConditions.flatMap((f) => f.args)
+  };
+}
+function handleFieldCondition(fieldName, value, schema, baseFieldName) {
+  const propertyField = `json_extract(value, '$.${fieldName}')`;
+  const nestedFieldName = `${baseFieldName}.${fieldName}`;
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+    if (value instanceof RegExp) {
+      return translateLeafOperator("$regex", propertyField, value, schema, nestedFieldName);
+    }
+    if (value instanceof Date) {
+      return translateLeafOperator("$eq", propertyField, value, schema, nestedFieldName);
+    }
+    const valueObj = value;
+    if (Object.keys(valueObj).length === 0) {
+      return { sql: "1=0", args: [] };
+    }
+    if (isOperatorObject(valueObj)) {
+      const fragments2 = [];
+      for (const [op, opValue] of Object.entries(valueObj)) {
+        if (op === "$not") {
+          const innerFragment = handleFieldCondition(fieldName, opValue, schema, baseFieldName);
+          if (!innerFragment)
+            return null;
+          fragments2.push({ sql: `NOT (${innerFragment.sql})`, args: innerFragment.args });
+        } else {
+          const frag = translateLeafOperator(op, propertyField, opValue, schema, nestedFieldName);
+          if (!frag)
+            return null;
+          fragments2.push(frag);
+        }
+      }
+      if (fragments2.some((f) => f === null))
+        return null;
+      return {
+        sql: fragments2.map((f) => f.sql).join(" AND "),
+        args: fragments2.flatMap((f) => f.args)
+      };
+    }
+    const fragments = Object.entries(valueObj).map(([nestedKey, nestedValue]) => {
+      const nestedField = `json_extract(value, '$.${fieldName}.${nestedKey}')`;
+      return translateLeafOperator("$eq", nestedField, nestedValue, schema, `${nestedFieldName}.${nestedKey}`);
+    });
+    if (fragments.some((f) => f === null))
+      return null;
+    return {
+      sql: fragments.map((f) => f.sql).join(" AND "),
+      args: fragments.flatMap((f) => f.args)
+    };
+  }
+  return translateLeafOperator("$eq", propertyField, value, schema, nestedFieldName);
+}
 function buildElemMatchConditions(criteria, schema, baseFieldName) {
   const conditions = [];
   const args = [];
   for (const [key, value] of Object.entries(criteria)) {
-    if (key.startsWith("$")) {
-      const fragment = processOperatorValue("value", { [key]: value }, schema, baseFieldName);
-      conditions.push(fragment.sql);
-      args.push(...fragment.args);
+    let fragment;
+    if (isLogicalOperator(key)) {
+      fragment = handleLogicalOperator(key, value, schema, baseFieldName);
+    } else if (key.startsWith("$")) {
+      fragment = translateLeafOperator(key, "value", value, schema, baseFieldName);
     } else {
-      const propertyField = `json_extract(value, '$.${key}')`;
-      const nestedFieldName = `${baseFieldName}.${key}`;
-      const fragment = processOperatorValue(propertyField, value, schema, nestedFieldName);
-      conditions.push(fragment.sql);
-      args.push(...fragment.args);
+      fragment = handleFieldCondition(key, value, schema, baseFieldName);
     }
+    if (!fragment)
+      return null;
+    conditions.push(fragment.sql);
+    args.push(...fragment.args);
   }
   return {
     sql: conditions.length > 0 ? conditions.join(" AND ") : "1=1",
@@ -12538,6 +12676,8 @@ function translateElemMatch(field, criteria, schema, actualFieldName) {
   }
   if (criteria.$and && Array.isArray(criteria.$and)) {
     const fragments = criteria.$and.map((cond) => buildElemMatchConditions(cond, schema, actualFieldName));
+    if (fragments.some((f) => f === null))
+      return null;
     const sql = fragments.map((f) => f.sql).join(" AND ");
     const args = fragments.flatMap((f) => f.args);
     return {
@@ -12547,6 +12687,8 @@ function translateElemMatch(field, criteria, schema, actualFieldName) {
   }
   if (criteria.$or && Array.isArray(criteria.$or)) {
     const fragments = criteria.$or.map((cond) => buildElemMatchConditions(cond, schema, actualFieldName));
+    if (fragments.some((f) => f === null))
+      return null;
     const sql = fragments.map((f) => f.sql).join(" OR ");
     const args = fragments.flatMap((f) => f.args);
     return {
@@ -12556,6 +12698,8 @@ function translateElemMatch(field, criteria, schema, actualFieldName) {
   }
   if (criteria.$nor && Array.isArray(criteria.$nor)) {
     const fragments = criteria.$nor.map((cond) => buildElemMatchConditions(cond, schema, actualFieldName));
+    if (fragments.some((f) => f === null))
+      return null;
     const sql = fragments.map((f) => f.sql).join(" OR ");
     const args = fragments.flatMap((f) => f.args);
     return {
@@ -12564,129 +12708,104 @@ function translateElemMatch(field, criteria, schema, actualFieldName) {
     };
   }
   const fragment = buildElemMatchConditions(criteria, schema, actualFieldName);
+  if (!fragment)
+    return null;
   return {
     sql: `EXISTS (SELECT 1 FROM jsonb_each(${field}) WHERE ${fragment.sql})`,
     args: fragment.args
   };
 }
-function processOperatorValue(field, value, schema, actualFieldName) {
-  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-    const [[op, opValue]] = Object.entries(value);
-    if (!op.startsWith("$")) {
-      const jsonPath = `json_extract(${field}, '$.${op}')`;
-      const nestedFieldName = `${actualFieldName}.${op}`;
-      return translateEq(jsonPath, opValue, schema, nestedFieldName);
-    }
-    switch (op) {
-      case "$eq":
-        return translateEq(field, opValue, schema, actualFieldName);
-      case "$ne":
-        return translateNe(field, opValue, schema, actualFieldName);
-      case "$gt":
-        return translateGt(field, opValue, schema, actualFieldName);
-      case "$gte":
-        return translateGte(field, opValue, schema, actualFieldName);
-      case "$lt":
-        return translateLt(field, opValue, schema, actualFieldName);
-      case "$lte":
-        return translateLte(field, opValue, schema, actualFieldName);
-      case "$in":
-        return translateIn(field, opValue, schema, actualFieldName);
-      case "$nin":
-        return translateNin(field, opValue, schema, actualFieldName);
-      case "$exists":
-        return translateExists(field, opValue);
-      case "$size":
-        return translateSize(field, opValue);
-      case "$mod": {
-        const result = translateMod(field, opValue);
-        if (!result)
-          return translateEq(field, opValue, schema, actualFieldName);
-        return result;
+function translateLeafOperator(op, field, value, schema, actualFieldName) {
+  switch (op) {
+    case "$eq":
+      return translateEq(field, value, schema, actualFieldName);
+    case "$ne":
+      return translateNe(field, value, schema, actualFieldName);
+    case "$gt":
+      return translateGt(field, value, schema, actualFieldName);
+    case "$gte":
+      return translateGte(field, value, schema, actualFieldName);
+    case "$lt":
+      return translateLt(field, value, schema, actualFieldName);
+    case "$lte":
+      return translateLte(field, value, schema, actualFieldName);
+    case "$in":
+      return translateIn(field, value, schema, actualFieldName);
+    case "$nin":
+      return translateNin(field, value, schema, actualFieldName);
+    case "$exists":
+      return translateExists(field, value);
+    case "$size":
+      return translateSize(field, value);
+    case "$mod": {
+      const result = translateMod(field, value);
+      if (!result)
+        return translateEq(field, value, schema, actualFieldName);
+      return result;
+    }
+    case "$regex": {
+      let pattern;
+      let options;
+      if (value instanceof RegExp) {
+        pattern = value.source;
+        options = value.flags;
+      } else if (typeof value === "string") {
+        pattern = value;
+      } else if (typeof value === "object" && value !== null) {
+        const regexObj = value;
+        pattern = regexObj.pattern || regexObj.$regex;
+        options = regexObj.$options;
+      } else {
+        return null;
       }
-      case "$regex": {
-        const options = value.$options;
-        const regexFragment = translateRegex(field, opValue, options, schema, actualFieldName);
-        return regexFragment || { sql: "1=0", args: [] };
-      }
-      case "$type": {
-        let jsonCol = "data";
-        let path2 = `$.${actualFieldName}`;
-        let useDirectType = false;
-        if (field === "value") {
-          jsonCol = "value";
-          path2 = "";
-          useDirectType = true;
-        } else if (field.startsWith("json_extract(")) {
-          const match = field.match(/json_extract\(([^,]+),\s*'([^']+)'\)/);
-          if (match) {
-            jsonCol = match[1];
-            path2 = match[2];
-          }
+      return translateRegex(field, pattern, options, schema, actualFieldName);
+    }
+    case "$type": {
+      let jsonCol = "data";
+      let path2 = `$.${actualFieldName}`;
+      let useDirectType = false;
+      if (field === "value") {
+        jsonCol = "value";
+        path2 = "";
+        useDirectType = true;
+      } else if (field.startsWith("json_extract(")) {
+        const match = field.match(/json_extract\(([^,]+),\s*'([^']+)'\)/);
+        if (match && match[1] && match[2]) {
+          jsonCol = match[1];
+          path2 = match[2];
+        }
+      }
+      if (useDirectType) {
+        const typeMap = {
+          null: "null",
+          boolean: "true",
+          number: "integer",
+          string: "text",
+          array: "array",
+          object: "object"
+        };
+        const sqlType = typeMap[value];
+        if (!sqlType)
+          return { sql: "1=0", args: [] };
+        if (value === "boolean") {
+          return { sql: `(type IN ('true', 'false'))`, args: [] };
         }
-        if (useDirectType) {
-          const typeMap = {
-            null: "null",
-            boolean: "true",
-            number: "integer",
-            string: "text",
-            array: "array",
-            object: "object"
-          };
-          const sqlType = typeMap[opValue];
-          if (!sqlType)
-            return { sql: "1=0", args: [] };
-          if (opValue === "boolean") {
-            return { sql: `(type IN ('true', 'false'))`, args: [] };
-          }
-          if (opValue === "number") {
-            return { sql: `(type IN ('integer', 'real'))`, args: [] };
-          }
-          return { sql: `type = '${sqlType}'`, args: [] };
+        if (value === "number") {
+          return { sql: `(type IN ('integer', 'real'))`, args: [] };
         }
-        const typeFragment = translateType(jsonCol, path2, opValue, true);
-        return typeFragment || { sql: "1=0", args: [] };
-      }
-      case "$elemMatch": {
-        const elemMatchFragment = translateElemMatch(field, opValue, schema, actualFieldName);
-        return elemMatchFragment || { sql: "1=0", args: [] };
-      }
-      case "$not": {
-        const result = translateNot(field, opValue, schema, actualFieldName);
-        if (!result)
-          return translateEq(field, opValue, schema, actualFieldName);
-        return result;
+        return { sql: `type = '${sqlType}'`, args: [] };
       }
-      case "$and": {
-        if (!Array.isArray(opValue))
-          return translateEq(field, opValue, schema, actualFieldName);
-        const fragments = opValue.map((v) => processOperatorValue(field, v, schema, actualFieldName));
-        const sql = fragments.map((f) => f.sql).join(" AND ");
-        const args = fragments.flatMap((f) => f.args);
-        return { sql: `(${sql})`, args };
-      }
-      case "$or": {
-        if (!Array.isArray(opValue))
-          return translateEq(field, opValue, schema, actualFieldName);
-        const fragments = opValue.map((v) => processOperatorValue(field, v, schema, actualFieldName));
-        const sql = fragments.map((f) => f.sql).join(" OR ");
-        const args = fragments.flatMap((f) => f.args);
-        return { sql: `(${sql})`, args };
-      }
-      default:
-        return translateEq(field, opValue, schema, actualFieldName);
+      const typeFragment = translateType(jsonCol, path2, value, true);
+      return typeFragment || { sql: "1=0", args: [] };
     }
+    default:
+      return translateEq(field, value, schema, actualFieldName);
   }
-  return translateEq(field, value, schema, actualFieldName);
 }
-function translateNot(field, criteria, schema, actualFieldName) {
-  if (criteria === undefined || criteria === null || typeof criteria !== "object" || Array.isArray(criteria) || Object.keys(criteria).length === 0) {
-    return { sql: "1=0", args: [] };
-  }
-  const inner = processOperatorValue(field, criteria, schema, actualFieldName);
+function wrapWithNot(innerFragment) {
   return {
-    sql: `NOT (${inner.sql})`,
-    args: inner.args
+    sql: `NOT (${innerFragment.sql})`,
+    args: innerFragment.args
   };
 }
 function translateType(jsonColumn, fieldName, type6, isDirectPath = false) {
@@ -12800,6 +12919,14 @@ function _stringify(value, stack) {
     }
     const objType = Object.prototype.toString.call(obj);
     if (objType !== "[object Object]") {
+      if (obj instanceof RegExp) {
+        stack.pop();
+        return `{"$regex":${strEscape(obj.source)},"$options":${strEscape(obj.flags)}}`;
+      }
+      if (obj instanceof Date) {
+        stack.pop();
+        return strEscape(obj.toISOString());
+      }
       const result = JSON.stringify(obj);
       stack.pop();
       return result;
@@ -12822,27 +12949,27 @@ function _stringify(value, stack) {
 }
 
 // src/query/builder.ts
-var QUERY_CACHE = new Map;
 var MAX_CACHE_SIZE = 1000;
-function buildWhereClause(selector, schema, collectionName) {
+var GLOBAL_CACHE = new Map;
+function buildWhereClause(selector, schema, collectionName, cache = GLOBAL_CACHE) {
   if (!selector || typeof selector !== "object")
     return null;
   const cacheKey = `v${schema.version}_${collectionName}_${stableStringify(selector)}`;
-  const cached = QUERY_CACHE.get(cacheKey);
-  if (cached) {
-    QUERY_CACHE.delete(cacheKey);
-    QUERY_CACHE.set(cacheKey, cached);
+  const cached = cache.get(cacheKey);
+  if (cached !== undefined) {
+    cache.delete(cacheKey);
+    cache.set(cacheKey, cached);
     return cached;
   }
   const result = processSelector(selector, schema, 0);
   if (!result)
     return null;
-  if (QUERY_CACHE.size >= MAX_CACHE_SIZE) {
-    const firstKey = QUERY_CACHE.keys().next().value;
+  if (cache.size >= MAX_CACHE_SIZE) {
+    const firstKey = cache.keys().next().value;
     if (firstKey)
-      QUERY_CACHE.delete(firstKey);
+      cache.delete(firstKey);
   }
-  QUERY_CACHE.set(cacheKey, result);
+  cache.set(cacheKey, result);
   return result;
 }
 function buildLogicalOperator(operator, conditions, schema, logicalDepth) {
@@ -12896,80 +13023,124 @@ function processSelector(selector, schema, logicalDepth) {
       if (Object.keys(value).length === 0) {
         return { sql: "1=0", args: [] };
       }
+      const fieldFragments = [];
       for (const [op, opValue] of Object.entries(value)) {
         let fragment;
-        switch (op) {
-          case "$eq":
-            fragment = translateEq(fieldName, opValue, schema, actualFieldName);
-            break;
-          case "$ne":
-            fragment = translateNe(fieldName, opValue, schema, actualFieldName);
-            break;
-          case "$gt":
-            fragment = translateGt(fieldName, opValue, schema, actualFieldName);
-            break;
-          case "$gte":
-            fragment = translateGte(fieldName, opValue, schema, actualFieldName);
-            break;
-          case "$lt":
-            fragment = translateLt(fieldName, opValue, schema, actualFieldName);
-            break;
-          case "$lte":
-            fragment = translateLte(fieldName, opValue, schema, actualFieldName);
-            break;
-          case "$in":
-            fragment = translateIn(fieldName, opValue, schema, actualFieldName);
-            break;
-          case "$nin":
-            fragment = translateNin(fieldName, opValue, schema, actualFieldName);
-            break;
-          case "$exists":
-            fragment = translateExists(fieldName, opValue);
-            break;
-          case "$regex":
-            const options = value.$options;
-            const regexFragment = translateRegex(fieldName, opValue, options, schema, actualFieldName);
-            if (!regexFragment)
+        if (op === "$not") {
+          if (typeof opValue !== "object" || opValue === null || Array.isArray(opValue)) {
+            const eqFrag = translateLeafOperator("$eq", fieldName, opValue, schema, actualFieldName);
+            if (!eqFrag)
               return null;
-            fragment = regexFragment;
-            break;
-          case "$elemMatch":
-            const elemMatchFragment = translateElemMatch(fieldName, opValue, schema, actualFieldName);
-            if (!elemMatchFragment)
+            fragment = wrapWithNot(eqFrag);
+          } else if (opValue instanceof Date) {
+            const eqFrag = translateLeafOperator("$eq", fieldName, opValue, schema, actualFieldName);
+            if (!eqFrag)
               return null;
-            fragment = elemMatchFragment;
-            break;
-          case "$not": {
-            const notResult = translateNot(fieldName, opValue, schema, actualFieldName);
-            if (!notResult)
+            fragment = wrapWithNot(eqFrag);
+          } else if (opValue instanceof RegExp) {
+            const regexFrag = translateLeafOperator("$regex", fieldName, opValue, schema, actualFieldName);
+            if (!regexFrag)
               return null;
-            fragment = notResult;
-            break;
+            fragment = wrapWithNot(regexFrag);
+          } else {
+            const opValueObj = opValue;
+            const innerKeys = Object.keys(opValueObj);
+            if (innerKeys.length === 0) {
+              fragment = { sql: "1=0", args: [] };
+            } else if (innerKeys.some((k) => k === "$and" || k === "$or" || k === "$nor")) {
+              let recursivelyWrapLeafOperators = function(items2, field2) {
+                return items2.map((item) => {
+                  const keys = Object.keys(item);
+                  if (keys.some((k) => !k.startsWith("$")))
+                    return item;
+                  if (keys.length === 1 && LOGICAL_OPS.has(keys[0])) {
+                    const logicalOp2 = keys[0];
+                    return { [logicalOp2]: recursivelyWrapLeafOperators(item[logicalOp2], field2) };
+                  }
+                  return { [field2]: item };
+                });
+              };
+              const logicalOp = innerKeys[0];
+              const nestedSelector = opValueObj;
+              const items = nestedSelector[logicalOp];
+              const LOGICAL_OPS = new Set(["$and", "$or", "$nor"]);
+              const wrappedItems = recursivelyWrapLeafOperators(items, field);
+              const innerFragment = processSelector({ [logicalOp]: wrappedItems }, schema, logicalDepth + 1);
+              if (!innerFragment)
+                return null;
+              fragment = wrapWithNot(innerFragment);
+            } else if (innerKeys.length === 1 && innerKeys[0] === "$elemMatch") {
+              const elemMatchFragment = translateElemMatch(fieldName, opValueObj.$elemMatch, schema, actualFieldName);
+              if (!elemMatchFragment)
+                return null;
+              fragment = wrapWithNot(elemMatchFragment);
+            } else {
+              const hasOperators = innerKeys.some((k) => k.startsWith("$"));
+              if (!hasOperators) {
+                const eqFrag = translateLeafOperator("$eq", fieldName, opValueObj, schema, actualFieldName);
+                if (!eqFrag)
+                  return null;
+                fragment = wrapWithNot(eqFrag);
+              } else {
+                const [[innerOp, innerVal]] = Object.entries(opValueObj);
+                const innerFrag = translateLeafOperator(innerOp, fieldName, innerVal, schema, actualFieldName);
+                if (!innerFrag)
+                  return null;
+                fragment = wrapWithNot(innerFrag);
+              }
+            }
           }
-          case "$type":
-            const typeFragment = translateType("data", actualFieldName, opValue);
-            if (!typeFragment)
-              return null;
-            fragment = typeFragment;
-            break;
-          case "$size":
-            fragment = translateSize(fieldName, opValue);
-            break;
-          case "$mod": {
-            const modResult = translateMod(fieldName, opValue);
-            if (!modResult)
-              return null;
-            fragment = modResult;
-            break;
+        } else if (op === "$elemMatch") {
+          const elemMatchFragment = translateElemMatch(fieldName, opValue, schema, actualFieldName);
+          if (!elemMatchFragment)
+            return null;
+          fragment = elemMatchFragment;
+        } else if (op === "$regex") {
+          const regexValue = opValue;
+          const optionsValue = value.$options;
+          let combinedValue;
+          if (typeof regexValue === "string" && optionsValue) {
+            combinedValue = { $regex: regexValue, $options: optionsValue };
+          } else {
+            combinedValue = regexValue;
           }
-          default:
-            continue;
+          const leafFrag = translateLeafOperator("$regex", fieldName, combinedValue, schema, actualFieldName);
+          if (!leafFrag)
+            return null;
+          fragment = leafFrag;
+        } else if (op === "$options") {
+          continue;
+        } else if (!op.startsWith("$")) {
+          const jsonPath = `json_extract(${fieldName}, '$.${op}')`;
+          const nestedFieldName = `${actualFieldName}.${op}`;
+          const leafFrag = translateLeafOperator("$eq", jsonPath, opValue, schema, nestedFieldName);
+          if (!leafFrag)
+            return null;
+          fragment = leafFrag;
+        } else {
+          const leafFrag = translateLeafOperator(op, fieldName, opValue, schema, actualFieldName);
+          if (!leafFrag)
+            return null;
+          fragment = leafFrag;
+        }
+        if (fieldFragments.length > 0) {
+          const prev = fieldFragments.pop();
+          fieldFragments.push({
+            sql: `(${prev.sql} AND ${fragment.sql})`,
+            args: [...prev.args, ...fragment.args]
+          });
+        } else {
+          fieldFragments.push(fragment);
         }
-        conditions.push(fragment.sql);
-        args.push(...fragment.args);
       }
+      fieldFragments.forEach((f) => {
+        conditions.push(f.sql);
+        args.push(...f.args);
+      });
     } else {
-      const fragment = translateEq(fieldName, value, schema, actualFieldName);
+      const fragment = translateLeafOperator("$eq", fieldName, value, schema, actualFieldName);
+      if (!fragment)
+        return null;
       conditions.push(fragment.sql);
       args.push(...fragment.args);
     }
@@ -13423,6 +13594,7 @@ class BunSQLiteStorageInstance {
   db;
   stmtManager;
   changeStream$ = new import_rxjs2.Subject;
+  queryCache = new Map;
   databaseName;
   collectionName;
   schema;
@@ -13590,7 +13762,7 @@ class BunSQLiteStorageInstance {
     return rows.map((row) => JSON.parse(row.data));
   }
   async query(preparedQuery) {
-    const whereResult = buildWhereClause(preparedQuery.query.selector, this.schema, this.collectionName);
+    const whereResult = buildWhereClause(preparedQuery.query.selector, this.schema, this.collectionName, this.queryCache);
     if (!whereResult) {
       return this.queryWithOurMemory(preparedQuery);
     }
@@ -13645,7 +13817,7 @@ class BunSQLiteStorageInstance {
     return path2.split(".").reduce((current, key) => current?.[key], obj);
   }
   async count(preparedQuery) {
-    const whereResult = buildWhereClause(preparedQuery.query.selector, this.schema, this.collectionName);
+    const whereResult = buildWhereClause(preparedQuery.query.selector, this.schema, this.collectionName, this.queryCache);
     if (!whereResult) {
       const allDocs = await this.queryWithOurMemory(preparedQuery);
       return {
@@ -13680,12 +13852,16 @@ class BunSQLiteStorageInstance {
     if (this.closed)
       return this.closed;
     this.closed = (async () => {
+      this.queryCache.clear();
       this.changeStream$.complete();
       this.stmtManager.close();
       releaseDatabase(this.databaseName);
     })();
     return this.closed;
   }
+  getCacheSize() {
+    return this.queryCache.size;
+  }
   async remove() {
     if (this.closed)
       throw new Error("already closed");

package/dist/src/instance.d.ts

@@ -5,6 +5,7 @@ export declare class BunSQLiteStorageInstance<RxDocType> implements RxStorageIns
     private db;
     private stmtManager;
     private changeStream$;
+    private queryCache;
     readonly databaseName: string;
     readonly collectionName: string;
     readonly schema: Readonly<RxJsonSchema<RxDocumentData<RxDocType>>>;
@@ -24,6 +25,7 @@ export declare class BunSQLiteStorageInstance<RxDocType> implements RxStorageIns
     changeStream(): Observable<EventBulk<RxStorageChangeEvent<RxDocumentData<RxDocType>>, RxStorageDefaultCheckpoint>>;
     cleanup(minimumDeletedTime: number): Promise<boolean>;
     close(): Promise<void>;
+    getCacheSize(): number;
     remove(): Promise<void>;
     private attachmentMapKey;
     getAttachmentData(documentId: string, attachmentId: string, digest: string): Promise<string>;

package/dist/src/query/builder.d.ts

@@ -2,6 +2,6 @@ import type { RxJsonSchema, MangoQuerySelector, RxDocumentData } from 'rxdb';
 import type { SqlFragment } from './operators';
 export declare function getCacheSize(): number;
 export declare function clearCache(): void;
-export declare function buildWhereClause<RxDocType>(selector: MangoQuerySelector<RxDocumentData<RxDocType>>, schema: RxJsonSchema<RxDocumentData<RxDocType>>, collectionName: string): SqlFragment | null;
+export declare function buildWhereClause<RxDocType>(selector: MangoQuerySelector<RxDocumentData<RxDocType>>, schema: RxJsonSchema<RxDocumentData<RxDocType>>, collectionName: string, cache?: Map<string, SqlFragment | null>): SqlFragment | null;
 export declare function buildLogicalOperator<RxDocType>(operator: 'or' | 'nor' | 'and', conditions: MangoQuerySelector<RxDocumentData<RxDocType>>[], schema: RxJsonSchema<RxDocumentData<RxDocType>>, logicalDepth: number): SqlFragment | null;
 //# sourceMappingURL=builder.d.ts.map

package/dist/src/query/operators.d.ts

@@ -19,7 +19,8 @@ export declare function translateNin<RxDocType>(field: string, values: unknown[]
 export declare function translateExists(field: string, exists: boolean): SqlFragment;
 export declare function translateRegex<RxDocType>(field: string, pattern: string, options: string | undefined, schema: RxJsonSchema<RxDocumentData<RxDocType>>, fieldName: string): SqlFragment | null;
 export declare function translateElemMatch<RxDocType>(field: string, criteria: ElemMatchCriteria, schema: RxJsonSchema<RxDocumentData<RxDocType>>, actualFieldName: string): SqlFragment | null;
-export declare function translateNot<RxDocType>(field: string, criteria: unknown, schema: RxJsonSchema<RxDocumentData<RxDocType>>, actualFieldName: string): SqlFragment | null;
+export declare function translateLeafOperator<RxDocType>(op: string, field: string, value: unknown, schema: RxJsonSchema<RxDocumentData<RxDocType>>, actualFieldName: string): SqlFragment | null;
+export declare function wrapWithNot(innerFragment: SqlFragment): SqlFragment;
 export declare function translateType(jsonColumn: string, fieldName: string, type: string, isDirectPath?: boolean): SqlFragment | null;
 export declare function translateSize(field: string, size: number): SqlFragment;
 export declare function translateMod(field: string, value: unknown): SqlFragment | null;

package/dist/src/query/smart-regex.d.ts

@@ -3,5 +3,6 @@ export interface SqlFragment {
     sql: string;
     args: (string | number | boolean)[];
 }
+export declare function clearRegexCache(): void;
 export declare function smartRegexToLike<RxDocType>(field: string, pattern: string, options: string | undefined, schema: RxJsonSchema<RxDocumentData<RxDocType>>, fieldName: string): SqlFragment | null;
 //# sourceMappingURL=smart-regex.d.ts.map

package/package.json

@@ -1,11 +1,16 @@
 {
   "name": "bun-sqlite-for-rxdb",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "author": "adam2am",
   "repository": {
     "type": "git",
     "url": "https://github.com/adam2am/bun-sqlite-for-rxdb.git"
   },
+  "scripts": {
+    "build": "bun build src/index.ts --outdir dist --target bun && tsc --emitDeclarationOnly --declaration --outDir dist",
+    "test": "bun test test/",
+    "typecheck": "tsc --noEmit"
+  },
   "main": "dist/index.js",
   "dependencies": {},
   "devDependencies": {
@@ -45,11 +50,6 @@
     "README.md",
     "LICENSE"
   ],
-  "scripts": {
-    "build": "bun build src/index.ts --outdir dist --target bun && tsc --emitDeclarationOnly --declaration --outDir dist",
-    "test": "bun test src/",
-    "typecheck": "tsc --noEmit"
-  },
   "type": "module",
   "types": "dist/index.d.ts"
 }