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

package/dist/chunk-TBNF5DV5.js

@@ -0,0 +1,261 @@
+import {
+  encrypt
+} from "./chunk-37WOJQWY.js";
+import {
+  NOYDB_FORMAT_VERSION
+} from "./chunk-JC75UBMT.js";
+
+// src/with-shape/blobs/export-blobs.ts
+var ExportBlobsAbortedError = class extends Error {
+  constructor(reason) {
+    super(`exportBlobs aborted: ${reason}`);
+    this.name = "ExportBlobsAbortedError";
+  }
+};
+var EXPORT_AUDIT_COLLECTION = "_export_audit";
+function createExportBlobsHandle(actor, listAccessibleCollections, getCollection, writeAudit, options) {
+  let aborted = false;
+  const abort = () => {
+    aborted = true;
+  };
+  if (options.signal) {
+    if (options.signal.aborted) aborted = true;
+    options.signal.addEventListener("abort", () => {
+      aborted = true;
+    });
+  }
+  function assertLive() {
+    if (aborted) throw new ExportBlobsAbortedError("aborted by caller");
+  }
+  const allowlist = options.collections ? new Set(options.collections) : null;
+  let auditPromise = null;
+  function writeAuditOnce() {
+    if (!auditPromise) {
+      auditPromise = writeAudit({
+        id: generateBatchId(),
+        mechanism: "exportBlobs",
+        actor,
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        collections: options.collections ?? null,
+        predicate: Boolean(options.where),
+        afterBlobId: options.afterBlobId ?? null
+      });
+    }
+    return auditPromise;
+  }
+  async function* generate() {
+    await writeAuditOnce();
+    assertLive();
+    const allCollections = await listAccessibleCollections();
+    const targets = allCollections.filter((name) => {
+      if (name.startsWith("_")) return false;
+      if (allowlist && !allowlist.has(name)) return false;
+      return true;
+    });
+    let resumeCursorHit = options.afterBlobId === void 0;
+    for (const collectionName of targets) {
+      if (aborted) return;
+      const coll = getCollection(collectionName);
+      const records = await coll.list().catch(() => []);
+      for (const record of records) {
+        if (aborted) return;
+        assertLive();
+        const idField = record.id;
+        if (typeof idField !== "string") continue;
+        if (options.where && !options.where(record, { collection: collectionName, id: idField })) continue;
+        const blobSet = coll.blob(idField);
+        const slots = await blobSet.list().catch(() => []);
+        for (const slot of slots) {
+          if (aborted) return;
+          if (!resumeCursorHit) {
+            if (slot.eTag === options.afterBlobId) {
+              resumeCursorHit = true;
+            }
+            continue;
+          }
+          const bytes = await blobSet.get(slot.name);
+          if (!bytes) continue;
+          const item = {
+            blobId: slot.eTag,
+            recordRef: { collection: collectionName, id: idField, slot: slot.name },
+            bytes,
+            meta: {
+              size: slot.size,
+              filename: slot.filename,
+              ...slot.mimeType !== void 0 && { mimeType: slot.mimeType },
+              ...slot.uploadedAt !== void 0 && { createdAt: slot.uploadedAt }
+            }
+          };
+          yield item;
+        }
+      }
+    }
+  }
+  const handle = {
+    abort,
+    get aborted() {
+      return aborted;
+    },
+    [Symbol.asyncIterator]: () => generate()
+  };
+  return handle;
+}
+function generateBatchId() {
+  const raw = globalThis.crypto.getRandomValues(new Uint8Array(16));
+  let s = "";
+  for (const b of raw) s += b.toString(16).padStart(2, "0");
+  return `batch-${Date.now().toString(36)}-${s.slice(0, 12)}`;
+}
+
+// src/with-shape/blobs/blob-compaction.ts
+var BLOB_EVICTION_AUDIT_COLLECTION = "_blob_eviction_audit";
+async function runCompaction(ctx, options = {}) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const maxEvictions = options.maxEvictions ?? Infinity;
+  const dryRun = options.dryRun === true;
+  const allCollections = await ctx.listCollections();
+  const byCollection = {};
+  let evicted = 0;
+  let records = 0;
+  let auditEntries = 0;
+  let held = 0;
+  let collectionsWithPolicy = 0;
+  outer: for (const collectionName of allCollections) {
+    if (collectionName.startsWith("_")) continue;
+    const config = ctx.getBlobFields(collectionName);
+    if (!config) continue;
+    const configuredSlots = Object.keys(config);
+    if (configuredSlots.length === 0) continue;
+    collectionsWithPolicy += 1;
+    byCollection[collectionName] = { records: 0, evicted: 0 };
+    const ids = await ctx.listRecords(collectionName);
+    for (const recordId of ids) {
+      if (evicted >= maxEvictions) break outer;
+      const record = await ctx.getRecord(collectionName, recordId).catch(() => null);
+      if (record === null) continue;
+      records += 1;
+      byCollection[collectionName].records += 1;
+      const slots = await ctx.listSlots(collectionName, recordId).catch(() => []);
+      for (const slot of slots) {
+        if (evicted >= maxEvictions) break outer;
+        const policy = config[slot.name];
+        if (!policy) continue;
+        const reason = evaluatePolicy(policy, record, slot, now);
+        if (!reason) continue;
+        if (isHeld(policy, record, now)) {
+          held += 1;
+          continue;
+        }
+        if (!dryRun) {
+          await ctx.deleteSlot(collectionName, recordId, slot.name);
+          await writeAuditEntry(ctx, {
+            id: generateEvictionId(collectionName, recordId, slot.name),
+            collection: collectionName,
+            recordId,
+            slotName: slot.name,
+            blobHash: slot.eTag,
+            reason,
+            evictedAt: now.toISOString(),
+            actor: ctx.actor
+          });
+          auditEntries += 1;
+        }
+        evicted += 1;
+        byCollection[collectionName].evicted += 1;
+      }
+    }
+  }
+  return {
+    evicted,
+    records,
+    collections: collectionsWithPolicy,
+    auditEntries,
+    held,
+    byCollection
+  };
+}
+function isHeld(policy, record, now) {
+  if (policy.legalHold) {
+    try {
+      if (policy.legalHold(record)) return true;
+    } catch {
+      return true;
+    }
+  }
+  if (policy.retainUntil) {
+    try {
+      const until = policy.retainUntil(record);
+      if (until !== null && until !== void 0) {
+        const t = until instanceof Date ? until.getTime() : typeof until === "number" ? until : Date.parse(String(until));
+        if (!Number.isFinite(t)) return true;
+        if (t > now.getTime()) return true;
+      }
+    } catch {
+      return true;
+    }
+  }
+  return false;
+}
+function evaluatePolicy(policy, record, slot, now) {
+  let ttlTriggered = false;
+  let predicateTriggered = false;
+  if (policy.retainDays !== void 0 && policy.retainDays > 0) {
+    const uploadedAt = Date.parse(slot.uploadedAt);
+    if (Number.isFinite(uploadedAt)) {
+      const ageMs = now.getTime() - uploadedAt;
+      const limitMs = policy.retainDays * 864e5;
+      if (ageMs > limitMs) ttlTriggered = true;
+    }
+  }
+  if (policy.evictWhen) {
+    try {
+      if (policy.evictWhen(record)) predicateTriggered = true;
+    } catch {
+    }
+  }
+  if (ttlTriggered && predicateTriggered) return "both";
+  if (ttlTriggered) return "ttl";
+  if (predicateTriggered) return "predicate";
+  return null;
+}
+function generateEvictionId(collection, recordId, slotName) {
+  const rand = globalThis.crypto.getRandomValues(new Uint8Array(8));
+  let suffix = "";
+  for (const b of rand) suffix += b.toString(16).padStart(2, "0");
+  return `${collection}__${recordId}__${slotName}__${suffix}`;
+}
+async function writeAuditEntry(ctx, entry) {
+  const json = JSON.stringify(entry);
+  let envelope;
+  if (ctx.encrypted) {
+    const dek = await ctx.getDEK(BLOB_EVICTION_AUDIT_COLLECTION);
+    const { iv, data } = await encrypt(json, dek);
+    envelope = {
+      _noydb: NOYDB_FORMAT_VERSION,
+      _v: 1,
+      _ts: entry.evictedAt,
+      _iv: iv,
+      _data: data,
+      _by: entry.actor
+    };
+  } else {
+    envelope = {
+      _noydb: NOYDB_FORMAT_VERSION,
+      _v: 1,
+      _ts: entry.evictedAt,
+      _iv: "",
+      _data: json,
+      _by: entry.actor
+    };
+  }
+  await ctx.adapter.put(ctx.vault, BLOB_EVICTION_AUDIT_COLLECTION, entry.id, envelope);
+}
+
+export {
+  ExportBlobsAbortedError,
+  EXPORT_AUDIT_COLLECTION,
+  createExportBlobsHandle,
+  BLOB_EVICTION_AUDIT_COLLECTION,
+  runCompaction
+};
+//# sourceMappingURL=chunk-TBNF5DV5.js.map

