@aigne/afs-did-space 1.12.0-beta.5

package/dist/blocklet-hook.mjs

@@ -0,0 +1,178 @@
+import { AFSAlreadyExistsError, makeNsLog } from "@aigne/afs";
+
+//#region src/blocklet-hook.ts
+/**
+* Blocklet publish/resolve write & delete hooks (#674 Phase 3, v2).
+*
+* AFS-native registration keyed on a PUBLISH MARKER, not `blocklet.yaml`:
+* `arc deploy` writes `<blocklet-root>/.blocklet-publish.json` LAST (always —
+* even for blocklets that have no `blocklet.yaml`, e.g. a plain `index.html`
+* one), and that write registers the blocklet in the global resolve table under
+* `resolve/blocklet/<id>`. The CF/Node serve path reads the table back to find
+* the owner space + path. There is NO REST endpoint — registration rides the
+* AFS write of the marker, mirroring how `.share` files reconcile.
+*
+* Why a marker and not `blocklet.yaml`: not every blocklet has a manifest, and
+* the blocklet's identity at publish time is the target slug
+* (`/user/blocklets/<slug>/`), which `arc deploy` already knows (manifest id
+* else dir name). Keying on a publish-written marker (a) works for ALL blocklet
+* shapes, (b) leaves the developer's files untouched (so a static blocklet stays
+* a static blocklet — a synthesized manifest could flip its serve type), and
+* (c) registers only on an explicit publish, not on any incidental manifest write.
+*
+* Contract (see planning/did-integration/blocklet-publish-resolve/design.md):
+*   marker  : <blocklet-root>/.blocklet-publish.json  = { "id": "<slug>", ... }
+*   register: resolve/blocklet/<id> → { owner, path, type:"blocklet", name:id }
+*     - owner = PLAINTEXT space-owner DID (so the reader can open the space)
+*     - path  = the blocklet root (dir holding the marker), captured at write
+*               time — scope-absolute, so resolve replays it regardless of WHERE
+*               it was written (`/user/...` lands physically under
+*               `blocklets/<instance>/user/...` and we capture that real path)
+*   resolve : resolve/blocklet/<id> → { owner, path }
+*   serve   : getUserSpace(owner) → createAfsBlockletReader(afs, path)
+*
+* All hooks are best-effort / fail-soft: a marker that doesn't parse or has no
+* `id`, or a registration failure, MUST NOT break the underlying file write.
+*
+* #764 Phase 4 extends the marker with an optional `domains: string[]` (from
+* the manifest's `sites[].domains`) that also registers `resolve/domain/<domain>`
+* → { did, owner, path }. This is the ONE deliberate exception to fail-soft: a
+* domain already owned by a different owner rejects the write loudly instead
+* of silently overwriting — see `applyBlockletWriteHook`'s doc comment.
+*/
+const log = makeNsLog("provider:did-space:blocklet-hook");
+/** The publish marker `arc deploy` writes (last) into a blocklet's DID-Space root. */
+const BLOCKLET_PUBLISH_MARKER = ".blocklet-publish.json";
+/**
+* True if `afsPath`'s basename is the publish marker. Accepts a leading slash
+* and any directory depth.
+*/
+function isBlockletPublishMarkerPath(afsPath) {
+	const p = afsPath.startsWith("/") ? afsPath.slice(1) : afsPath;
+	return p === BLOCKLET_PUBLISH_MARKER || p.endsWith(`/${BLOCKLET_PUBLISH_MARKER}`);
+}
+/**
+* Parse a publish-marker payload and extract `{id, did, domains}`. Returns
+* null on any failure (non-UTF-8, non-JSON, not an object, missing/blank
+* `id`) — the caller treats null as "not registerable" and leaves the write
+* untouched. A malformed `domains` field (not an array, or with non-string /
+* empty elements) is NOT a parse failure — it is silently dropped down to
+* only the valid string entries (empty result → field omitted), same
+* fail-soft spirit as the rest of this parser.
+*/
+function parseBlockletPublishMarker(bytes) {
+	let text;
+	try {
+		text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+	} catch {
+		return null;
+	}
+	let doc;
+	try {
+		doc = JSON.parse(text);
+	} catch {
+		return null;
+	}
+	if (!doc || typeof doc !== "object" || Array.isArray(doc)) return null;
+	const record = doc;
+	const id = record.id;
+	if (typeof id !== "string" || id.length === 0) return null;
+	const did = typeof record.did === "string" && record.did.length > 0 ? record.did : void 0;
+	const domains = Array.isArray(record.domains) ? record.domains.filter((d) => typeof d === "string" && d.length > 0) : void 0;
+	const publishVersion = typeof record.publishVersion === "number" && Number.isFinite(record.publishVersion) ? record.publishVersion : void 0;
+	const hasWebCache = typeof record.hasWebCache === "boolean" ? record.hasWebCache : void 0;
+	return {
+		id,
+		did,
+		...domains && domains.length > 0 ? { domains } : {},
+		...publishVersion !== void 0 ? { publishVersion } : {},
+		...hasWebCache !== void 0 ? { hasWebCache } : {}
+	};
+}
+/** Blocklet root for a marker tree path: strip the trailing marker segment. */
+function blockletDir(treePath) {
+	const norm = treePath.replace(/^\/+/, "");
+	const idx = norm.lastIndexOf("/");
+	return idx === -1 ? "" : norm.slice(0, idx);
+}
+/**
+* applyBlockletWriteHook — called AFTER a successful publish-marker write in any
+* DID Space write path. Registers `resolve/blocklet/<id>` → {owner, path} and,
+* when the marker declares `domains` (#764), `resolve/domain/<domain>` →
+* {did, owner, path} for each.
+*
+* No-op when the resolver is absent, the path isn't the publish marker, or the
+* marker has no usable `id`.
+*
+* Domain conflict is a DELIBERATE, SCOPED exception to this file's usual
+* fail-soft rule: the user wants a domain claimed by a different owner to
+* reject the publish loudly, not silently succeed into someone else's slot.
+* The conflict check therefore runs OUTSIDE the fail-soft try/catch below —
+* validate every domain BEFORE registering anything (so a conflict on one
+* domain never leaves a partial registration), then register. A registration
+* failure unrelated to a conflict (e.g. a transient resolver error) keeps the
+* existing fail-soft contract: the marker write itself must not fail.
+*/
+async function applyBlockletWriteHook(params) {
+	if (!params.resolver || !isBlockletPublishMarkerPath(params.afsPath)) return;
+	const marker = parseBlockletPublishMarker(params.bytes);
+	if (!marker) return;
+	const { id, domains = [] } = marker;
+	const did = marker.did ?? `did:blocklet:${id}`;
+	const path = blockletDir(params.treePath);
+	const { resolver, ownerDid } = params;
+	const existingBlocklet = await resolver.resolveBlocklet(id);
+	if (existingBlocklet && existingBlocklet.owner !== ownerDid) throw new AFSAlreadyExistsError(id, `blocklet "${id}" is already registered to a different owner`);
+	for (const domain of domains) {
+		const existing = await resolver.resolveDomain(domain);
+		if (existing && existing.owner !== ownerDid) throw new AFSAlreadyExistsError(domain, `domain "${domain}" is already registered to a different owner`);
+	}
+	const { publishVersion, hasWebCache } = marker;
+	try {
+		await resolver.registerBlocklet(id, {
+			owner: ownerDid,
+			path,
+			type: "blocklet",
+			name: id,
+			...publishVersion !== void 0 ? { publishVersion } : {},
+			...hasWebCache !== void 0 ? { hasWebCache } : {}
+		});
+		for (const domain of domains) await resolver.registerDomain(domain, {
+			did,
+			owner: ownerDid,
+			path,
+			...publishVersion !== void 0 ? { publishVersion } : {},
+			...hasWebCache !== void 0 ? { hasWebCache } : {}
+		});
+		const stale = (await resolver.domainsForBlocklet(ownerDid, path)).filter((d) => !domains.includes(d));
+		for (const domain of stale) await resolver.unregisterDomain(domain);
+		if (params.purgeCachesForDomains && domains.length > 0) await params.purgeCachesForDomains(domains);
+	} catch (err) {
+		log.warn(`[blocklet-hook] registration for "${id}" failed: ${err instanceof Error ? err.message : err}`);
+	}
+}
+/**
+* applyBlockletDeleteHook — called AFTER a publish marker is deleted. Looks up
+* the registered blocklet by (owner, path) and unregisters it, along with any
+* domains registered for the same (owner, path) (#764). We key by path rather
+* than re-parsing the marker because the delete path has no bytes; the
+* (owner, path) pair uniquely identifies a published blocklet (one marker per
+* root). No-op when nothing matches.
+*/
+async function applyBlockletDeleteHook(params) {
+	if (!params.resolver || !isBlockletPublishMarkerPath(params.afsPath)) return;
+	const path = blockletDir(params.treePath);
+	const { resolver, ownerDid } = params;
+	try {
+		const all = await resolver.listBlocklets();
+		for (const { id, entry } of all) if (entry.owner === ownerDid && entry.path === path) await resolver.unregisterBlocklet(id);
+		const domains = await resolver.domainsForBlocklet(ownerDid, path);
+		for (const domain of domains) await resolver.unregisterDomain(domain);
+	} catch (err) {
+		log.warn(`[blocklet-hook] unregister for path "${path}" failed: ${err instanceof Error ? err.message : err}`);
+	}
+}
+
+//#endregion
+export { BLOCKLET_PUBLISH_MARKER, applyBlockletDeleteHook, applyBlockletWriteHook };
+//# sourceMappingURL=blocklet-hook.mjs.map

