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

package/dist/bundle/index.d.cts

@@ -1,7 +1,7 @@
-export { k as COMPRESSION_BROTLI, l as COMPRESSION_GZIP, m as COMPRESSION_NONE, C as CompressionAlgo, F as FLAG_COMPRESSED, n as FLAG_HAS_INTEGRITY_HASH, N as NOYDB_BUNDLE_FORMAT_VERSION, a as NOYDB_BUNDLE_MAGIC, b as NOYDB_BUNDLE_PREFIX_BYTES, c as NoydbBundleHeader, d as NoydbBundleReadResult, W as WriteNoydbBundleOptions, o as encodeBundleHeader, g as generateULID, i as isULID, r as readNoydbBundle, e as readNoydbBundleHeader, j as resetBrotliSupportCache, v as validateBundleHeader, w as writeNoydbBundle } from '../index-CywCC1qZ.cjs';
-import '../types-Bnb82f5R.cjs';
-import '../lazy-builder-CZVLKh0Z.cjs';
-import '../predicate-SBHmi6D0.cjs';
-import '../strategy-D-SrOLCl.cjs';
+export { l as COMPRESSION_BROTLI, m as COMPRESSION_GZIP, n as COMPRESSION_NONE, C as CompressionAlgo, F as FLAG_COMPRESSED, o as FLAG_HAS_INTEGRITY_HASH, N as NOYDB_BUNDLE_FORMAT_VERSION, b as NOYDB_BUNDLE_MAGIC, c as NOYDB_BUNDLE_PREFIX_BYTES, d as NoydbBundleHeader, e as NoydbBundleReadResult, R as ReadNoydbBundleOptions, W as WriteNoydbBundleOptions, p as encodeBundleHeader, g as generateULID, i as isULID, r as readNoydbBundle, f as readNoydbBundleHeader, k as resetBrotliSupportCache, v as validateBundleHeader, w as writeNoydbBundle } from '../index-hdFvZkBP.cjs';
+export { B as BackupCorruptedError, r as BackupLedgerError, s as BundleIntegrityError, t as BundleSealMismatchError, u as BundleVersionConflictError } from '../index-CmVgTkqk.cjs';
+import '../types-C4lwMKKF.cjs';
+import '../lazy-builder-C-rPfWG0.cjs';
+import '../predicate-Dnu81tsS.cjs';
+import '../strategy-DSTrsZ8t.cjs';
 import '../strategy-BSxFXGzb.cjs';
-import '../index-6xNpPsxR.cjs';

package/dist/bundle/index.d.ts

@@ -1,7 +1,7 @@
-export { k as COMPRESSION_BROTLI, l as COMPRESSION_GZIP, m as COMPRESSION_NONE, C as CompressionAlgo, F as FLAG_COMPRESSED, n as FLAG_HAS_INTEGRITY_HASH, N as NOYDB_BUNDLE_FORMAT_VERSION, a as NOYDB_BUNDLE_MAGIC, b as NOYDB_BUNDLE_PREFIX_BYTES, c as NoydbBundleHeader, d as NoydbBundleReadResult, W as WriteNoydbBundleOptions, o as encodeBundleHeader, g as generateULID, i as isULID, r as readNoydbBundle, e as readNoydbBundleHeader, j as resetBrotliSupportCache, v as validateBundleHeader, w as writeNoydbBundle } from '../index-8QDuznDr.js';
-import '../types-Bo7NSXJr.js';
-import '../lazy-builder-BwEoBQZ9.js';
-import '../predicate-SBHmi6D0.js';
-import '../strategy-D-SrOLCl.js';
+export { l as COMPRESSION_BROTLI, m as COMPRESSION_GZIP, n as COMPRESSION_NONE, C as CompressionAlgo, F as FLAG_COMPRESSED, o as FLAG_HAS_INTEGRITY_HASH, N as NOYDB_BUNDLE_FORMAT_VERSION, b as NOYDB_BUNDLE_MAGIC, c as NOYDB_BUNDLE_PREFIX_BYTES, d as NoydbBundleHeader, e as NoydbBundleReadResult, R as ReadNoydbBundleOptions, W as WriteNoydbBundleOptions, p as encodeBundleHeader, g as generateULID, i as isULID, r as readNoydbBundle, f as readNoydbBundleHeader, k as resetBrotliSupportCache, v as validateBundleHeader, w as writeNoydbBundle } from '../index-4agOpzqd.js';
+export { B as BackupCorruptedError, r as BackupLedgerError, s as BundleIntegrityError, t as BundleSealMismatchError, u as BundleVersionConflictError } from '../index-CNwA-B6-.js';
+import '../types-DW9RGSSs.js';
+import '../lazy-builder-Rpd-V3jP.js';
+import '../predicate-Dnu81tsS.js';
+import '../strategy-DSTrsZ8t.js';
 import '../strategy-BSxFXGzb.js';
