bun-sqlite-for-rxdb 1.1.3 → 1.4.0

package/dist/index.js

@@ -10341,80 +10341,6 @@ var require_dist = __commonJS((exports) => {
   exports.default = PQueue;
 });
 
-// node_modules/fast-stable-stringify/index.js
-var require_fast_stable_stringify = __commonJS((exports, module) => {
-  var objToString = Object.prototype.toString;
-  var objKeys = Object.keys || function(obj) {
-    var keys = [];
-    for (var name in obj) {
-      keys.push(name);
-    }
-    return keys;
-  };
-  function stringify(val, isArrayProp) {
-    var i, max, str, keys, key, propVal, toStr;
-    if (val === true) {
-      return "true";
-    }
-    if (val === false) {
-      return "false";
-    }
-    switch (typeof val) {
-      case "object":
-        if (val === null) {
-          return null;
-        } else if (val.toJSON && typeof val.toJSON === "function") {
-          return stringify(val.toJSON(), isArrayProp);
-        } else {
-          toStr = objToString.call(val);
-          if (toStr === "[object Array]") {
-            str = "[";
-            max = val.length - 1;
-            for (i = 0;i < max; i++) {
-              str += stringify(val[i], true) + ",";
-            }
-            if (max > -1) {
-              str += stringify(val[i], true);
-            }
-            return str + "]";
-          } else if (toStr === "[object Object]") {
-            keys = objKeys(val).sort();
-            max = keys.length;
-            str = "";
-            i = 0;
-            while (i < max) {
-              key = keys[i];
-              propVal = stringify(val[key], false);
-              if (propVal !== undefined) {
-                if (str) {
-                  str += ",";
-                }
-                str += JSON.stringify(key) + ":" + propVal;
-              }
-              i++;
-            }
-            return "{" + str + "}";
-          } else {
-            return JSON.stringify(val);
-          }
-        }
-      case "function":
-      case "undefined":
-        return isArrayProp ? null : undefined;
-      case "string":
-        return JSON.stringify(val);
-      default:
-        return isFinite(val) ? val : null;
-    }
-  }
-  module.exports = function(val) {
-    var returnVal = stringify(val, false);
-    if (returnVal !== undefined) {
-      return "" + returnVal;
-    }
-  };
-});
-
 // node_modules/rxdb/dist/esm/rx-storage-multiinstance.js
 var import_rxjs = __toESM(require_cjs(), 1);
 var import_operators = __toESM(require_operators(), 1);
