@noy-db/hub 0.1.0-pre.8 → 0.2.0-pre.1

package/dist/query/index.cjs

@@ -23,10 +23,16 @@ __export(query_exports, {
   Aggregation: () => Aggregation,
   CollectionIndexes: () => CollectionIndexes,
   DEFAULT_JOIN_MAX_ROWS: () => DEFAULT_JOIN_MAX_ROWS,
+  DanglingReferenceError: () => DanglingReferenceError,
   GROUPBY_MAX_CARDINALITY: () => GROUPBY_MAX_CARDINALITY,
   GROUPBY_WARN_CARDINALITY: () => GROUPBY_WARN_CARDINALITY,
+  GroupCardinalityError: () => GroupCardinalityError,
   GroupedAggregation: () => GroupedAggregation,
   GroupedQuery: () => GroupedQuery,
+  GroupedQueryN: () => GroupedQueryN,
+  IndexRequiredError: () => IndexRequiredError,
+  IndexWriteFailureError: () => IndexWriteFailureError,
+  JoinTooLargeError: () => JoinTooLargeError,
   Query: () => Query,
   ScanBuilder: () => ScanBuilder,
   applyJoins: () => applyJoins,
@@ -111,6 +117,8 @@ function evaluateClause(record, clause) {
       return evaluateFieldClause(record, clause);
     case "filter":
       return clause.fn(record);
+    case "wherePredicate":
+      return clause.fn(record, clause.ctx);
     case "group":
       if (clause.op === "and") {
         for (const child of clause.clauses) {
@@ -154,6 +162,38 @@ var GroupCardinalityError = class extends NoydbError {
     this.maxGroups = maxGroups;
   }
 };
+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];
+  }
+};
+var IndexWriteFailureError = class extends NoydbError {
+  recordId;
+  field;
+  op;
+  cause;
+  constructor(args) {
+    super(
+      "INDEX_WRITE_FAILURE",
+      `Index side-car ${args.op} failed for field "${args.field}" on record "${args.recordId}"`
+    );
+    this.name = "IndexWriteFailureError";
+    this.recordId = args.recordId;
+    this.field = args.field;
+    this.op = args.op;
+    this.cause = args.cause;
+  }
+};
 var JoinTooLargeError = class extends NoydbError {
   leftRows;
   rightRows;
@@ -418,6 +458,9 @@ var NO_AGGREGATE = {
   groupBy() {
     throw NOT_ENABLED;
   },
+  groupByN() {
+    throw NOT_ENABLED;
+  },
   scanAggregate() {
     throw NOT_ENABLED;
   }
@@ -436,11 +479,83 @@ var Query = class _Query {
   plan;
   joinContext;
   aggregateStrategy;
-  constructor(source, plan = EMPTY_PLAN, joinContext, aggregateStrategy = NO_AGGREGATE) {
+  predicates;
+  constructor(source, plan = EMPTY_PLAN, joinContext, aggregateStrategy = NO_AGGREGATE, predicates) {
     this.source = source;
     this.plan = plan;
     this.joinContext = joinContext;
     this.aggregateStrategy = aggregateStrategy;
+    this.predicates = predicates;
+  }
+  /**
+   * @internal — accessor for the materialized-view dependency
+   * analyzer. Not part of the public API; consumers should use the
+   * builder methods, not inspect the plan directly.
+   */
+  _plan() {
+    return this.plan;
+  }
+  /**
+   * @internal — accessor for the materialized-view dependency
+   * analyzer. Returns the join resolution context (or `undefined` for
+   * queries constructed without a Collection backing).
+   */
+  _joinContext() {
+    return this.joinContext;
+  }
+  /**
+   * @internal — clone this Query with a declared-predicate map
+   * attached. Used by the materialized-view registry to enable
+   * `.wherePredicate(name, ctx?)` for the MV's query callback (#153).
+   * Consumers don't call this directly.
+   */
+  _withPredicates(predicates) {
+    return new _Query(
+      this.source,
+      this.plan,
+      this.joinContext,
+      this.aggregateStrategy,
+      predicates
+    );
+  }
+  /**
+   * Filter by a registered deterministic predicate (#153). Requires
+   * the Query to have been augmented with a predicates map (typically
+   * via the materialized-view registry — bare Queries constructed
+   * outside an MV throw on `.wherePredicate()`).
+   *
+   * `ctx` is an optional opaque value passed verbatim to the predicate
+   * function. Both `predicateHash` (from the registration) and a
+   * canonical-JSON hash of `ctx` fold into the MV's `queryHash`, so
+   * either changing forces refresh on next visit.
+   */
+  wherePredicate(name, ctx) {
+    if (!this.predicates) {
+      throw new Error(
+        `.wherePredicate("${name}"): no predicates registered on this Query. Function-based predicates require the Query to be obtained from inside a materialized-view query() callback whose strategy declares \`predicates: { ${name}: { hash, fn } }\`.`
+      );
+    }
+    const decl = this.predicates.get(name);
+    if (!decl) {
+      throw new Error(
+        `.wherePredicate("${name}"): predicate not registered. Available: ${[...this.predicates.keys()].join(", ") || "(none)"}.`
+      );
+    }
+    const clause = {
+      type: "wherePredicate",
+      name,
+      ctx,
+      predicateHash: decl.hash,
+      ctxHash: canonicalCtxHash(ctx),
+      fn: decl.fn
+    };
+    return new _Query(
+      this.source,
+      { ...this.plan, clauses: [...this.plan.clauses, clause] },
+      this.joinContext,
+      this.aggregateStrategy,
+      this.predicates
+    );
   }
   /** Add a field comparison. Multiple where() calls are AND-combined. */
   where(field, op, value) {
@@ -449,7 +564,8 @@ var Query = class _Query {
       this.source,
       { ...this.plan, clauses: [...this.plan.clauses, clause] },
       this.joinContext,
-      this.aggregateStrategy
+      this.aggregateStrategy,
+      this.predicates
     );
   }
   /**
@@ -459,7 +575,7 @@ var Query = class _Query {
    */
   or(builder) {
     const sub = builder(
-      new _Query(this.source, EMPTY_PLAN, this.joinContext, this.aggregateStrategy)
+      new _Query(this.source, EMPTY_PLAN, this.joinContext, this.aggregateStrategy, this.predicates)
     );
     const group = {
       type: "group",
@@ -470,7 +586,8 @@ var Query = class _Query {
       this.source,
       { ...this.plan, clauses: [...this.plan.clauses, group] },
       this.joinContext,
-      this.aggregateStrategy
+      this.aggregateStrategy,
+      this.predicates
     );
   }
   /**
@@ -479,7 +596,7 @@ var Query = class _Query {
    */
   and(builder) {
     const sub = builder(
-      new _Query(this.source, EMPTY_PLAN, this.joinContext, this.aggregateStrategy)
+      new _Query(this.source, EMPTY_PLAN, this.joinContext, this.aggregateStrategy, this.predicates)
     );
     const group = {
       type: "group",
@@ -490,7 +607,8 @@ var Query = class _Query {
       this.source,
       { ...this.plan, clauses: [...this.plan.clauses, group] },
       this.joinContext,
-      this.aggregateStrategy
+      this.aggregateStrategy,
+      this.predicates
     );
   }
   /** Escape hatch: add an arbitrary predicate function. Not serializable. */
@@ -503,7 +621,8 @@ var Query = class _Query {
       this.source,
       { ...this.plan, clauses: [...this.plan.clauses, clause] },
       this.joinContext,
-      this.aggregateStrategy
+      this.aggregateStrategy,
+      this.predicates
     );
   }
   /** Sort by a field. Subsequent calls are tie-breakers. */
@@ -512,7 +631,8 @@ var Query = class _Query {
       this.source,
       { ...this.plan, orderBy: [...this.plan.orderBy, { field, direction }] },
       this.joinContext,
-      this.aggregateStrategy
+      this.aggregateStrategy,
+      this.predicates
     );
   }
   /** Cap the result size. */
@@ -521,7 +641,8 @@ var Query = class _Query {
       this.source,
       { ...this.plan, limit: n },
       this.joinContext,
-      this.aggregateStrategy
+      this.aggregateStrategy,
+      this.predicates
     );
   }
   /** Skip the first N matching records (after ordering). */
@@ -530,7 +651,8 @@ var Query = class _Query {
       this.source,
       { ...this.plan, offset: n },
       this.joinContext,
-      this.aggregateStrategy
+      this.aggregateStrategy,
+      this.predicates
     );
   }
   /**
@@ -629,7 +751,8 @@ var Query = class _Query {
       this.source,
       { ...this.plan, joins: [...this.plan.joins, leg] },
       this.joinContext,
-      this.aggregateStrategy
+      this.aggregateStrategy,
+      this.predicates
     );
   }
   /**
@@ -721,53 +844,10 @@ var Query = class _Query {
     }
     return this.aggregateStrategy.aggregate(executeRecords, spec, upstreams);
   }
-  /**
-   * Partition matching records into buckets keyed by a field, then
-   * terminate with `.aggregate(spec)` to compute per-bucket
-   * reducers..
-   *
-   * ```ts
-   * const byClient = invoices.query()
-   *   .where('status', '==', 'open')
-   *   .groupBy('clientId')
-   *   .aggregate({ total: sum('amount'), n: count() })
-   *   .run()
-   * // → [ { clientId: 'c1', total: 5250, n: 3 }, … ]
-   * ```
-   *
-   * Result rows carry the group key value under the grouping field
-   * name plus every reducer output from the spec. Buckets are
-   * emitted in first-seen order — consumers who want a specific
-   * ordering should `.sort()` downstream.
-   *
-   * **Cardinality caps:** a one-shot warning fires at 10_000
-   * distinct groups; `GroupCardinalityError` throws at 100_000.
-   * Grouping on a high-uniqueness field like `id` or `createdAt` is
-   * almost always a query mistake — the error message names the
-   * field and observed cardinality and suggests narrowing with
-   * `.where()` first.
-   *
-   * **Null / undefined keys:** records with a missing or explicitly
-   * `null` group field get their own buckets. `Map`-based
-   * partitioning distinguishes `undefined` from `null`, so the two
-   * cases do NOT merge. Consumers who want them merged should
-   * coalesce upstream with `.filter()`.
-   *
-   * **Joins are not applied** — same rationale as `.count()` and
-   * `.aggregate()`. Joined fields in are projection-only, so
-   * running a join inside a grouping pipeline would be wasteful and
-   * could trigger `DanglingReferenceError` in strict mode for a
-   * call whose intent is purely to bucket-and-reduce. Grouping by
-   * a joined field is explicitly out of scope for — file an
-   * issue if a real consumer needs it.
-   *
-   * **Filter clauses (`.filter(fn)`):** grouped queries still
-   * support filter clauses in the underlying plan — they run in
-   * the same candidate/filter pipeline that `.aggregate()` uses.
-   * The performance caveat is the same: filter clauses cost O(N)
-   * per record and can't be index-accelerated.
-   */
-  groupBy(field) {
+  groupBy(...fields) {
+    if (fields.length === 0) {
+      throw new Error(".groupBy() requires at least one field");
+    }
     const source = this.source;
     const clauses = this.plan.clauses;
     const executeRecords = () => {
@@ -779,36 +859,21 @@ var Query = class _Query {
       const subscribe = source.subscribe.bind(source);
       upstreams.push({ subscribe: (cb) => subscribe(cb) });
     }
-    const joinCtx = this.joinContext;
-    const dictLabelResolver = joinCtx?.resolveDictSource ? (() => {
-      const dictSource = joinCtx.resolveDictSource(field);
-      if (!dictSource) return void 0;
-      const snapshot = dictSource.snapshot();
-      const dictMap = /* @__PURE__ */ new Map();
-      for (const entry of snapshot) {
-        const k = entry["key"];
-        const labels = entry["labels"];
-        if (typeof k === "string" && labels && typeof labels === "object") {
-          dictMap.set(k, labels);
-        }
-      }
-      return async (key, locale, fallback) => {
-        const labels = dictMap.get(key);
-        if (!labels) return void 0;
-        if (labels[locale] !== void 0) return labels[locale];
-        const chain = Array.isArray(fallback) ? fallback : fallback ? [fallback] : [];
-        for (const fb of chain) {
-          if (fb === "any") {
-            const any = Object.values(labels)[0];
-            if (any !== void 0) return any;
-          } else if (labels[fb] !== void 0) {
-            return labels[fb];
-          }
-        }
-        return void 0;
-      };
-    })() : void 0;
-    return this.aggregateStrategy.groupBy(executeRecords, field, upstreams, dictLabelResolver);
+    if (fields.length === 1) {
+      const field = fields[0];
+      const dictLabelResolver = buildDictLabelResolver(this.joinContext, field);
+      return this.aggregateStrategy.groupBy(
+        executeRecords,
+        field,
+        upstreams,
+        dictLabelResolver
+      );
+    }
+    return this.aggregateStrategy.groupByN(
+      executeRecords,
+      fields,
+      upstreams
+    );
   }
   /**
    * Re-run the query whenever the source notifies of changes.
@@ -1034,6 +1099,16 @@ function serializeClause(clause) {
   if (clause.type === "filter") {
     return { type: "filter", fn: "[function]" };
   }
+  if (clause.type === "wherePredicate") {
+    return {
+      type: "wherePredicate",
+      name: clause.name,
+      ctx: clause.ctx,
+      predicateHash: clause.predicateHash,
+      ctxHash: clause.ctxHash,
+      fn: "[function]"
+    };
+  }
   if (clause.type === "group") {
     return {
       type: "group",
@@ -1043,6 +1118,53 @@ function serializeClause(clause) {
   }
   return clause;
 }
+function canonicalCtxHash(ctx) {
+  if (ctx === void 0) return "";
+  const canonical = JSON.stringify(ctx, (_key, value) => {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      const sorted = {};
+      for (const k of Object.keys(value).sort()) {
+        sorted[k] = value[k];
+      }
+      return sorted;
+    }
+    return value;
+  });
+  let h = 5381;
+  for (let i = 0; i < canonical.length; i++) {
+    h = (h << 5) + h ^ canonical.charCodeAt(i);
+  }
+  return (h >>> 0).toString(16).padStart(8, "0");
+}
+function buildDictLabelResolver(joinCtx, field) {
+  if (!joinCtx?.resolveDictSource) return void 0;
+  const dictSource = joinCtx.resolveDictSource(field);
+  if (!dictSource) return void 0;
+  const snapshot = dictSource.snapshot();
+  const dictMap = /* @__PURE__ */ new Map();
+  for (const entry of snapshot) {
+    const k = entry["key"];
+    const labels = entry["labels"];
+    if (typeof k === "string" && labels && typeof labels === "object") {
+      dictMap.set(k, labels);
+    }
+  }
+  return async (key, locale, fallback) => {
+    const labels = dictMap.get(key);
+    if (!labels) return void 0;
+    if (labels[locale] !== void 0) return labels[locale];
+    const chain = Array.isArray(fallback) ? fallback : fallback ? [fallback] : [];
+    for (const fb of chain) {
+      if (fb === "any") {
+        const any = Object.values(labels)[0];
+        if (any !== void 0) return any;
+      } else if (labels[fb] !== void 0) {
+        return labels[fb];
+      }
+    }
+    return void 0;
+  };
+}
 
 // src/indexing/eager-indexes.ts
 var CollectionIndexes = class {
@@ -1379,31 +1501,53 @@ function buildLiveAggregation(recompute, upstreams) {
   return new LiveAggregationImpl(recompute, upstreams);
 }
 
+// src/aggregate/canonical-key.ts
+function canonicalGroupKey(fields, row) {
+  const sorted = [...fields].sort();
+  const parts = [];
+  for (const name of sorted) {
+    const v = row[name];
+    const serialised = v === void 0 ? "undefined" : JSON.stringify(v);
+    parts.push(`${name}=${serialised}`);
+  }
+  return parts.join("|");
+}
+
 // src/aggregate/groupby.ts
 var GROUPBY_WARN_CARDINALITY = 1e4;
 var GROUPBY_MAX_CARDINALITY = 1e5;
 var warnedCardinalityFields = /* @__PURE__ */ new Set();
-function warnCardinalityApproaching(field, observed) {
-  if (warnedCardinalityFields.has(field)) return;
-  warnedCardinalityFields.add(field);
+function warnCardinalityApproaching(fields, observed) {
+  const key = JSON.stringify([...fields].sort());
+  if (warnedCardinalityFields.has(key)) return;
+  warnedCardinalityFields.add(key);
+  const label = `[${fields.join(", ")}]`;
   console.warn(
-    `[noy-db] .groupBy("${field}") produced ${observed} distinct groups, ${Math.round(observed / GROUPBY_MAX_CARDINALITY * 100)}% of the ${GROUPBY_MAX_CARDINALITY}-group ceiling. Narrow the query with .where() before grouping, or switch to a lower-cardinality field.`
+    `[noy-db] .groupBy(${label}) produced ${observed} distinct groups, ${Math.round(observed / GROUPBY_MAX_CARDINALITY * 100)}% of the ${GROUPBY_MAX_CARDINALITY}-group ceiling. Narrow the query with .where() before grouping, or switch to a lower-cardinality field.`
   );
 }
 function resetGroupByWarnings() {
   warnedCardinalityFields.clear();
 }
-var GroupedQuery = class {
-  constructor(executeRecords, field, upstreams, dictLabelResolver) {
+var GroupedQueryBase = class {
+  constructor(executeRecords, fieldOrFields, upstreams, dictLabelResolver) {
     this.executeRecords = executeRecords;
-    this.field = field;
     this.upstreams = upstreams;
     this.dictLabelResolver = dictLabelResolver;
+    this.fields = typeof fieldOrFields === "string" ? [fieldOrFields] : [...fieldOrFields];
   }
   executeRecords;
-  field;
   upstreams;
   dictLabelResolver;
+  /**
+   * Field set this grouped query buckets on. Stored in declaration
+   * order — the same order is preserved on every result row by
+   * `groupAndReduce`. For the single-field constructor, this is
+   * `[field]`.
+   */
+  fields;
+};
+var GroupedQuery = class extends GroupedQueryBase {
   /**
    * Build a grouped aggregation. Returns a `GroupedAggregation`
    * with `.run()`, `.runAsync()`, and `.live()` terminals — same shape
@@ -1413,70 +1557,93 @@ var GroupedQuery = class {
   aggregate(spec) {
     return new GroupedAggregation(
       this.executeRecords,
-      this.field,
+      this.fields,
+      spec,
+      this.upstreams,
+      this.dictLabelResolver
+    );
+  }
+};
+var GroupedQueryN = class extends GroupedQueryBase {
+  aggregate(spec) {
+    return new GroupedAggregation(
+      this.executeRecords,
+      this.fields,
       spec,
       this.upstreams,
       this.dictLabelResolver
     );
   }
 };
-function groupAndReduce(records, field, spec) {
+function groupAndReduce(records, fieldOrFields, spec) {
+  const fields = typeof fieldOrFields === "string" ? [fieldOrFields] : fieldOrFields;
+  if (fields.length === 0) {
+    throw new Error(".groupBy() requires at least one field");
+  }
   const buckets = /* @__PURE__ */ new Map();
+  const fieldLabel = fields.length === 1 ? fields[0] : `[${fields.join(", ")}]`;
   for (const record of records) {
-    const key = readPath(record, field);
-    let bucket = buckets.get(key);
+    const keyValues = {};
+    for (const f of fields) {
+      keyValues[f] = readPath(record, f);
+    }
+    const dedupKey = canonicalGroupKey(fields, keyValues);
+    let bucket = buckets.get(dedupKey);
     if (bucket === void 0) {
       if (buckets.size >= GROUPBY_MAX_CARDINALITY) {
         throw new GroupCardinalityError(
-          field,
+          fieldLabel,
           buckets.size + 1,
           GROUPBY_MAX_CARDINALITY
         );
       }
-      bucket = [];
-      buckets.set(key, bucket);
+      bucket = { keyValues, records: [] };
+      buckets.set(dedupKey, bucket);
     }
-    bucket.push(record);
+    bucket.records.push(record);
   }
   if (buckets.size >= GROUPBY_WARN_CARDINALITY) {
-    warnCardinalityApproaching(field, buckets.size);
+    warnCardinalityApproaching(fields, buckets.size);
   }
-  const keys = Object.keys(spec);
+  const reducerKeys = Object.keys(spec);
   const out = [];
-  for (const [groupKey, bucketRecords] of buckets) {
+  for (const bucket of buckets.values()) {
     const state = {};
-    for (const key of keys) {
-      state[key] = spec[key].init();
+    for (const rk of reducerKeys) {
+      state[rk] = spec[rk].init();
     }
-    for (const record of bucketRecords) {
-      for (const key of keys) {
-        state[key] = spec[key].step(state[key], record);
+    for (const record of bucket.records) {
+      for (const rk of reducerKeys) {
+        state[rk] = spec[rk].step(state[rk], record);
       }
     }
-    const row = { [field]: groupKey };
-    for (const key of keys) {
-      row[key] = spec[key].finalize(state[key]);
+    const row = {};
+    for (const f of fields) {
+      row[f] = bucket.keyValues[f];
+    }
+    for (const rk of reducerKeys) {
+      row[rk] = spec[rk].finalize(state[rk]);
     }
     out.push(row);
   }
   return out;
 }
 var GroupedAggregation = class {
-  constructor(executeRecords, field, spec, upstreams, dictLabelResolver) {
+  constructor(executeRecords, fields, spec, upstreams, dictLabelResolver) {
     this.executeRecords = executeRecords;
-    this.field = field;
     this.spec = spec;
     this.upstreams = upstreams;
     this.dictLabelResolver = dictLabelResolver;
+    this.fields = typeof fields === "string" ? [fields] : [...fields];
   }
   executeRecords;
-  field;
   spec;
   upstreams;
   dictLabelResolver;
+  fields;
   /** Execute the query, group, reduce, and return an array of rows. */
   run() {
-    return groupAndReduce(this.executeRecords(), this.field, this.spec);
+    return groupAndReduce(this.executeRecords(), this.fields, this.spec);
   }
   /**
    * Execute the query, group, reduce, and resolve `<field>Label` for
@@ -1486,17 +1653,22 @@ var GroupedAggregation = class {
    *
    * The `<field>Label` field is appended to each row. Rows whose group
    * key has no dictionary entry get `<field>Label: undefined`.
+   *
+   * Dict-label resolution is single-field only — multi-key groupings
+   * do not produce a `<field>Label`. The resolver is only attached
+   * by the builder when `fields.length === 1`.
    */
   async runAsync(opts) {
-    const rows = groupAndReduce(this.executeRecords(), this.field, this.spec);
-    if (!opts?.locale || !this.dictLabelResolver) return rows;
+    const rows = groupAndReduce(this.executeRecords(), this.fields, this.spec);
+    if (!opts?.locale || !this.dictLabelResolver || this.fields.length !== 1) return rows;
     const resolve = this.dictLabelResolver;
     const locale = opts.locale;
     const fallback = opts.fallback;
-    const labelKey = `${this.field}Label`;
+    const field = this.fields[0];
+    const labelKey = `${field}Label`;
     return Promise.all(
       rows.map(async (row) => {
-        const key = row[this.field];
+        const key = row[field];
         if (typeof key !== "string") return row;
         const label = await resolve(key, locale, fallback);
         return { ...row, [labelKey]: label };
@@ -1520,7 +1692,7 @@ var GroupedAggregation = class {
    * Always call `live.stop()` when finished.
    */
   live() {
-    const recompute = () => groupAndReduce(this.executeRecords(), this.field, this.spec);
+    const recompute = () => groupAndReduce(this.executeRecords(), this.fields, this.spec);
     return buildLiveAggregation(recompute, this.upstreams);
   }
 };
@@ -1931,10 +2103,16 @@ function coerceRefKey2(value) {
   Aggregation,
   CollectionIndexes,
   DEFAULT_JOIN_MAX_ROWS,
+  DanglingReferenceError,
   GROUPBY_MAX_CARDINALITY,
   GROUPBY_WARN_CARDINALITY,
+  GroupCardinalityError,
   GroupedAggregation,
   GroupedQuery,
+  GroupedQueryN,
+  IndexRequiredError,
+  IndexWriteFailureError,
+  JoinTooLargeError,
   Query,
   ScanBuilder,
   applyJoins,