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

package/dist/{aggregate/index.cjs → chunk-LV7M27WM.js}

@@ -1,45 +1,153 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+import {
+  MoneyUnsupportedError,
+  formatScaledInt,
+  parseToScaledInt,
+  readPath,
+  scaleForCurrency
+} from "./chunk-M2YKN37S.js";
+import {
+  applyI18nLocale
+} from "./chunk-5LUY7UTV.js";
+import {
+  GroupCardinalityError
+} from "./chunk-ZYUC53LT.js";
+
+// src/with-lookup/aggregate/reducers.ts
+function count(opts) {
+  const _seed = opts?.seed;
+  void _seed;
+  return {
+    op: "count",
+    init: () => 0,
+    step: (state) => state + 1,
+    remove: (state) => state - 1,
+    finalize: (state) => state,
+    merge: (a, b) => a + b
+  };
+}
+function sum(field, opts) {
+  const _seed = opts?.seed;
+  void _seed;
+  return {
+    op: "sum",
+    field,
+    // Money-only metadata, read by `wrapMoneyReducers`. No effect on a
+    // generic numeric sum.
+    ...opts?.convertTo !== void 0 ? { convertTo: opts.convertTo } : {},
+    ...opts?.fx !== void 0 ? { fx: opts.fx } : {},
+    init: () => 0,
+    step: (state, record) => state + readNumber(record, field),
+    remove: (state, record) => state - readNumber(record, field),
+    finalize: (state) => state,
+    merge: (a, b) => a + b
+  };
+}
+function avg(field, opts) {
+  const _seed = opts?.seed;
+  void _seed;
+  return {
+    op: "avg",
+    field,
+    init: () => ({ sum: 0, count: 0 }),
+    step: (state, record) => ({
+      sum: state.sum + readNumber(record, field),
+      count: state.count + 1
+    }),
+    remove: (state, record) => ({
+      sum: state.sum - readNumber(record, field),
+      count: state.count - 1
+    }),
+    finalize: (state) => state.count === 0 ? null : state.sum / state.count,
+    merge: (a, b) => ({ sum: a.sum + b.sum, count: a.count + b.count })
+  };
+}
+function pushValue(state, value) {
+  return { values: [...state.values, value] };
+}
+function removeValue(state, value) {
+  const idx = state.values.indexOf(value);
+  if (idx < 0) return state;
+  const next = state.values.slice();
+  next.splice(idx, 1);
+  return { values: next };
+}
+function min(field, opts) {
+  const _seed = opts?.seed;
+  void _seed;
+  return {
+    op: "min",
+    field,
+    init: () => ({ values: [] }),
+    step: (state, record) => pushValue(state, readNumber(record, field)),
+    remove: (state, record) => removeValue(state, readNumber(record, field)),
+    finalize: (state) => {
+      if (state.values.length === 0) return null;
+      let out = state.values[0];
+      for (let i = 1; i < state.values.length; i++) {
+        const v = state.values[i];
+        if (v < out) out = v;
+      }
+      return out;
+    },
+    merge: (a, b) => ({ values: [...a.values, ...b.values] })
+  };
+}
+function max(field, opts) {
+  const _seed = opts?.seed;
+  void _seed;
+  return {
+    op: "max",
+    field,
+    init: () => ({ values: [] }),
+    step: (state, record) => pushValue(state, readNumber(record, field)),
+    remove: (state, record) => removeValue(state, readNumber(record, field)),
+    finalize: (state) => {
+      if (state.values.length === 0) return null;
+      let out = state.values[0];
+      for (let i = 1; i < state.values.length; i++) {
+        const v = state.values[i];
+        if (v > out) out = v;
+      }
+      return out;
+    },
+    merge: (a, b) => ({ values: [...a.values, ...b.values] })
+  };
+}
+function moneySum(field, opts) {
+  return sum(field, opts);
+}
+function moneyMin(field, opts) {
+  return min(field, opts);
+}
+function moneyMax(field, opts) {
+  return max(field, opts);
+}
+var reducerBuilder = {
+  count,
+  // The generic F parameter on sum/min/max in the interface is type-only; the
+  // standalone factories are plain `(field: string)` functions. With M=never the
+  // conditional return collapses to the numeric branch, matching the factories'
+  // return type, but TypeScript cannot verify that collapse for a generic method
+  // signature — so each factory is cast directly to the method's type.
+  sum,
+  avg,
+  min,
+  max,
+  moneySum,
+  moneyMin,
+  moneyMax
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+function readNumber(record, field) {
+  const value = readPath(record, field);
+  if (typeof value === "object" && value !== null && "amount" in value && "currency" in value) {
+    throw new Error(
+      `aggregate: field "${field}" holds a money value but was not money-aware \u2014 declare it in the collection's moneyFields so sum/min/max stay exact`
+    );
   }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/aggregate/index.ts
-var aggregate_exports = {};
-__export(aggregate_exports, {
-  Aggregation: () => Aggregation,
-  GROUPBY_MAX_CARDINALITY: () => GROUPBY_MAX_CARDINALITY,
-  GROUPBY_WARN_CARDINALITY: () => GROUPBY_WARN_CARDINALITY,
-  GroupedAggregation: () => GroupedAggregation,
-  GroupedQuery: () => GroupedQuery,
-  GroupedQueryN: () => GroupedQueryN,
-  avg: () => avg,
-  buildLiveAggregation: () => buildLiveAggregation,
-  count: () => count,
-  groupAndReduce: () => groupAndReduce,
-  max: () => max,
-  min: () => min,
-  reduceRecords: () => reduceRecords,
-  resetGroupByWarnings: () => resetGroupByWarnings,
-  sum: () => sum,
-  withAggregate: () => withAggregate
-});
-module.exports = __toCommonJS(aggregate_exports);
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
 
-// src/aggregate/aggregation.ts
+// src/with-lookup/aggregate/aggregation.ts
 function reduceRecords(records, spec) {
   const state = {};
   for (const key of Object.keys(spec)) {
@@ -162,22 +270,7 @@ function buildLiveAggregation(recompute, upstreams) {
   return new LiveAggregationImpl(recompute, upstreams);
 }
 
-// src/query/predicate.ts
-function readPath(record, path) {
-  if (record === null || record === void 0) return void 0;
-  if (!path.includes(".")) {
-    return record[path];
-  }
-  const segments = path.split(".");
-  let cursor = record;
-  for (const segment of segments) {
-    if (cursor === null || cursor === void 0) return void 0;
-    cursor = cursor[segment];
-  }
-  return cursor;
-}
-
-// src/aggregate/canonical-key.ts
+// src/with-lookup/aggregate/canonical-key.ts
 function canonicalGroupKey(fields, row) {
   const sorted = [...fields].sort();
   const parts = [];
@@ -189,36 +282,192 @@ function canonicalGroupKey(fields, row) {
   return parts.join("|");
 }
 
-// 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;
+// src/with-shape/money/money-reducer.ts
+function toScaledIntFromAny(v, scale) {
+  if (typeof v === "bigint") return v;
+  if (typeof v === "number") {
+    const r = parseToScaledInt(v, scale);
+    return r.ok ? r.value : null;
   }
-};
-var GroupCardinalityError = class extends NoydbError {
-  /** The field being grouped on. */
-  field;
-  /** Observed number of distinct groups at the moment the cap tripped. */
-  cardinality;
-  /** The cap that was exceeded. */
-  maxGroups;
-  constructor(field, cardinality, maxGroups) {
-    super(
-      "GROUP_CARDINALITY",
-      `.groupBy("${field}") produced ${cardinality} distinct groups, exceeding the ${maxGroups}-group ceiling. This is almost always a query mistake \u2014 grouping on a high-uniqueness field like "id" or "createdAt" produces one bucket per record. Narrow the query with .where() before grouping, or group on a lower-cardinality field (status, category, clientId). If you genuinely need high-cardinality grouping, file an issue with your use case.`
-    );
-    this.name = "GroupCardinalityError";
-    this.field = field;
-    this.cardinality = cardinality;
-    this.maxGroups = maxGroups;
+  if (typeof v === "string") {
+    if (!v.includes(".")) {
+      try {
+        return BigInt(v);
+      } catch {
+        return null;
+      }
+    }
+    const r = parseToScaledInt(v, scale);
+    return r.ok ? r.value : null;
   }
-};
+  return null;
+}
+function readMoney(record, field, desc) {
+  const raw = readPath(record, field);
+  if (raw === null || raw === void 0) return null;
+  if (desc.mode === "fixed") {
+    const cur = desc.fixedCurrency;
+    const value2 = toScaledIntFromAny(raw, desc.scaleFor(cur));
+    return value2 === null ? null : { currency: cur, value: value2 };
+  }
+  if (typeof raw !== "object") return null;
+  const o = raw;
+  if (typeof o.currency !== "string") return null;
+  const scale = desc.allows(o.currency) ? desc.scaleFor(o.currency) : 0;
+  const value = toScaledIntFromAny(o.amount, scale);
+  return value === null ? null : { currency: o.currency, value };
+}
+function targetScaleFor(desc, currency) {
+  if (desc.allows(currency)) return desc.scaleFor(currency);
+  const s = scaleForCurrency(currency);
+  if (s === null) {
+    throw new Error(`money: cannot determine scale for conversion target "${currency}"`);
+  }
+  return s;
+}
+function parseRate(rate) {
+  const s = String(rate).trim();
+  const neg = s.startsWith("-");
+  const body = neg ? s.slice(1) : s;
+  const dot = body.indexOf(".");
+  const intPart = dot === -1 ? body : body.slice(0, dot);
+  const fracPart = dot === -1 ? "" : body.slice(dot + 1);
+  const int = BigInt((intPart === "" ? "0" : intPart) + fracPart);
+  return { int: neg ? -int : int, scale: fracPart.length };
+}
+function divRoundHalfEven(n, d) {
+  const q = n / d;
+  const r = n % d;
+  const twiceR = (r < 0n ? -r : r) * 2n;
+  if (twiceR < d) return q;
+  if (twiceR > d) return q + (n < 0n ? -1n : 1n);
+  return q % 2n === 0n ? q : q + (n < 0n ? -1n : 1n);
+}
+function convertScaled(value, srcScale, rate, targetScale) {
+  const { int: rateInt, scale: rateScale } = parseRate(rate);
+  const product = value * rateInt;
+  const curScale = srcScale + rateScale;
+  if (curScale === targetScale) return product;
+  if (curScale < targetScale) return product * 10n ** BigInt(targetScale - curScale);
+  return divRoundHalfEven(product, 10n ** BigInt(curScale - targetScale));
+}
+function finalizeSum(state, desc, convertTo, fx) {
+  if (convertTo !== void 0) {
+    if (fx === void 0) {
+      throw new Error(`money: sum convertTo "${convertTo}" requires an fx rate map`);
+    }
+    const targetScale = targetScaleFor(desc, convertTo);
+    let total = 0n;
+    for (const [cur, v] of state) {
+      if (cur === convertTo) {
+        total += convertScaled(v, desc.scaleFor(cur), 1, targetScale);
+        continue;
+      }
+      const rate = fx[`${cur}->${convertTo}`];
+      if (rate === void 0) {
+        throw new Error(`money: no fx rate for "${cur}->${convertTo}"`);
+      }
+      total += convertScaled(v, desc.scaleFor(cur), rate, targetScale);
+    }
+    return formatScaledInt(total, targetScale);
+  }
+  if (desc.mode === "fixed") {
+    const cur = desc.fixedCurrency;
+    return formatScaledInt(state.get(cur) ?? 0n, desc.scaleFor(cur));
+  }
+  const out = {};
+  for (const [cur, v] of state) out[cur] = formatScaledInt(v, desc.scaleFor(cur));
+  return out;
+}
+function moneySumReducer(field, desc, convertTo, fx) {
+  return {
+    op: "sum",
+    field,
+    init: () => /* @__PURE__ */ new Map(),
+    step: (state, record) => {
+      const m = readMoney(record, field, desc);
+      if (m) state.set(m.currency, (state.get(m.currency) ?? 0n) + m.value);
+      return state;
+    },
+    remove: (state, record) => {
+      const m = readMoney(record, field, desc);
+      if (m) state.set(m.currency, (state.get(m.currency) ?? 0n) - m.value);
+      return state;
+    },
+    finalize: (state) => finalizeSum(state, desc, convertTo, fx)
+  };
+}
+function extremum(values, op) {
+  let out = values[0];
+  for (let i = 1; i < values.length; i++) {
+    const v = values[i];
+    if (op === "min" ? v < out : v > out) out = v;
+  }
+  return out;
+}
+function moneyMinMaxReducer(op, field, desc) {
+  return {
+    op,
+    field,
+    init: () => /* @__PURE__ */ new Map(),
+    step: (state, record) => {
+      const m = readMoney(record, field, desc);
+      if (m) {
+        const arr = state.get(m.currency);
+        if (arr) arr.push(m.value);
+        else state.set(m.currency, [m.value]);
+      }
+      return state;
+    },
+    remove: (state, record) => {
+      const m = readMoney(record, field, desc);
+      if (m) {
+        const arr = state.get(m.currency);
+        if (arr) {
+          const idx = arr.indexOf(m.value);
+          if (idx >= 0) arr.splice(idx, 1);
+        }
+      }
+      return state;
+    },
+    finalize: (state) => {
+      if (desc.mode === "fixed") {
+        const cur = desc.fixedCurrency;
+        const arr = state.get(cur);
+        if (!arr || arr.length === 0) return null;
+        return formatScaledInt(extremum(arr, op), desc.scaleFor(cur));
+      }
+      const out = {};
+      for (const [cur, arr] of state) {
+        if (arr.length > 0) out[cur] = formatScaledInt(extremum(arr, op), desc.scaleFor(cur));
+      }
+      return out;
+    }
+  };
+}
+function wrapMoneyReducers(spec, moneyFields) {
+  let changed = false;
+  const out = {};
+  for (const [key, reducer] of Object.entries(spec)) {
+    const field = reducer.field;
+    const desc = field ? moneyFields[field] : void 0;
+    if (desc && reducer.op === "avg") {
+      throw new MoneyUnsupportedError(
+        field,
+        `avg() is not supported on money field "${field}" in v1 \u2014 use sum() and count() and divide at the boundary.`
+      );
+    }
+    if (desc && (reducer.op === "sum" || reducer.op === "min" || reducer.op === "max")) {
+      changed = true;
+      out[key] = reducer.op === "sum" ? moneySumReducer(field, desc, reducer.convertTo, reducer.fx) : moneyMinMaxReducer(reducer.op, field, desc);
+    } else {
+      out[key] = reducer;
+    }
+  }
+  return changed ? out : spec;
+}
 
-// src/aggregate/groupby.ts
+// src/with-lookup/aggregate/groupby.ts
 var GROUPBY_WARN_CARDINALITY = 1e4;
 var GROUPBY_MAX_CARDINALITY = 1e5;
 var warnedCardinalityFields = /* @__PURE__ */ new Set();
@@ -235,15 +484,17 @@ function resetGroupByWarnings() {
   warnedCardinalityFields.clear();
 }
 var GroupedQueryBase = class {
-  constructor(executeRecords, fieldOrFields, upstreams, dictLabelResolver) {
+  constructor(executeRecords, fieldOrFields, upstreams, dictLabelResolver, moneyFields) {
     this.executeRecords = executeRecords;
     this.upstreams = upstreams;
     this.dictLabelResolver = dictLabelResolver;
+    this.moneyFields = moneyFields;
     this.fields = typeof fieldOrFields === "string" ? [fieldOrFields] : [...fieldOrFields];
   }
   executeRecords;
   upstreams;
   dictLabelResolver;
+  moneyFields;
   /**
    * Field set this grouped query buckets on. Stored in declaration
    * order — the same order is preserved on every result row by
@@ -251,40 +502,43 @@ var GroupedQueryBase = class {
    * `[field]`.
    */
   fields;
+  /** Apply money-aware reducer rewriting when money fields are declared. */
+  wrapSpec(spec) {
+    return this.moneyFields ? wrapMoneyReducers(spec, this.moneyFields) : spec;
+  }
 };
 var GroupedQuery = class extends GroupedQueryBase {
-  /**
-   * Build a grouped aggregation. Returns a `GroupedAggregation`
-   * with `.run()`, `.runAsync()`, and `.live()` terminals — same shape
-   * as the non-grouped `.aggregate()` wrapper, just with an array
-   * result (one row per bucket) instead of a single reduced object.
-   */
-  aggregate(spec) {
+  aggregate(specOrBuild) {
+    const spec = typeof specOrBuild === "function" ? specOrBuild(reducerBuilder) : specOrBuild;
     return new GroupedAggregation(
       this.executeRecords,
       this.fields,
-      spec,
+      this.wrapSpec(spec),
       this.upstreams,
       this.dictLabelResolver
     );
   }
 };
 var GroupedQueryN = class extends GroupedQueryBase {
-  aggregate(spec) {
+  aggregate(specOrBuild) {
+    const spec = typeof specOrBuild === "function" ? specOrBuild(reducerBuilder) : specOrBuild;
     return new GroupedAggregation(
       this.executeRecords,
       this.fields,
-      spec,
+      this.wrapSpec(spec),
       this.upstreams,
       this.dictLabelResolver
     );
   }
 };
-function groupAndReduce(records, fieldOrFields, spec) {
+function groupAndReduce(records, fieldOrFields, spec, moneyFields) {
   const fields = typeof fieldOrFields === "string" ? [fieldOrFields] : fieldOrFields;
   if (fields.length === 0) {
     throw new Error(".groupBy() requires at least one field");
   }
+  if (moneyFields) {
+    spec = wrapMoneyReducers(spec, moneyFields);
+  }
   const buckets = /* @__PURE__ */ new Map();
   const fieldLabel = fields.length === 1 ? fields[0] : `[${fields.join(", ")}]`;
   for (const record of records) {
@@ -346,9 +600,29 @@ var GroupedAggregation = class {
   upstreams;
   dictLabelResolver;
   fields;
-  /** Execute the query, group, reduce, and return an array of rows. */
-  run() {
-    return groupAndReduce(this.executeRecords(), this.fields, this.spec);
+  /**
+   * Execute the query, group, reduce, and return an array of rows.
+   *
+   * `opts` (query-form MV grouping): when a `locale` + `i18nFields` are
+   * given, the declared group-key `i18nText` fields are resolved to that locale
+   * at the `mv` layer BEFORE bucketing — so an i18n group key is a stable string
+   * instead of a raw `{locale}` map. The MV executor passes the MV's
+   * `i18nLocale`/`i18nFields`; ordinary `.run()` callers pass nothing and are
+   * unaffected.
+   */
+  run(opts) {
+    let records = this.executeRecords();
+    if (opts?.locale !== void 0 && opts.i18nFields !== void 0) {
+      const groupI18n = {};
+      for (const f of this.fields) {
+        const d = opts.i18nFields[f];
+        if (d !== void 0) groupI18n[f] = d;
+      }
+      if (Object.keys(groupI18n).length > 0) {
+        records = records.map((r) => applyI18nLocale(r, groupI18n, opts.locale, void 0, "mv"));
+      }
+    }
+    return groupAndReduce(records, this.fields, this.spec);
   }
   /**
    * Execute the query, group, reduce, and resolve `<field>Label` for
@@ -402,130 +676,27 @@ var GroupedAggregation = class {
   }
 };
 
-// src/aggregate/active.ts
-function withAggregate() {
-  return {
-    aggregate(executeRecords, spec, upstreams) {
-      return new Aggregation(executeRecords, spec, upstreams);
-    },
-    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);
-      return reduceRecords(collected, spec);
-    }
-  };
-}
-
-// src/aggregate/reducers.ts
-function count(opts) {
-  const _seed = opts?.seed;
-  void _seed;
-  return {
-    init: () => 0,
-    step: (state) => state + 1,
-    remove: (state) => state - 1,
-    finalize: (state) => state
-  };
-}
-function sum(field, opts) {
-  const _seed = opts?.seed;
-  void _seed;
-  return {
-    init: () => 0,
-    step: (state, record) => state + readNumber(record, field),
-    remove: (state, record) => state - readNumber(record, field),
-    finalize: (state) => state
-  };
-}
-function avg(field, opts) {
-  const _seed = opts?.seed;
-  void _seed;
-  return {
-    init: () => ({ sum: 0, count: 0 }),
-    step: (state, record) => ({
-      sum: state.sum + readNumber(record, field),
-      count: state.count + 1
-    }),
-    remove: (state, record) => ({
-      sum: state.sum - readNumber(record, field),
-      count: state.count - 1
-    }),
-    finalize: (state) => state.count === 0 ? null : state.sum / state.count
-  };
-}
-function pushValue(state, value) {
-  return { values: [...state.values, value] };
-}
-function removeValue(state, value) {
-  const idx = state.values.indexOf(value);
-  if (idx < 0) return state;
-  const next = state.values.slice();
-  next.splice(idx, 1);
-  return { values: next };
-}
-function min(field, opts) {
-  const _seed = opts?.seed;
-  void _seed;
-  return {
-    init: () => ({ values: [] }),
-    step: (state, record) => pushValue(state, readNumber(record, field)),
-    remove: (state, record) => removeValue(state, readNumber(record, field)),
-    finalize: (state) => {
-      if (state.values.length === 0) return null;
-      let out = state.values[0];
-      for (let i = 1; i < state.values.length; i++) {
-        const v = state.values[i];
-        if (v < out) out = v;
-      }
-      return out;
-    }
-  };
-}
-function max(field, opts) {
-  const _seed = opts?.seed;
-  void _seed;
-  return {
-    init: () => ({ values: [] }),
-    step: (state, record) => pushValue(state, readNumber(record, field)),
-    remove: (state, record) => removeValue(state, readNumber(record, field)),
-    finalize: (state) => {
-      if (state.values.length === 0) return null;
-      let out = state.values[0];
-      for (let i = 1; i < state.values.length; i++) {
-        const v = state.values[i];
-        if (v > out) out = v;
-      }
-      return out;
-    }
-  };
-}
-function readNumber(record, field) {
-  const value = readPath(record, field);
-  return typeof value === "number" && Number.isFinite(value) ? value : 0;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
+  count,
+  sum,
+  avg,
+  min,
+  max,
+  moneySum,
+  moneyMin,
+  moneyMax,
+  reducerBuilder,
+  wrapMoneyReducers,
+  reduceRecords,
   Aggregation,
-  GROUPBY_MAX_CARDINALITY,
+  buildLiveAggregation,
+  canonicalGroupKey,
   GROUPBY_WARN_CARDINALITY,
-  GroupedAggregation,
+  GROUPBY_MAX_CARDINALITY,
+  resetGroupByWarnings,
   GroupedQuery,
   GroupedQueryN,
-  avg,
-  buildLiveAggregation,
-  count,
   groupAndReduce,
-  max,
-  min,
-  reduceRecords,
-  resetGroupByWarnings,
-  sum,
-  withAggregate
-});
-//# sourceMappingURL=index.cjs.map
+  GroupedAggregation
+};
+//# sourceMappingURL=chunk-LV7M27WM.js.map