@@ -12284,6 +12210,36 @@ function addRxStorageMultiInstanceSupport(storageName, instanceCreationParams, i
 // src/instance.ts
 var import_rxjs2 = __toESM(require_cjs(), 1);
 
+// src/query/regex-matcher.ts
+var REGEX_CACHE = new Map;
+var MAX_REGEX_CACHE_SIZE = 100;
+function compileRegex(pattern, options) {
+  const cacheKey = `${pattern}::${options || ""}`;
+  const cached = REGEX_CACHE.get(cacheKey);
+  if (cached) {
+    return cached.regex;
+  }
+  const regex = new RegExp(pattern, options);
+  if (REGEX_CACHE.size >= MAX_REGEX_CACHE_SIZE) {
+    const firstKey = REGEX_CACHE.keys().next().value;
+    if (firstKey) {
+      REGEX_CACHE.delete(firstKey);
+    }
+  }
+  REGEX_CACHE.set(cacheKey, { regex });
+  return regex;
+}
+function matchesRegex(value, pattern, options) {
+  const regex = compileRegex(pattern, options);
+  if (typeof value === "string") {
+    return regex.test(value);
+  }
+  if (Array.isArray(value)) {
+    return value.some((v) => typeof v === "string" && regex.test(v));
+  }
+  return false;
+}
+
 // src/query/schema-mapper.ts
 function getColumnInfo(path2, schema) {
   if (path2 === "_deleted") {
@@ -12298,71 +12254,180 @@ 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" };
 }
 
 // src/query/smart-regex.ts
-function smartRegexToLike(field, pattern, options) {
-  const caseInsensitive = options?.includes("i");
+var INDEX_CACHE = new Map;
+var MAX_INDEX_CACHE_SIZE = 1000;
+function hasExpressionIndex(fieldName, schema) {
+  const indexKey = schema.indexes ? JSON.stringify(schema.indexes) : "none";
+  const cacheKey = `${schema.version}_${fieldName}_${indexKey}`;
+  const cached = INDEX_CACHE.get(cacheKey);
+  if (cached !== undefined) {
+    INDEX_CACHE.delete(cacheKey);
+    INDEX_CACHE.set(cacheKey, cached);
+    return cached;
+  }
+  if (!schema.indexes) {
+    if (INDEX_CACHE.size >= MAX_INDEX_CACHE_SIZE) {
+      const firstKey = INDEX_CACHE.keys().next().value;
+      if (firstKey)
+        INDEX_CACHE.delete(firstKey);
+    }
+    INDEX_CACHE.set(cacheKey, false);
+    return false;
+  }
+  const hasLowerIndex = schema.indexes.some((idx) => {
+    const fields = Array.isArray(idx) ? idx : [idx];
+    return fields.some((f) => {
+      if (typeof f !== "string")
+        return false;
+      const normalized = f.toLowerCase().replace(/\s/g, "");
+      return normalized === `lower(${fieldName})`;
+    });
+  });
+  if (INDEX_CACHE.size >= MAX_INDEX_CACHE_SIZE) {
+    const firstKey = INDEX_CACHE.keys().next().value;
+    if (firstKey)
+      INDEX_CACHE.delete(firstKey);
+  }
+  INDEX_CACHE.set(cacheKey, hasLowerIndex);
+  return hasLowerIndex;
+}
+function isComplexRegex(pattern) {
+  return /[*+?()[\]{}|]/.test(pattern.replace(/\\\./g, ""));
+}
+function escapeForLike(str) {
+  return str.replace(/[\\%_]/g, "\\$&");
+}
+function smartRegexToLike(field, pattern, options, schema, fieldName) {
+  if (typeof pattern !== "string")
+    return null;
+  const caseInsensitive = options?.includes("i") ?? false;
+  const hasLowerIndex = hasExpressionIndex(fieldName, schema);
   const startsWithAnchor = pattern.startsWith("^");
   const endsWithAnchor = pattern.endsWith("$");
   let cleanPattern = pattern.replace(/^\^/, "").replace(/\$$/, "");
-  if (startsWithAnchor && endsWithAnchor && !/[*+?()[\]{}|]/.test(cleanPattern)) {
-    const exact = cleanPattern.replace(/\\\./g, ".");
+  if (isComplexRegex(cleanPattern)) {
+    return null;
+  }
+  const unescaped = cleanPattern.replace(/\\\./g, ".");
+  const escaped = escapeForLike(unescaped);
+  if (startsWithAnchor && endsWithAnchor) {
     if (caseInsensitive) {
-      const escaped = exact.replace(/%/g, "\\%").replace(/_/g, "\\_");
-      return { sql: `${field} LIKE ? COLLATE NOCASE ESCAPE '\\'`, args: [escaped] };
+      return hasLowerIndex ? { sql: `LOWER(${field}) = ?`, args: [unescaped.toLowerCase()] } : { sql: `${field} = ? COLLATE NOCASE`, args: [unescaped] };
     }
-    return { sql: `${field} = ?`, args: [exact] };
+    return { sql: `${field} = ?`, args: [unescaped] };
   }
   if (startsWithAnchor) {
-    const prefix = cleanPattern.replace(/\\\./g, ".");
-    if (!/[*+?()[\]{}|]/.test(prefix)) {
-      const escaped = prefix.replace(/%/g, "\\%").replace(/_/g, "\\_");
-      return caseInsensitive ? { sql: `${field} LIKE ? COLLATE NOCASE ESCAPE '\\'`, args: [escaped + "%"] } : { sql: `${field} LIKE ? ESCAPE '\\'`, args: [escaped + "%"] };
+    const suffix = caseInsensitive ? escaped.toLowerCase() : escaped;
+    if (caseInsensitive && hasLowerIndex) {
+      return { sql: `LOWER(${field}) LIKE ? ESCAPE '\\'`, args: [suffix + "%"] };
     }
+    return { sql: `${field} LIKE ?${caseInsensitive ? " COLLATE NOCASE" : ""} ESCAPE '\\'`, args: [suffix + "%"] };
   }
   if (endsWithAnchor) {
-    const suffix = cleanPattern.replace(/\\\./g, ".");
-    if (!/[*+?()[\]{}|]/.test(suffix)) {
-      const escaped = suffix.replace(/%/g, "\\%").replace(/_/g, "\\_");
-      return caseInsensitive ? { sql: `${field} LIKE ? COLLATE NOCASE ESCAPE '\\'`, args: ["%" + escaped] } : { sql: `${field} LIKE ? ESCAPE '\\'`, args: ["%" + escaped] };
+    const prefix = caseInsensitive ? escaped.toLowerCase() : escaped;
+    if (caseInsensitive && hasLowerIndex) {
+      return { sql: `LOWER(${field}) LIKE ? ESCAPE '\\'`, args: ["%" + prefix] };
     }
+    return { sql: `${field} LIKE ?${caseInsensitive ? " COLLATE NOCASE" : ""} ESCAPE '\\'`, args: ["%" + prefix] };
   }
-  cleanPattern = cleanPattern.replace(/\\\./g, ".");
-  if (!/[*+?()[\]{}|^$]/.test(cleanPattern)) {
-    const escaped = cleanPattern.replace(/%/g, "\\%").replace(/_/g, "\\_");
-    return caseInsensitive ? { sql: `${field} LIKE ? COLLATE NOCASE ESCAPE '\\'`, args: ["%" + escaped + "%"] } : { sql: `${field} LIKE ? ESCAPE '\\'`, args: ["%" + escaped + "%"] };
+  const middle = caseInsensitive ? escaped.toLowerCase() : escaped;
+  if (caseInsensitive && hasLowerIndex) {
+    return { sql: `LOWER(${field}) LIKE ? ESCAPE '\\'`, args: ["%" + middle + "%"] };
   }
-  return null;
+  return { sql: `${field} LIKE ?${caseInsensitive ? " COLLATE NOCASE" : ""} ESCAPE '\\'`, args: ["%" + middle + "%"] };
 }
 
 // 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: [] };
   }
@@ -12371,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: [] };
   }
@@ -12390,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 {
@@ -12406,80 +12499,213 @@ function translateExists(field, exists) {
     args: []
   };
 }
-function translateRegex(field, pattern, options) {
-  const smartResult = smartRegexToLike(field, pattern, options);
+function translateRegex(field, pattern, options, schema, fieldName) {
+  const smartResult = smartRegexToLike(field, pattern, options, schema, fieldName);
   if (smartResult)
     return smartResult;
   return null;
 }
-function translateElemMatch(field, criteria) {
-  return null;
-}
-function translateNot(field, criteria) {
-  const inner = processOperatorValue(field, criteria);
+function buildElemMatchConditions(criteria, schema, baseFieldName) {
+  const conditions = [];
+  const args = [];
+  for (const [key, value] of Object.entries(criteria)) {
+    if (key.startsWith("$")) {
+      const fragment = processOperatorValue("value", { [key]: value }, schema, baseFieldName);
+      conditions.push(fragment.sql);
+      args.push(...fragment.args);
+    } else {
+      const propertyField = `json_extract(value, '$.${key}')`;
+      const nestedFieldName = `${baseFieldName}.${key}`;
+      const fragment = processOperatorValue(propertyField, value, schema, nestedFieldName);
+      conditions.push(fragment.sql);
+      args.push(...fragment.args);
+    }
+  }
   return {
-    sql: `NOT(${inner.sql})`,
-    args: inner.args
+    sql: conditions.length > 0 ? conditions.join(" AND ") : "1=1",
+    args
   };
 }
-function translateNor(conditions) {
-  if (conditions.length === 0) {
-    return { sql: "1=1", args: [] };
+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: [] };
   }
-  const fragments = conditions.map((condition) => {
-    const [[field, value]] = Object.entries(condition);
-    return processOperatorValue(field, value);
-  });
-  const sql = fragments.map((f) => `(${f.sql})`).join(" OR ");
-  const args = fragments.flatMap((f) => f.args);
+  if (typeof criteria !== "object" || criteria === null) {
+    return {
+      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, schema, actualFieldName));
+    const sql = fragments.map((f) => f.sql).join(" AND ");
+    const args = fragments.flatMap((f) => f.args);
+    return {
+      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, schema, actualFieldName));
+    const sql = fragments.map((f) => f.sql).join(" OR ");
+    const args = fragments.flatMap((f) => f.args);
+    return {
+      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, schema, actualFieldName));
+    const sql = fragments.map((f) => f.sql).join(" OR ");
+    const args = fragments.flatMap((f) => f.args);
+    return {
+      sql: `EXISTS (SELECT 1 FROM jsonb_each(${field}) WHERE NOT (${sql}))`,
+      args
+    };
+  }
+  const fragment = buildElemMatchConditions(criteria, schema, actualFieldName);
   return {
-    sql: `NOT(${sql})`,
-    args
+    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}')`;
+      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":
+        return translateSize(field, opValue);
+      case "$mod": {
+        const result = translateMod(field, opValue);
+        if (!result)
+          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, schema, actualFieldName);
+        if (!result)
+          return translateEq(field, opValue, schema, actualFieldName);
+        return result;
+      }
+      case "$and": {
+        if (!Array.isArray(opValue))
+          return translateEq(field, opValue, schema, actualFieldName);
+        const fragments = opValue.map((v) => processOperatorValue(field, v, schema, actualFieldName));
+        const sql = fragments.map((f) => f.sql).join(" AND ");
+        const args = fragments.flatMap((f) => f.args);
+        return { sql: `(${sql})`, args };
+      }
+      case "$or": {
+        if (!Array.isArray(opValue))
+          return translateEq(field, opValue, schema, actualFieldName);
+        const fragments = opValue.map((v) => processOperatorValue(field, v, schema, actualFieldName));
+        const sql = fragments.map((f) => f.sql).join(" OR ");
+        const args = fragments.flatMap((f) => f.args);
+        return { sql: `(${sql})`, args };
+      }
       default:
-        return translateEq(field, opValue);
+        return translateEq(field, opValue, schema, actualFieldName);
     }
   }
