@noy-db/hub 0.2.0-pre.15 → 0.2.0-pre.16

package/dist/index.cjs

@@ -2879,13 +2879,22 @@ var init_predicate = __esm({
 });
 
 // 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;
+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;
+  }
+  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;
 }
@@ -2893,13 +2902,15 @@ 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 };
+    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 value = toScaledInt(o.amount);
+  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) {
@@ -3217,11 +3228,14 @@ function warnCardinalityApproaching(fields, observed) {
     `[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 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) {
@@ -3664,10 +3678,14 @@ function summarizeQueryPlan(query) {
   });
 }
 function summarizeUnionPlan(spec) {
-  const arms = (spec.unionSources ?? []).map((s) => s.collection).join(",");
+  const arms = (spec.unionSources ?? []).map((s) => {
+    const joins = s.join?.length ? `[${s.join.map((j) => `${j.field}\u2192${j.as}`).join(";")}]` : "";
+    return `${s.collection}${joins}`;
+  }).join(",");
   const groupBy = Array.isArray(spec.groupBy) ? [...spec.groupBy].sort().join(",") : typeof spec.groupBy === "string" ? spec.groupBy : "";
   const aggKeys = spec.aggregate ? Object.keys(spec.aggregate).sort().join(",") : "";
-  return `union(${arms})|groupBy(${groupBy})|aggregate(${aggKeys})`;
+  const moneyKeys = spec.moneyFields ? Object.keys(spec.moneyFields).sort().join(",") : "";
+  return `union(${arms})|groupBy(${groupBy})|aggregate(${aggKeys})|money(${moneyKeys})`;
 }
 var init_dependency_analyzer = __esm({
   "src/materialized-views/dependency-analyzer.ts"() {
@@ -3794,6 +3812,7 @@ var init_registry = __esm({
         let isQuery = false;
         if (spec.unionSources) {
           dependencies = new Set(spec.unionSources.map((s) => s.collection));
+          if (spec.sources) for (const s of spec.sources) dependencies.add(s);
           queryPlanSummary = summarizeUnionPlan(spec);
         } else {
           const q = spec.query(dbForQuery);
@@ -3948,7 +3967,13 @@ async function materializeUnionResult(spec, db) {
   const unified = [];
   for (const arm of spec.unionSources) {
     const coll = db.collection(arm.collection);
-    const sourceRows = coll.query().toArray();
+    let q = coll.query();
+    if (arm.join?.length) {
+      for (const leg of arm.join) {
+        q = q.join(leg.field, { as: leg.as, maxRows: leg.maxRows, strategy: leg.strategy });
+      }
+    }
+    const sourceRows = q.toArray();
     for (const r of sourceRows) {
       const mapped = arm.map(r);
       if (mapped == null) continue;
@@ -3965,7 +3990,7 @@ async function materializeUnionResult(spec, db) {
     }
     return [...seen.values()];
   }
-  return groupAndReduce(unified, groupFields, spec.aggregate);
+  return groupAndReduce(unified, groupFields, spec.aggregate, spec.moneyFields);
 }
 async function listOutputIds(outputColl) {
   const cAny = outputColl;
@@ -4520,11 +4545,15 @@ var init_read_only_facade = __esm({
 });
 
 // src/derivations/strategy-hash.ts
-async function computeStrategyHash(source, outputKeys, derive) {
+async function computeStrategyHash(source, outputKeys, derive, sources) {
   const canonical2 = JSON.stringify({
     source,
     outputs: [...outputKeys].sort(),
-    derive: derive.toString()
+    derive: derive.toString(),
+    // Declared sibling sources (#344) — adding/removing a trigger
+    // collection invalidates cached derived records. Omitted when empty
+    // so strategies without siblings keep their existing hash.
+    ...sources?.length ? { sources: [...sources].sort() } : {}
   });
   const bytes = new TextEncoder().encode(canonical2);
   const digest = await crypto.subtle.digest("SHA-256", bytes);
@@ -4553,11 +4582,16 @@ var init_registry3 = __esm({
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       async register(spec) {
         const outputKeys = Object.keys(spec.outputs);
-        const strategyHash = await computeStrategyHash(spec.source, outputKeys, spec.derive);
+        const strategyHash = await computeStrategyHash(spec.source, outputKeys, spec.derive, spec.sources);
         const reg = { spec, strategyHash };
         const fromSource = this._bySource.get(spec.source);
         if (fromSource) fromSource.push(reg);
         else this._bySource.set(spec.source, [reg]);
+        for (const extra of spec.sources ?? []) {
+          const fromExtra = this._bySource.get(extra);
+          if (fromExtra) fromExtra.push(reg);
+          else this._bySource.set(extra, [reg]);
+        }
         for (const key of outputKeys) {
           const output = spec.outputs[key];
           if (!output) continue;
@@ -5892,6 +5926,7 @@ __export(src_exports, {
   resolveI18nText: () => resolveI18nText,
   resolvePolicy: () => resolvePolicy,
   resolvePublicEnvelopeSchema: () => resolveSchema,
+  resolveSequenceKey: () => resolveSequenceKey,
   resolveSession: () => resolveSession,
   revokeAllSessions: () => revokeAllSessions,
   revokeDelegation: () => revokeDelegation,
@@ -7990,6 +8025,21 @@ init_crypto();
 init_errors();
 var SEQUENCE_COLLECTION = "_sequences";
 var MAX_NEXT_ATTEMPTS = 16;
+function resolveSequenceKey(series, opts) {
+  const partition = opts?.partition;
+  if (!partition || partition.length === 0) return series;
+  const parts = partition.map((p) => {
+    if (typeof p === "number" && !Number.isFinite(p)) {
+      throw new ValidationError(`sequence partition component must be a finite number, got ${p}`);
+    }
+    const s = String(p);
+    if (s === "") {
+      throw new ValidationError("sequence partition component must not be empty");
+    }
+    return encodeURIComponent(s);
+  });
+  return `${series}\0${parts.join("/")}`;
+}
 async function sleepBackoff(attempt) {
   const ceil = Math.min(2 ** attempt, 32);
   const ms = Math.floor(Math.random() * ceil);
@@ -8020,7 +8070,8 @@ var SequenceStore = class {
   handle(name) {
     return {
       next: () => this.next(name),
-      peek: () => this.peek(name)
+      peek: () => this.peek(name),
+      seedTo: (n) => this.seedTo(name, n)
     };
   }
   assertOnline() {
@@ -8073,6 +8124,30 @@ var SequenceStore = class {
     void lastConflict;
     throw new SequenceContentionError(name, MAX_NEXT_ATTEMPTS);
   }
+  async seedTo(name, n) {
+    this.assertOnline();
+    if (n <= 0) return;
+    let lastConflict;
+    for (let attempt = 0; attempt < MAX_NEXT_ATTEMPTS; attempt++) {
+      const { env, value } = await this.read(name);
+      if (value >= n) return;
+      const expectedVersion = env?._v ?? 0;
+      const envelope = await this.encryptState({ value: n }, expectedVersion + 1);
+      try {
+        await this.adapter.put(this.vault, SEQUENCE_COLLECTION, name, envelope, expectedVersion);
+        return;
+      } catch (err) {
+        if (err instanceof ConflictError) {
+          lastConflict = err;
+          if (attempt < MAX_NEXT_ATTEMPTS - 1) await sleepBackoff(attempt);
+          continue;
+        }
+        throw err;
+      }
+    }
+    void lastConflict;
+    throw new SequenceContentionError(name, MAX_NEXT_ATTEMPTS);
+  }
 };
 
 // src/numbering/descriptor.ts
@@ -14599,7 +14674,7 @@ var TxCollection = class {
     this._ctx._ops.push(op);
   }
 };
-async function runTransaction(db, fn, options) {
+async function runTransaction(db, fn, options, txInvariants) {
   if (options?.amendment) {
     if (typeof options.reason !== "string" || options.reason.trim().length === 0) {
       throw new ValidationError(
@@ -14623,12 +14698,19 @@ async function runTransaction(db, fn, options) {
   }
   const priorEnvelopes = /* @__PURE__ */ new Map();
   const store = db._store;
+  const invariants = txInvariants ?? [];
+  const watchedScopes = new Set(invariants.map((i) => i.scope));
+  const plainBefore = /* @__PURE__ */ new Map();
   for (const op of ctx._ops) {
     const key = keyOf(op);
     if (!priorEnvelopes.has(key)) {
       const env = await store.get(op.vaultName, op.collectionName, op.id);
       priorEnvelopes.set(key, env);
     }
+    if (watchedScopes.has(op.collectionName) && !plainBefore.has(key)) {
+      const prior = await db.vault(op.vaultName).collection(op.collectionName).get(op.id);
+      plainBefore.set(key, prior ?? null);
+    }
     if (op.expectedVersion !== void 0) {
       const env = priorEnvelopes.get(key) ?? null;
       const actual = env?._v ?? 0;
@@ -14726,6 +14808,58 @@ async function runTransaction(db, fn, options) {
       );
     }
   }
+  if (invariants.length > 0) {
+    const lastOp = /* @__PURE__ */ new Map();
+    const order = [];
+    for (const op of ctx._ops) {
+      const key = keyOf(op);
+      if (!lastOp.has(key)) order.push(key);
+      lastOp.set(key, op);
+    }
+    const changesByScope = /* @__PURE__ */ new Map();
+    const scopeVault = /* @__PURE__ */ new Map();
+    for (const key of order) {
+      const op = lastOp.get(key);
+      if (!watchedScopes.has(op.collectionName)) continue;
+      const before = plainBefore.get(key) ?? null;
+      const after = op.type === "delete" ? null : op.record ?? null;
+      const change = { before, after };
+      const arr = changesByScope.get(op.collectionName);
+      if (arr) arr.push(change);
+      else changesByScope.set(op.collectionName, [change]);
+      scopeVault.set(op.collectionName, op.vaultName);
+    }
+    try {
+      for (const inv of invariants) {
+        const changes = changesByScope.get(inv.scope);
+        if (changes === void 0 || changes.length === 0) continue;
+        const vaultName = scopeVault.get(inv.scope);
+        const v = db.vault(vaultName);
+        const facade = v._getReadOnlyFacade() ?? {
+          collection(name) {
+            const c = v.collection(name);
+            return {
+              get: (id) => c.get(id),
+              list: () => c.list(),
+              query: () => c.query()
+            };
+          }
+        };
+        const ctxForInv = {
+          existing: null,
+          vault: facade,
+          userId: v.userId,
+          role: v.role
+        };
+        await inv.check(changes, ctxForInv);
+      }
+    } catch (err) {
+      await revertExecuted(ctx._executed, store, db);
+      throw err instanceof InvariantError ? err : new InvariantError(
+        err instanceof Error ? err.message : `invariant violated: ${String(err)}`
+      );
+    }
+  }
   return bodyResult;
 }
 async function revertExecuted(executed, store, db) {
@@ -15731,9 +15865,18 @@ var Collection = class {
         if (DerivationExecutor2 === null) {
           ({ DerivationExecutor: DerivationExecutor2 } = await Promise.resolve().then(() => (init_executor2(), executor_exports2)));
         }
-        const sourceWithId = { ...incoming, id };
+        let sourceWithId;
+        let sourceVersion = version;
+        if (spec.source === this.name) {
+          sourceWithId = { ...incoming, id };
+        } else {
+          const primary = await this.derivationSource.getCollection(spec.source).get(id);
+          if (primary === null || primary === void 0) continue;
+          sourceWithId = { ...primary, id };
+          sourceVersion = 0;
+        }
         const ctx = { vault: this.derivationSource.getReadOnlyFacade() };
-        const result = await DerivationExecutor2.run(spec, sourceWithId, version, strategyHash, ctx);
+        const result = await DerivationExecutor2.run(spec, sourceWithId, sourceVersion, strategyHash, ctx);
         for (const key of Object.keys(spec.outputs)) {
           const out = result.outputs[key];
           if (!out) continue;
@@ -17716,37 +17859,34 @@ var OverlayedCollection = class {
   /** Get the merged row by id. */
   async get(id) {
     const overlayRow = await this.overlayCollection.get(id);
-    if (overlayRow !== null && this.shadowPredicateApplies(overlayRow)) {
-      return overlayRow;
-    }
     const baseRow = await this.baseCollection.get(id);
-    if (baseRow !== null) return baseRow;
-    return null;
+    return this.mergeRows(overlayRow, baseRow);
   }
   /** List union of base + overlay ids, applying the merge per row. */
   async list() {
     const baseRows = await this.baseCollection.list();
     const overlayRows = await this.overlayCollection.list();
-    const merged = /* @__PURE__ */ new Map();
     const idOf = (row) => {
       if (this.baseRowKey) return this.baseRowKey(row);
       const idField = row.id;
       return typeof idField === "string" ? idField : "";
     };
+    const baseById = /* @__PURE__ */ new Map();
+    const overlayById = /* @__PURE__ */ new Map();
     for (const row of baseRows) {
       const id = idOf(row);
-      if (id) merged.set(id, row);
+      if (id) baseById.set(id, row);
     }
     for (const row of overlayRows) {
       const id = idOf(row);
-      if (!id) continue;
-      if (this.shadowPredicateApplies(row)) {
-        merged.set(id, row);
-      } else if (!merged.has(id)) {
-        continue;
-      }
+      if (id) overlayById.set(id, row);
+    }
+    const out = [];
+    for (const id of /* @__PURE__ */ new Set([...baseById.keys(), ...overlayById.keys()])) {
+      const merged = this.mergeRows(overlayById.get(id) ?? null, baseById.get(id) ?? null);
+      if (merged !== null) out.push(merged);
     }
-    return [...merged.values()];
+    return out;
   }
   /**
    * Write to the overlay. Two forms:
@@ -17786,9 +17926,42 @@ var OverlayedCollection = class {
   async delete(id) {
     await this.overlayCollection.delete(id);
   }
-  /** True when `overlay[shadowField] === shadowValue`. */
-  shadowPredicateApplies(row) {
-    return row[this.spec.shadowField] === this.spec.shadowValue;
+  /**
+   * Merge a single id's overlay + base rows into the visible row.
+   *
+   * Priority (first match wins):
+   *  1. Binary shadow win — overlay present AND
+   *     `overlay[shadowField] === shadowValue` → return the overlay row
+   *     entirely. This stays FIRST so the original binary behaviour is
+   *     unchanged whether or not `mergeMode` is configured.
+   *  2. Field-level merge — overlay present, `mergeMode` configured,
+   *     and a rule whose `whenStatus` equals `overlay[shadowField]`.
+   *     The matched rule pulls its `overlayFields` (those present on
+   *     the overlay row) on top of the base row. With no base row, the
+   *     overlay row is returned as-is.
+   *  3. Fallback — return the base row (possibly `null`). An
+   *     overlay-only row that qualifies under neither (1) nor (2) and
+   *     has no base is therefore NOT surfaced.
+   */
+  mergeRows(overlayRow, baseRow) {
+    const shadowField = this.spec.shadowField;
+    if (overlayRow !== null && overlayRow[shadowField] === this.spec.shadowValue) {
+      return overlayRow;
+    }
+    if (overlayRow !== null && this.spec.mergeMode) {
+      const status = overlayRow[shadowField];
+      const rule = this.spec.mergeMode.rules.find((r) => r.whenStatus === status);
+      if (rule) {
+        if (baseRow === null) return overlayRow;
+        const overlaySrc = overlayRow;
+        const picked = {};
+        for (const field of rule.overlayFields) {
+          if (field in overlaySrc) picked[field] = overlaySrc[field];
+        }
+        return { ...baseRow, ...picked };
+      }
+    }
+    return baseRow;
   }
   // ─── Throw-stubs for the unimplemented Collection<T> surface ───────
   //
@@ -20212,17 +20385,23 @@ var Vault = class {
    * const cur = await vault.sequence('invoice-2026').peek()  // current value, no allocation
    * ```
    */
-  sequence(name) {
-    if (this.numberingConfigs.has(name)) {
+  sequence(series, opts) {
+    if (series.includes("\0")) {
+      throw new ValidationError(`sequence("${series}"): series name must not contain a null byte (\\x00).`);
+    }
+    if (this.numberingConfigs.has(series)) {
       const eng = this.deferred();
       return {
-        next: async (opts) => {
-          if (!opts?.for) {
-            throw new ValidationError(`sequence("${name}") is a deferred-numbering series; call next({ for: recordId }).`);
+        next: async (nextOpts) => {
+          if (!nextOpts?.for) {
+            throw new ValidationError(`sequence("${series}") is a deferred-numbering series; call next({ for: recordId }).`);
           }
-          return (await eng.enqueue(name, opts.for)).assigned;
+          return (await eng.enqueue(series, nextOpts.for)).assigned;
         },
-        peek: () => eng.peek(name)
+        peek: () => eng.peek(series),
+        seedTo: () => {
+          throw new ValidationError(`sequence("${series}") is a deferred-numbering series; seedTo is CAS-only.`);
+        }
       };
     }
     if (!this.sequenceStore) {
@@ -20234,7 +20413,7 @@ var Vault = class {
         actor: this.keyring.userId
       });
     }
-    return this.sequenceStore.handle(name);
+    return this.sequenceStore.handle(resolveSequenceKey(series, opts));
   }
   /** @internal — lazily build the deferred-numbering engine with a cache-coherent stamp. */
   deferred() {
@@ -20526,9 +20705,24 @@ var Vault = class {
           });
         }
         if (rule.mode === "cascade") {
+          const txCtx = this.noydb._activeTxContextOrNull;
           for (const match of matches) {
             const matchId = match["id"] ?? null;
             if (matchId === null) continue;
+            if (txCtx !== null) {
+              const prior = await this.adapter.get(this.name, rule.collection, matchId);
+              if (prior !== null) {
+                txCtx._executed.push({
+                  op: {
+                    type: "delete",
+                    vaultName: this.name,
+                    collectionName: rule.collection,
+                    id: matchId
+                  },
+                  priorEnvelope: prior
+                });
+              }
+            }
             await fromCollection.delete(matchId);
           }
         }
@@ -22727,7 +22921,7 @@ var NOT_ENABLED6 = new Error(
   'Multi-record transactions require the tx strategy. Import `{ withTransactions }` from "@noy-db/hub/tx" and pass it to `createNoydb({ txStrategy: withTransactions() })`.'
 );
 var NO_TX = {
-  async runTransaction() {
+  async runTransaction(_db, _fn, _options, _txInvariants) {
     throw NOT_ENABLED6;
   },
   async runDryRun() {
@@ -26045,7 +26239,7 @@ function recordId2(record) {
   return typeof id === "string" ? id : "";
 }
 function immutableGuard(config) {
-  const { collection, after, appendOnly, amendmentRoles } = config;
+  const { collection, after, appendOnly, amendmentRoles, amendmentInvariant } = config;
   if (appendOnly && after !== void 0) {
     throw new ValidationError("immutableGuard: `after` and `appendOnly` are mutually exclusive");
   }
@@ -26071,12 +26265,16 @@ function immutableGuard(config) {
       }
     },
     // The authorized override: inside an amendment transaction the
-    // check/onDelete are skipped and the change is ledgered. No extra
-    // invariant — the amendment itself is the sanctioned exception.
+    // check/onDelete are skipped and the change is ledgered. By default
+    // there is no extra invariant — the amendment itself is the
+    // sanctioned exception. Callers may supply `amendmentInvariant` to
+    // keep a constraint inviolable even under amendment (e.g. forbid
+    // deletes, or preserve a cross-record sum); a throw reverts the
+    // amendment and surfaces as `InvariantError`.
     amendment: {
       roles: amendmentRoles ?? ["admin", "owner"],
-      invariant: () => {
-      }
+      invariant: amendmentInvariant ?? (() => {
+      })
     }
   };
   return withGuard(spec);
@@ -26097,6 +26295,18 @@ function withDerivation(spec) {
   if (typeof spec.derive !== "function") {
     throw new ValidationError("withDerivation: derive must be a function");
   }
+  if (spec.sources !== void 0) {
+    for (const extra of spec.sources) {
+      if (typeof extra !== "string" || extra.length === 0) {
+        throw new ValidationError("withDerivation: each entry in sources[] must be a non-empty string");
+      }
+      if (extra === spec.source) {
+        throw new ValidationError(
+          `withDerivation: sources[] must not contain the primary source "${spec.source}"`
+        );
+      }
+    }
+  }
   const lifecycleMode = typeof spec.lifecycle === "string" ? spec.lifecycle : spec.lifecycle.mode;
   for (const [outputKey, outputSpec] of Object.entries(spec.outputs)) {
     if (outputSpec.shape === "array") {
@@ -26183,6 +26393,16 @@ function withMaterializedView(spec) {
         `withMaterializedView "${spec.name}": UNION strategy with aggregate requires groupBy \u2014 use groupBy to declare the bucketing keys, or remove aggregate for a pure dedup MV`
       );
     }
+    if (spec.moneyFields && !spec.aggregate) {
+      throw new MaterializedViewConfigError(
+        `withMaterializedView "${spec.name}": moneyFields requires aggregate \u2014 moneyFields rewrites sum/min/max reducers over money output fields, so it is meaningless without an aggregate spec`
+      );
+    }
+    if (spec.unionSources.some((s) => s.join && s.join.length > 0) && (!spec.sources || spec.sources.length === 0)) {
+      throw new MaterializedViewConfigError(
+        `withMaterializedView "${spec.name}": a unionSources arm declares join(s) but no \`sources\` are listed \u2014 declare sources: [...] with the right-side (join-target) collection names so writes to them trigger MV refresh`
+      );
+    }
     if (spec.predicates) {
       throw new MaterializedViewConfigError(
         `withMaterializedView "${spec.name}": predicates are not supported on UNION strategies \u2014 UNION mode does not use a Query<T> chain, so .wherePredicate() cannot fire. Use the query() form, or open an issue if per-arm predicates are needed`
@@ -27438,6 +27658,7 @@ function shortJSON(value) {
   resolveI18nText,
   resolvePolicy,
   resolvePublicEnvelopeSchema,
+  resolveSequenceKey,
   resolveSession,
   revokeAllSessions,
   revokeDelegation,