-import '../index-DJTf9yxn.js';

package/dist/bundle/index.js

@@ -13,15 +13,26 @@ import {
   resetBrotliSupportCache,
   validateBundleHeader,
   writeNoydbBundle
-} from "../chunk-EXHNQEV4.js";
-import "../chunk-PTVMYYON.js";
+} from "../chunk-7H6DOO3E.js";
+import "../chunk-5SCJ5UEF.js";
 import {
   generateULID,
   isULID
 } from "../chunk-FZU343FL.js";
-import "../chunk-RKJ6OL7K.js";
-import "../chunk-ACLDOTNQ.js";
+import "../chunk-YS3POABP.js";
+import {
+  BackupCorruptedError,
+  BackupLedgerError,
+  BundleIntegrityError,
+  BundleSealMismatchError,
+  BundleVersionConflictError
+} from "../chunk-ADQ5MQ54.js";
 export {
+  BackupCorruptedError,
+  BackupLedgerError,
+  BundleIntegrityError,
+  BundleSealMismatchError,
+  BundleVersionConflictError,
   COMPRESSION_BROTLI,
   COMPRESSION_GZIP,
   COMPRESSION_NONE,

package/dist/{chunk-GOUT6DND.js → chunk-23TTQXVO.js}

@@ -1,11 +1,11 @@
 import {
   evaluateClause,
   readPath
-} from "./chunk-M5INGEFC.js";
+} from "./chunk-MRIBLZL3.js";
 import {
   DanglingReferenceError,
   JoinTooLargeError
-} from "./chunk-ACLDOTNQ.js";
+} from "./chunk-ADQ5MQ54.js";
 
 // src/query/join.ts
 var DEFAULT_JOIN_MAX_ROWS = 5e4;
@@ -244,6 +244,9 @@ var NO_AGGREGATE = {
   groupBy() {
     throw NOT_ENABLED;
   },
+  groupByN() {
+    throw NOT_ENABLED;
+  },
   scanAggregate() {
     throw NOT_ENABLED;
   }
@@ -262,11 +265,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) {
@@ -275,7 +350,8 @@ var Query = class _Query {
       this.source,
       { ...this.plan, clauses: [...this.plan.clauses, clause] },
       this.joinContext,
-      this.aggregateStrategy
+      this.aggregateStrategy,
+      this.predicates
     );
   }
   /**
@@ -285,7 +361,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",
@@ -296,7 +372,8 @@ var Query = class _Query {
       this.source,
       { ...this.plan, clauses: [...this.plan.clauses, group] },
       this.joinContext,
-      this.aggregateStrategy
+      this.aggregateStrategy,
+      this.predicates
     );
   }
   /**
@@ -305,7 +382,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",
@@ -316,7 +393,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. */
@@ -329,7 +407,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. */
@@ -338,7 +417,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. */
@@ -347,7 +427,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). */
@@ -356,7 +437,8 @@ var Query = class _Query {
       this.source,
       { ...this.plan, offset: n },
       this.joinContext,
-      this.aggregateStrategy
+      this.aggregateStrategy,
+      this.predicates
     );
   }
   /**
@@ -455,7 +537,8 @@ var Query = class _Query {
       this.source,
       { ...this.plan, joins: [...this.plan.joins, leg] },
       this.joinContext,
-      this.aggregateStrategy
+      this.aggregateStrategy,
+      this.predicates
     );
   }
   /**
@@ -547,53 +630,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 = () => {
@@ -605,36 +645,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.
@@ -860,6 +885,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",
@@ -869,6 +904,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/query/scan-builder.ts
 var DEFAULT_SCAN_PAGE_SIZE = 100;
@@ -1282,4 +1364,4 @@ export {
   executePlan,
   ScanBuilder
 };
-//# sourceMappingURL=chunk-GOUT6DND.js.map
+//# sourceMappingURL=chunk-23TTQXVO.js.map