-  return translateEq(field, value);
+  return translateEq(field, value, schema, actualFieldName);
+}
+function translateNot(field, criteria, schema, actualFieldName) {
+  if (criteria === undefined || criteria === null || typeof criteria !== "object" || Array.isArray(criteria) || Object.keys(criteria).length === 0) {
+    return { sql: "1=0", args: [] };
+  }
+  const inner = processOperatorValue(field, criteria, schema, actualFieldName);
+  return {
+    sql: `NOT (${inner.sql})`,
+    args: inner.args
+  };
 }
-function translateType(field, type6) {
+function translateType(jsonColumn, fieldName, type6, isDirectPath = false) {
+  const jsonPath = isDirectPath ? fieldName : `$.${fieldName}`;
   switch (type6) {
-    case "number":
-      return {
-        sql: `(typeof(${field}) = 'integer' OR typeof(${field}) = 'real')`,
-        args: []
-      };
-    case "string":
-      return { sql: `typeof(${field}) = 'text'`, args: [] };
     case "null":
-      return { sql: `typeof(${field}) = 'null'`, args: [] };
+      return { sql: `json_type(${jsonColumn}, '${jsonPath}') = 'null'`, args: [] };
     case "boolean":
+      return { sql: `json_type(${jsonColumn}, '${jsonPath}') IN ('true', 'false')`, args: [] };
+    case "number":
+      return { sql: `json_type(${jsonColumn}, '${jsonPath}') IN ('integer', 'real')`, args: [] };
+    case "string":
+      return { sql: `json_type(${jsonColumn}, '${jsonPath}') = 'text'`, args: [] };
     case "array":
+      return { sql: `json_type(${jsonColumn}, '${jsonPath}') = 'array'`, args: [] };
     case "object":
-    case "date":
+      return { sql: `json_type(${jsonColumn}, '${jsonPath}') = 'object'`, args: [] };
     default:
-      return null;
+      return { sql: "1=0", args: [] };
   }
 }
 function translateSize(field, size) {
@@ -12488,19 +12714,120 @@ function translateSize(field, size) {
     args: [size]
   };
 }
-function translateMod(field, [divisor, remainder]) {
+function translateMod(field, value) {
+  if (!Array.isArray(value) || value.length !== 2)
+    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]
   };
 }
 
