bun-sqlite-for-rxdb 1.3.1 → 1.4.0

package/dist/index.js

@@ -12254,6 +12254,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" };
 }
 
@@ -12342,31 +12349,85 @@ function smartRegexToLike(field, pattern, options, schema, fieldName) {
 }
 
 // src/query/operators.ts
-function translateEq(field, value) {
+function translateEq(field, value, schema, actualFieldName) {
   if (value === null) {
     return { sql: `${field} IS NULL`, args: [] };
   }
+  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: [value]
+      };
+    }
+  }
   return { sql: `${field} = ?`, args: [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: [value]
+      };
+    }
+  }
+  return { sql: `(${field} <> ? OR ${field} IS NULL)`, args: [value] };
 }
-function translateGt(field, 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: [value]
+      };
+    }
+  }
   return { sql: `${field} > ?`, args: [value] };
 }
-function translateGte(field, 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: [value]
+      };
+    }
+  }
   return { sql: `${field} >= ?`, args: [value] };
 }
-function translateLt(field, 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: [value]
+      };
+    }
+  }
   return { sql: `${field} < ?`, args: [value] };
 }
-function translateLte(field, 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: [value]
+      };
+    }
+  }
   return { sql: `${field} <= ?`, args: [value] };
 }
-function translateIn(field, values) {
+function translateIn(field, values, schema, actualFieldName) {
   if (!Array.isArray(values) || values.length === 0) {
     return { sql: "1=0", args: [] };
   }
@@ -12375,17 +12436,31 @@ function translateIn(field, values) {
   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: [] };
   }
@@ -12394,15 +12469,29 @@ function translateNin(field, values) {
   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: 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: ninClause, args };
 }
 function translateExists(field, exists) {
   return {
@@ -12416,17 +12505,18 @@ function translateRegex(field, pattern, options, schema, fieldName) {
     return smartResult;
   return null;
 }
-function buildElemMatchConditions(criteria) {
+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 });
+      const fragment = processOperatorValue("value", { [key]: value }, schema, baseFieldName);
       conditions.push(fragment.sql);
       args.push(...fragment.args);
     } else {
-      const propertyField = `json_extract(json_each.value, '$.${key}')`;
-      const fragment = processOperatorValue(propertyField, value);
+      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);
     }
@@ -12436,73 +12526,74 @@ function buildElemMatchConditions(criteria) {
     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));
     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));
     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));
     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") {
-    return null;
-  }
+  const fragment = buildElemMatchConditions(criteria, schema, actualFieldName);
   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) {
+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}')`;
-      return translateEq(jsonPath, opValue);
+      const nestedFieldName = `${actualFieldName}.${op}`;
+      return translateEq(jsonPath, opValue, schema, nestedFieldName);
     }
     switch (op) {
       case "$eq":
-        return translateEq(field, opValue);
+        return translateEq(field, opValue, schema, actualFieldName);
       case "$ne":
-        return translateNe(field, opValue);
+        return translateNe(field, opValue, schema, actualFieldName);
       case "$gt":
-        return translateGt(field, opValue);
+        return translateGt(field, opValue, schema, actualFieldName);
       case "$gte":
-        return translateGte(field, opValue);
+        return translateGte(field, opValue, schema, actualFieldName);
       case "$lt":
-        return translateLt(field, opValue);
+        return translateLt(field, opValue, schema, actualFieldName);
       case "$lte":
-        return translateLte(field, opValue);
+        return translateLte(field, opValue, schema, actualFieldName);
       case "$in":
-        return translateIn(field, opValue);
+        return translateIn(field, opValue, schema, actualFieldName);
       case "$nin":
-        return translateNin(field, opValue);
+        return translateNin(field, opValue, schema, actualFieldName);
       case "$exists":
         return translateExists(field, opValue);
       case "$size":
@@ -12510,48 +12601,96 @@ function processOperatorValue(field, value) {
       case "$mod": {
         const result = translateMod(field, opValue);
         if (!result)
-          return translateEq(field, opValue);
+          return translateEq(field, opValue, schema, actualFieldName);
         return result;
       }
+      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];
+          }
+        }
+        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: [] };
+        }
+        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);
+        const result = translateNot(field, opValue, schema, actualFieldName);
         if (!result)
