@noy-db/hub 0.3.0-pre.10 → 0.3.0-pre.11

package/dist/cargo/index.js

@@ -1,56 +1,56 @@
 import {
   withCargo
-} from "../chunk-U3WZCU7E.js";
+} from "../chunk-UFILRICG.js";
 import {
   CustodyApi,
   NO_CARGO
-} from "../chunk-ZYJ55N7N.js";
+} from "../chunk-BZO4WCJI.js";
 import {
   createDeedOwner,
   isDeedVault,
   liberateVault,
   loadDeedMarker
-} from "../chunk-UN4FVIBH.js";
+} from "../chunk-PXWVF7MC.js";
 import {
   fuseRetrieval
 } from "../chunk-AURFOK3D.js";
-import "../chunk-OBKWYKYC.js";
-import "../chunk-OT76OZL6.js";
+import {
+  diffVault
+} from "../chunk-LB7FD65R.js";
+import "../chunk-7NS43EXZ.js";
+import "../chunk-BCYQA5BK.js";
 import {
   isQuorum,
   runDrainBarrier
-} from "../chunk-TWKKOM55.js";
+} from "../chunk-D26JB3LZ.js";
 import {
-  diffVault
-} from "../chunk-LB7FD65R.js";
-import "../chunk-YCXCR7VG.js";
-import "../chunk-QSFOZUYL.js";
-import "../chunk-OXCSVM3B.js";
-import "../chunk-J4LPNIGK.js";
-import "../chunk-OVYRLHPE.js";
+  groupAndReduce,
+  reduceRecords
+} from "../chunk-IGJHJYM6.js";
+import {
+  readPath
+} from "../chunk-IGJCYUT5.js";
+import "../chunk-KPGX66PM.js";
+import "../chunk-K62IUKOD.js";
+import "../chunk-5XIPOCQC.js";
+import "../chunk-BE7N3AXA.js";
+import "../chunk-ARSAMO24.js";
+import "../chunk-5ZOSG3RJ.js";
+import "../chunk-4N5QFSNQ.js";
 import {
   generateULID
 } from "../chunk-ZJADGNYF.js";
 import "../chunk-SVLR4POP.js";
-import "../chunk-MCHVVJIA.js";
-import "../chunk-QA2KUPCP.js";
-import "../chunk-2OV5NVE7.js";
-import "../chunk-VEPTFUJY.js";
-import "../chunk-HYR4WZZ3.js";
+import "../chunk-QQJXBZCO.js";
+import "../chunk-FQQF23MC.js";
+import "../chunk-MSPNM2OM.js";
+import "../chunk-SYMS4546.js";
+import "../chunk-X6CMGUAG.js";
 import "../chunk-LP7BEXCT.js";
 import {
   sha256Hex
-} from "../chunk-3OPY6MK2.js";
-import "../chunk-YN5IAHN6.js";
-import {
-  groupAndReduce,
-  reduceRecords
-} from "../chunk-DFVUTGT2.js";
-import {
-  readPath
-} from "../chunk-IGJCYUT5.js";
-import "../chunk-EOXAAJTY.js";
-import "../chunk-VEAVKDDB.js";
+} from "../chunk-HUS3J5WM.js";
+import "../chunk-CKZW6P5V.js";
 import {
   CargoNotEnabledError,
   CrossShardJoinError,
@@ -62,7 +62,7 @@ import {
   UnknownShardError,
   ValidationError,
   VaultTemplateNotFoundError
-} from "../chunk-S7VFUQM2.js";
+} from "../chunk-FH542DDY.js";
 import "../chunk-PZ5AY32C.js";
 export {
   CargoNotEnabledError,

package/dist/chunk-25NDNMQ7.js

@@ -0,0 +1,70 @@
+import {
+  envelopeBodyForHash
+} from "./chunk-QQJXBZCO.js";
+import {
+  sha256Hex
+} from "./chunk-HUS3J5WM.js";
+
+// src/with-commit/history/ledger/entry.ts
+function canonicalJson(value) {
+  if (value === null) return "null";
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new Error(
+        `canonicalJson: refusing to encode non-finite number ${String(value)}`
+      );
+    }
+    return JSON.stringify(value);
+  }
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "bigint") {
+    throw new Error("canonicalJson: BigInt is not JSON-serializable");
+  }
+  if (typeof value === "undefined" || typeof value === "function") {
+    throw new Error(
+      `canonicalJson: refusing to encode ${typeof value} \u2014 include all fields explicitly`
+    );
+  }
+  if (Array.isArray(value)) {
+    return "[" + value.map((v) => canonicalJson(v)).join(",") + "]";
+  }
+  if (typeof value === "object") {
+    const obj = value;
+    const keys = Object.keys(obj).sort();
+    const parts = [];
+    for (const key of keys) {
+      parts.push(JSON.stringify(key) + ":" + canonicalJson(obj[key]));
+    }
+    return "{" + parts.join(",") + "}";
+  }
+  throw new Error(`canonicalJson: unexpected value type: ${typeof value}`);
+}
+async function sha256Hex2(input) {
+  return sha256Hex(new TextEncoder().encode(input));
+}
+async function hashEntry(entry) {
+  return sha256Hex2(canonicalJson(entry));
+}
+function paddedIndex(index) {
+  return String(index).padStart(10, "0");
+}
+function parseIndex(key) {
+  return Number.parseInt(key, 10);
+}
+
+// src/with-commit/history/ledger/hash.ts
+async function envelopePayloadHash(envelope) {
+  if (!envelope) return "";
+  return sha256Hex2(envelopeBodyForHash(envelope));
+}
+
+export {
+  canonicalJson,
+  sha256Hex2 as sha256Hex,
+  hashEntry,
+  paddedIndex,
+  parseIndex,
+  envelopePayloadHash
+};
+//# sourceMappingURL=chunk-25NDNMQ7.js.map