+// src/utils/stable-stringify.ts
+var strEscapeRegex = /[\u0000-\u001f\u0022\u005c\ud800-\udfff]/;
+function strEscape(str) {
+  if (str.length < 5000 && !strEscapeRegex.test(str)) {
+    return `"${str}"`;
+  }
+  return JSON.stringify(str);
+}
+function callSafe(method, thisArg) {
+  try {
+    return method.call(thisArg);
+  } catch (error) {
+    return `[Error: ${error instanceof Error ? error.message : String(error)}]`;
+  }
+}
+function sortKeys(keys) {
+  if (keys.length > 100) {
+    return keys.sort();
+  }
+  for (let i = 1;i < keys.length; i++) {
+    const current = keys[i];
+    let pos = i;
+    while (pos !== 0 && keys[pos - 1] > current) {
+      keys[pos] = keys[pos - 1];
+      pos--;
+    }
+    keys[pos] = current;
+  }
+  return keys;
+}
+function stableStringify(value) {
+  return _stringify(value, []);
+}
+function _stringify(value, stack) {
+  if (value === null)
+    return "null";
+  if (value === true)
+    return "true";
+  if (value === false)
+    return "false";
+  const type6 = typeof value;
+  if (type6 === "string")
+    return strEscape(value);
+  if (type6 === "number")
+    return isFinite(value) ? String(value) : "null";
+  if (type6 === "undefined")
+    return "null";
+  if (type6 === "bigint")
+    return String(value);
+  if (Array.isArray(value)) {
+    if (stack.indexOf(value) !== -1)
+      return '"[Circular]"';
+    stack.push(value);
+    if (value.length === 0) {
+      stack.pop();
+      return "[]";
+    }
+    let res = "[" + _stringify(value[0], stack);
+    for (let i = 1;i < value.length; i++) {
+      res += "," + _stringify(value[i], stack);
+    }
+    stack.pop();
+    return res + "]";
+  }
+  if (type6 === "object") {
+    const obj = value;
+    if (stack.indexOf(value) !== -1)
+      return '"[Circular]"';
+    stack.push(value);
+    if ("toJSON" in obj && typeof obj.toJSON === "function") {
+      const result = _stringify(callSafe(obj.toJSON, obj), stack);
+      stack.pop();
+      return result;
+    }
+    const objType = Object.prototype.toString.call(obj);
+    if (objType !== "[object Object]") {
+      const result = JSON.stringify(obj);
+      stack.pop();
+      return result;
+    }
+    const keys = sortKeys(Object.keys(obj));
+    let res = "{";
+    let separator = "";
+    for (let i = 0;i < keys.length; i++) {
+      const key = keys[i];
+      const val = obj[key];
+      if (val === undefined)
+        continue;
+      res += separator + strEscape(key) + ":" + _stringify(val, stack);
+      separator = ",";
+    }
+    stack.pop();
+    return res + "}";
+  }
+  return "null";
+}
+
 // src/query/builder.ts
-var import_fast_stable_stringify = __toESM(require_fast_stable_stringify(), 1);
 var QUERY_CACHE = new Map;
