@odla-ai/chapter 0.47.5 → 0.47.6

package/dist/worker/index.js

@@ -6874,6 +6874,7 @@ var handleAdminNetworkSharedNotes = async (req, url, env, ctx) => {
 // src/network-person-registry.ts
 var TOKEN = /^[a-z0-9][a-z0-9._:-]{0,127}$/;
 var CHAPTER_ID = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
+var FIXTURE_MARKER = /fixture|(?:^|[\s._:-])(dummy|sample|test(?:case)?)(?:$|[\s._:-])/i;
 function normalizeNetworkIdentity(kind, value) {
   const trimmed = value.trim();
   if (kind === "email") return trimmed.toLowerCase();
@@ -6900,6 +6901,9 @@ function validateNetworkPersonImport(input, allowedChapterIds) {
   if (!sourceRecordId || sourceRecordId.length > 200) errors.push("sourceRecordId is required and bounded");
   if (!provenance || provenance.length > 500) errors.push("provenance is required and bounded");
   if (!displayName || displayName.length > 200) errors.push("displayName is required and bounded");
+  if (FIXTURE_MARKER.test(sourceRecordId) || FIXTURE_MARKER.test(displayName)) {
+    errors.push("fixture, test, sample, and dummy rows cannot become network Persons");
+  }
   const rawConsent = raw2.consent && typeof raw2.consent === "object" && !Array.isArray(raw2.consent) ? raw2.consent : {};
   const consentStates = ["unknown", "granted", "denied"];
   const marketing = typeof rawConsent.marketing === "string" ? rawConsent.marketing : "";
@@ -7312,6 +7316,247 @@ async function suppressNetworkPerson(db, input, mutationId, actor, now = Date.no
   return next;
 }
 
+// src/network-person-bulk-preview.ts
+var NETWORK_PERSON_BULK_IMPORT_MAX_ROWS = 5e3;
+var NETWORK_PERSON_BULK_IMPORT_VERSION = 1;
+var networkPersonBulkEmptyCounts = () => ({
+  new: 0,
+  replay: 0,
+  exactMatchReview: 0,
+  invalid: 0,
+  rejected: 0,
+  failed: 0
+});
+var incrementNetworkPersonBulkCount = (counts, status) => {
+  if (status === "exact_match_review") counts.exactMatchReview += 1;
+  else counts[status] += 1;
+};
+function stableValue(value) {
+  if (Array.isArray(value)) return value.map(stableValue);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, stableValue(item)]));
+  }
+  return value;
+}
+async function networkPersonBulkSha256(value) {
+  const bytes = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(value));
+  return [...new Uint8Array(bytes)].map((part) => part.toString(16).padStart(2, "0")).join("");
+}
+function assertNetworkPersonBulkRows(rows5) {
+  if (!Array.isArray(rows5) || rows5.length < 1) {
+    throw new NetworkPersonRegistryError("bulk_rows_required", "bulk import requires at least one row");
+  }
+  if (rows5.length > NETWORK_PERSON_BULK_IMPORT_MAX_ROWS) {
+    throw new NetworkPersonRegistryError(
+      "bulk_rows_exceeded",
+      `bulk import is limited to ${NETWORK_PERSON_BULK_IMPORT_MAX_ROWS.toLocaleString()} rows`
+    );
+  }
+  return rows5;
+}
+async function networkPersonBulkBatchDigest(rows5) {
+  const bounded = assertNetworkPersonBulkRows(rows5);
+  return networkPersonBulkSha256(JSON.stringify(stableValue({ version: NETWORK_PERSON_BULK_IMPORT_VERSION, rows: bounded })));
+}
+async function networkPersonRegistryStateDigest(state) {
+  const snapshot = {
+    persons: state.persons.map(({ id, revision, state: personState, mergedIntoId }) => ({ id, revision, state: personState, mergedIntoId })).sort((a, b) => a.id.localeCompare(b.id)),
+    claims: state.claims.map(({ id, personId }) => ({ id, personId })).sort((a, b) => a.id.localeCompare(b.id)),
+    aliases: state.aliases.map(({ id, revision, status, personId }) => ({ id, revision, status, personId })).sort((a, b) => a.id.localeCompare(b.id)),
+    links: state.links.map(({ id, personId, state: linkState }) => ({ id, personId, state: linkState })).sort((a, b) => a.id.localeCompare(b.id))
+  };
+  return networkPersonBulkSha256(JSON.stringify(stableValue(snapshot)));
+}
+function rejectedValidation(errors) {
+  return errors.some((error) => /approved|real person|non-development|development or invalid email|fixture, test, sample/i.test(error));
+}
+async function classifyNetworkPersonBulkRows(rows5, allowedChapterIds, state) {
+  const aliasIds = new Set(state.aliases.map((alias) => alias.id));
+  const batchAliases = /* @__PURE__ */ new Set();
+  const claimOwners = /* @__PURE__ */ new Map();
+  for (const claim of state.claims) {
+    const owners = claimOwners.get(claim.id) ?? /* @__PURE__ */ new Set();
+    owners.add(claim.personId);
+    claimOwners.set(claim.id, owners);
+  }
+  const results = [];
+  const values = [];
+  for (let index2 = 0; index2 < rows5.length; index2 += 1) {
+    const validation = validateNetworkPersonImport(rows5[index2], allowedChapterIds);
+    if (!validation.ok || !validation.value) {
+      const errors = validation.errors.slice(0, 8);
+      results.push({ rowNumber: index2 + 2, status: rejectedValidation(errors) ? "rejected" : "invalid", errors });
+      values.push(null);
+      continue;
+    }
+    const value = validation.value;
+    const aliasId = await networkSourceKey(value.sourceSystem, value.sourceRecordId);
+    if (batchAliases.has(aliasId)) {
+      results.push({ rowNumber: index2 + 2, status: "rejected", errors: ["duplicate source record in this batch"] });
+      values.push(null);
+      continue;
+    }
+    batchAliases.add(aliasId);
+    if (aliasIds.has(aliasId)) {
+      results.push({ rowNumber: index2 + 2, status: "replay" });
+      values.push(value);
+      continue;
+    }
+    const claims = await Promise.all(value.identities.map(networkIdentityClaim));
+    const candidates = new Set(claims.flatMap((claim) => [...claimOwners.get(claim.id) ?? []]));
+    results.push(candidates.size ? { rowNumber: index2 + 2, status: "exact_match_review", candidateCount: candidates.size } : { rowNumber: index2 + 2, status: "new" });
+    const plannedOwner = `bulk_row_${index2 + 2}`;
+    for (const claim of claims) {
+      const owners = claimOwners.get(claim.id) ?? /* @__PURE__ */ new Set();
+      owners.add(plannedOwner);
+      claimOwners.set(claim.id, owners);
+    }
+    values.push(value);
+  }
+  return { rows: results, values };
+}
+async function previewNetworkPersonBulkImport(db, rows5, allowedChapterIds) {
+  const bounded = assertNetworkPersonBulkRows(rows5);
+  const state = await loadNetworkPersonRegistry(db);
+  const classified = await classifyNetworkPersonBulkRows(bounded, allowedChapterIds, state);
+  const counts = networkPersonBulkEmptyCounts();
+  for (const row of classified.rows) incrementNetworkPersonBulkCount(counts, row.status);
+  return {
+    version: NETWORK_PERSON_BULK_IMPORT_VERSION,
+    batchDigest: await networkPersonBulkBatchDigest(bounded),
+    stateDigest: await networkPersonRegistryStateDigest(state),
+    rowCount: bounded.length,
+    counts,
+    rows: classified.rows
+  };
+}
+
+// src/network-person-bulk-import.ts
+async function derivedMutationId(batchMutationId, part) {
+  return `bulk_${await networkPersonBulkSha256(`${batchMutationId}\0${part}`)}`;
+}
+function matchingEvent(events, mutationId, kind) {
+  return events.find((event) => event.mutationId === mutationId && event.kind === kind);
+}
+function eventString(event, key) {
+  return typeof event.detail[key] === "string" ? String(event.detail[key]) : "";
+}
+function eventCounts(event) {
+  const value = event.detail.counts;
+  return value && typeof value === "object" && !Array.isArray(value) ? { ...networkPersonBulkEmptyCounts(), ...value } : networkPersonBulkEmptyCounts();
+}
+async function applyNetworkPersonBulkImport(db, input, batchMutationId, actor, allowedChapterIds, now = Date.now()) {
+  if (input.reviewed !== true) throw new NetworkPersonRegistryError("bulk_review_required", "the exact preview must be explicitly reviewed before apply");
+  const rows5 = assertNetworkPersonBulkRows(input.rows);
+  const batchDigest = await networkPersonBulkBatchDigest(rows5);
+  if (!/^[a-f0-9]{64}$/.test(input.expectedBatchDigest) || batchDigest !== input.expectedBatchDigest) {
+    throw new NetworkPersonRegistryError("bulk_digest_changed", "bulk import rows changed after preview; preview again");
+  }
+  if (!/^[a-f0-9]{64}$/.test(input.expectedStateDigest)) {
+    throw new NetworkPersonRegistryError("bulk_state_digest_required", "a reviewed registry state digest is required");
+  }
+  const startedMutationId = await derivedMutationId(batchMutationId, "started");
+  const completedMutationId = await derivedMutationId(batchMutationId, "completed");
+  let state = await loadNetworkPersonRegistry(db);
+  const completed = matchingEvent(state.events, completedMutationId, "bulk_import_completed");
+  if (completed) {
+    if (eventString(completed, "batchDigest") !== batchDigest) {
+      throw new NetworkPersonRegistryError("bulk_mutation_conflict", "batch mutation id was already used for different rows");
+    }
+    return {
+      version: NETWORK_PERSON_BULK_IMPORT_VERSION,
+      batchDigest,
+      stateDigest: eventString(completed, "stateDigest"),
+      rowCount: Number(completed.detail.rowCount) || rows5.length,
+      counts: eventCounts(completed),
+      rows: [],
+      replayed: true
+    };
+  }
+  let started = matchingEvent(state.events, startedMutationId, "bulk_import_started");
+  if (!started) {
+    const preview = await previewNetworkPersonBulkImport(db, rows5, allowedChapterIds);
+    if (preview.stateDigest !== input.expectedStateDigest) {
+      throw new NetworkPersonRegistryError("bulk_state_changed", "network Person registry changed after preview; preview again");
+    }
+    try {
+      await db.transact([
+        networkPersonEventOp("bulk_import_started", startedMutationId, actor, now, {
+          batchDigest,
+          stateDigest: input.expectedStateDigest,
+          rowCount: rows5.length,
+          previewCounts: preview.counts
+        })
+      ], {
+        mutationId: startedMutationId,
+        guards: [{ ns: "networkPersonEvents", id: `network_person_event:${startedMutationId}`, exists: false }]
+      });
+    } catch (error) {
+      if (!(error instanceof Error) || error.code !== "transact_guard_failed") throw error;
+    }
+    state = await loadNetworkPersonRegistry(db);
+    started = matchingEvent(state.events, startedMutationId, "bulk_import_started");
+  }
+  if (!started || eventString(started, "batchDigest") !== batchDigest || eventString(started, "stateDigest") !== input.expectedStateDigest) {
+    throw new NetworkPersonRegistryError("bulk_mutation_conflict", "batch mutation id does not match the reviewed preview");
+  }
+  const classified = await classifyNetworkPersonBulkRows(rows5, allowedChapterIds, state);
+  const results = [];
+  const counts = networkPersonBulkEmptyCounts();
+  for (let index2 = 0; index2 < classified.rows.length; index2 += 1) {
+    const row = classified.rows[index2];
+    const value = classified.values[index2];
+    if (!value) {
+      results.push(row);
+      incrementNetworkPersonBulkCount(counts, row.status);
+      continue;
+    }
+    try {
+      const result = await importNetworkPerson(
+        db,
+        value,
+        await derivedMutationId(batchMutationId, `row_${index2 + 2}`),
+        actor,
+        now + index2 + 1
+      );
+      const status = "replayed" in result && result.replayed ? "replay" : result.status === "ambiguous" ? "exact_match_review" : "new";
+      const applied = {
+        rowNumber: index2 + 2,
+        status,
+        ...result.status === "ambiguous" ? { candidateCount: result.alias.candidatePersonIds?.length ?? 0 } : {}
+      };
+      results.push(applied);
+      incrementNetworkPersonBulkCount(counts, status);
+    } catch (error) {
+      const failed = {
+        rowNumber: index2 + 2,
+        status: "failed",
+        errors: [error instanceof Error ? error.message : "row failed"]
+      };
+      results.push(failed);
+      incrementNetworkPersonBulkCount(counts, failed.status);
+    }
+  }
+  if (counts.failed === 0) {
+    await db.transact([
+      networkPersonEventOp("bulk_import_completed", completedMutationId, actor, now + rows5.length + 1, {
+        batchDigest,
+        stateDigest: input.expectedStateDigest,
+        rowCount: rows5.length,
+        counts
+      })
+    ], { mutationId: completedMutationId });
+  }
+  return {
+    version: NETWORK_PERSON_BULK_IMPORT_VERSION,
+    batchDigest,
+    stateDigest: input.expectedStateDigest,
+    rowCount: rows5.length,
+    counts,
+    rows: results
+  };
+}
+
 // src/network-person-route-projection.ts
 function redactedName(displayName) {
   return displayName.split(/\s+/).filter(Boolean).map((part) => `${part[0]?.toUpperCase() ?? ""}\u2026`).join(" ");
@@ -7428,7 +7673,7 @@ async function revealNetworkPersonRegistryRecord(db, input, mutationId, actor, n
 
 // src/worker-routes-network-person-registry.ts
 var PATH2 = "/api/admin/network-person-registry";
-var MAX_BODY2 = 32e3;
+var MAX_BODY2 = 8 * 1024 * 1024;
 var MUTATION_ID4 = /^[A-Za-z0-9_-]{16,128}$/;
 var positiveRevision = (value) => {
   const parsed = Number(value);
@@ -7443,7 +7688,7 @@ async function gate10(req, env, ctx) {
 }
 function registryError(error) {
   if (error instanceof NetworkPersonRegistryError) {
-    const status = error.code.includes("stale") || error.code === "identity_conflict" ? 409 : error.code.endsWith("not_found") ? 404 : 400;
+    const status = error.code.includes("stale") || error.code === "identity_conflict" || error.code === "bulk_state_changed" || error.code === "bulk_digest_changed" || error.code === "bulk_mutation_conflict" ? 409 : error.code.endsWith("not_found") ? 404 : 400;
     return json({ error: error.message, code: error.code }, status);
   }
   if (error instanceof Error && error.code === "transact_guard_failed") {
@@ -7478,6 +7723,23 @@ var handleAdminNetworkPersonRegistry = async (req, url, env, ctx) => {
     if (!MUTATION_ID4.test(mutationId)) return json({ error: "a valid mutationId is required" }, 400);
     const actionActor = { id: got.user.userId };
     try {
+      if (command === "preview-bulk-import") {
+        const result = await previewNetworkPersonBulkImport(
+          db,
+          input.rows,
+          ctx.chapter.networkPersonRegistry.chapterIds
+        );
+        return json({ result });
+      }
+      if (command === "apply-bulk-import") {
+        const result = await applyNetworkPersonBulkImport(db, {
+          rows: input.rows,
+          expectedBatchDigest: typeof input.expectedBatchDigest === "string" ? input.expectedBatchDigest : "",
+          expectedStateDigest: typeof input.expectedStateDigest === "string" ? input.expectedStateDigest : "",
+          reviewed: input.reviewed === true
+        }, mutationId, actionActor, ctx.chapter.networkPersonRegistry.chapterIds);
+        return json({ result }, result.replayed ? 200 : 201);
+      }
       if (command === "import") {
         const validated = validateNetworkPersonImport(input, ctx.chapter.networkPersonRegistry.chapterIds);
         if (!validated.ok || !validated.value) return json({ error: "invalid import", details: validated.errors }, 400);