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

package/dist/chunk-4CTHCN4J.js

@@ -0,0 +1,480 @@
+import {
+  dictCollectionName
+} from "./chunk-NJ4EOKMB.js";
+import {
+  getAtPath,
+  presentI18nForJoin
+} from "./chunk-6JTIAGHD.js";
+import {
+  PeriodClosedError,
+  UnknownDictCodeError,
+  ValidationError
+} from "./chunk-BIOUI4HL.js";
+
+// src/via/lookup/registry.ts
+function enforceStaticDictOnPut(staticFields, record) {
+  if (!staticFields || Object.keys(staticFields).length === 0) return;
+  if (!record || typeof record !== "object") return;
+  const obj = record;
+  for (const [field, desc] of Object.entries(staticFields)) {
+    if (desc.validateCodes === false) continue;
+    const known = new Set(desc.keys);
+    const values = getAtPath(obj, field);
+    for (const value of values) {
+      if (value === void 0 || value === null) continue;
+      const codes = Array.isArray(value) ? value : [value];
+      for (const code of codes) {
+        if (typeof code !== "string") continue;
+        if (!known.has(code)) {
+          throw new UnknownDictCodeError(desc.name, field, code);
+        }
+      }
+    }
+  }
+}
+function resolveDictSource(leftCollection, field, staticDescriptorByField, dictKeyFieldRegistry, getDictionaryHandle) {
+  const staticFields = staticDescriptorByField.get(leftCollection);
+  if (staticFields && field in staticFields) {
+    const desc = staticFields[field];
+    const rows = Object.entries(desc.table).map(
+      ([key, labels]) => ({ key, labels, ...labels })
+    );
+    const source = {
+      snapshot() {
+        return rows;
+      },
+      lookupById(id) {
+        return rows.find((e) => e["key"] === id);
+      }
+    };
+    if (desc.displayLocale !== void 0) {
+      ;
+      source.displayLocale = desc.displayLocale;
+    }
+    return source;
+  }
+  const dictFields = dictKeyFieldRegistry.get(leftCollection);
+  if (!dictFields || !(field in dictFields)) return null;
+  const dictName = dictFields[field];
+  if (!dictName) return null;
+  const handle = getDictionaryHandle(dictName);
+  return {
+    snapshot() {
+      return handle.snapshotEntries();
+    },
+    lookupById(id) {
+      const entries = handle.snapshotEntries();
+      return entries.find((e) => e["key"] === id);
+    }
+  };
+}
+async function updateReferencingRecords(registry, getCollection, name, oldKey, newKey) {
+  for (const [collectionName, dictFields] of registry) {
+    const fields = Object.entries(dictFields).filter(([, dn]) => dn === name).map(([field]) => field);
+    if (fields.length === 0) continue;
+    const coll = getCollection(collectionName);
+    const records = await coll.list();
+    for (const record of records) {
+      let changed = false;
+      const updated = { ...record };
+      for (const field of fields) {
+        if (updated[field] === oldKey) {
+          updated[field] = newKey;
+          changed = true;
+        }
+      }
+      if (changed) {
+        const id = record["id"];
+        if (id !== void 0) {
+          await coll.put(id, updated);
+        }
+      }
+    }
+  }
+}
+function resolveLabelFromMap(labels, locale, fallback) {
+  if (labels[locale] !== void 0) return labels[locale];
+  const chain = Array.isArray(fallback) ? fallback : fallback ? [fallback] : [];
+  for (const fb of chain) {
+    if (fb === "any") {
+      const any = Object.values(labels)[0];
+      if (any !== void 0) return any;
+    } else if (labels[fb] !== void 0) {
+      return labels[fb];
+    }
+  }
+  return void 0;
+}
+function lookupToStaticDictCompat(desc) {
+  if (desc.backing !== "static" || desc.table === void 0) return void 0;
+  return {
+    _noydbStaticDict: true,
+    _viaBrand: "i18n",
+    name: desc.dimension,
+    table: desc.table,
+    keys: desc.keys ?? Object.keys(desc.table),
+    ...desc.displayLocale !== void 0 ? { displayLocale: desc.displayLocale } : {},
+    ...desc.onMissing !== void 0 ? { onMissing: desc.onMissing } : {},
+    ...desc.substitute !== void 0 ? { substitute: desc.substitute } : {},
+    validateCodes: desc.vocabulary === "closed"
+  };
+}
+function collectLookupDictCompat(lookupFields) {
+  const dictFieldMap = {};
+  const staticEntries = [];
+  for (const [field, desc] of Object.entries(lookupFields ?? {})) {
+    if (desc.backing === "reserved") {
+      dictFieldMap[field] = desc.dimension;
+    } else {
+      const compat = lookupToStaticDictCompat(desc);
+      if (compat) staticEntries.push([field, compat]);
+    }
+  }
+  return { dictFieldMap, staticEntries };
+}
+function reservedDictDepsOf(names, dictKeyFieldRegistry) {
+  const out = /* @__PURE__ */ new Set();
+  for (const name of names) {
+    const fieldMap = dictKeyFieldRegistry.get(name);
+    if (!fieldMap) continue;
+    for (const dictName of Object.values(fieldMap)) out.add(dictCollectionName(dictName));
+  }
+  return [...out];
+}
+function materializeBackingTable(descriptor, rows) {
+  const keys = new Set(rows.keys());
+  const owner = /* @__PURE__ */ new Map();
+  for (const key of keys) owner.set(key, key);
+  const altIndex = /* @__PURE__ */ new Map();
+  const altFields = descriptor.altKeys ?? [];
+  for (const [canonicalKey, row] of rows) {
+    for (const altField of altFields) {
+      const value = coerceLookupKey(row[altField]);
+      if (value === void 0 || value === "") continue;
+      const existingOwner = owner.get(value);
+      if (existingOwner !== void 0 && existingOwner !== canonicalKey) {
+        throw new ValidationError(
+          `lookup "${descriptor.dimension}": altKey field "${altField}" value "${value}" is claimed by both "${existingOwner}" and "${canonicalKey}" \u2014 key/altKey values must be unique across the dimension.`
+        );
+      }
+      owner.set(value, canonicalKey);
+      altIndex.set(value, canonicalKey);
+    }
+  }
+  return { keys, altIndex };
+}
+function checkLookupMembership(descriptor, key, getDictionary, getCollection) {
+  if (descriptor.backing === "static") {
+    const known = descriptor.keys ?? (descriptor.table ? Object.keys(descriptor.table) : []);
+    return known.includes(key);
+  }
+  if (descriptor.backing === "reserved") {
+    if ((descriptor.keys ?? []).includes(key)) return true;
+    return getDictionary(descriptor.dimension).snapshotEntries().some((e) => e["key"] === key);
+  }
+  return buildLookupAltIndex(descriptor, getDictionary, getCollection).keys.has(key);
+}
+function coerceLookupKey(raw) {
+  return typeof raw === "string" || typeof raw === "number" ? String(raw) : void 0;
+}
+function resolveBackingRowKey(descriptor, row) {
+  return coerceLookupKey(row[descriptor.key]);
+}
+function matchesReferencingValue(rec, field, compareKey) {
+  return coerceLookupKey(rec[field]) === compareKey;
+}
+function buildLookupAltIndex(descriptor, getDictionary, getCollection) {
+  if (descriptor.backing === "static") {
+    return materializeBackingTable(descriptor, new Map(Object.entries(descriptor.table ?? {})));
+  }
+  if (descriptor.backing === "reserved") {
+    const entries = getDictionary(descriptor.dimension).snapshotEntries();
+    return materializeBackingTable(descriptor, new Map(entries.map((e) => [String(e["key"]), e])));
+  }
+  const rows = getCollection(descriptor.dimension).querySourceForJoin().snapshot();
+  const keyed = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    const row = r;
+    const key = resolveBackingRowKey(descriptor, row);
+    if (key !== void 0) keyed.set(key, row);
+  }
+  return materializeBackingTable(descriptor, keyed);
+}
+function collectLookupRefEdges(collectionName, lookupFields) {
+  const edges = [];
+  for (const [field, desc] of Object.entries(lookupFields ?? {})) {
+    if (desc.backing === "static") continue;
+    const backing = desc.backing === "reserved" ? dictCollectionName(desc.dimension) : desc.dimension;
+    edges.push({
+      referencing: { collection: collectionName, field },
+      sources: [
+        { collection: backing, field: "*" },
+        ...desc.present?.label !== void 0 ? [{ collection: backing, field: desc.present.label }] : []
+      ],
+      onDelete: desc.onDelete,
+      keyField: desc.key
+    });
+  }
+  return edges;
+}
+function registerLookupRefEdges(graph, collectionName, lookupFields) {
+  for (const e of collectLookupRefEdges(collectionName, lookupFields)) {
+    graph.registerDerived(e.referencing, e.sources, "ref", "record", e.onDelete, e.keyField);
+  }
+}
+function buildLookupSnapshotRows(descriptor, isReservedDimension, getDictionary, getCollection) {
+  const dimension = descriptor.dimension;
+  if (isReservedDimension(dimension)) {
+    const rows = /* @__PURE__ */ new Map();
+    for (const entry of getDictionary(dimension).snapshotEntries()) {
+      const key = entry["key"];
+      if (typeof key === "string") rows.set(key, entry);
+    }
+    return rows;
+  }
+  if (descriptor.backing === "collection") {
+    const rawRows = getCollection(dimension).querySourceForJoin().snapshot();
+    const rows = /* @__PURE__ */ new Map();
+    for (const r of rawRows) {
+      const row = r;
+      const key = resolveBackingRowKey(descriptor, row);
+      if (key !== void 0) rows.set(key, row);
+    }
+    return rows;
+  }
+  return void 0;
+}
+
+// src/via/lookup/snapshot.ts
+function readRowField(row, field, by, locale, fallback) {
+  if (!row || field === void 0) return void 0;
+  const raw = row[field];
+  if (by === void 0) return typeof raw === "string" ? raw : void 0;
+  if (!raw || typeof raw !== "object") return void 0;
+  const map = raw;
+  const val = map[locale];
+  if (typeof val === "string") return val;
+  if (typeof fallback === "string" && typeof map[fallback] === "string") return map[fallback];
+  return void 0;
+}
+function buildLookupSnapshot(dimension, rows, descriptor) {
+  void dimension;
+  return {
+    row: (key) => rows.get(key),
+    label: (key, locale, fallback) => readRowField(rows.get(key), descriptor.present?.label, descriptor.present?.by, locale, fallback),
+    compareKeys: (a, b, locale) => {
+      const sortField = descriptor.sortBy ?? descriptor.present?.label;
+      const av = readRowField(rows.get(a), sortField, descriptor.present?.by, locale) ?? a;
+      const bv = readRowField(rows.get(b), sortField, descriptor.present?.by, locale) ?? b;
+      return av < bv ? -1 : av > bv ? 1 : 0;
+    }
+  };
+}
+function presentLookupForJoin(record, locale, lookupFields, getSnapshotRows) {
+  let result = record;
+  for (const [field, desc] of Object.entries(lookupFields)) {
+    if (desc.present === void 0) continue;
+    const raw = record[field];
+    if (typeof raw !== "string") continue;
+    const rows = desc.backing === "static" ? desc.table ? new Map(Object.entries(desc.table)) : void 0 : getSnapshotRows(desc);
+    if (!rows) continue;
+    const label = buildLookupSnapshot(desc.dimension, rows, desc).label(raw, locale);
+    if (label === void 0) continue;
+    if (result === record) result = { ...record };
+    result[`${field}Label`] = label;
+  }
+  return result;
+}
+function buildPresentForJoin(i18nFields, lookupFields, getSnapshotRows) {
+  const hasI18n = i18nFields !== void 0 && Object.keys(i18nFields).length > 0;
+  const hasLookup = lookupFields !== void 0 && Object.keys(lookupFields).length > 0;
+  if (!hasI18n && !hasLookup) return void 0;
+  const resolveRows = getSnapshotRows ?? (() => void 0);
+  return (record, locale) => {
+    if (record === null || typeof record !== "object") return record;
+    let result = record;
+    if (hasI18n) result = presentI18nForJoin(result, i18nFields, locale);
+    if (hasLookup) result = presentLookupForJoin(result, locale, lookupFields, resolveRows);
+    return result;
+  };
+}
+
+// src/port/with/lookup-strategy.ts
+function isLookupDescriptor(x) {
+  return typeof x === "object" && x !== null && x._viaBrand === "lookup";
+}
+
+// src/kernel/via/dispatch.ts
+function touchFor(batch, collection) {
+  let t = batch.get(collection);
+  if (!t) {
+    t = { puts: /* @__PURE__ */ new Set(), deletes: /* @__PURE__ */ new Map() };
+    batch.set(collection, t);
+  }
+  return t;
+}
+function resolveRollupDeleteIntents(registry, collectionName, deleted) {
+  if (!registry) return [];
+  const intents = [];
+  for (const { spec } of registry.strategiesForSource(collectionName)) {
+    if (!spec.rollup || spec.rollup.from !== collectionName) continue;
+    const kv = deleted[spec.rollup.key];
+    if (typeof kv === "string" || typeof kv === "number") intents.push({ into: spec.source, parentId: String(kv), field: spec.rollup.field });
+  }
+  return intents;
+}
+function findRollupSpecForIntent(registry, collectionName, intent) {
+  return registry?.strategiesForSource(collectionName).find((s) => s.spec.source === intent.into && s.spec.rollup?.field === intent.field && s.spec.rollup?.from === collectionName)?.spec;
+}
+var WaveContext = class {
+  _seen = /* @__PURE__ */ new Set();
+  seen(targetKey) {
+    if (this._seen.has(targetKey)) return true;
+    this._seen.add(targetKey);
+    return false;
+  }
+};
+async function runGraphDispatchWave(vault, batch) {
+  const wave = new WaveContext();
+  for (const [collectionName, touch] of batch) {
+    if (vault.graph.dependentsOf(collectionName).length === 0) continue;
+    const coll = vault._getCollection(collectionName);
+    if (!coll) continue;
+    for (const id of touch.puts) {
+      try {
+        const stored = await coll._getStoredRecordForDispatch(id);
+        if (!stored) continue;
+        await coll.dispatchDerivations(id, stored.record, stored.version, wave);
+        await coll.dispatchMaterializedViews(id, stored.record, wave);
+      } catch (err) {
+        console.warn(`[via-dispatch] wave recompute failed for ${collectionName}/${id}:`, err);
+        vault._emit("derivation:wave-error", { collection: collectionName, id, error: err });
+      }
+    }
+    for (const [id, intents] of touch.deletes) {
+      try {
+        await coll._recomputeDeletedRollups(intents, wave);
+        await coll.dispatchMaterializedViewsOnDelete(id);
+        await coll.dispatchArrayDerivationsOnDelete(id);
+      } catch (err) {
+        console.warn(`[via-dispatch] wave delete-recompute failed for ${collectionName}/${id}:`, err);
+        vault._emit("derivation:wave-error", { collection: collectionName, id, error: err });
+      }
+    }
+  }
+}
+async function putDerivedOutput(outColl, id, value, ctx, options) {
+  try {
+    await outColl.put(id, value, options);
+    return "written";
+  } catch (err) {
+    if (!(err instanceof PeriodClosedError)) throw err;
+    const targetCollection = outColl.name;
+    const event = {
+      source: ctx.source,
+      target: { collection: targetCollection, id },
+      period: err.periodName,
+      endDate: err.endDate
+    };
+    ctx.emit("derivation:skipped-frozen", event);
+    if (ctx.audit) await ctx.audit(event);
+    return "skipped-frozen";
+  }
+}
+function ledgerAuditHook(ledger, actor) {
+  if (!ledger) return void 0;
+  return async (e) => {
+    await ledger.append({
+      op: "lifecycle",
+      collection: e.target.collection,
+      id: e.target.id,
+      version: 0,
+      actor,
+      payloadHash: "",
+      reason: JSON.stringify({ event: "derivation-skipped-frozen", ...e })
+    });
+  };
+}
+async function forgetDerivedFanout(vault, ref, envelope, stats, lookupCompareKeys) {
+  const coll = vault._getCollection(ref.collection);
+  if (coll) {
+    const mv = await coll.dispatchMaterializedViewsOnDelete(ref.id);
+    stats.recordsErased += mv.deleted;
+    stats.derivedResidueUndecodable.push(...mv.residueUndecodable);
+    stats.derivedResidueDeclined.push(...mv.residueDeclined);
+  }
+  const edges = vault.graph.derivedArtifactsOf(ref.collection);
+  if (edges.length === 0 || !coll) return;
+  if (edges.some((e) => e.kind === "ref")) {
+    const { cascaded, nullified, residue } = await applyLookupRefsFanout(vault, ref.collection, ref.id, lookupCompareKeys);
+    stats.lookupReferencesCascaded += cascaded;
+    stats.lookupReferencesNullified += nullified;
+    stats.lookupReferencesResidue.push(...residue);
+  }
+  if (edges.some((e) => e.kind === "derivation")) {
+    stats.recordsErased += await coll.dispatchArrayDerivationsOnDelete(ref.id, true);
+  }
+  if (envelope && edges.some((e) => e.kind === "rollup")) {
+    const priorRecord = await coll._decodeEnvelope(envelope, ref.id);
+    if (priorRecord) {
+      for (const r of await coll.dispatchRollupsOnDelete(ref.id, priorRecord)) {
+        if (r.outcome === "written") stats.aggregatesRecomputed += 1;
+        else if (r.outcome === "skipped-frozen") stats.residueFrozen.push(`${r.into}:${r.parentId}`);
+      }
+    }
+  }
+}
+async function applyLookupRefsFanout(vault, backing, key, compareKeys) {
+  let cascaded = 0;
+  let nullified = 0;
+  const residue = [];
+  for (const { referencing, onDelete, keyField } of vault.graph.referencingEdgesOf(backing)) {
+    if (onDelete === "restrict") continue;
+    const compareKey = keyField === "id" ? key : compareKeys.get(keyField);
+    if (compareKey === void 0) {
+      residue.push(`${backing}:${key}:${referencing.collection}.${referencing.field}`);
+      continue;
+    }
+    const coll = vault._getCollection(referencing.collection);
+    if (!coll) continue;
+    const matches = (await coll.list()).filter((rec) => matchesReferencingValue(rec, referencing.field, compareKey));
+    for (const rec of matches) {
+      const id = rec["id"];
+      if (id === void 0) continue;
+      if (onDelete === "cascade") {
+        await coll.delete(id);
+        cascaded++;
+      } else if (onDelete === "nullify") {
+        await coll.put(id, { ...rec, [referencing.field]: null });
+        nullified++;
+      }
+    }
+  }
+  return { cascaded, nullified, residue };
+}
+
+export {
+  enforceStaticDictOnPut,
+  resolveDictSource,
+  updateReferencingRecords,
+  resolveLabelFromMap,
+  collectLookupDictCompat,
+  reservedDictDepsOf,
+  checkLookupMembership,
+  coerceLookupKey,
+  matchesReferencingValue,
+  buildLookupAltIndex,
+  registerLookupRefEdges,
+  buildLookupSnapshotRows,
+  buildLookupSnapshot,
+  buildPresentForJoin,
+  isLookupDescriptor,
+  touchFor,
+  resolveRollupDeleteIntents,
+  findRollupSpecForIntent,
+  runGraphDispatchWave,
+  putDerivedOutput,
+  ledgerAuditHook,
+  forgetDerivedFanout
+};
+//# sourceMappingURL=chunk-4CTHCN4J.js.map