package/dist/blocklet-hook.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"blocklet-hook.mjs","names":[],"sources":["../src/blocklet-hook.ts"],"sourcesContent":["/**\n * Blocklet publish/resolve write & delete hooks (#674 Phase 3, v2).\n *\n * AFS-native registration keyed on a PUBLISH MARKER, not `blocklet.yaml`:\n * `arc deploy` writes `<blocklet-root>/.blocklet-publish.json` LAST (always —\n * even for blocklets that have no `blocklet.yaml`, e.g. a plain `index.html`\n * one), and that write registers the blocklet in the global resolve table under\n * `resolve/blocklet/<id>`. The CF/Node serve path reads the table back to find\n * the owner space + path. There is NO REST endpoint — registration rides the\n * AFS write of the marker, mirroring how `.share` files reconcile.\n *\n * Why a marker and not `blocklet.yaml`: not every blocklet has a manifest, and\n * the blocklet's identity at publish time is the target slug\n * (`/user/blocklets/<slug>/`), which `arc deploy` already knows (manifest id\n * else dir name). Keying on a publish-written marker (a) works for ALL blocklet\n * shapes, (b) leaves the developer's files untouched (so a static blocklet stays\n * a static blocklet — a synthesized manifest could flip its serve type), and\n * (c) registers only on an explicit publish, not on any incidental manifest write.\n *\n * Contract (see planning/did-integration/blocklet-publish-resolve/design.md):\n *   marker  : <blocklet-root>/.blocklet-publish.json  = { \"id\": \"<slug>\", ... }\n *   register: resolve/blocklet/<id> → { owner, path, type:\"blocklet\", name:id }\n *     - owner = PLAINTEXT space-owner DID (so the reader can open the space)\n *     - path  = the blocklet root (dir holding the marker), captured at write\n *               time — scope-absolute, so resolve replays it regardless of WHERE\n *               it was written (`/user/...` lands physically under\n *               `blocklets/<instance>/user/...` and we capture that real path)\n *   resolve : resolve/blocklet/<id> → { owner, path }\n *   serve   : getUserSpace(owner) → createAfsBlockletReader(afs, path)\n *\n * All hooks are best-effort / fail-soft: a marker that doesn't parse or has no\n * `id`, or a registration failure, MUST NOT break the underlying file write.\n *\n * #764 Phase 4 extends the marker with an optional `domains: string[]` (from\n * the manifest's `sites[].domains`) that also registers `resolve/domain/<domain>`\n * → { did, owner, path }. This is the ONE deliberate exception to fail-soft: a\n * domain already owned by a different owner rejects the write loudly instead\n * of silently overwriting — see `applyBlockletWriteHook`'s doc comment.\n */\n\nimport { AFSAlreadyExistsError, makeNsLog } from \"@aigne/afs\";\nimport type { DIDSpaceResolver } from \"./resolve.js\";\n\nconst log = makeNsLog(\"provider:did-space:blocklet-hook\");\n\n/** The publish marker `arc deploy` writes (last) into a blocklet's DID-Space root. */\nexport const BLOCKLET_PUBLISH_MARKER = \".blocklet-publish.json\";\n\n/** Shape of the publish marker payload. */\nexport interface BlockletPublishMarker {\n  /** The blocklet slug — manifest `id` else the publish dir name. Resolve key. */\n  id: string;\n  /** Full blocklet DID. Load-bearing for domain registration (#764) — see below. */\n  did?: string;\n  /** ISO publish timestamp (informational). */\n  publishedAt?: string;\n  /** Custom domains declared under `sites[].domains` in the manifest (#764). */\n  domains?: string[];\n  /**\n   * Monotonic timestamp (Date.now()) written by the CLI at publish time.\n   * Materialized into resolve entries; used by CF Worker edge-cache invalidation\n   * so that the cached page key changes on every publish (#1110).\n   */\n  publishVersion?: number;\n  /**\n   * True when the published bundle includes pre-rendered `.web-cache/` content.\n   * Materialized into resolve entries so the CF Worker knows to do edge-caching\n   * without checking the blocklet files (#1110).\n   */\n  hasWebCache?: boolean;\n}\n\n/**\n * True if `afsPath`'s basename is the publish marker. Accepts a leading slash\n * and any directory depth.\n */\nexport function isBlockletPublishMarkerPath(afsPath: string): boolean {\n  const p = afsPath.startsWith(\"/\") ? afsPath.slice(1) : afsPath;\n  return p === BLOCKLET_PUBLISH_MARKER || p.endsWith(`/${BLOCKLET_PUBLISH_MARKER}`);\n}\n\n/**\n * Parse a publish-marker payload and extract `{id, did, domains}`. Returns\n * null on any failure (non-UTF-8, non-JSON, not an object, missing/blank\n * `id`) — the caller treats null as \"not registerable\" and leaves the write\n * untouched. A malformed `domains` field (not an array, or with non-string /\n * empty elements) is NOT a parse failure — it is silently dropped down to\n * only the valid string entries (empty result → field omitted), same\n * fail-soft spirit as the rest of this parser.\n */\nexport function parseBlockletPublishMarker(bytes: Uint8Array): {\n  id: string;\n  did?: string;\n  domains?: string[];\n  publishVersion?: number;\n  hasWebCache?: boolean;\n} | null {\n  let text: string;\n  try {\n    text = new TextDecoder(\"utf-8\", { fatal: true }).decode(bytes);\n  } catch {\n    return null;\n  }\n  let doc: unknown;\n  try {\n    doc = JSON.parse(text);\n  } catch {\n    return null;\n  }\n  if (!doc || typeof doc !== \"object\" || Array.isArray(doc)) return null;\n  const record = doc as Record<string, unknown>;\n  const id = record.id;\n  if (typeof id !== \"string\" || id.length === 0) return null;\n  const did = typeof record.did === \"string\" && record.did.length > 0 ? record.did : undefined;\n  const domains = Array.isArray(record.domains)\n    ? record.domains.filter((d): d is string => typeof d === \"string\" && d.length > 0)\n    : undefined;\n  const publishVersion =\n    typeof record.publishVersion === \"number\" && Number.isFinite(record.publishVersion)\n      ? record.publishVersion\n      : undefined;\n  const hasWebCache = typeof record.hasWebCache === \"boolean\" ? record.hasWebCache : undefined;\n  return {\n    id,\n    did,\n    ...(domains && domains.length > 0 ? { domains } : {}),\n    ...(publishVersion !== undefined ? { publishVersion } : {}),\n    ...(hasWebCache !== undefined ? { hasWebCache } : {}),\n  };\n}\n\n/** Blocklet root for a marker tree path: strip the trailing marker segment. */\nfunction blockletDir(treePath: string): string {\n  const norm = treePath.replace(/^\\/+/, \"\");\n  const idx = norm.lastIndexOf(\"/\");\n  return idx === -1 ? \"\" : norm.slice(0, idx);\n}\n\n/**\n * applyBlockletWriteHook — called AFTER a successful publish-marker write in any\n * DID Space write path. Registers `resolve/blocklet/<id>` → {owner, path} and,\n * when the marker declares `domains` (#764), `resolve/domain/<domain>` →\n * {did, owner, path} for each.\n *\n * No-op when the resolver is absent, the path isn't the publish marker, or the\n * marker has no usable `id`.\n *\n * Domain conflict is a DELIBERATE, SCOPED exception to this file's usual\n * fail-soft rule: the user wants a domain claimed by a different owner to\n * reject the publish loudly, not silently succeed into someone else's slot.\n * The conflict check therefore runs OUTSIDE the fail-soft try/catch below —\n * validate every domain BEFORE registering anything (so a conflict on one\n * domain never leaves a partial registration), then register. A registration\n * failure unrelated to a conflict (e.g. a transient resolver error) keeps the\n * existing fail-soft contract: the marker write itself must not fail.\n */\nexport async function applyBlockletWriteHook(params: {\n  afsPath: string;\n  /** Whole-tree (scope-absolute) tree path of the written publish marker. */\n  treePath: string;\n  bytes: Uint8Array;\n  /** PLAINTEXT space-owner DID (NOT the de-id scope). */\n  ownerDid: string;\n  resolver: DIDSpaceResolver | undefined;\n  /**\n   * Optional callback invoked after all blocklet/domain resolve entries are\n   * (re-)registered. Receives the full list of active domains for the newly\n   * published blocklet. Intended for CF edge-cache purge: delete the cached\n   * HTML for each domain so the next request fetches the new content (#1110).\n   * The callback is best-effort — any error it throws is swallowed by the\n   * outer fail-soft try/catch (same contract as registration failures).\n   */\n  purgeCachesForDomains?: (domains: string[]) => Promise<void>;\n}): Promise<void> {\n  if (!params.resolver || !isBlockletPublishMarkerPath(params.afsPath)) return;\n  const marker = parseBlockletPublishMarker(params.bytes);\n  if (!marker) return;\n  const { id, domains = [] } = marker;\n  const did = marker.did ?? `did:blocklet:${id}`;\n  const path = blockletDir(params.treePath);\n  const { resolver, ownerDid } = params;\n\n  // Validate blocklet id ownership before registering ANYTHING. Like the\n  // domain check below, this runs outside the fail-soft try/catch so a\n  // genuine conflict surfaces as a write rejection rather than a silent\n  // swallow.\n  const existingBlocklet = await resolver.resolveBlocklet(id);\n  if (existingBlocklet && existingBlocklet.owner !== ownerDid) {\n    throw new AFSAlreadyExistsError(\n      id,\n      `blocklet \"${id}\" is already registered to a different owner`,\n    );\n  }\n\n  // Validate ALL domains before registering ANYTHING (data-loss prevention —\n  // a conflict must not leave a partial registration). Un-caught: a genuine\n  // conflict (or any other error surfaced while checking) propagates to the\n  // caller as a write rejection, it is not swallowed.\n  for (const domain of domains) {\n    const existing = await resolver.resolveDomain(domain);\n    if (existing && existing.owner !== ownerDid) {\n      throw new AFSAlreadyExistsError(\n        domain,\n        `domain \"${domain}\" is already registered to a different owner`,\n      );\n    }\n  }\n\n  const { publishVersion, hasWebCache } = marker;\n  try {\n    await resolver.registerBlocklet(id, {\n      owner: ownerDid,\n      path,\n      type: \"blocklet\",\n      name: id,\n      ...(publishVersion !== undefined ? { publishVersion } : {}),\n      ...(hasWebCache !== undefined ? { hasWebCache } : {}),\n    });\n    for (const domain of domains) {\n      await resolver.registerDomain(domain, {\n        did,\n        owner: ownerDid,\n        path,\n        ...(publishVersion !== undefined ? { publishVersion } : {}),\n        ...(hasWebCache !== undefined ? { hasWebCache } : {}),\n      });\n    }\n    // Reconcile: drop domains previously registered for this (owner, path)\n    // that are no longer in the new list (developer removed a custom domain).\n    const stale = (await resolver.domainsForBlocklet(ownerDid, path)).filter(\n      (d) => !domains.includes(d),\n    );\n    for (const domain of stale) {\n      await resolver.unregisterDomain(domain);\n    }\n    // Purge CF edge caches for all active domains so the next request fetches\n    // fresh content (#1110). Best-effort — failure here is swallowed below.\n    if (params.purgeCachesForDomains && domains.length > 0) {\n      await params.purgeCachesForDomains(domains);\n    }\n  } catch (err) {\n    // Fail-soft: a registration failure (e.g. invalid id, or a transient\n    // resolver error during domain register/reconcile) must not break the\n    // write — the file is already persisted; resolve just won't see it.\n    log.warn(\n      `[blocklet-hook] registration for \"${id}\" failed: ${err instanceof Error ? err.message : err}`,\n    );\n  }\n}\n\n/**\n * applyBlockletDeleteHook — called AFTER a publish marker is deleted. Looks up\n * the registered blocklet by (owner, path) and unregisters it, along with any\n * domains registered for the same (owner, path) (#764). We key by path rather\n * than re-parsing the marker because the delete path has no bytes; the\n * (owner, path) pair uniquely identifies a published blocklet (one marker per\n * root). No-op when nothing matches.\n */\nexport async function applyBlockletDeleteHook(params: {\n  afsPath: string;\n  treePath: string;\n  ownerDid: string;\n  resolver: DIDSpaceResolver | undefined;\n}): Promise<void> {\n  if (!params.resolver || !isBlockletPublishMarkerPath(params.afsPath)) return;\n  const path = blockletDir(params.treePath);\n  const { resolver, ownerDid } = params;\n  try {\n    const all = await resolver.listBlocklets();\n    for (const { id, entry } of all) {\n      if (entry.owner === ownerDid && entry.path === path) {\n        await resolver.unregisterBlocklet(id);\n      }\n    }\n    const domains = await resolver.domainsForBlocklet(ownerDid, path);\n    for (const domain of domains) {\n      await resolver.unregisterDomain(domain);\n    }\n  } catch (err) {\n    log.warn(\n      `[blocklet-hook] unregister for path \"${path}\" failed: ${err instanceof Error ? err.message : err}`,\n    );\n  }\n}\n"],"mappings":"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"}