@noy-db/hub 0.2.0-pre.11 → 0.2.0-pre.12

package/dist/periods/index.d.cts

@@ -1,10 +1,10 @@
-import { ag as PeriodsStrategy } from '../types-DiSXn3a4.cjs';
-export { ah as CarryForwardContext, ai as ClosePeriodOptions, aj as OpenPeriodOptions, ak as PERIODS_COLLECTION, al as PeriodRecord, am as ReadOnlyCollection, an as appendPeriodLedgerEntry, ao as assertTsWritable, ap as chainAnchor, aq as loadPeriods, ar as validatePeriodName } from '../types-DiSXn3a4.cjs';
+import { ag as PeriodsStrategy } from '../types-BGwjsDef.cjs';
+export { ah as CarryForwardContext, ai as ClosePeriodOptions, aj as OpenPeriodOptions, ak as PERIODS_COLLECTION, al as PeriodRecord, am as ReadOnlyCollection, an as appendPeriodLedgerEntry, ao as assertTsWritable, ap as chainAnchor, aq as loadPeriods, ar as validatePeriodName } from '../types-BGwjsDef.cjs';
 import '../lazy-builder-Ci5_YG73.cjs';
 import '../predicate-Bt5ft-9c.cjs';
-import '../strategy-CT2LCKAX.cjs';
+import '../strategy-rtpKDfTC.cjs';
 import '../strategy-BSxFXGzb.cjs';