package/dist/chunk-TVOHSPVK.js

@@ -0,0 +1,21 @@
+import {
+  SealedRecordNotEnabledError
+} from "./chunk-FZCGIJEJ.js";
+
+// src/with-audit/sealed-record/strategy.ts
+var NO_SEALED_RECORD = {
+  async sealRecordToHost() {
+    throw new SealedRecordNotEnabledError();
+  },
+  async revokeSealedRecord() {
+    throw new SealedRecordNotEnabledError();
+  },
+  async rotateRecordCek() {
+    throw new SealedRecordNotEnabledError();
+  }
+};
+
+export {
+  NO_SEALED_RECORD
+};
+//# sourceMappingURL=chunk-TVOHSPVK.js.map

package/dist/chunk-TVS6BUUR.js

@@ -0,0 +1,41 @@
+import {
+  NoydbError
+} from "./chunk-FZCGIJEJ.js";
+
+// src/with-shape/links/names.ts
+var LINK_COLLECTION_PREFIX = "_links_";
+function linkCollectionName(name) {
+  return `${LINK_COLLECTION_PREFIX}${name}`;
+}
+function isLinkCollectionName(name) {
+  return name.startsWith(LINK_COLLECTION_PREFIX);
+}
+function linkRowKey(aId, bId) {
+  return `${encodeURIComponent(aId)}|${encodeURIComponent(bId)}`;
+}
+var LinkIntegrityError = class extends NoydbError {
+  link;
+  endpoint;
+  id;
+  count;
+  constructor(link, endpoint, id, count) {
+    super(
+      "LINK_INTEGRITY",
+      `Cannot delete "${endpoint}"/"${id}": ${count} link(s) in "${link}" still reference it (onDelete: 'strict').`
+    );
+    this.name = "LinkIntegrityError";
+    this.link = link;
+    this.endpoint = endpoint;
+    this.id = id;
+    this.count = count;
+  }
+};
+
+export {
+  LINK_COLLECTION_PREFIX,
+  linkCollectionName,
+  isLinkCollectionName,
+  linkRowKey,
+  LinkIntegrityError
+};
+//# sourceMappingURL=chunk-TVS6BUUR.js.map

