bun-sqlite-for-rxdb 1.3.1 → 1.5.0

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;
@@ -12254,6 +12283,13 @@ function getColumnInfo(path2, schema) {
   if (path2 === schema.primaryKey) {
     return { column: "id", type: "string" };
   }
+  const properties = schema.properties;
+  const fieldSchema = properties?.[path2];
+  if (fieldSchema && typeof fieldSchema === "object" && "type" in fieldSchema) {
+    if (fieldSchema.type === "array") {
+      return { jsonPath: `$.${path2}`, type: "array" };
+    }
+  }
   return { jsonPath: `$.${path2}`, type: "unknown" };
 }
 
@@ -12295,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, ""));
 }
@@ -12304,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("^");
@@ -12342,67 +12389,161 @@ function smartRegexToLike(field, pattern, options, schema, fieldName) {
 }
 
 // src/query/operators.ts
-function translateEq(field, value) {
+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: [] };
   }
-  return { sql: `${field} = ?`, args: [value] };
+  if (schema && actualFieldName) {
+    const columnInfo = getColumnInfo(actualFieldName, schema);
+    if (field !== "value" && columnInfo.type === "array") {
+      return {
+        sql: `EXISTS (SELECT 1 FROM jsonb_each(${field}) WHERE value = ?)`,
+        args: [normalizeValueForSQLite(value)]
+      };
+    }
+  }
+  return { sql: `${field} = ?`, args: [normalizeValueForSQLite(value)] };
 }
