bun-sqlite-for-rxdb 1.5.4 → 1.5.7

package/dist/index.js

@@ -12463,9 +12463,19 @@ function getColumnInfo(path2, schema) {
   const properties = schema.properties;
   const fieldSchema = properties?.[path2];
   if (fieldSchema && typeof fieldSchema === "object" && "type" in fieldSchema) {
-    if (fieldSchema.type === "array") {
+    const schemaType = fieldSchema.type;
+    if (schemaType === "array") {
       return { jsonPath: `$.${path2}`, type: "array" };
     }
+    if (schemaType === "string") {
+      return { jsonPath: `$.${path2}`, type: "string" };
+    }
+    if (schemaType === "number") {
+      return { jsonPath: `$.${path2}`, type: "number" };
+    }
+    if (schemaType === "boolean") {
+      return { jsonPath: `$.${path2}`, type: "boolean" };
+    }
   }
   return { jsonPath: `$.${path2}`, type: "unknown" };
 }
@@ -12526,32 +12536,41 @@ function smartRegexToLike(field, pattern, options, schema, fieldName) {
   const escaped = escapeForLike(unescaped);
   if (startsWithAnchor && endsWithAnchor) {
     if (caseInsensitive) {
-      return hasLowerIndex ? { sql: `LOWER(${field}) = ?`, args: [unescaped.toLowerCase()] } : { sql: `${field} = ? COLLATE NOCASE`, args: [unescaped] };
+      return { sql: `LOWER(${field}) = LOWER(?)`, args: [unescaped] };
     }
     return { sql: `${field} = ?`, args: [unescaped] };
   }
   if (startsWithAnchor) {
-    const suffix = caseInsensitive ? escaped.toLowerCase() : escaped;
-    if (caseInsensitive && hasLowerIndex) {
-      return { sql: `LOWER(${field}) LIKE ? ESCAPE '\\'`, args: [suffix + "%"] };
+    if (caseInsensitive) {
+      return { sql: `LOWER(${field}) LIKE LOWER(?) ESCAPE '\\'`, args: [escaped + "%"] };
     }
-    return { sql: `${field} LIKE ?${caseInsensitive ? " COLLATE NOCASE" : ""} ESCAPE '\\'`, args: [suffix + "%"] };
+    return { sql: `${field} LIKE ? ESCAPE '\\'`, args: [escaped + "%"] };
   }
   if (endsWithAnchor) {
-    const prefix = caseInsensitive ? escaped.toLowerCase() : escaped;
-    if (caseInsensitive && hasLowerIndex) {
-      return { sql: `LOWER(${field}) LIKE ? ESCAPE '\\'`, args: ["%" + prefix] };
+    if (caseInsensitive) {
+      return { sql: `LOWER(${field}) LIKE LOWER(?) ESCAPE '\\'`, args: ["%" + escaped] };
     }
-    return { sql: `${field} LIKE ?${caseInsensitive ? " COLLATE NOCASE" : ""} ESCAPE '\\'`, args: ["%" + prefix] };
+    return { sql: `${field} LIKE ? ESCAPE '\\'`, args: ["%" + escaped] };
   }
-  const middle = caseInsensitive ? escaped.toLowerCase() : escaped;
-  if (caseInsensitive && hasLowerIndex) {
-    return { sql: `LOWER(${field}) LIKE ? ESCAPE '\\'`, args: ["%" + middle + "%"] };
+  if (caseInsensitive) {
+    return { sql: `LOWER(${field}) LIKE LOWER(?) ESCAPE '\\'`, args: ["%" + escaped + "%"] };
   }
-  return { sql: `${field} LIKE ?${caseInsensitive ? " COLLATE NOCASE" : ""} ESCAPE '\\'`, args: ["%" + middle + "%"] };
+  return { sql: `${field} LIKE ? ESCAPE '\\'`, args: ["%" + escaped + "%"] };
 }
 
 // src/query/operators.ts
+function buildJsonPath(fieldName) {
+  const segments = fieldName.split(".");
+  let path2 = "$";
+  for (const segment of segments) {
+    if (/^\d+$/.test(segment)) {
+      path2 += `[${segment}]`;
+    } else {
+      path2 += `.${segment}`;
+    }
+  }
+  return path2;
+}
 function normalizeValueForSQLite(value) {
   if (value instanceof Date) {
     return value.toISOString();
@@ -12715,6 +12734,18 @@ function translateExists(field, exists) {
   };
 }
 function translateRegex(field, pattern, options, schema, fieldName) {
+  const columnInfo = getColumnInfo(fieldName, schema);
+  const isArray = field !== "value" && columnInfo.type === "array";
+  if (isArray) {
+    const smartResult2 = smartRegexToLike("value", pattern, options, schema, fieldName);
+    if (smartResult2) {
+      return {
+        sql: `EXISTS (SELECT 1 FROM jsonb_each(${field}) WHERE ${smartResult2.sql})`,
+        args: smartResult2.args
+      };
+    }
+    return null;
+  }
   const smartResult = smartRegexToLike(field, pattern, options, schema, fieldName);
   if (smartResult)
     return smartResult;
@@ -12757,7 +12788,7 @@ function handleLogicalOperator(operator, value, schema, baseFieldName) {
   };
 }
 function handleFieldCondition(fieldName, value, schema, baseFieldName) {
-  const propertyField = `json_extract(value, '$.${fieldName}')`;
+  const propertyField = `json_extract(value, '${buildJsonPath(fieldName)}')`;
   const nestedFieldName = `${baseFieldName}.${fieldName}`;
   if (typeof value === "object" && value !== null && !Array.isArray(value)) {
     if (value instanceof RegExp) {
@@ -12831,17 +12862,14 @@ 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 jsonb_each(${field}) WHERE value = ?)`,
-      args: [criteria]
-    };
+  if (typeof criteria !== "object" || criteria === null || Array.isArray(criteria)) {
+    return null;
   }
   if (criteria.$and && Array.isArray(criteria.$and)) {
     const fragments = criteria.$and.map((cond) => buildElemMatchConditions(cond, schema, actualFieldName));
     if (fragments.some((f) => f === null))
       return null;
-    const sql = fragments.map((f) => f.sql).join(" AND ");
+    const 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})`,
@@ -12852,7 +12880,7 @@ function translateElemMatch(field, criteria, schema, actualFieldName) {
     const fragments = criteria.$or.map((cond) => buildElemMatchConditions(cond, schema, actualFieldName));
     if (fragments.some((f) => f === null))
       return null;
-    const sql = fragments.map((f) => f.sql).join(" OR ");
+    const 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})`,
@@ -12863,7 +12891,7 @@ function translateElemMatch(field, criteria, schema, actualFieldName) {
     const fragments = criteria.$nor.map((cond) => buildElemMatchConditions(cond, schema, actualFieldName));
     if (fragments.some((f) => f === null))
       return null;
-    const sql = fragments.map((f) => f.sql).join(" OR ");
+    const 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}))`,
@@ -12874,7 +12902,7 @@ function translateElemMatch(field, criteria, schema, actualFieldName) {
   if (!fragment)
     return null;
   return {
-    sql: `EXISTS (SELECT 1 FROM jsonb_each(${field}) WHERE ${fragment.sql})`,
+    sql: `EXISTS (SELECT 1 FROM jsonb_each(${field}) WHERE ${asBoolean(fragment.sql)})`,
     args: fragment.args
   };
 }
@@ -12898,8 +12926,21 @@ function translateLeafOperator(op, field, value, schema, actualFieldName) {
       return translateNin(field, value, schema, actualFieldName);
     case "$exists":
       return translateExists(field, value);
-    case "$size":
-      return translateSize(field, value);
+    case "$size": {
+      const columnInfo = getColumnInfo(actualFieldName, schema);
+      if (columnInfo.type !== "array" && columnInfo.type !== "unknown") {
+        return { sql: "1=0", args: [] };
+      }
+      let jsonColumn = "data";
+      let jsonPath = actualFieldName;
+      let isDirectPath = false;
+      if (field === "value") {
+        jsonColumn = "value";
+        jsonPath = "";
+        isDirectPath = true;
+      }
+      return translateSize(jsonColumn, jsonPath, value, isDirectPath);
+    }
     case "$mod": {
       const result = translateMod(field, value);
       if (!result)
@@ -12965,9 +13006,12 @@ function translateLeafOperator(op, field, value, schema, actualFieldName) {
       return translateEq(field, value, schema, actualFieldName);
   }
 }
+function asBoolean(sql) {
+  return `COALESCE((${sql}), 0)`;
+}
 function wrapWithNot(innerFragment) {
   return {
-    sql: `NOT (${innerFragment.sql})`,
+    sql: `NOT (${asBoolean(innerFragment.sql)})`,
     args: innerFragment.args
   };
 }
@@ -12977,22 +13021,28 @@ function translateType(jsonColumn, fieldName, type6, isDirectPath = false) {
     case "null":
       return { sql: `json_type(${jsonColumn}, '${jsonPath}') = 'null'`, args: [] };
     case "boolean":
+    case "bool":
       return { sql: `json_type(${jsonColumn}, '${jsonPath}') IN ('true', 'false')`, args: [] };
     case "number":
+    case "int":
+    case "long":
+    case "double":
+    case "decimal":
       return { sql: `json_type(${jsonColumn}, '${jsonPath}') IN ('integer', 'real')`, args: [] };
     case "string":
-      return { sql: `json_type(${jsonColumn}, '${jsonPath}') = 'text'`, args: [] };
+      return { sql: `COALESCE(json_type(${jsonColumn}, '${jsonPath}') = 'text', 0)`, args: [] };
     case "array":
       return { sql: `json_type(${jsonColumn}, '${jsonPath}') = 'array'`, args: [] };
     case "object":
       return { sql: `json_type(${jsonColumn}, '${jsonPath}') = 'object'`, args: [] };
     default:
-      return { sql: "1=0", args: [] };
+      return null;
   }
 }
-function translateSize(field, size) {
+function translateSize(jsonColumn, jsonPath, size, isDirectPath = false) {
+  const path2 = isDirectPath ? jsonPath : `$.${jsonPath}`;
   return {
-    sql: `json_array_length(${field}) = ?`,
+    sql: `json_array_length(${jsonColumn}, '${path2}') = ?`,
     args: [size]
   };
 }
@@ -13116,7 +13166,7 @@ function buildWhereClause(selector, schema, collectionName, cache) {
   if (!selector || typeof selector !== "object")
     return null;
   const actualCache = cache ?? getGlobalCache();
-  const cacheKey = `v${schema.version}_${stableStringify(selector)}`;
+  const cacheKey = `v3_${schema.version}_${stableStringify(selector)}`;
   const cached = actualCache.get(cacheKey);
   if (cached !== undefined) {
     return cached;
@@ -13153,6 +13203,9 @@ function splitSelector(selector, schema) {
   const jsSelector = jsConditions.length > 0 ? jsConditions.length === 1 ? jsConditions[0] : { $and: jsConditions } : null;
   return { sqlWhere, jsSelector };
 }
+function coerceToBoolean(sql) {
+  return `COALESCE((${sql}), 0)`;
+}
 function buildLogicalOperator(operator, conditions, schema, logicalDepth) {
   if (conditions.length === 0) {
     return { sql: operator === "or" ? "1=0" : "1=1", args: [] };
@@ -13160,9 +13213,12 @@ function buildLogicalOperator(operator, conditions, schema, logicalDepth) {
   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(operator === "and" ? " AND " : " OR ");
   const args = fragments.flatMap((f) => f.args);
-  return operator === "nor" ? { sql: `NOT(${sql})`, args } : { sql, args };
+  if (operator === "nor") {
+    return { sql: `NOT(${coerceToBoolean(sql)})`, args };
+  }
+  return { sql, args };
 }
 function processSelector(selector, schema, logicalDepth) {
   if (!selector || typeof selector !== "object")
@@ -13206,7 +13262,7 @@ function processSelector(selector, schema, logicalDepth) {
       continue;
     }
     const columnInfo = getColumnInfo(field, schema);
-    const fieldName = columnInfo.column || `json_extract(data, '${columnInfo.jsonPath}')`;
+    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)) {
       if (Object.keys(value).length === 0) {
@@ -13217,15 +13273,15 @@ function processSelector(selector, schema, logicalDepth) {
         let fragment;
         if (op === "$not") {
           if (typeof opValue !== "object" || opValue === null || Array.isArray(opValue)) {
-            const eqFrag = translateLeafOperator("$eq", fieldName, opValue, schema, actualFieldName);
-            if (!eqFrag)
+            const neFrag = translateLeafOperator("$ne", fieldName, opValue, schema, actualFieldName);
+            if (!neFrag)
               return null;
-            fragment = wrapWithNot(eqFrag);
+            fragment = neFrag;
           } else if (opValue instanceof Date) {
-            const eqFrag = translateLeafOperator("$eq", fieldName, opValue, schema, actualFieldName);
-            if (!eqFrag)
+            const neFrag = translateLeafOperator("$ne", fieldName, opValue, schema, actualFieldName);
+            if (!neFrag)
               return null;
-            fragment = wrapWithNot(eqFrag);
+            fragment = neFrag;
           } else if (opValue instanceof RegExp) {
             const regexFrag = translateLeafOperator("$regex", fieldName, opValue, schema, actualFieldName);
             if (!regexFrag)
@@ -13266,16 +13322,23 @@ function processSelector(selector, schema, logicalDepth) {
             } else {
               const hasOperators = innerKeys.some((k) => k.startsWith("$"));
               if (!hasOperators) {
-                const eqFrag = translateLeafOperator("$eq", fieldName, opValueObj, schema, actualFieldName);
-                if (!eqFrag)
+                const neFrag = translateLeafOperator("$ne", fieldName, opValueObj, schema, actualFieldName);
+                if (!neFrag)
                   return null;
-                fragment = wrapWithNot(eqFrag);
+                fragment = neFrag;
               } else {
                 const [[innerOp, innerVal]] = Object.entries(opValueObj);
-                const innerFrag = translateLeafOperator(innerOp, fieldName, innerVal, schema, actualFieldName);
-                if (!innerFrag)
-                  return null;
-                fragment = wrapWithNot(innerFrag);
+                if (innerOp === "$eq") {
+                  const neFrag = translateLeafOperator("$ne", fieldName, innerVal, schema, actualFieldName);
+                  if (!neFrag)
+                    return null;
+                  fragment = neFrag;
+                } else {
+                  const innerFrag = translateLeafOperator(innerOp, fieldName, innerVal, schema, actualFieldName);
+                  if (!innerFrag)
+                    return null;
+                  fragment = wrapWithNot(innerFrag);
+                }
               }
             }
           }
@@ -13300,7 +13363,7 @@ function processSelector(selector, schema, logicalDepth) {
         } else if (op === "$options") {
           continue;
         } else if (!op.startsWith("$")) {
-          const jsonPath = `json_extract(${fieldName}, '$.${op}')`;
+          const jsonPath = `json_extract(${fieldName}, '${buildJsonPath(op)}')`;
           const nestedFieldName = `${actualFieldName}.${op}`;
           const leafFrag = translateLeafOperator("$eq", jsonPath, opValue, schema, nestedFieldName);
           if (!leafFrag)
@@ -13811,6 +13874,7 @@ class BunSQLiteStorageInstance {
     this.initTable(filename);
   }
   initTable(filename) {
+    this.db.run("PRAGMA case_sensitive_like = ON");
     if (filename !== ":memory:") {
       this.db.run("PRAGMA journal_mode = WAL");
       this.db.run("PRAGMA synchronous = NORMAL");

package/dist/src/debug-array-index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=debug-array-index.d.ts.map

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

@@ -8,6 +8,7 @@ type OperatorExpression = {
     [key: string]: unknown;
 };
 export type ElemMatchCriteria = QueryValue | OperatorExpression;
+export declare function buildJsonPath(fieldName: string): string;
 export declare function translateEq<RxDocType>(field: string, value: unknown, schema?: RxJsonSchema<RxDocumentData<RxDocType>>, actualFieldName?: string): SqlFragment;
 export declare function translateNe<RxDocType>(field: string, value: unknown, schema?: RxJsonSchema<RxDocumentData<RxDocType>>, actualFieldName?: string): SqlFragment;
 export declare function translateGt<RxDocType>(field: string, value: unknown, schema?: RxJsonSchema<RxDocumentData<RxDocType>>, actualFieldName?: string): SqlFragment;
@@ -22,7 +23,7 @@ export declare function translateElemMatch<RxDocType>(field: string, criteria: E
 export declare function translateLeafOperator<RxDocType>(op: string, field: string, value: unknown, schema: RxJsonSchema<RxDocumentData<RxDocType>>, actualFieldName: string): SqlFragment | null;
 export declare function wrapWithNot(innerFragment: SqlFragment): SqlFragment;
 export declare function translateType(jsonColumn: string, fieldName: string, type: string, isDirectPath?: boolean): SqlFragment | null;
-export declare function translateSize(field: string, size: number): SqlFragment;
+export declare function translateSize(jsonColumn: string, jsonPath: string, size: number, isDirectPath?: boolean): SqlFragment;
 export declare function translateMod(field: string, value: unknown): SqlFragment | null;
 export {};
 //# sourceMappingURL=operators.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bun-sqlite-for-rxdb",
-  "version": "1.5.4",
+  "version": "1.5.7",
   "author": "adam2am",
   "repository": {
     "type": "git",
@@ -14,6 +14,7 @@
   "main": "dist/index.js",
   "dependencies": {},
   "devDependencies": {
+    "@msgpack/msgpack": "^3.1.3",
     "@types/better-sqlite3": "^7.6.13",
     "@types/bun": "latest",
     "better-sqlite3": "^12.6.2",