-var MAX_CACHE_SIZE = 500;
-function buildWhereClause(selector, schema) {
-  const cacheKey = `v${schema.version}_${import_fast_stable_stringify.default(selector)}`;
+var MAX_CACHE_SIZE = 1000;
+function buildWhereClause(selector, schema, collectionName) {
+  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);
@@ -12508,6 +12835,8 @@ function buildWhereClause(selector, schema) {
     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 (firstKey)
@@ -12516,12 +12845,27 @@ function buildWhereClause(selector, schema) {
   QUERY_CACHE.set(cacheKey, result);
   return result;
 }
+function buildLogicalOperator(operator, conditions, schema, logicalDepth) {
+  if (conditions.length === 0) {
+    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 args = fragments.flatMap((f) => f.args);
+  return operator === "nor" ? { sql: `NOT(${sql})`, args } : { sql, args };
+}
 function processSelector(selector, schema, logicalDepth) {
+  if (!selector || typeof selector !== "object")
+    return null;
   const conditions = [];
   const args = [];
   for (const [field, value] of Object.entries(selector)) {
     if (field === "$and" && Array.isArray(value)) {
-      const andFragments = value.map((subSelector) => processSelector(subSelector, schema, logicalDepth));
+      const andFragments = value.map((subSelector) => processSelector(subSelector, schema, logicalDepth + 1));
+      if (andFragments.some((f) => f === null))
+        return null;
       const andConditions = andFragments.map((f) => f.sql);
       const needsParens = logicalDepth > 0 && andConditions.length > 1;
       const joined = andConditions.join(" AND ");
@@ -12530,81 +12874,94 @@ function processSelector(selector, schema, logicalDepth) {
       continue;
     }
     if (field === "$or" && Array.isArray(value)) {
-      const orFragments = value.map((subSelector) => processSelector(subSelector, schema, logicalDepth + 1));
-      const orConditions = orFragments.map((f) => f.sql);
-      const needsParens = logicalDepth > 0 && orConditions.length > 1;
-      const joined = orConditions.join(" OR ");
-      conditions.push(needsParens ? `(${joined})` : joined);
-      orFragments.forEach((f) => args.push(...f.args));
+      const orFragment = buildLogicalOperator("or", value, schema, logicalDepth);
+      if (!orFragment)
+        return null;
+      conditions.push(`(${orFragment.sql})`);
+      args.push(...orFragment.args);
       continue;
     }
     if (field === "$nor" && Array.isArray(value)) {
-      const norFragment = translateNor(value);
+      const norFragment = buildLogicalOperator("nor", value, schema, logicalDepth);
+      if (!norFragment)
+        return null;
       conditions.push(norFragment.sql);
       args.push(...norFragment.args);
       continue;
     }
     const columnInfo = getColumnInfo(field, schema);
     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);
             break;
           case "$regex":
             const options = value.$options;
-            const regexFragment = translateRegex(fieldName, opValue, options);
+            const regexFragment = translateRegex(fieldName, opValue, options, schema, actualFieldName);
             if (!regexFragment)
-              continue;
+              return null;
             fragment = regexFragment;
             break;
           case "$elemMatch":
-            const elemMatchFragment = translateElemMatch(fieldName, opValue);
+            const elemMatchFragment = translateElemMatch(fieldName, opValue, schema, actualFieldName);
             if (!elemMatchFragment)
-              continue;
+              return null;
             fragment = elemMatchFragment;
             break;
-          case "$not":
-            fragment = translateNot(fieldName, opValue);
+          case "$not": {
+            const notResult = translateNot(fieldName, opValue, schema, actualFieldName);
+            if (!notResult)
+              return null;
+            fragment = notResult;
             break;
+          }
           case "$type":
-            const typeFragment = translateType(fieldName, opValue);
+            const typeFragment = translateType("data", actualFieldName, opValue);
             if (!typeFragment)
-              continue;
+              return null;
             fragment = typeFragment;
             break;
           case "$size":
             fragment = translateSize(fieldName, opValue);
             break;
-          case "$mod":
-            fragment = translateMod(fieldName, opValue);
+          case "$mod": {
+            const modResult = translateMod(fieldName, opValue);
+            if (!modResult)
+              return null;
+            fragment = modResult;
             break;
+          }
           default:
             continue;
         }
@@ -12612,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);
     }
@@ -12621,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);
@@ -12828,32 +13279,64 @@ function ensureRxStorageInstanceParamsAreCorrect(params) {
 class StatementManager {
   db;
   staticStatements = new Map;
+  static MAX_STATEMENTS = 500;
+  closed = false;
   constructor(db) {
     this.db = db;
   }
+  checkClosed() {
+    if (this.closed) {
+      throw new Error("StatementManager is closed");
+    }
+  }
+  evictOldest() {
+    if (this.staticStatements.size >= StatementManager.MAX_STATEMENTS) {
+      const firstKey = this.staticStatements.keys().next().value;
+      if (firstKey) {
+        const stmt = this.staticStatements.get(firstKey);
+        stmt?.finalize();
+        this.staticStatements.delete(firstKey);
+      }
+    }
+  }
   all(queryWithParams) {
+    this.checkClosed();
     const { query, params } = queryWithParams;
-    if (this.isStaticSQL(query)) {
-      let stmt = this.staticStatements.get(query);
-      if (!stmt) {
-        stmt = this.db.query(query);
-        this.staticStatements.set(query, stmt);
-      }
-      return stmt.all(...params);
+    let stmt = this.staticStatements.get(query);
+    if (stmt) {
+      this.staticStatements.delete(query);
+      this.staticStatements.set(query, stmt);
     } else {
-      const stmt = this.db.prepare(query);
-      try {
-        return stmt.all(...params);
-      } finally {
-        stmt.finalize();
-      }
+      this.evictOldest();
+      stmt = this.db.query(query);
+      this.staticStatements.set(query, stmt);
     }
+    return stmt.all(...params);
+  }
+  get(queryWithParams) {
+    this.checkClosed();
+    const { query, params } = queryWithParams;
+    let stmt = this.staticStatements.get(query);
+    if (stmt) {
+      this.staticStatements.delete(query);
+      this.staticStatements.set(query, stmt);
+    } else {
+      this.evictOldest();
+      stmt = this.db.query(query);
+      this.staticStatements.set(query, stmt);
+    }
+    return stmt.get(...params);
   }
   run(queryWithParams) {
+    this.checkClosed();
     const { query, params } = queryWithParams;
     if (this.isStaticSQL(query)) {
       let stmt = this.staticStatements.get(query);
-      if (!stmt) {
+      if (stmt) {
+        this.staticStatements.delete(query);
+        this.staticStatements.set(query, stmt);
+      } else {
+        this.evictOldest();
         stmt = this.db.query(query);
         this.staticStatements.set(query, stmt);
       }
@@ -12872,6 +13355,7 @@ class StatementManager {
       stmt.finalize();
     }
     this.staticStatements.clear();
+    this.closed = true;
   }
   isStaticSQL(query) {
     if (query.includes("WHERE (")) {
@@ -12912,6 +13396,28 @@ function releaseDatabase(databaseName) {
   }
 }
 
+// src/transaction-queue.ts
+var TX_QUEUE_BY_DATABASE = new WeakMap;
+async function sqliteTransaction(database, handler) {
+  let queue = TX_QUEUE_BY_DATABASE.get(database);
+  if (!queue) {
+    queue = Promise.resolve();
+  }
+  const result = queue.then(async () => {
+    database.run("BEGIN IMMEDIATE");
+    try {
+      const handlerResult = await handler();
+      database.run("COMMIT");
+      return handlerResult;
+    } catch (error) {
+      database.run("ROLLBACK");
+      throw error;
+    }
+  });
+  TX_QUEUE_BY_DATABASE.set(database, result.then(() => {}).catch(() => {}));
+  return result;
+}
+
 // src/instance.ts
 class BunSQLiteStorageInstance {
   db;
@@ -12947,6 +13453,15 @@ class BunSQLiteStorageInstance {
     if (filename !== ":memory:") {
       this.db.run("PRAGMA journal_mode = WAL");
       this.db.run("PRAGMA synchronous = NORMAL");
+      this.db.run("PRAGMA wal_autocheckpoint = 1000");
+      this.db.run("PRAGMA cache_size = -32000");
+      this.db.run("PRAGMA analysis_limit = 400");
+      const mmapSize = this.options.mmapSize ?? 268435456;
+      if (mmapSize > 0) {
+        this.db.run(`PRAGMA mmap_size = ${mmapSize}`);
+      }
+      this.db.run("PRAGMA temp_store = MEMORY");
+      this.db.run("PRAGMA locking_mode = NORMAL");
     }
     this.db.run(`
 			CREATE TABLE IF NOT EXISTS "${this.tableName}" (
@@ -12962,8 +13477,17 @@ class BunSQLiteStorageInstance {
     if (this.schema.indexes) {
       for (const index of this.schema.indexes) {
         const fields = Array.isArray(index) ? index : [index];
-        const indexName = `idx_${this.tableName}_${fields.join("_")}`;
-        const columns = fields.map((field) => `json_extract(data, '$.${field}')`).join(", ");
+        const indexName = `idx_${this.tableName}_${fields.join("_").replace(/[()]/g, "_")}`;
+        const columns = fields.map((field) => {
+          if (typeof field !== "string")
+            return `json_extract(data, '$.${field}')`;
+          const funcMatch = field.match(/^(\w+)\((.+)\)$/);
+          if (funcMatch) {
+            const [, func, fieldName] = funcMatch;
+            return `${func}(json_extract(data, '$.${fieldName}'))`;
+          }
+          return `json_extract(data, '$.${field}')`;
+        }).join(", ");
         this.db.run(`CREATE INDEX IF NOT EXISTS "${indexName}" ON "${this.tableName}"(${columns})`);
       }
     }
@@ -12976,69 +13500,85 @@ class BunSQLiteStorageInstance {
 		`);
   }
   async bulkWrite(documentWrites, context) {
-    if (documentWrites.length === 0) {
-      return { error: [] };
-    }
-    const ids = documentWrites.map((w) => w.document[this.primaryPath]);
-    const docsInDb = await this.findDocumentsById(ids, true);
-    const docsInDbMap = new Map(docsInDb.map((d) => [d[this.primaryPath], d]));
-    const categorized = categorizeBulkWriteRows(this, this.primaryPath, docsInDbMap, documentWrites, context);
-    const insertQuery = `INSERT INTO "${this.tableName}" (id, data, deleted, rev, mtime_ms) VALUES (?, jsonb(?), ?, ?, ?)`;
-    const updateQuery = `UPDATE "${this.tableName}" SET data = jsonb(?), deleted = ?, rev = ?, mtime_ms = ? WHERE id = ?`;
-    for (const row of categorized.bulkInsertDocs) {
-      const doc = row.document;
-      const id = doc[this.primaryPath];
-      try {
-        this.stmtManager.run({ query: insertQuery, params: [id, JSON.stringify(doc), doc._deleted ? 1 : 0, doc._rev, doc._meta.lwt] });
-      } catch (err) {
-        if (err.code === "SQLITE_CONSTRAINT_PRIMARYKEY" || err.code === "SQLITE_CONSTRAINT_UNIQUE") {
-          const documentInDb = docsInDbMap.get(id);
-          categorized.errors.push({
-            isError: true,
-            status: 409,
-            documentId: id,
-            writeRow: row,
-            documentInDb: documentInDb || doc
-          });
-        } else {
-          throw err;
+    return sqliteTransaction(this.db, async () => {
+      if (documentWrites.length === 0) {
+        return { error: [] };
+      }
+      const ids = documentWrites.map((w) => w.document[this.primaryPath]);
+      const docsInDb = await this.findDocumentsById(ids, true);
+      const docsInDbMap = new Map(docsInDb.map((d) => [d[this.primaryPath], d]));
+      const categorized = categorizeBulkWriteRows(this, this.primaryPath, docsInDbMap, documentWrites, context);
+      const updateQuery = `UPDATE "${this.tableName}" SET data = jsonb(?), deleted = ?, rev = ?, mtime_ms = ? WHERE id = ?`;
+      const BATCH_SIZE = 100;
+      for (let i = 0;i < categorized.bulkInsertDocs.length; i += BATCH_SIZE) {
+        const batch = categorized.bulkInsertDocs.slice(i, i + BATCH_SIZE);
+        const placeholders = batch.map(() => "(?, jsonb(?), ?, ?, ?)").join(", ");
+        const insertQuery = `INSERT INTO "${this.tableName}" (id, data, deleted, rev, mtime_ms) VALUES ${placeholders}`;
+        const params = [];
+        for (const row of batch) {
+          const doc = row.document;
+          const id = doc[this.primaryPath];
+          params.push(id, JSON.stringify(doc), doc._deleted ? 1 : 0, doc._rev, doc._meta.lwt);
+        }
+        try {
+          this.stmtManager.run({ query: insertQuery, params });
+        } catch (err) {
+          if (err && typeof err === "object" && "code" in err && (err.code === "SQLITE_CONSTRAINT_PRIMARYKEY" || err.code === "SQLITE_CONSTRAINT_UNIQUE")) {
+            for (const row of batch) {
+              const doc = row.document;
+              const id = doc[this.primaryPath];
+              const documentInDb = docsInDbMap.get(id);
+              categorized.errors.push({
+                isError: true,
+                status: 409,
+                documentId: id,
+                writeRow: row,
+                documentInDb: documentInDb || doc
+              });
+            }
+          } else {
+            throw err;
+          }
         }
       }
-    }
-    for (const row of categorized.bulkUpdateDocs) {
-      const doc = row.document;
-      const id = doc[this.primaryPath];
-      this.stmtManager.run({ query: updateQuery, params: [JSON.stringify(doc), doc._deleted ? 1 : 0, doc._rev, doc._meta.lwt, id] });
-    }
-    const insertAttQuery = `INSERT OR REPLACE INTO "${this.tableName}_attachments" (id, data, digest) VALUES (?, ?, ?)`;
-    const deleteAttQuery = `DELETE FROM "${this.tableName}_attachments" WHERE id = ?`;
-    for (const att of [...categorized.attachmentsAdd, ...categorized.attachmentsUpdate]) {
-      this.stmtManager.run({
-        query: insertAttQuery,
-        params: [
-          this.attachmentMapKey(att.documentId, att.attachmentId),
-          att.attachmentData.data,
-          att.digest
-        ]
-      });
-    }
-    for (const att of categorized.attachmentsRemove) {
-      this.stmtManager.run({
-        query: deleteAttQuery,
-        params: [this.attachmentMapKey(att.documentId, att.attachmentId)]
-      });
-    }
-    const failedDocIds = new Set(categorized.errors.map((e) => e.documentId));
-    categorized.eventBulk.events = categorized.eventBulk.events.filter((event) => !failedDocIds.has(event.documentId));
-    if (categorized.eventBulk.events.length > 0 && categorized.newestRow) {
-      const lastState = categorized.newestRow.document;
-      categorized.eventBulk.checkpoint = {
-        id: lastState[this.primaryPath],
-        lwt: lastState._meta.lwt
-      };
-      this.changeStream$.next(categorized.eventBulk);
-    }
-    return { error: categorized.errors };
+      for (let i = 0;i < categorized.bulkUpdateDocs.length; i += BATCH_SIZE) {
+        const batch = categorized.bulkUpdateDocs.slice(i, i + BATCH_SIZE);
+        for (const row of batch) {
+          const doc = row.document;
+          const id = doc[this.primaryPath];
+          this.stmtManager.run({ query: updateQuery, params: [JSON.stringify(doc), doc._deleted ? 1 : 0, doc._rev, doc._meta.lwt, id] });
+        }
+      }
+      const insertAttQuery = `INSERT OR REPLACE INTO "${this.tableName}_attachments" (id, data, digest) VALUES (?, ?, ?)`;
+      const deleteAttQuery = `DELETE FROM "${this.tableName}_attachments" WHERE id = ?`;
+      for (const att of [...categorized.attachmentsAdd, ...categorized.attachmentsUpdate]) {
+        this.stmtManager.run({
+          query: insertAttQuery,
+          params: [
+            this.attachmentMapKey(att.documentId, att.attachmentId),
+            att.attachmentData.data,
+            att.digest
+          ]
+        });
+      }
+      for (const att of categorized.attachmentsRemove) {
+        this.stmtManager.run({
+          query: deleteAttQuery,
+          params: [this.attachmentMapKey(att.documentId, att.attachmentId)]
+        });
+      }
+      const failedDocIds = new Set(categorized.errors.map((e) => e.documentId));
+      categorized.eventBulk.events = categorized.eventBulk.events.filter((event) => !failedDocIds.has(event.documentId));
+      if (categorized.eventBulk.events.length > 0 && categorized.newestRow) {
+        const lastState = categorized.newestRow.document;
+        categorized.eventBulk.checkpoint = {
+          id: lastState[this.primaryPath],
+          lwt: lastState._meta.lwt
+        };
+        this.changeStream$.next(categorized.eventBulk);
+      }
+      return { error: categorized.errors };
+    });
   }
   async findDocumentsById(ids, withDeleted) {
     if (ids.length === 0)
@@ -13050,72 +13590,42 @@ class BunSQLiteStorageInstance {
     return rows.map((row) => JSON.parse(row.data));
   }
   async query(preparedQuery) {
-    try {
-      const { sql: whereClause, args } = buildWhereClause(preparedQuery.query.selector, this.schema);
-      const sql = `
-		SELECT json(data) as data FROM "${this.tableName}"
-			WHERE (${whereClause})
-		`;
-      if (process.env.DEBUG_QUERIES) {
-        const explainSql = `EXPLAIN QUERY PLAN ${sql}`;
-        const plan = this.stmtManager.all({ query: explainSql, params: args });
-        console.log("[DEBUG_QUERIES] Query plan:", JSON.stringify(plan, null, 2));
-        console.log("[DEBUG_QUERIES] SQL:", sql);
-        console.log("[DEBUG_QUERIES] Args:", args);
-      }
-      const rows = this.stmtManager.all({ query: sql, params: args });
-      let documents = rows.map((row) => JSON.parse(row.data));
-      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);
-      }
-      return { documents };
-    } catch (err) {
-      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.matchesSelector(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);
-      }
-      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;
+    const whereResult = buildWhereClause(preparedQuery.query.selector, this.schema, this.collectionName);
+    if (!whereResult) {
+      return this.queryWithOurMemory(preparedQuery);
+    }
+    const { sql: whereClause, args } = whereResult;
+    let sql = `SELECT json(data) as data FROM "${this.tableName}" WHERE (${whereClause})`;
+    const queryArgs = [...args];
+    if (preparedQuery.query.sort && preparedQuery.query.sort.length > 0) {
+      const orderBy = preparedQuery.query.sort.map((sortField) => {
+        const [field, direction] = Object.entries(sortField)[0];
+        const dir = direction === "asc" ? "ASC" : "DESC";
+        return `json_extract(data, '$.${field}') ${dir}`;
+      }).join(", ");
+      sql += ` ORDER BY ${orderBy}`;
+    }
+    if (preparedQuery.query.limit) {
+      sql += ` LIMIT ?`;
+      queryArgs.push(preparedQuery.query.limit);
+    }
+    if (preparedQuery.query.skip) {
+      if (!preparedQuery.query.limit) {
+        sql += ` LIMIT -1`;
+      }
+      sql += ` OFFSET ?`;
+      queryArgs.push(preparedQuery.query.skip);
+    }
+    if (process.env.DEBUG_QUERIES) {
+      const explainSql = `EXPLAIN QUERY PLAN ${sql}`;
+      const plan = this.stmtManager.all({ query: explainSql, params: queryArgs });
+      console.log("[DEBUG_QUERIES] Query plan:", JSON.stringify(plan, null, 2));
+      console.log("[DEBUG_QUERIES] SQL:", sql);
+      console.log("[DEBUG_QUERIES] Args:", queryArgs);
+    }
+    const rows = this.stmtManager.all({ query: sql, params: queryArgs });
+    const documents = rows.map((row) => JSON.parse(row.data));
+    return { documents };
   }
   sortDocuments(docs, sort) {
     return docs.sort((a, b) => {
@@ -13135,9 +13645,18 @@ class BunSQLiteStorageInstance {
     return path2.split(".").reduce((current, key) => current?.[key], obj);
   }
   async count(preparedQuery) {
-    const result = await this.query(preparedQuery);
+    const whereResult = buildWhereClause(preparedQuery.query.selector, this.schema, this.collectionName);
+    if (!whereResult) {
+      const allDocs = await this.queryWithOurMemory(preparedQuery);
+      return {
+        count: allDocs.documents.length,
+        mode: "fast"
+      };
+    }
+    const { sql, args } = whereResult;
+    const result = this.db.query(`SELECT COUNT(*) as count FROM "${this.tableName}" WHERE (${sql})`).get(...args);
     return {
-      count: result.documents.length,
+      count: result?.count ?? 0,
       mode: "fast"
     };
   }
@@ -13198,9 +13717,64 @@ class BunSQLiteStorageInstance {
     const rows = this.stmtManager.all({ query: sql, params: [checkpointLwt, checkpointLwt, checkpointId, limit] });
     const documents = rows.map((row) => JSON.parse(row.data));
     const lastDoc = documents[documents.length - 1];
-    const newCheckpoint = lastDoc ? { id: lastDoc[this.primaryPath], lwt: lastDoc._meta.lwt } : checkpoint ?? null;
+    const newCheckpoint = lastDoc ? {
+      id: String(lastDoc[this.primaryPath]),
+      lwt: lastDoc._meta.lwt
+    } : checkpoint ?? null;
     return { documents, checkpoint: newCheckpoint };
   }
+  queryWithOurMemory(preparedQuery) {
+    const query = `SELECT json(data) as data FROM "${this.tableName}"`;
+    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 };
+  }
+  matchesRegexSelector(doc, selector) {
+    for (const [field, value] of Object.entries(selector)) {
+      if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        const ops = value;
+        if (ops.$regex) {
+          const fieldValue = this.getNestedValue(doc, field);
+          const pattern = ops.$regex;
+          const options = ops.$options;
+          if (!matchesRegex(fieldValue, pattern, options))
+            return false;
+        }
+      }
+    }
+    return true;
+  }
 }
 
 // src/storage.ts