-function translateNe(field, value) {
+function translateNe(field, value, schema, actualFieldName) {
   if (value === null) {
     return { sql: `${field} IS NOT NULL`, args: [] };
   }
-  return { sql: `${field} <> ?`, args: [value] };
+  if (schema && actualFieldName) {
+    const columnInfo = getColumnInfo(actualFieldName, schema);
+    if (field !== "value" && columnInfo.type === "array") {
+      return {
+        sql: `NOT EXISTS (SELECT 1 FROM jsonb_each(${field}) WHERE value = ?)`,
+        args: [normalizeValueForSQLite(value)]
+      };
+    }
+  }
+  return { sql: `(${field} <> ? OR ${field} IS NULL)`, args: [normalizeValueForSQLite(value)] };
 }
-function translateGt(field, value) {
-  return { sql: `${field} > ?`, args: [value] };
+function translateGt(field, value, schema, actualFieldName) {
+  if (schema && actualFieldName) {
+    const columnInfo = getColumnInfo(actualFieldName, schema);
+    if (field !== "value" && columnInfo.type === "array") {
+      return {
+        sql: `EXISTS (SELECT 1 FROM jsonb_each(${field}) WHERE value > ?)`,
+        args: [normalizeValueForSQLite(value)]
+      };
+    }
+  }
+  return { sql: `${field} > ?`, args: [normalizeValueForSQLite(value)] };
 }
-function translateGte(field, value) {
-  return { sql: `${field} >= ?`, args: [value] };
+function translateGte(field, value, schema, actualFieldName) {
+  if (schema && actualFieldName) {
+    const columnInfo = getColumnInfo(actualFieldName, schema);
+    if (field !== "value" && columnInfo.type === "array") {
+      return {
+        sql: `EXISTS (SELECT 1 FROM jsonb_each(${field}) WHERE value >= ?)`,
+        args: [normalizeValueForSQLite(value)]
+      };
+    }
+  }
+  return { sql: `${field} >= ?`, args: [normalizeValueForSQLite(value)] };
 }
-function translateLt(field, value) {
-  return { sql: `${field} < ?`, args: [value] };
+function translateLt(field, value, schema, actualFieldName) {
+  if (schema && actualFieldName) {
+    const columnInfo = getColumnInfo(actualFieldName, schema);
+    if (field !== "value" && columnInfo.type === "array") {
+      return {
+        sql: `EXISTS (SELECT 1 FROM jsonb_each(${field}) WHERE value < ?)`,
+        args: [normalizeValueForSQLite(value)]
+      };
+    }
+  }
+  return { sql: `${field} < ?`, args: [normalizeValueForSQLite(value)] };
 }
-function translateLte(field, value) {
-  return { sql: `${field} <= ?`, args: [value] };
+function translateLte(field, value, schema, actualFieldName) {
+  if (schema && actualFieldName) {
+    const columnInfo = getColumnInfo(actualFieldName, schema);
+    if (field !== "value" && columnInfo.type === "array") {
+      return {
+        sql: `EXISTS (SELECT 1 FROM jsonb_each(${field}) WHERE value <= ?)`,
+        args: [normalizeValueForSQLite(value)]
+      };
+    }
+  }
+  return { sql: `${field} <= ?`, args: [normalizeValueForSQLite(value)] };
 }
-function translateIn(field, values) {
+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: [] };
   }
-  const placeholders = nonNullValues.map(() => "?").join(", ");
-  const inClause = `${field} IN (${placeholders})`;
+  if (schema && actualFieldName) {
+    const columnInfo = getColumnInfo(actualFieldName, schema);
+    if (field !== "value" && columnInfo.type === "array") {
+      const inClause2 = `EXISTS (SELECT 1 FROM jsonb_each(${field}) WHERE value IN (SELECT value FROM json_each(?)))`;
+      const args2 = [JSON.stringify(nonNullValues)];
+      if (hasNull) {
+        return {
+          sql: `(${inClause2} OR ${field} IS NULL)`,
+          args: args2
+        };
+      }
+      return { sql: inClause2, args: args2 };
+    }
+  }
+  const inClause = `${field} IN (SELECT value FROM json_each(?))`;
+  const args = [JSON.stringify(nonNullValues)];
   if (hasNull) {
     return {
       sql: `(${inClause} OR ${field} IS NULL)`,
-      args: nonNullValues
+      args
     };
   }
-  return { sql: inClause, args: nonNullValues };
+  return { sql: inClause, args };
 }
-function translateNin(field, values) {
+function translateNin(field, values, schema, actualFieldName) {
   if (!Array.isArray(values) || values.length === 0) {
     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: [] };
   }
-  const placeholders = nonNullValues.map(() => "?").join(", ");
-  const ninClause = `${field} NOT IN (${placeholders})`;
+  if (schema && actualFieldName) {
+    const columnInfo = getColumnInfo(actualFieldName, schema);
+    if (field !== "value" && columnInfo.type === "array") {
+      const ninClause2 = `NOT EXISTS (SELECT 1 FROM jsonb_each(${field}) WHERE value IN (SELECT value FROM json_each(?)))`;
+      const args2 = [JSON.stringify(nonNullValues)];
+      if (hasNull) {
+        return {
+          sql: `(${ninClause2} AND ${field} IS NOT NULL)`,
+          args: args2
+        };
+      }
+      return { sql: `(${field} IS NULL OR ${ninClause2})`, args: args2 };
+    }
+  }
+  const ninClause = `${field} NOT IN (SELECT value FROM json_each(?))`;
+  const args = [JSON.stringify(nonNullValues)];
   if (hasNull) {
     return {
       sql: `(${ninClause} AND ${field} IS NOT NULL)`,
-      args: nonNullValues
+      args
     };
   }
-  return { sql: ninClause, args: nonNullValues };
+  return { sql: `(${field} IS NULL OR ${ninClause})`, args };
 }
 function translateExists(field, exists) {
   return {
@@ -12416,142 +12557,259 @@ function translateRegex(field, pattern, options, schema, fieldName) {
     return smartResult;
   return null;
 }
-function buildElemMatchConditions(criteria) {
+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("json_each.value", { [key]: value });
-      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(json_each.value, '$.${key}')`;
-      const fragment = processOperatorValue(propertyField, value);
-      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",
     args
   };
 }
-function translateElemMatch(field, criteria) {
+function translateElemMatch(field, criteria, schema, actualFieldName) {
+  if (typeof criteria === "object" && criteria !== null && !Array.isArray(criteria) && Object.keys(criteria).length === 0) {
+    return { sql: "1=0", args: [] };
+  }
   if (typeof criteria !== "object" || criteria === null) {
     return {
-      sql: `EXISTS (SELECT 1 FROM json_each(${field}) WHERE json_each.value = ?)`,
+      sql: `EXISTS (SELECT 1 FROM jsonb_each(${field}) WHERE value = ?)`,
       args: [criteria]
     };
   }
   if (criteria.$and && Array.isArray(criteria.$and)) {
-    const fragments = criteria.$and.map((cond) => buildElemMatchConditions(cond));
+    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 {
-      sql: `EXISTS (SELECT 1 FROM json_each(${field}) WHERE ${sql})`,
+      sql: `EXISTS (SELECT 1 FROM jsonb_each(${field}) WHERE ${sql})`,
       args
     };
   }
   if (criteria.$or && Array.isArray(criteria.$or)) {
-    const fragments = criteria.$or.map((cond) => buildElemMatchConditions(cond));
+    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 {
-      sql: `EXISTS (SELECT 1 FROM json_each(${field}) WHERE ${sql})`,
+      sql: `EXISTS (SELECT 1 FROM jsonb_each(${field}) WHERE ${sql})`,
       args
     };
   }
   if (criteria.$nor && Array.isArray(criteria.$nor)) {
-    const fragments = criteria.$nor.map((cond) => buildElemMatchConditions(cond));
+    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 {
-      sql: `EXISTS (SELECT 1 FROM json_each(${field}) WHERE NOT (${sql}))`,
+      sql: `EXISTS (SELECT 1 FROM jsonb_each(${field}) WHERE NOT (${sql}))`,
       args
     };
   }
-  const fragment = buildElemMatchConditions(criteria);
-  if (fragment.sql === "1=1") {
+  const fragment = buildElemMatchConditions(criteria, schema, actualFieldName);
+  if (!fragment)
     return null;
-  }
   return {
-    sql: `EXISTS (SELECT 1 FROM json_each(${field}) WHERE ${fragment.sql})`,
+    sql: `EXISTS (SELECT 1 FROM jsonb_each(${field}) WHERE ${fragment.sql})`,
     args: fragment.args
   };
 }
-function processOperatorValue(field, value) {
-  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-    const [[op, opValue]] = Object.entries(value);
-    if (!op.startsWith("$")) {
-      const jsonPath = `json_extract(${field}, '$.${op}')`;
-      return translateEq(jsonPath, opValue);
-    }
-    switch (op) {
-      case "$eq":
-        return translateEq(field, opValue);
-      case "$ne":
-        return translateNe(field, opValue);
-      case "$gt":
-        return translateGt(field, opValue);
-      case "$gte":
-        return translateGte(field, opValue);
-      case "$lt":
-        return translateLt(field, opValue);
-      case "$lte":
-        return translateLte(field, opValue);
-      case "$in":
-        return translateIn(field, opValue);
-      case "$nin":
-        return translateNin(field, opValue);
-      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);
-        return result;
-      }
-      case "$not": {
-        const result = translateNot(field, opValue);
-        if (!result)
-          return translateEq(field, opValue);
-        return result;
-      }
-      case "$and": {
-        if (!Array.isArray(opValue))
-          return translateEq(field, opValue);
-        const fragments = opValue.map((v) => processOperatorValue(field, v));
-        const sql = fragments.map((f) => f.sql).join(" AND ");
-        const args = fragments.flatMap((f) => f.args);
-        return { sql: `(${sql})`, args };
+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 "$or": {
-        if (!Array.isArray(opValue))
-          return translateEq(field, opValue);
-        const fragments = opValue.map((v) => processOperatorValue(field, v));
-        const sql = fragments.map((f) => f.sql).join(" OR ");
-        const args = fragments.flatMap((f) => f.args);
-        return { sql: `(${sql})`, args };
+      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 (value === "number") {
+          return { sql: `(type IN ('integer', 'real'))`, args: [] };
+        }
+        return { sql: `type = '${sqlType}'`, args: [] };
       }
-      default:
-        return translateEq(field, opValue);
+      const typeFragment = translateType(jsonCol, path2, value, true);
+      return typeFragment || { sql: "1=0", args: [] };
     }
+    default:
+      return translateEq(field, value, schema, actualFieldName);
   }
-  return translateEq(field, value);
 }
-function translateNot(field, criteria) {
-  if (!criteria || typeof criteria === "object" && Object.keys(criteria).length === 0)
-    return null;
-  const inner = processOperatorValue(field, criteria);
+function wrapWithNot(innerFragment) {
   return {
-    sql: `NOT(${inner.sql})`,
-    args: inner.args
+    sql: `NOT (${innerFragment.sql})`,
+    args: innerFragment.args
   };
 }
-function translateType(jsonColumn, fieldName, type6) {
-  const jsonPath = `$.${fieldName}`;
+function translateType(jsonColumn, fieldName, type6, isDirectPath = false) {
+  const jsonPath = isDirectPath ? fieldName : `$.${fieldName}`;
   switch (type6) {
     case "null":
       return { sql: `json_type(${jsonColumn}, '${jsonPath}') = 'null'`, args: [] };
@@ -12566,7 +12824,7 @@ function translateType(jsonColumn, fieldName, type6) {
     case "object":
       return { sql: `json_type(${jsonColumn}, '${jsonPath}') = 'object'`, args: [] };
     default:
-      return null;
+      return { sql: "1=0", args: [] };
   }
 }
 function translateSize(field, size) {
@@ -12577,11 +12835,11 @@ function translateSize(field, size) {
 }
 function translateMod(field, value) {
   if (!Array.isArray(value) || value.length !== 2)
-    return null;
+    return { sql: "1=0", args: [] };
   const [divisor, remainder] = value;
   return {
-    sql: `${field} % ? = ?`,
-    args: [divisor, remainder]
+    sql: `(${field} - (CAST(${field} / ? AS INTEGER) * ?)) = ?`,
+    args: [divisor, divisor, remainder]
   };
 }
 
@@ -12661,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;
@@ -12683,37 +12949,37 @@ 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) {
   if (conditions.length === 0) {
-    return { sql: "1=1", args: [] };
+    return { sql: operator === "or" ? "1=0" : "1=1", args: [] };
   }
   const fragments = conditions.map((subSelector) => processSelector(subSelector, schema, logicalDepth + 1));
   if (fragments.some((f) => f === null))
     return null;
-  const sql = fragments.map((f) => f.sql).join(" OR ");
+  const sql = fragments.map((f) => `(${f.sql})`).join(" OR ");
   const args = fragments.flatMap((f) => f.args);
   return operator === "nor" ? { sql: `NOT(${sql})`, args } : { sql, args };
 }
@@ -12738,8 +13004,7 @@ function processSelector(selector, schema, logicalDepth) {
       const orFragment = buildLogicalOperator("or", value, schema, logicalDepth);
       if (!orFragment)
         return null;
-      const needsParens = logicalDepth > 0;
-      conditions.push(needsParens ? `(${orFragment.sql})` : orFragment.sql);
+      conditions.push(`(${orFragment.sql})`);
       args.push(...orFragment.args);
       continue;
     }
@@ -12755,80 +13020,127 @@ function processSelector(selector, schema, logicalDepth) {
     const fieldName = columnInfo.column || `json_extract(data, '${columnInfo.jsonPath}')`;
     const actualFieldName = columnInfo.jsonPath?.replace(/^\$\./, "") || columnInfo.column || field;
     if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      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);
-            break;
-          case "$ne":
-            fragment = translateNe(fieldName, opValue);
-            break;
-          case "$gt":
-            fragment = translateGt(fieldName, opValue);
-            break;
-          case "$gte":
-            fragment = translateGte(fieldName, opValue);
-            break;
-          case "$lt":
-            fragment = translateLt(fieldName, opValue);
-            break;
-          case "$lte":
-            fragment = translateLte(fieldName, opValue);
-            break;
-          case "$in":
-            fragment = translateIn(fieldName, opValue);
-            break;
-          case "$nin":
-            fragment = translateNin(fieldName, opValue);
-            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);
-            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);
-            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);
+      const fragment = translateLeafOperator("$eq", fieldName, value, schema, actualFieldName);
+      if (!fragment)
+        return null;
       conditions.push(fragment.sql);
       args.push(...fragment.args);
     }
@@ -12837,6 +13149,100 @@ function processSelector(selector, schema, logicalDepth) {
   return { sql: where, args };
 }
 
+// src/query/lightweight-matcher.ts
+var operators = {
+  $eq: (a, b) => a === b,
+  $ne: (a, b) => a !== b,
+  $gt: (a, b) => a > b,
+  $gte: (a, b) => a >= b,
+  $lt: (a, b) => a < b,
+  $lte: (a, b) => a <= b,
+  $in: (a, b) => Array.isArray(b) && b.some((v) => v === a),
+  $nin: (a, b) => Array.isArray(b) && !b.some((v) => v === a),
+  $exists: (a, b) => a !== undefined === b,
+  $type: (a, b) => {
+    const type6 = Array.isArray(a) ? "array" : typeof a;
+    return type6 === b;
+  },
+  $mod: (a, b) => {
+    if (!Array.isArray(b) || b.length !== 2)
+      return false;
+    const [divisor, remainder] = b;
+    return typeof a === "number" && a % divisor === remainder;
+  },
+  $size: (a, b) => Array.isArray(a) && a.length === b
+};
+function getNestedValue(obj, path2) {
+  return path2.split(".").reduce((current, key) => current?.[key], obj);
+}
+function matchesSelector(doc, selector) {
+  if (!selector || typeof selector !== "object")
+    return true;
+  if (selector.$and) {
+    return Array.isArray(selector.$and) && selector.$and.every((s) => matchesSelector(doc, s));
+  }
+  if (selector.$or) {
+    return Array.isArray(selector.$or) && selector.$or.some((s) => matchesSelector(doc, s));
+  }
+  if (selector.$nor) {
+    return Array.isArray(selector.$nor) && !selector.$nor.some((s) => matchesSelector(doc, s));
+  }
+  for (const [field, condition] of Object.entries(selector)) {
+    const value = getNestedValue(doc, field);
+    if (typeof condition !== "object" || condition === null || Array.isArray(condition)) {
+      if (value !== condition)
+        return false;
+      continue;
+    }
+    for (const [op, opValue] of Object.entries(condition)) {
+      if (op === "$regex") {
+        const options = condition.$options;
+        if (!matchesRegex(value, opValue, options))
+          return false;
+        continue;
+      }
+      if (op === "$not") {
+        if (matchesOperator(value, opValue))
+          return false;
+        continue;
+      }
+      if (op === "$elemMatch") {
+        if (!Array.isArray(value))
+          return false;
+        const hasMatch = value.some((item) => matchesSelector(item, opValue));
+        if (!hasMatch)
+          return false;
+        continue;
+      }
+      if (op === "$options")
+        continue;
+      const operator = operators[op];
+      if (!operator)
+        return false;
+      if (!operator(value, opValue))
+        return false;
+    }
+  }
+  return true;
+}
+function matchesOperator(value, operator) {
+  if (typeof operator !== "object" || operator === null) {
+    return value === operator;
+  }
+  for (const [op, opValue] of Object.entries(operator)) {
+    if (op === "$regex") {
+      const options = operator.$options;
+      return matchesRegex(value, opValue, options);
+    }
+    const operatorFn = operators[op];
+    if (!operatorFn)
+      return false;
+    if (operatorFn(value, opValue))
+      return true;
+  }
+  return false;
+}
+
 // src/rxdb-helpers.ts
 function randomToken2(length) {
   return Math.random().toString(36).substring(2, 2 + length);
@@ -13188,6 +13594,7 @@ class BunSQLiteStorageInstance {
   db;
   stmtManager;
   changeStream$ = new import_rxjs2.Subject;
+  queryCache = new Map;
   databaseName;
   collectionName;
   schema;
@@ -13355,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);
     }
@@ -13375,6 +13782,9 @@ class BunSQLiteStorageInstance {
       queryArgs.push(preparedQuery.query.limit);
     }
     if (preparedQuery.query.skip) {
+      if (!preparedQuery.query.limit) {
+        sql += ` LIMIT -1`;
+      }
       sql += ` OFFSET ?`;
       queryArgs.push(preparedQuery.query.skip);
     }
@@ -13389,31 +13799,6 @@ class BunSQLiteStorageInstance {
     const documents = rows.map((row) => JSON.parse(row.data));
     return { documents };
   }
-  matchesSelector(doc, selector) {
-    for (const [key, value] of Object.entries(selector)) {
-      const docValue = this.getNestedValue(doc, key);
-      if (typeof value === "object" && value !== null) {
-        for (const [op, opValue] of Object.entries(value)) {
-          if (op === "$eq" && docValue !== opValue)
-            return false;
-          if (op === "$ne" && docValue === opValue)
-            return false;
-          if (op === "$gt" && !(docValue > opValue))
-            return false;
-          if (op === "$gte" && !(docValue >= opValue))
-            return false;
-          if (op === "$lt" && !(docValue < opValue))
-            return false;
-          if (op === "$lte" && !(docValue <= opValue))
-            return false;
-        }
-      } else {
-        if (docValue !== value)
-          return false;
-      }
-    }
-    return true;
-  }
   sortDocuments(docs, sort) {
     return docs.sort((a, b) => {
       for (const sortField of sort) {
@@ -13432,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 {
@@ -13467,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");
@@ -13512,17 +13901,38 @@ class BunSQLiteStorageInstance {
   }
   queryWithOurMemory(preparedQuery) {
     const query = `SELECT json(data) as data FROM "${this.tableName}"`;
-    const rows = this.stmtManager.all({ query, params: [] });
-    let documents = rows.map((row) => JSON.parse(row.data));
-    documents = documents.filter((doc) => this.matchesRegexSelector(doc, preparedQuery.query.selector));
-    if (preparedQuery.query.sort && preparedQuery.query.sort.length > 0) {
-      documents = this.sortDocuments(documents, preparedQuery.query.sort);
-    }
-    if (preparedQuery.query.skip) {
-      documents = documents.slice(preparedQuery.query.skip);
-    }
-    if (preparedQuery.query.limit) {
-      documents = documents.slice(0, preparedQuery.query.limit);
+    const selector = preparedQuery.query.selector;
+    const hasSort = preparedQuery.query.sort && preparedQuery.query.sort.length > 0;
+    if (hasSort) {
+      const rows = this.stmtManager.all({ query, params: [] });
+      let documents2 = rows.map((row) => JSON.parse(row.data));
+      documents2 = documents2.filter((doc) => matchesSelector(doc, selector));
+      documents2 = this.sortDocuments(documents2, preparedQuery.query.sort);
+      if (preparedQuery.query.skip) {
+        documents2 = documents2.slice(preparedQuery.query.skip);
+      }
+      if (preparedQuery.query.limit) {
+        documents2 = documents2.slice(0, preparedQuery.query.limit);
+      }
+      return { documents: documents2 };
+    }
+    const stmt = this.db.prepare(query);
+    const documents = [];
+    const skip = preparedQuery.query.skip || 0;
+    const limit = preparedQuery.query.limit;
+    let skipped = 0;
+    for (const row of stmt.iterate()) {
+      const doc = JSON.parse(row.data);
+      if (matchesSelector(doc, selector)) {
+        if (skipped < skip) {
+          skipped++;
+          continue;
+        }
+        documents.push(doc);
+        if (limit && documents.length >= limit) {
+          break;
+        }
+      }
     }
     return { documents };
   }