package/dist/chunk-2JMMY7HZ.js

@@ -0,0 +1,188 @@
+import {
+  putDerivedOutput
+} from "./chunk-DGH65E7Q.js";
+import {
+  wrapDbWithPredicates
+} from "./chunk-3G4KMVUN.js";
+import {
+  canonicalGroupKey,
+  groupAndReduce
+} from "./chunk-IGJHJYM6.js";
+import {
+  applyI18nLocale
+} from "./chunk-BE7N3AXA.js";
+import {
+  LocaleNotSpecifiedError,
+  MaterializedViewTooLargeError
+} from "./chunk-FH542DDY.js";
+
+// src/with-formula/materialized-views/executor.ts
+var DEFAULT_MAX_ROWS = 1e5;
+async function materializeQueryResult(q, mvName, i18nLocale, i18nFields) {
+  if (typeof q?.toArray === "function") {
+    return await q.toArray();
+  }
+  if (typeof q?.run === "function") {
+    const runOpts = i18nLocale !== void 0 ? { locale: i18nLocale, i18nFields } : void 0;
+    const result = await Promise.resolve(q.run(runOpts));
+    if (Array.isArray(result)) {
+      return result;
+    }
+    return [result];
+  }
+  throw new Error(
+    `MV "${mvName}": query() must return a Query<T>, Aggregation, or GroupedAggregation. Got something without a .toArray() or .run() terminal.`
+  );
+}
+async function materializeUnionResult(spec, db) {
+  const unified = [];
+  for (const arm of spec.unionSources) {
+    const coll = db.collection(arm.collection);
+    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;
+      unified.push(mapped);
+    }
+  }
+  if (!spec.groupBy) return unified;
+  const groupFields = typeof spec.groupBy === "string" ? [spec.groupBy] : spec.groupBy;
+  if (spec.i18nLocale !== void 0 && spec.i18nFields !== void 0) {
+    const groupI18n = {};
+    for (const f of groupFields) {
+      const d = spec.i18nFields[f];
+      if (d !== void 0) groupI18n[f] = d;
+    }
+    if (Object.keys(groupI18n).length > 0) {
+      for (let i = 0; i < unified.length; i++) {
+        unified[i] = applyI18nLocale(unified[i], groupI18n, spec.i18nLocale, void 0, "mv");
+      }
+    }
+  }
+  for (const f of groupFields) {
+    for (const row of unified) {
+      const v = row[f];
+      if (v !== null && typeof v === "object") {
+        throw new LocaleNotSpecifiedError(
+          f,
+          `Materialized view "${spec.name}" groups by "${f}", whose value is a raw i18n locale map \u2014 an unstable object group key. Declare { i18nLocale, i18nFields } on the MV to resolve it at the 'mv' layer, or group by a dictKey/staticDict code (the stable key) and resolve the label at read time.`
+        );
+      }
+    }
+  }
+  if (!spec.aggregate) {
+    const seen = /* @__PURE__ */ new Map();
+    for (const row of unified) {
+      const k = canonicalGroupKey(groupFields, row);
+      if (!seen.has(k)) seen.set(k, row);
+    }
+    return [...seen.values()];
+  }
+  return groupAndReduce(unified, groupFields, spec.aggregate, spec.moneyFields);
+}
+var MaterializedViewExecutor = {
+  async refresh(reg, accessor) {
+    const spec = reg.spec;
+    const outputColl = accessor.getCollection(reg.outputCollection);
+    const maxRows = spec.maxRows ?? DEFAULT_MAX_ROWS;
+    const onEmpty = spec.onEmpty ?? "delete";
+    const strict = spec.strict ?? false;
+    const baseCtx = accessor.getQueryContext();
+    const ctxForQuery = spec.predicates ? wrapDbWithPredicates(baseCtx, spec.predicates) : baseCtx;
+    let rows;
+    if (spec.unionSources) {
+      rows = await materializeUnionResult(spec, ctxForQuery);
+    } else {
+      const q = spec.query(ctxForQuery);
+      rows = await materializeQueryResult(q, spec.name, spec.i18nLocale, spec.i18nFields);
+    }
+    if (rows.length > maxRows) {
+      throw new MaterializedViewTooLargeError(spec.name, rows.length, maxRows);
+    }
+    const txCtx = accessor.getActiveTxContext();
+    const adapter = outputColl.adapter;
+    const vaultName = outputColl.vault;
+    const newIds = /* @__PURE__ */ new Set();
+    const enrichedRows = [];
+    for (const row of rows) {
+      const id = spec.rowKey(row);
+      newIds.add(id);
+      const meta = {
+        mvName: spec.name,
+        queryHash: reg.queryHash,
+        sourceVersions: {},
+        materializedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      enrichedRows.push({ id, record: { ...row, _materializedFrom: meta } });
+    }
+    let written = 0;
+    let failed = 0;
+    for (const { id, record } of enrichedRows) {
+      try {
+        if (txCtx !== null) {
+          const prior = await adapter.get(vaultName, reg.outputCollection, id);
+          txCtx._executed.push({
+            op: { type: "put", vaultName, collectionName: reg.outputCollection, id },
+            priorEnvelope: prior
+          });
+        }
+        if (accessor.dispatchCtx) {
+          if (await putDerivedOutput(outputColl, id, record, accessor.dispatchCtx) === "written") written++;
+        } else {
+          await outputColl.put(id, record);
+          written++;
+        }
+      } catch (err) {
+        failed++;
+        if (strict) throw err;
+        console.warn(`[mv] "${spec.name}" row write failed:`, err);
+      }
+    }
+    let deleted = 0;
+    if (onEmpty === "delete") {
+      const priorIds = await listOutputIds(outputColl);
+      for (const priorId of priorIds) {
+        if (newIds.has(priorId)) continue;
+        try {
+          const outAny = outputColl;
+          if (typeof outAny._internalDelete === "function") {
+            await outAny._internalDelete(priorId, txCtx);
+            deleted++;
+          } else {
+            await outputColl.delete(priorId);
+            deleted++;
+          }
+        } catch (err) {
+          failed++;
+          if (strict) throw err;
+          console.warn(`[mv] "${spec.name}" tombstone failed for id="${priorId}":`, err);
+        }
+      }
+    }
+    return { written, deleted, failed };
+  }
+};
+async function listOutputIds(outputColl) {
+  const cAny = outputColl;
+  const adapter = cAny.adapter;
+  const vault = cAny.vault;
+  const name = cAny.name;
+  if (typeof adapter?.list !== "function") return [];
+  try {
+    const ids = await adapter.list(vault, name);
+    return [...ids];
+  } catch {
+    return [];
+  }
+}
+
+export {
+  MaterializedViewExecutor
+};
+//# sourceMappingURL=chunk-2JMMY7HZ.js.map