package/dist/chunk-UMC5QZTX.js

@@ -0,0 +1,86 @@
+import {
+  grant,
+  revoke
+} from "./chunk-CCIR2OJH.js";
+import {
+  CargoNotEnabledError,
+  CustodyNotEnabledError
+} from "./chunk-FZCGIJEJ.js";
+
+// src/with-cargo/strategy.ts
+var NO_CARGO = {
+  async extractPartition() {
+    throw new CargoNotEnabledError();
+  }
+};
+
+// src/with-party/custody/active.ts
+function withCustody() {
+  return {
+    async grantCustodian(host, vault, options, factors) {
+      return host._grantCustodianImpl(grant, vault, options, factors);
+    },
+    async revokeCustodian(host, vault, options, factors) {
+      return host._revokeCustodianImpl(revoke, vault, options, factors);
+    },
+    async liberate(vault, opts) {
+      const { liberateVault } = await import("./liberate-GFUQJRK5.js");
+      return liberateVault(vault, opts);
+    }
+  };
+}
+
+// src/with-party/custody/strategy.ts
+var NO_CUSTODY = {
+  async grantCustodian() {
+    throw new CustodyNotEnabledError();
+  },
+  async revokeCustodian() {
+    throw new CustodyNotEnabledError();
+  },
+  async liberate() {
+    throw new CustodyNotEnabledError();
+  }
+};
+
+// src/with-party/custody/index.ts
+var CustodyApi = class {
+  constructor(_grantCustodian, _revokeCustodian, _liberate) {
+    this._grantCustodian = _grantCustodian;
+    this._revokeCustodian = _revokeCustodian;
+    this._liberate = _liberate;
+  }
+  _grantCustodian;
+  _revokeCustodian;
+  _liberate;
+  /**
+   * Owner-only: grant the FR-6 `custodian` role. The custodian operates every
+   * collection (rw + access) but is provably unable to grant / revoke / rotate /
+   * extract-and-sever. Defended in depth (gate + owner-only role check) inside
+   * the injected `Noydb.grantCustodian`.
+   */
+  async grantCustodian(options, factors) {
+    return this._grantCustodian(options, factors);
+  }
+  /** Owner-only: revoke a custodian. */
+  async revokeCustodian(options, factors) {
+    return this._revokeCustodian(options, factors);
+  }
+  /**
+   * Custodian-only: the audited claim of ownership over a sealed-owner (Deed)
+   * vault. Mints a DISTINCT new owner re-wrapping the incumbent DEKs under a
+   * fresh KEK (the latent owner is never impersonated), ledger-audited. See
+   * {@link liberateVault}.
+   */
+  async liberate(opts) {
+    return this._liberate(opts);
+  }
+};
+
+export {
+  NO_CARGO,
+  withCustody,
+  NO_CUSTODY,
+  CustodyApi
+};
+//# sourceMappingURL=chunk-UMC5QZTX.js.map