bun-sqlite-for-rxdb 1.5.8 → 1.6.0

package/dist/index.js

@@ -12581,22 +12581,69 @@ function normalizeValueForSQLite(value) {
   if (value === undefined) {
     return null;
   }
+  if (Array.isArray(value)) {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "object" && value !== null) {
+    return JSON.stringify(value);
+  }
   return value;
 }
 function translateEq(field, value, schema, actualFieldName) {
   if (value === null) {
     return { sql: `${field} IS NULL`, args: [] };
   }
+  if (Array.isArray(value) || typeof value === "object" && value !== null && !(value instanceof Date) && !(value instanceof RegExp)) {
+    try {
+      return {
+        sql: `${field} = json(?)`,
+        args: [JSON.stringify(value)]
+      };
+    } catch (e) {
+      return { sql: "1=0", args: [] };
+    }
+  }
   if (schema && actualFieldName) {
     const columnInfo = getColumnInfo(actualFieldName, schema);
     if (field !== "value" && columnInfo.type === "array") {
+      const comparison2 = "value = ?";
+      const guardedSql = addTypeGuard("value", value, comparison2);
       return {
-        sql: `EXISTS (SELECT 1 FROM jsonb_each(${field}) WHERE value = ?)`,
+        sql: `EXISTS (SELECT 1 FROM jsonb_each(data, '${buildJsonPath(actualFieldName)}') WHERE ${guardedSql})`,
         args: [normalizeValueForSQLite(value)]
       };
     }
   }
-  return { sql: `${field} = ?`, args: [normalizeValueForSQLite(value)] };
+  const comparison = `${field} = ?`;
+  return {
+    sql: addTypeGuard(field, value, comparison),
+    args: [normalizeValueForSQLite(value)]
+  };
+}
+function addTypeGuard(field, value, comparisonSql) {
+  let typeExpr = "";
+  if (field === "value") {
+    typeExpr = "type";
+  } else if (field.includes("json_extract")) {
+    const match = field.match(/json_extract\(([^,]+),\s*'([^']+)'\)/);
+    if (match) {
+      const [, jsonColumn, jsonPath] = match;
+      typeExpr = `json_type(${jsonColumn}, '${jsonPath}')`;
+    }
+  }
+  if (!typeExpr)
+    return comparisonSql;
+  const valueType = typeof value;
+  if (valueType === "number") {
+    return `(${typeExpr} IN ('integer', 'real') AND ${comparisonSql})`;
+  }
+  if (valueType === "string") {
+    return `(${typeExpr} = 'text' AND ${comparisonSql})`;
+  }
+  if (valueType === "boolean") {
+    return `(${typeExpr} IN ('true', 'false') AND ${comparisonSql})`;
+  }
+  return comparisonSql;
 }
 function translateNe(field, value, schema, actualFieldName) {
   if (value === null) {
@@ -12605,8 +12652,10 @@ function translateNe(field, value, schema, actualFieldName) {
   if (schema && actualFieldName) {
     const columnInfo = getColumnInfo(actualFieldName, schema);
     if (field !== "value" && columnInfo.type === "array") {
+      const comparison = "value = ?";
+      const guardedSql = addTypeGuard("value", value, comparison);
       return {
-        sql: `NOT EXISTS (SELECT 1 FROM jsonb_each(${field}) WHERE value = ?)`,
+        sql: `NOT EXISTS (SELECT 1 FROM jsonb_each(data, '${buildJsonPath(actualFieldName)}') WHERE ${guardedSql})`,
         args: [normalizeValueForSQLite(value)]
       };
     }
@@ -12617,49 +12666,73 @@ function translateGt(field, value, schema, actualFieldName) {
   if (schema && actualFieldName) {
     const columnInfo = getColumnInfo(actualFieldName, schema);
     if (field !== "value" && columnInfo.type === "array") {
+      const comparison2 = "value > ?";
+      const guardedSql = addTypeGuard("value", value, comparison2);
       return {
-        sql: `EXISTS (SELECT 1 FROM jsonb_each(${field}) WHERE value > ?)`,
+        sql: `EXISTS (SELECT 1 FROM jsonb_each(data, '${buildJsonPath(actualFieldName)}') WHERE ${guardedSql})`,
         args: [normalizeValueForSQLite(value)]
       };
     }
   }
-  return { sql: `${field} > ?`, args: [normalizeValueForSQLite(value)] };
+  const comparison = `${field} > ?`;
+  return {
+    sql: addTypeGuard(field, value, comparison),
+    args: [normalizeValueForSQLite(value)]
+  };
 }
 function translateGte(field, value, schema, actualFieldName) {
   if (schema && actualFieldName) {
     const columnInfo = getColumnInfo(actualFieldName, schema);
     if (field !== "value" && columnInfo.type === "array") {
+      const comparison2 = "value >= ?";
+      const guardedSql = addTypeGuard("value", value, comparison2);
       return {
-        sql: `EXISTS (SELECT 1 FROM jsonb_each(${field}) WHERE value >= ?)`,
+        sql: `EXISTS (SELECT 1 FROM jsonb_each(data, '${buildJsonPath(actualFieldName)}') WHERE ${guardedSql})`,
         args: [normalizeValueForSQLite(value)]
       };
     }
   }
-  return { sql: `${field} >= ?`, args: [normalizeValueForSQLite(value)] };
+  const comparison = `${field} >= ?`;
+  return {
+    sql: addTypeGuard(field, value, comparison),
+    args: [normalizeValueForSQLite(value)]
+  };
 }
 function translateLt(field, value, schema, actualFieldName) {
   if (schema && actualFieldName) {
     const columnInfo = getColumnInfo(actualFieldName, schema);
     if (field !== "value" && columnInfo.type === "array") {
+      const comparison2 = "value < ?";
+      const guardedSql = addTypeGuard("value", value, comparison2);
       return {
-        sql: `EXISTS (SELECT 1 FROM jsonb_each(${field}) WHERE value < ?)`,
+        sql: `EXISTS (SELECT 1 FROM jsonb_each(data, '${buildJsonPath(actualFieldName)}') WHERE ${guardedSql})`,
         args: [normalizeValueForSQLite(value)]
       };
     }
   }
-  return { sql: `${field} < ?`, args: [normalizeValueForSQLite(value)] };
+  const comparison = `${field} < ?`;
+  return {
+    sql: addTypeGuard(field, value, comparison),
+    args: [normalizeValueForSQLite(value)]
+  };
 }
 function translateLte(field, value, schema, actualFieldName) {
   if (schema && actualFieldName) {
     const columnInfo = getColumnInfo(actualFieldName, schema);
     if (field !== "value" && columnInfo.type === "array") {
+      const comparison2 = "value <= ?";
+      const guardedSql = addTypeGuard("value", value, comparison2);
       return {
-        sql: `EXISTS (SELECT 1 FROM jsonb_each(${field}) WHERE value <= ?)`,
+        sql: `EXISTS (SELECT 1 FROM jsonb_each(data, '${buildJsonPath(actualFieldName)}') WHERE ${guardedSql})`,
         args: [normalizeValueForSQLite(value)]
       };
     }
   }
-  return { sql: `${field} <= ?`, args: [normalizeValueForSQLite(value)] };
+  const comparison = `${field} <= ?`;
+  return {
+    sql: addTypeGuard(field, value, comparison),
+    args: [normalizeValueForSQLite(value)]
+  };
 }
 function translateIn(field, values, schema, actualFieldName) {
   if (!Array.isArray(values) || values.length === 0) {
@@ -12673,26 +12746,34 @@ function translateIn(field, values, schema, actualFieldName) {
   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
-        };
+      try {
+        const inClause = `EXISTS (SELECT 1 FROM jsonb_each(data, '${buildJsonPath(actualFieldName)}') WHERE value IN (SELECT value FROM json_each(?)))`;
+        const args = [JSON.stringify(nonNullValues)];
+        if (hasNull) {
+          return {
+            sql: `(${inClause} OR ${field} IS NULL)`,
+            args
+          };
+        }
+        return { sql: inClause, args };
+      } catch (e) {
+        return { sql: "1=0", args: [] };
       }
-      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
-    };
+  try {
+    const inClause = `${field} IN (SELECT value FROM json_each(?))`;
+    const args = [JSON.stringify(nonNullValues)];
+    if (hasNull) {
+      return {
+        sql: `(${inClause} OR ${field} IS NULL)`,
+        args
+      };
+    }
+    return { sql: inClause, args };
+  } catch (e) {
+    return { sql: "1=0", args: [] };
   }
-  return { sql: inClause, args };
 }
 function translateNin(field, values, schema, actualFieldName) {
   if (!Array.isArray(values) || values.length === 0) {
@@ -12706,30 +12787,54 @@ function translateNin(field, values, schema, actualFieldName) {
   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
-        };
+      try {
+        const ninClause = `NOT EXISTS (SELECT 1 FROM jsonb_each(data, '${buildJsonPath(actualFieldName)}') WHERE value IN (SELECT value FROM json_each(?)))`;
+        const args = [JSON.stringify(nonNullValues)];
+        if (hasNull) {
+          return {
+            sql: `(${ninClause} AND ${field} IS NOT NULL)`,
+            args
+          };
+        }
+        return { sql: `(${field} IS NULL OR ${ninClause})`, args };
+      } catch (e) {
+        return { sql: "1=1", args: [] };
       }
-      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
-    };
+  try {
+    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
+      };
+    }
+    return { sql: `(${field} IS NULL OR ${ninClause})`, args };
+  } catch (e) {
+    return { sql: "1=1", args: [] };
   }
-  return { sql: `(${field} IS NULL OR ${ninClause})`, args };
 }
 function translateExists(field, exists) {
+  let typeExpr = "";
+  if (field === "value") {
+    typeExpr = "type";
+  } else if (field.includes("json_extract")) {
+    const match = field.match(/json_extract\(([^,]+),\s*'([^']+)'\)/);
+    if (match) {
+      const [, jsonColumn, jsonPath] = match;
+      typeExpr = `json_type(${jsonColumn}, '${jsonPath}')`;
+    }
+  }
+  if (!typeExpr) {
+    return {
+      sql: exists ? `${field} IS NOT NULL` : `${field} IS NULL`,
+      args: []
+    };
+  }
   return {
-    sql: exists ? `${field} IS NOT NULL` : `${field} IS NULL`,
+    sql: exists ? `${typeExpr} IS NOT NULL` : `${typeExpr} IS NULL`,
     args: []
   };
 }
@@ -12740,7 +12845,7 @@ function translateRegex(field, pattern, options, schema, fieldName) {
     const smartResult2 = smartRegexToLike("value", pattern, options, schema, fieldName);
     if (smartResult2) {
       return {
-        sql: `EXISTS (SELECT 1 FROM jsonb_each(${field}) WHERE ${smartResult2.sql})`,
+        sql: `EXISTS (SELECT 1 FROM jsonb_each(data, '${buildJsonPath(fieldName)}') WHERE ${smartResult2.sql})`,
         args: smartResult2.args
       };
     }
@@ -12752,7 +12857,7 @@ function translateRegex(field, pattern, options, schema, fieldName) {
   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"]);
+var LEAF_OPERATORS = new Set(["$eq", "$ne", "$gt", "$gte", "$lt", "$lte", "$in", "$nin", "$exists", "$regex", "$type", "$size", "$mod", "$elemMatch", "$all"]);
 function isLogicalOperator(key) {
   return LOGICAL_OPERATORS.has(key);
 }
@@ -12872,7 +12977,7 @@ function translateElemMatch(field, criteria, schema, actualFieldName) {
     const sql = fragments.map((f) => `COALESCE((${f.sql}), 0)`).join(" AND ");
     const args = fragments.flatMap((f) => f.args);
     return {
-      sql: `EXISTS (SELECT 1 FROM jsonb_each(${field}) WHERE ${sql})`,
+      sql: `EXISTS (SELECT 1 FROM jsonb_each(data, '${buildJsonPath(actualFieldName)}') WHERE ${sql})`,
       args
     };
   }
@@ -12883,7 +12988,7 @@ function translateElemMatch(field, criteria, schema, actualFieldName) {
     const sql = fragments.map((f) => `COALESCE((${f.sql}), 0)`).join(" OR ");
     const args = fragments.flatMap((f) => f.args);
     return {
-      sql: `EXISTS (SELECT 1 FROM jsonb_each(${field}) WHERE ${sql})`,
+      sql: `EXISTS (SELECT 1 FROM jsonb_each(data, '${buildJsonPath(actualFieldName)}') WHERE ${sql})`,
       args
     };
   }
@@ -12894,7 +12999,7 @@ function translateElemMatch(field, criteria, schema, actualFieldName) {
     const sql = fragments.map((f) => `COALESCE((${f.sql}), 0)`).join(" OR ");
     const args = fragments.flatMap((f) => f.args);
     return {
-      sql: `EXISTS (SELECT 1 FROM jsonb_each(${field}) WHERE NOT (${sql}))`,
+      sql: `EXISTS (SELECT 1 FROM jsonb_each(data, '${buildJsonPath(actualFieldName)}') WHERE NOT (${sql}))`,
       args
     };
   }
@@ -12902,7 +13007,7 @@ function translateElemMatch(field, criteria, schema, actualFieldName) {
   if (!fragment)
     return null;
   return {
-    sql: `EXISTS (SELECT 1 FROM jsonb_each(${field}) WHERE ${asBoolean(fragment.sql)})`,
+    sql: `EXISTS (SELECT 1 FROM jsonb_each(data, '${buildJsonPath(actualFieldName)}') WHERE ${asBoolean(fragment.sql)})`,
     args: fragment.args
   };
 }
@@ -12979,6 +13084,42 @@ function translateLeafOperator(op, field, value, schema, actualFieldName) {
           path2 = match[2];
         }
       }
+      if (Array.isArray(value)) {
+        const types = value;
+        if (types.length === 0)
+          return { sql: "1=0", args: [] };
+        if (useDirectType) {
+          const typeMap = {
+            null: "null",
+            boolean: "true",
+            number: "integer",
+            string: "text",
+            array: "array",
+            object: "object"
+          };
+          const conditions = [];
+          for (const t of types) {
+            const sqlType = typeMap[t];
+            if (!sqlType)
+              continue;
+            if (t === "boolean")
+              conditions.push(`(type IN ('true', 'false'))`);
+            else if (t === "number")
+              conditions.push(`(type IN ('integer', 'real'))`);
+            else
+              conditions.push(`type = '${sqlType}'`);
+          }
+          if (conditions.length === 0)
+            return { sql: "1=0", args: [] };
+          return { sql: `(${conditions.join(" OR ")})`, args: [] };
+        } else {
+          const fragments = types.map((t) => translateType(jsonCol, path2, t, true)).filter((f) => f !== null);
+          if (fragments.length === 0)
+            return { sql: "1=0", args: [] };
+          const sql = fragments.map((f) => f.sql).join(" OR ");
+          return { sql: `(${sql})`, args: [] };
+        }
+      }
       if (useDirectType) {
         const typeMap = {
           null: "null",
@@ -13002,6 +13143,33 @@ function translateLeafOperator(op, field, value, schema, actualFieldName) {
       const typeFragment = translateType(jsonCol, path2, value, true);
       return typeFragment || { sql: "1=0", args: [] };
     }
+    case "$all": {
+      if (!Array.isArray(value) || value.length === 0)
+        return { sql: "1=0", args: [] };
+      const fragments = [];
+      for (const val of value) {
+        if (val instanceof RegExp) {
+          const frag = translateLeafOperator("$regex", field, val, schema, actualFieldName);
+          if (!frag)
+            return null;
+          fragments.push(frag);
+        } else if (typeof val === "object" && val !== null && !Array.isArray(val) && "$elemMatch" in val) {
+          const frag = translateElemMatch(actualFieldName, val.$elemMatch, schema, actualFieldName);
+          if (!frag)
+            return null;
+          fragments.push(frag);
+        } else {
+          const frag = translateLeafOperator("$eq", field, val, schema, actualFieldName);
+          if (!frag)
+            return null;
+          fragments.push(frag);
+        }
+      }
+      return {
+        sql: `(${fragments.map((f) => f.sql).join(" AND ")})`,
+        args: fragments.flatMap((f) => f.args)
+      };
+    }
     default:
       return translateEq(field, value, schema, actualFieldName);
   }
@@ -13162,11 +13330,21 @@ function _stringify(value, stack) {
 }
 
 // src/query/builder.ts
+function isOperatorObject2(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return false;
+  if (value instanceof Date || value instanceof RegExp)
+    return false;
+  const keys = Object.keys(value);
+  if (keys.length === 0)
+    return false;
+  return keys.every((k) => k.startsWith("$"));
+}
 function buildWhereClause(selector, schema, collectionName, cache) {
   if (!selector || typeof selector !== "object")
     return null;
   const actualCache = cache ?? getGlobalCache();
-  const cacheKey = `v3_${schema.version}_${stableStringify(selector)}`;
+  const cacheKey = `v4_${schema.version}_${stableStringify(selector)}`;
   const cached = actualCache.get(cacheKey);
   if (cached !== undefined) {
     return cached;
@@ -13226,6 +13404,17 @@ function processSelector(selector, schema, logicalDepth) {
   const conditions = [];
   const args = [];
   for (const [field, value] of Object.entries(selector)) {
+    if (field.includes(".") && !field.startsWith("$")) {
+      const parts = field.split(".");
+      let currentPath = "";
+      for (const part of parts) {
+        currentPath = currentPath ? `${currentPath}.${part}` : part;
+        const columnInfo2 = getColumnInfo(currentPath, schema);
+        if (columnInfo2.type === "array") {
+          return null;
+        }
+      }
+    }
     if (field === "$and" && Array.isArray(value)) {
       const andFragments = value.map((subSelector) => processSelector(subSelector, schema, logicalDepth + 1));
       if (andFragments.some((f) => f === null))
@@ -13265,9 +13454,26 @@ function processSelector(selector, schema, logicalDepth) {
     const fieldName = columnInfo.column || `json_extract(data, '${buildJsonPath(field)}')`;
     const actualFieldName = columnInfo.jsonPath?.replace(/^\$\./, "") || columnInfo.column || field;
     if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      const valueUnknown = value;
+      if (valueUnknown instanceof Date || valueUnknown instanceof RegExp) {
+        const fragment = translateLeafOperator("$eq", fieldName, value, schema, actualFieldName);
+        if (!fragment)
+          return null;
+        conditions.push(fragment.sql);
+        args.push(...fragment.args);
+        continue;
+      }
       if (Object.keys(value).length === 0) {
         return { sql: "1=0", args: [] };
       }
+      if (!isOperatorObject2(value)) {
+        const fragment = translateLeafOperator("$eq", fieldName, value, schema, actualFieldName);
+        if (!fragment)
+          return null;
+        conditions.push(fragment.sql);
+        args.push(...fragment.args);
+        continue;
+      }
       const fieldFragments = [];
       for (const [op, opValue] of Object.entries(value)) {
         let fragment;
@@ -13402,98 +13608,225 @@ function processSelector(selector, schema, logicalDepth) {
 }
 
 // src/query/lightweight-matcher.ts
+function isOperatorObject3(obj) {
+  if (typeof obj !== "object" || obj === null || Array.isArray(obj))
+    return false;
+  const keys = Object.keys(obj);
+  if (keys.length === 0)
+    return false;
+  return keys.every((k) => k.startsWith("$"));
+}
+function isSameBsonType(a, b) {
+  if (a === null || b === null)
+    return a === b;
+  return typeof a === typeof b;
+}
+function getNestedValue(obj, path2) {
+  const segments = path2.split(".");
+  let value = obj;
+  for (let i = 0;i < segments.length; i++) {
+    const field = segments[i];
+    if (Array.isArray(value) && !/^\d+$/.test(field)) {
+      const remainingPath = segments.slice(i).join(".");
+      const results = [];
+      for (const item of value) {
+        const res = getNestedValue(item, remainingPath);
+        if (res !== undefined) {
+          if (Array.isArray(res))
+            results.push(...res);
+          else
+            results.push(res);
+        }
+      }
+      return results.length > 0 ? results : undefined;
+    }
+    value = value?.[field];
+    if (value === undefined)
+      return;
+  }
+  return value;
+}
 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),
+  $eq: (a, b) => {
+    if (typeof a === "object" && typeof b === "object" && a !== null && b !== null) {
+      return stableStringify(a) === stableStringify(b);
+    }
+    return a === b;
+  },
+  $ne: (a, b) => {
+    if (typeof a === "object" && typeof b === "object" && a !== null && b !== null) {
+      return stableStringify(a) !== stableStringify(b);
+    }
+    return a !== b;
+  },
+  $gt: (a, b) => isSameBsonType(a, b) && a > b,
+  $gte: (a, b) => isSameBsonType(a, b) && a >= b,
+  $lt: (a, b) => isSameBsonType(a, b) && a < b,
+  $lte: (a, b) => isSameBsonType(a, b) && a <= b,
+  $in: (a, b) => {
+    if (!Array.isArray(b))
+      return false;
+    const aStr = typeof a === "object" && a !== null ? stableStringify(a) : undefined;
+    return b.some((v) => {
+      if (aStr !== undefined && typeof v === "object" && v !== null) {
+        return aStr === stableStringify(v);
+      }
+      return v === a;
+    });
+  },
+  $nin: (a, b) => {
+    if (!Array.isArray(b))
+      return false;
+    const aStr = typeof a === "object" && a !== null ? stableStringify(a) : undefined;
+    return !b.some((v) => {
+      if (aStr !== undefined && typeof v === "object" && v !== null) {
+        return aStr === stableStringify(v);
+      }
+      return v === a;
+    });
+  },
   $exists: (a, b) => a !== undefined === b,
+  $mod: (a, b) => Array.isArray(b) && b.length === 2 && typeof a === "number" && a % b[0] === b[1],
+  $size: (a, b) => Array.isArray(a) && a.length === b,
+  $regex: (a, b) => {
+    const pattern = typeof b === "string" ? b : b.pattern;
+    const flags = typeof b === "string" ? undefined : b.options;
+    return matchesRegex(a, pattern, flags);
+  },
   $type: (a, b) => {
-    const type6 = Array.isArray(a) ? "array" : typeof a;
-    return type6 === b;
+    let type6;
+    if (a === null)
+      type6 = "null";
+    else if (Array.isArray(a))
+      type6 = "array";
+    else
+      type6 = typeof a;
+    const matchType = (t) => {
+      if (t === "int" || t === "long" || t === "decimal" || t === "double")
+        return type6 === "number";
+      if (t === "bool")
+        return type6 === "boolean";
+      return type6 === t;
+    };
+    return Array.isArray(b) ? b.some(matchType) : matchType(b);
+  },
+  $not: (a, b, matcher) => {
+    if (isOperatorObject3(b)) {
+      return !matchesOperators(a, b, matcher);
+    }
+    return operators.$ne(a, b, matcher);
   },
-  $mod: (a, b) => {
-    if (!Array.isArray(b) || b.length !== 2)
+  $elemMatch: (val, query, matcher) => {
+    if (!Array.isArray(val))
       return false;
-    const [divisor, remainder] = b;
-    return typeof a === "number" && a % divisor === remainder;
+    const isOpObj = isOperatorObject3(query) && !["$and", "$or", "$nor"].some((k) => (k in query));
+    return val.some((item) => {
+      if (isOpObj)
+        return matchesOperators(item, query, matcher);
+      return matcher(item, query);
+    });
   },
-  $size: (a, b) => Array.isArray(a) && a.length === b
+  $all: (a, b, matcher) => {
+    if (!Array.isArray(b))
+      return false;
+    if (!Array.isArray(a)) {
+      return b.length === 1 && operators.$eq(a, b[0], matcher);
+    }
+    return b.every((req) => {
+      if (typeof req === "object" && req !== null && !Array.isArray(req) && !(req instanceof Date) && !(req instanceof RegExp)) {
+        if (req.$elemMatch) {
+          return operators.$elemMatch(a, req.$elemMatch, matcher);
+        }
+      }
+      if (req instanceof RegExp) {
+        return a.some((item) => matchesRegex(item, req.source, req.flags));
+      }
+      const reqStr = typeof req === "object" && req !== null ? stableStringify(req) : undefined;
+      return a.some((item) => {
+        if (reqStr !== undefined && typeof item === "object" && item !== null) {
+          return reqStr === stableStringify(item);
+        }
+        return item === req;
+      });
+    });
+  }
 };
-function getNestedValue(obj, path2) {
-  return path2.split(".").reduce((current, key) => current?.[key], obj);
+function matchesOperators(value, condition, matcher) {
+  for (const [op, arg] of Object.entries(condition)) {
+    if (op === "$options")
+      continue;
+    const fn = operators[op];
+    if (fn) {
+      let operatorArg = arg;
+      if (op === "$regex" && typeof arg === "string" && condition.$options) {
+        operatorArg = { pattern: arg, options: condition.$options };
+      }
+      const isNegative = op === "$ne" || op === "$nin";
+      const isStructural = op === "$size" || op === "$type" || op === "$elemMatch" || op === "$all";
+      const argIsArrayOrObject = typeof arg === "object" && arg !== null;
+      const skipTraversal = argIsArrayOrObject && (op === "$eq" || op === "$ne");
+      if (Array.isArray(value) && !isStructural && !skipTraversal) {
+        const predicate = (v) => fn(v, operatorArg, matcher);
+        if (isNegative ? !value.every(predicate) : !value.some(predicate))
+          return false;
+      } else {
+        if (!fn(value, operatorArg, matcher))
+          return false;
+      }
+    }
+  }
+  return true;
 }
 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));
-  }
+  if (Array.isArray(selector.$and) && !selector.$and.every((s) => matchesSelector(doc, s)))
+    return false;
+  if (Array.isArray(selector.$or) && !selector.$or.some((s) => matchesSelector(doc, s)))
+    return false;
+  if (Array.isArray(selector.$nor) && selector.$nor.some((s) => matchesSelector(doc, s)))
+    return false;
   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;
+    if (field.startsWith("$"))
       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))
+    const value = getNestedValue(doc, field);
+    if (typeof condition === "object" && condition !== null && !Array.isArray(condition)) {
+      const conditionUnknown = condition;
+      if (conditionUnknown instanceof Date || conditionUnknown instanceof RegExp) {
+        const eq = operators.$eq;
+        if (Array.isArray(value)) {
+          if (!value.some((v) => eq(v, condition, matchesSelector)))
+            return false;
+        } else {
+          if (!eq(value, condition, matchesSelector))
+            return false;
+        }
+      } else if (isOperatorObject3(condition)) {
+        if (!matchesOperators(value, condition, matchesSelector))
           return false;
-        continue;
+      } else {
+        const eq = operators.$eq;
+        if (Array.isArray(value)) {
+          if (!value.some((v) => eq(v, condition, matchesSelector)))
+            return false;
+        } else {
+          if (!eq(value, condition, matchesSelector))
+            return false;
+        }
       }
-      if (op === "$elemMatch") {
-        if (!Array.isArray(value))
+    } else {
+      const eq = operators.$eq;
+      if (Array.isArray(value)) {
+        if (!value.some((v) => eq(v, condition, matchesSelector)))
           return false;
-        const hasMatch = value.some((item) => matchesSelector(item, opValue));
-        if (!hasMatch)
+      } else {
+        if (!eq(value, condition, matchesSelector))
           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) {
@@ -14101,7 +14434,7 @@ class BunSQLiteStorageInstance {
       const stmt = this.db.prepare(sql);
       const documents = [];
       let skipped = 0;
-      for (const row of stmt.all(...queryArgs)) {
+      for (const row of stmt.iterate(...queryArgs)) {
         const doc = JSON.parse(row.data);
         if (matchesSelector(doc, jsSelector)) {
           if (skip > 0 && skipped < skip) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bun-sqlite-for-rxdb",
-  "version": "1.5.8",
+  "version": "1.6.0",
   "author": "adam2am",
   "repository": {
     "type": "git",