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

package/dist/aggregate/index.cjs

@@ -25,6 +25,7 @@ __export(aggregate_exports, {
   GROUPBY_WARN_CARDINALITY: () => GROUPBY_WARN_CARDINALITY,
   GroupedAggregation: () => GroupedAggregation,
   GroupedQuery: () => GroupedQuery,
+  GroupedQueryN: () => GroupedQueryN,
   avg: () => avg,
   buildLiveAggregation: () => buildLiveAggregation,
   count: () => count,
@@ -176,6 +177,18 @@ function readPath(record, path) {
   return cursor;
 }
 
+// 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/errors.ts
 var NoydbError = class extends Error {
   /** Machine-readable error code. Stable across library versions. */
@@ -209,27 +222,37 @@ var GroupCardinalityError = class extends NoydbError {
 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
@@ -239,70 +262,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
@@ -312,17 +358,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 };
@@ -346,7 +397,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);
   }
 };
@@ -360,6 +411,9 @@ function withAggregate() {
     groupBy(executeRecords, field, upstreams, dictLabelResolver) {
       return new GroupedQuery(executeRecords, field, upstreams, dictLabelResolver);
     },
+    groupByN(executeRecords, fields, upstreams) {
+      return new GroupedQueryN(executeRecords, fields, upstreams);
+    },
     async scanAggregate(iter, spec) {
       const collected = [];
       for await (const record of iter) collected.push(record);
@@ -462,6 +516,7 @@ function readNumber(record, field) {
   GROUPBY_WARN_CARDINALITY,
   GroupedAggregation,
   GroupedQuery,
+  GroupedQueryN,
   avg,
   buildLiveAggregation,
   count,