@noy-db/hub 0.2.0-pre.14 → 0.2.0-pre.16

package/dist/indexing/index.cjs

@@ -33,6 +33,92 @@ __export(indexing_exports, {
 });
 module.exports = __toCommonJS(indexing_exports);
 
+// src/errors.ts
+var NoydbError = class extends Error {
+  /** Machine-readable error code. Stable across library versions. */
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "NoydbError";
+    this.code = code;
+  }
+};
+var IndexRequiredError = class extends NoydbError {
+  collection;
+  touchedFields;
+  missingFields;
+  constructor(args) {
+    super(
+      "INDEX_REQUIRED",
+      `Collection "${args.collection}": query references unindexed fields in lazy mode (missing: ${args.missingFields.join(", ")}). Declare an index on each field, or use collection.scan() for non-indexed iteration.`
+    );
+    this.name = "IndexRequiredError";
+    this.collection = args.collection;
+    this.touchedFields = [...args.touchedFields];
+    this.missingFields = [...args.missingFields];
+  }
+};
+
+// src/money/where.ts
+function isMoneyValueObject(v) {
+  return typeof v === "object" && v !== null && "currency" in v;
+}
+function readStored(actual, operand) {
+  let amount;
+  let currency;
+  if (operand.mode === "fixed") {
+    if (typeof actual !== "string" && typeof actual !== "number") return null;
+    amount = actual;
+    currency = operand.entries[0]?.currency ?? "";
+  } else {
+    if (!isMoneyValueObject(actual)) return null;
+    if (typeof actual.currency !== "string") return null;
+    amount = actual.amount;
+    currency = actual.currency;
+  }
+  if (typeof amount !== "string" && typeof amount !== "number") return null;
+  try {
+    return { scaled: BigInt(amount).toString(), currency };
+  } catch {
+    return null;
+  }
+}
+function evaluateMoneyClause(actual, op, operand) {
+  const stored = readStored(actual, operand);
+  if (stored === null) return op === "!=";
+  const a = BigInt(stored.scaled);
+  if (op === "in") {
+    return operand.entries.some(
+      (e2) => e2.currency === stored.currency && BigInt(e2.scaled) === a
+    );
+  }
+  if (op === "between") {
+    const [lo, hi] = operand.entries;
+    if (!lo || !hi || lo.currency !== stored.currency) return false;
+    return a >= BigInt(lo.scaled) && a <= BigInt(hi.scaled);
+  }
+  const e = operand.entries[0];
+  if (!e) return false;
+  if (e.currency !== stored.currency) return op === "!=";
+  const b = BigInt(e.scaled);
+  switch (op) {
+    case "==":
+      return a === b;
+    case "!=":
+      return a !== b;
+    case "<":
+      return a < b;
+    case "<=":
+      return a <= b;
+    case ">":
+      return a > b;
+    case ">=":
+      return a >= b;
+    default:
+      return false;
+  }
+}
+
 // src/query/predicate.ts
 function readPath(record, path) {
   if (record === null || record === void 0) return void 0;
@@ -50,6 +136,7 @@ function readPath(record, path) {
 function evaluateFieldClause(record, clause) {
   const actual = readPath(record, clause.field);
   const { op, value } = clause;
+  if (clause.money) return evaluateMoneyClause(actual, op, clause.money);
   switch (op) {
     case "==":
       return actual === value;
@@ -90,14 +177,14 @@ function isComparable(a, b) {
   if (a instanceof Date && b instanceof Date) return true;
   return false;
 }
-function evaluateClause(record, clause) {
+function evaluateClause(record, clause, fnRecord) {
   switch (clause.type) {
     case "field":
       return evaluateFieldClause(record, clause);
     case "filter":
-      return clause.fn(record);
+      return clause.fn(fnRecord !== void 0 ? fnRecord : record);
     case "wherePredicate":
-      return clause.fn(record, clause.ctx);
+      return clause.fn(fnRecord !== void 0 ? fnRecord : record, clause.ctx);
     case "crossJoin":
       throw new Error(
         `evaluateClause: 'crossJoin' clauses are expansion primitives and are not evaluated per-record. This is a query planner routing error \u2014 crossJoin clauses must be extracted from the clause list before calling evaluateClause or filterRecords.`
@@ -105,12 +192,12 @@ function evaluateClause(record, clause) {
     case "group":
       if (clause.op === "and") {
         for (const child of clause.clauses) {
-          if (!evaluateClause(record, child)) return false;
+          if (!evaluateClause(record, child, fnRecord)) return false;
         }
         return true;
       } else {
         for (const child of clause.clauses) {
-          if (evaluateClause(record, child)) return true;
+          if (evaluateClause(record, child, fnRecord)) return true;
         }
         return false;
       }
@@ -545,32 +632,6 @@ function makeLazyState(persisted) {
   };
 }
 
-// src/errors.ts
-var NoydbError = class extends Error {
-  /** Machine-readable error code. Stable across library versions. */
-  code;
-  constructor(code, message) {
-    super(message);
-    this.name = "NoydbError";
-    this.code = code;
-  }
-};
-var IndexRequiredError = class extends NoydbError {
-  collection;
-  touchedFields;
-  missingFields;
-  constructor(args) {
-    super(
-      "INDEX_REQUIRED",
-      `Collection "${args.collection}": query references unindexed fields in lazy mode (missing: ${args.missingFields.join(", ")}). Declare an index on each field, or use collection.scan() for non-indexed iteration.`
-    );
-    this.name = "IndexRequiredError";
-    this.collection = args.collection;
-    this.touchedFields = [...args.touchedFields];
-    this.missingFields = [...args.missingFields];
-  }
-};
-
 // src/indexing/lazy-builder.ts
 var EMPTY_PLAN = {
   clauses: [],