-import '../index-B8bjExET.cjs';
+import '../index-Cmop06zJ.cjs';
 import '@noy-db/attestation';
 
 /**

package/dist/periods/index.d.ts

@@ -1,10 +1,10 @@
-import { ag as PeriodsStrategy } from '../types-CD8mc8zR.js';
-export { ah as CarryForwardContext, ai as ClosePeriodOptions, aj as OpenPeriodOptions, ak as PERIODS_COLLECTION, al as PeriodRecord, am as ReadOnlyCollection, an as appendPeriodLedgerEntry, ao as assertTsWritable, ap as chainAnchor, aq as loadPeriods, ar as validatePeriodName } from '../types-CD8mc8zR.js';
+import { ag as PeriodsStrategy } from '../types-DRdfwgTG.js';
+export { ah as CarryForwardContext, ai as ClosePeriodOptions, aj as OpenPeriodOptions, ak as PERIODS_COLLECTION, al as PeriodRecord, am as ReadOnlyCollection, an as appendPeriodLedgerEntry, ao as assertTsWritable, ap as chainAnchor, aq as loadPeriods, ar as validatePeriodName } from '../types-DRdfwgTG.js';
 import '../lazy-builder-D5GU14TS.js';
 import '../predicate-Bt5ft-9c.js';
-import '../strategy-CT2LCKAX.js';
+import '../strategy-rtpKDfTC.js';
 import '../strategy-BSxFXGzb.js';
-import '../index-DfUbNad8.js';
+import '../index-CkFHr4OP.js';
 import '@noy-db/attestation';
 
 /**

package/dist/periods/index.js

@@ -6,13 +6,13 @@ import {
   loadPeriods,
   validatePeriodName,
   withPeriods
-} from "../chunk-3DGHRDCX.js";
+} from "../chunk-RRDWXNBQ.js";
 import "../chunk-UF3BUNQZ.js";
-import "../chunk-6MFH4BMK.js";
+import "../chunk-SJJQKNMP.js";
 import "../chunk-Z6FNBOTC.js";
-import "../chunk-SLV4LAKX.js";
-import "../chunk-R233SLY3.js";
-import "../chunk-O6EJ6WTI.js";
+import "../chunk-LYNNZEQD.js";
+import "../chunk-IUBHXEPJ.js";
+import "../chunk-AGRC7NQQ.js";
 export {
   PERIODS_COLLECTION,
   appendPeriodLedgerEntry,

package/dist/{public-envelope-QOXZEHKH.js → public-envelope-PFLZI5MO.js}

@@ -12,9 +12,9 @@ import {
   resolveLocale,
   savePublicEnvelope,
   validatePublicEnvelopeInput
-} from "./chunk-JQ4NEJJ6.js";
-import "./chunk-SLV4LAKX.js";
-import "./chunk-O6EJ6WTI.js";
+} from "./chunk-UA6G45ME.js";
+import "./chunk-LYNNZEQD.js";
+import "./chunk-AGRC7NQQ.js";
 export {
   DEFAULT_PUBLIC_ENVELOPE_SCHEMA,
   PUBLIC_ENVELOPE_FIELDS,
@@ -28,4 +28,4 @@ export {
   savePublicEnvelope,
   validatePublicEnvelopeInput
 };
-//# sourceMappingURL=public-envelope-QOXZEHKH.js.map
+//# sourceMappingURL=public-envelope-PFLZI5MO.js.map

package/dist/query/index.cjs

@@ -501,6 +501,263 @@ var NO_AGGREGATE = {
   }
 };
 
+// src/money/fixed-point.ts
+function formatScaledInt(value, scale) {
+  const negative = value < 0n;
+  const abs = (negative ? -value : value).toString();
+  if (scale === 0) return (negative ? "-" : "") + abs;
+  const padded = abs.padStart(scale + 1, "0");
+  const cut = padded.length - scale;
+  const intPart = padded.slice(0, cut);
+  const fracPart = padded.slice(cut);
+  return (negative ? "-" : "") + intPart + "." + fracPart;
+}
+
+// src/money/iso4217.ts
+var MINOR_UNITS = {
+  // 2-decimal majors
+  EUR: 2,
+  USD: 2,
+  GBP: 2,
+  CHF: 2,
+  CAD: 2,
+  AUD: 2,
+  NZD: 2,
+  SGD: 2,
+  HKD: 2,
+  CNY: 2,
+  INR: 2,
+  BRL: 2,
+  MXN: 2,
+  ZAR: 2,
+  RUB: 2,
+  TRY: 2,
+  PLN: 2,
+  SEK: 2,
+  NOK: 2,
+  DKK: 2,
+  CZK: 2,
+  HUF: 2,
+  RON: 2,
+  ILS: 2,
+  THB: 2,
+  PHP: 2,
+  MYR: 2,
+  IDR: 2,
+  AED: 2,
+  SAR: 2,
+  QAR: 2,
+  EGP: 2,
+  // 0-decimal
+  JPY: 0,
+  KRW: 0,
+  ISK: 0,
+  CLP: 0,
+  VND: 0,
+  XOF: 0,
+  XAF: 0,
+  PYG: 0,
+  // 3-decimal
+  BHD: 3,
+  KWD: 3,
+  OMR: 3,
+  TND: 3,
+  JOD: 3,
+  IQD: 3,
+  LYD: 3
+};
+function scaleForCurrency(code) {
+  const v = MINOR_UNITS[code];
+  return v === void 0 ? null : v;
+}
+
+// src/money/descriptor.ts
+var MoneyUnsupportedError = class extends NoydbError {
+  constructor(field, message) {
+    super(
+      "MONEY_UNSUPPORTED",
+      message ?? `money: operation is not supported on field "${field}" \u2014 use sum() and count() and divide at the boundary`
+    );
+    this.field = field;
+    this.name = "MoneyUnsupportedError";
+  }
+  field;
+};
+
+// src/money/money-reducer.ts
+function toScaledInt(v) {
+  if (typeof v === "string" || typeof v === "number" || typeof v === "bigint") {
+    try {
+      return BigInt(v);
+    } catch {
+      return 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 value2 = toScaledInt(raw);
+    return value2 === null ? null : { currency: desc.fixedCurrency, value: value2 };
+  }
+  if (typeof raw !== "object") return null;
+  const o = raw;
+  if (typeof o.currency !== "string") return null;
+  const value = toScaledInt(o.amount);
+  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/query/builder.ts
 var EMPTY_PLAN = {
   clauses: [],
@@ -947,6 +1204,10 @@ var Query = class _Query {
    * partition boundaries without an API break.
    */
   aggregate(spec) {
+    const moneyFields = this.source.moneyFields;
+    if (moneyFields) {
+      spec = wrapMoneyReducers(spec, moneyFields);
+    }
     const source = this.source;
     const clauses = this.plan.clauses;
     const joinCtx = this.joinContext;
@@ -994,13 +1255,15 @@ var Query = class _Query {
         executeRecords,
         field,
         upstreams,
-        dictLabelResolver
+        dictLabelResolver,
+        this.source.moneyFields
       );
     }
     return this.aggregateStrategy.groupByN(
       executeRecords,
       fields,
-      upstreams
+      upstreams,
+      this.source.moneyFields
     );
   }
   /**
@@ -1536,7 +1799,8 @@ function count(opts) {
     init: () => 0,
     step: (state) => state + 1,
     remove: (state) => state - 1,
-    finalize: (state) => state
+    finalize: (state) => state,
+    merge: (a, b) => a + b
   };
 }
 function sum(field, opts) {
@@ -1545,10 +1809,15 @@ function sum(field, opts) {
   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
+    finalize: (state) => state,
+    merge: (a, b) => a + b
   };
 }
 function avg(field, opts) {
@@ -1566,7 +1835,8 @@ function avg(field, opts) {
       sum: state.sum - readNumber(record, field),
       count: state.count - 1
     }),
-    finalize: (state) => state.count === 0 ? null : state.sum / state.count
+    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) {
@@ -1596,7 +1866,8 @@ function min(field, opts) {
         if (v < out) out = v;
       }
       return out;
-    }
+    },
+    merge: (a, b) => ({ values: [...a.values, ...b.values] })
   };
 }
 function max(field, opts) {
@@ -1616,11 +1887,17 @@ function max(field, opts) {
         if (v > out) out = v;
       }
       return out;
-    }
+    },
+    merge: (a, b) => ({ values: [...a.values, ...b.values] })
   };
 }
 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 typeof value === "number" && Number.isFinite(value) ? value : 0;
 }
 
@@ -1776,15 +2053,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
@@ -1792,6 +2071,10 @@ 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 {
   /**
@@ -1804,7 +2087,7 @@ var GroupedQuery = class extends GroupedQueryBase {
     return new GroupedAggregation(
       this.executeRecords,
       this.fields,
-      spec,
+      this.wrapSpec(spec),
       this.upstreams,
       this.dictLabelResolver
     );
@@ -1815,7 +2098,7 @@ var GroupedQueryN = class extends GroupedQueryBase {
     return new GroupedAggregation(
       this.executeRecords,
       this.fields,
-      spec,
+      this.wrapSpec(spec),
       this.upstreams,
       this.dictLabelResolver
     );