-          return translateEq(field, opValue);
+          return translateEq(field, opValue, schema, actualFieldName);
         return result;
       }
       case "$and": {
         if (!Array.isArray(opValue))
-          return translateEq(field, opValue);
-        const fragments = opValue.map((v) => processOperatorValue(field, v));
+          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);
-        const fragments = opValue.map((v) => processOperatorValue(field, v));
+          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);
+        return translateEq(field, opValue, schema, actualFieldName);
     }
   }
-  return translateEq(field, value);
+  return translateEq(field, value, schema, actualFieldName);
 }
-function translateNot(field, criteria) {
-  if (!criteria || typeof criteria === "object" && Object.keys(criteria).length === 0)
-    return null;
-  const inner = processOperatorValue(field, criteria);
+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);
   return {
-    sql: `NOT(${inner.sql})`,
+    sql: `NOT (${inner.sql})`,
     args: inner.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 +12705,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 +12716,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]
   };
 }
 
@@ -12708,12 +12847,12 @@ function buildWhereClause(selector, schema, collectionName) {
 }
 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 +12877,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,32 +12893,35 @@ 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: [] };
+      }
       for (const [op, opValue] of Object.entries(value)) {
         let fragment;
         switch (op) {
           case "$eq":
-            fragment = translateEq(fieldName, opValue);
+            fragment = translateEq(fieldName, opValue, schema, actualFieldName);
             break;
           case "$ne":
-            fragment = translateNe(fieldName, opValue);
+            fragment = translateNe(fieldName, opValue, schema, actualFieldName);
             break;
           case "$gt":
-            fragment = translateGt(fieldName, opValue);
+            fragment = translateGt(fieldName, opValue, schema, actualFieldName);
             break;
           case "$gte":
-            fragment = translateGte(fieldName, opValue);
+            fragment = translateGte(fieldName, opValue, schema, actualFieldName);
             break;
           case "$lt":
-            fragment = translateLt(fieldName, opValue);
+            fragment = translateLt(fieldName, opValue, schema, actualFieldName);
             break;
           case "$lte":
-            fragment = translateLte(fieldName, opValue);
+            fragment = translateLte(fieldName, opValue, schema, actualFieldName);
             break;
           case "$in":
-            fragment = translateIn(fieldName, opValue);
+            fragment = translateIn(fieldName, opValue, schema, actualFieldName);
             break;
           case "$nin":
-            fragment = translateNin(fieldName, opValue);
+            fragment = translateNin(fieldName, opValue, schema, actualFieldName);
             break;
           case "$exists":
             fragment = translateExists(fieldName, opValue);
@@ -12793,13 +12934,13 @@ function processSelector(selector, schema, logicalDepth) {
             fragment = regexFragment;
             break;
           case "$elemMatch":
-            const elemMatchFragment = translateElemMatch(fieldName, opValue);
+            const elemMatchFragment = translateElemMatch(fieldName, opValue, schema, actualFieldName);
             if (!elemMatchFragment)
               return null;
             fragment = elemMatchFragment;
             break;
           case "$not": {
-            const notResult = translateNot(fieldName, opValue);
+            const notResult = translateNot(fieldName, opValue, schema, actualFieldName);
             if (!notResult)
               return null;
             fragment = notResult;
@@ -12828,7 +12969,7 @@ function processSelector(selector, schema, logicalDepth) {
         args.push(...fragment.args);
       }
     } else {
-      const fragment = translateEq(fieldName, value);
+      const fragment = translateEq(fieldName, value, schema, actualFieldName);
       conditions.push(fragment.sql);
       args.push(...fragment.args);
     }
@@ -12837,6 +12978,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);
@@ -13375,6 +13610,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 +13627,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) {
@@ -13512,17 +13725,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 };
   }