@voltro/cms 0.86.0 → 0.87.0

package/dist/siteState.js

@@ -0,0 +1,47 @@
+import { SiteStateUnavailable as e } from "./errors.js";
+import { and as t, eq as n, generateId as r, id as i, table as a, text as o } from "@voltro/database";
+import { tenant as s } from "@voltro/plugin-multitenancy/mixin";
+//#region src/siteState.ts
+var c = "_voltro_cms_site_state_heads", l = a(c, {
+	id: i({ prefix: "cssh" }),
+	site: o().maxLength(64)
+}).with(s()).unique("cms_site_state_scope", ["tenantId", "site"]), u = (t) => {
+	if (![t.tenantId, t.site].every((e) => typeof e == "string" && e.length > 0 && e.length <= 64 && e.trim() === e)) throw new e({ reason: "scope" });
+	return {
+		tenantId: t.tenantId,
+		site: t.site
+	};
+}, d = (e) => t(n("tenantId", e.tenantId), n("site", e.site)), f = async (t, n) => {
+	let i = u(n), a = r({
+		kind: "typeid",
+		prefix: "cssh"
+	}, c);
+	if (a === null) throw new e({ reason: "state" });
+	await t.insertIgnore(c, {
+		id: String(a),
+		...i
+	}, { conflictColumns: ["tenantId", "site"] });
+	let [o] = await t.query({
+		table: c,
+		predicate: d(i),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: ["id"]
+	});
+	if (o === void 0) throw new e({ reason: "state" });
+}, p = async (t, n) => {
+	let r = u(n), [i] = await t.query({
+		table: c,
+		predicate: d(r),
+		lock: "share",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: ["id"]
+	});
+	if (i === void 0) throw new e({ reason: "state" });
+};
+//#endregion
+export { c as CMS_SITE_STATE_HEADS_TABLE, l as cmsSiteStateHeadsTable, u as copySiteScope, f as lockSiteState, p as lockSiteStateForRead, d as siteStatePredicate };

package/dist/snapshotAddressGraph.js

@@ -0,0 +1,55 @@
+import { readVerifiedSnapshotResource as e } from "./buildSnapshot.js";
+import { copySnapshotReferenceRoutes as t } from "./snapshotProjection.js";
+import { SnapshotRouteReadUnavailable as n } from "./snapshotRouteAdmission.js";
+import { readPlannedSnapshotReferenceAddress as r } from "./snapshotReferenceAddress.js";
+import { canonicalJson as i } from "@voltro/runtime";
+//#region src/snapshotAddressGraph.ts
+var a = (e) => {
+	throw new n({ reason: e });
+}, o = async (n, o, s, c, l) => {
+	if (s.length === 0 || s.length > 65 || s[0]?.source !== null || new Set(s.map((e) => e.source)).size !== s.length || Object.keys(c.nodes).length > 256) return a("bounds");
+	let u = s[0].context.snapshot;
+	if (s.some((e) => e.context.snapshot.id !== u.id || e.context.snapshot.digest !== u.digest || e.source?.startsWith("@ref:"))) return a("binding");
+	let d = (await e(n, o, u, "projection", "registry")).value;
+	if (!Array.isArray(d.types) || !d.types.every((e) => typeof e == "string")) return a("binding");
+	let f = t(d.referenceRoutes, d.types), p = [], m = /* @__PURE__ */ new Map();
+	if (Object.keys(f).length === 0) return p;
+	let h = [...s.map((e) => ({
+		source: e.source,
+		output: e.context.output,
+		fields: e.fields
+	})), ...Object.entries(c.nodes).map(([e, t]) => ({
+		source: e,
+		output: t.output,
+		fields: t.fields
+	}))];
+	for (let e of h) for (let t of e.fields.references) {
+		if (!Object.hasOwn(f, t.targetType)) continue;
+		if (p.length >= 8192) return a("bounds");
+		let s = f[t.targetType], c = i([
+			t.targetType,
+			t.targetDocumentId,
+			e.output.localeId,
+			s
+		]);
+		if (!m.has(c)) {
+			if (m.size >= 256) return a("bounds");
+			m.set(c, await r(n, o, {
+				snapshot: u,
+				output: e.output
+			}, t, s, l));
+		}
+		p.push({
+			source: e.source,
+			fieldPath: [...t.path],
+			mappingId: s,
+			target: m.get(c) ?? null
+		});
+	}
+	return p.sort((e, t) => {
+		let n = i([e.source, e.fieldPath]), r = i([t.source, t.fieldPath]);
+		return n < r ? -1 : +(n > r);
+	}), p;
+};
+//#endregion
+export { o as readAdmittedSnapshotAddressGraph };

package/dist/snapshotAddressRead.js

@@ -0,0 +1,73 @@
+import { compileSiteDelivery as e } from "./siteDelivery.js";
+import { defineContentLocations as t, resolveContentLocation as n } from "./contentLocations.js";
+import { readCapturedPublication as r } from "./publicationState.js";
+import { findVerifiedSnapshotResource as i, readVerifiedSnapshotResource as a } from "./buildSnapshot.js";
+import { verifySnapshotRouteOwnership as o } from "./snapshotRouting.js";
+import { contentRouteId as s } from "./contentRouteIdentity.js";
+import { admitSnapshotPublicDocument as c } from "./snapshotPublicAccess.js";
+import { SnapshotRouteReadUnavailable as l } from "./snapshotRouteAdmission.js";
+import { createHash as u } from "node:crypto";
+import { canonicalJson as d } from "@voltro/runtime";
+//#region src/snapshotAddressRead.ts
+var f = (e) => {
+	throw new l({ reason: e });
+}, p = (e) => u("sha256").update(d(e)).digest("hex"), m = (e, t) => d(e) === d(t), h = (e) => typeof e != "object" || !e || Array.isArray(e) ? f("binding") : e, g = async (e, t, n, r, i) => {
+	let a = { ...r }, o = { ...t };
+	if (n.manifest.parts.find((e) => e.part === "routes")?.format !== "voltro.cms.content-routes/v4") return f("binding");
+	if (typeof a.mappingId != "string" || !/^[A-Za-z][A-Za-z0-9_.-]{0,63}$/.test(a.mappingId)) return f("definition");
+	let s = await c(e, o, n, a.contentType, a.localeId, a.documentId, i);
+	return s === null ? null : _(e, o, n, a, s, i);
+}, _ = async (c, l, u, d, g, _) => {
+	if (g.contentType !== d.contentType || g.chain[0]?.documentId !== d.documentId) return f("binding");
+	let v = g.chain[0], y = [...g.chain.slice(1)].reverse(), b = (await a(c, l, u, "schema", `type:${d.contentType}`)).value, x = h(b.definition), S = t(x.locations ?? []), C = S.find((e) => e.id === d.mappingId);
+	if (C === void 0) return f("definition");
+	let w = (await a(c, l, u, "routes", "configuration")).value, T = (await a(c, l, u, "site", "configuration")).value, E = e(w.site), D = E.definition.locales.find((e) => e.id === d.localeId && e.enabled), O = w.types;
+	if (w.version !== 1 || w.tenantId !== l.tenantId || w.environment !== l.environment || E.definition.id !== l.site || !E.definition.environments.includes(l.environment) || !m(w.app, b.app) || T.definitionDigest !== p(E.definition) || !Array.isArray(O) || w.definitionDigest !== p({
+		site: E.definition,
+		types: O,
+		routing: w.routing
+	}) || D === void 0 || D.contentLocale !== g.requestedLocale) return f("binding");
+	let k = O.map(h).filter((e) => e.name === d.contentType), A = x.tree === void 0 ? null : h(x.tree);
+	if (k.length !== 1 || !m(k[0].locations, S) || !m(k[0].tree, A === null ? null : {
+		parent: A.parent,
+		segment: A.segment
+	})) return f("binding");
+	let j = s(l, d.localeId, d.contentType, d.documentId, d.mappingId), M = await i(c, l, u, "routes", `identity:${j}`);
+	if (M === null) return null;
+	if (M.value.version !== 1 || M.value.kind !== "route-index" || typeof M.value.target != "string") return f("route");
+	let N = M.value.target, P = (await a(c, l, u, "routes", N)).value;
+	if (P.version !== 1 || P.routeId !== j || P.contentType !== d.contentType || P.documentId !== d.documentId || P.mappingId !== d.mappingId || P.localeId !== d.localeId || P.tenantId !== l.tenantId || P.site !== l.site || P.environment !== l.environment || P.definitionDigest !== w.definitionDigest || P.variantId !== v.variantId || P.revisionId !== v.revisionId || P.revision !== v.revision || P.sourceLocale !== v.locale || P.requestedLocale !== g.requestedLocale || P.fallback !== (v.locale !== g.requestedLocale)) return f("route");
+	if (P.state === "unroutable") return N !== `unroutable:${j}` || P.reason !== "orphan" ? f("route") : null;
+	if (P.state !== "resolved" || typeof P.path != "string" || N !== `path:${p(P.path)}` || !m(P.ancestors, y)) return f("route");
+	if (o(w, P).owner !== "cms") return null;
+	let F = [];
+	for (let e of [...y, v]) {
+		let t = await r(c, l, u.manifest.publication.id, d.contentType, e.locale, e.variantId, _);
+		if (t === null || t.documentId !== e.documentId || t.revisionId !== e.revisionId || t.revision !== e.revision) return f("publication");
+		F.push(t);
+	}
+	let I = A === null ? null : F.map((e) => typeof A.segment != "string" || typeof e[A.segment] != "string" ? f("definition") : (n({
+		id: "segment",
+		segments: [{ field: A.segment }]
+	}, e, { prefix: "" }), e[A.segment])), L = n(C, F.at(-1), {
+		prefix: D.prefix,
+		...I === null ? {} : { treePath: I.join("/") }
+	});
+	return P.path === L ? {
+		output: {
+			routeId: j,
+			path: L,
+			mappingId: d.mappingId,
+			localeId: d.localeId,
+			requestedLocale: g.requestedLocale,
+			sourceLocale: v.locale,
+			fallback: v.locale !== g.requestedLocale
+		},
+		document: v,
+		ancestors: y,
+		schema: b,
+		route: P
+	} : f("route");
+};
+//#endregion
+export { _ as readAdmittedCapturedAddress, g as readCapturedPublicAddress };

package/dist/snapshotAppConsumer.js

@@ -0,0 +1,71 @@
+import { readRenderReadCredential as e } from "./renderReadAuthority.js";
+import { copySnapshotConsentPurposes as t } from "./snapshotPresentation.js";
+import { readAdmittedBuildSnapshot as n } from "./snapshotReadAdmission.js";
+import { readSnapshotAppExecution as r, verifyRetainedSnapshotRoutes as i, verifySnapshotAppExecution as a } from "./snapshotAppExecution.js";
+import { copySnapshotConsumer as o, issueSnapshotReadGrant as s } from "./snapshotConsumer.js";
+import { Schema as c } from "effect";
+import { canonicalJson as l } from "@voltro/runtime";
+//#region src/snapshotAppConsumer.ts
+var u = class extends c.TaggedError()("SnapshotAppConsumerUnavailable", { reason: c.Literals(["credential", "changed"]) }) {}, d = (e) => {
+	throw new u({ reason: e });
+}, f = async (c, u, f, p) => {
+	let m = {
+		tenantId: u.tenantId,
+		site: u.site,
+		environment: u.environment
+	}, h = {
+		id: f.snapshot.id,
+		digest: f.snapshot.digest
+	}, g = f.apiKey, _ = f.resume === void 0 ? void 0 : {
+		token: f.resume.token,
+		buildId: f.resume.buildId
+	}, v = p.verificationKeys?.map((e) => ({
+		id: e.id,
+		material: new Uint8Array(e.material)
+	})), y = {
+		id: p.key.id,
+		material: new Uint8Array(p.key.material)
+	}, b = p.now ?? Date.now, x = p.execution.run.bind(p.execution);
+	if (typeof g != "string" || g.length === 0 || g.length > 512) return d("credential");
+	let S = await c.transactional(async (t) => {
+		let i = b();
+		if (!Number.isSafeInteger(i) || !Number.isFinite(new Date(i).getTime())) return d("credential");
+		let a = await e(t, m, g, i);
+		if (a === null || a.scopes.length === 0) return d("credential");
+		let s = await n(t, m, h, i), c = await r(t, m, s), l = o(c.declaration.value, i);
+		return a.scopes.includes(l.requiredScope) ? c : d("credential");
+	}), C = S.definitions.value;
+	if (typeof C != "object" || !C || Array.isArray(C) || !("consentPurposes" in C)) return d("changed");
+	let w = t(C.consentPurposes), T = await x({
+		inputsId: S.inputsId,
+		executionId: S.executionId,
+		exportName: "definitions",
+		inputJson: l({ app: S.app })
+	});
+	if (a(S, "definitions", { app: S.app }, T), l(T.value) !== l(S.definitions.value)) return d("changed");
+	await i(S, x);
+	let E = await x({
+		inputsId: S.inputsId,
+		executionId: S.executionId,
+		exportName: "describe",
+		inputJson: "null"
+	});
+	return a(S, "describe", null, E), l(E.value) === l(S.declaration.value) ? c.transactional(async (e) => {
+		let t = b(), i = o(S.declaration.value, t), a = await n(e, m, h, t), c = await r(e, m, a);
+		return l(c) === l(S) ? {
+			...await s(e, m, {
+				apiKey: g,
+				snapshot: h,
+				..._ === void 0 ? {} : { resume: _ }
+			}, {
+				key: y,
+				now: t,
+				consumer: i,
+				...v === void 0 ? {} : { verificationKeys: v }
+			}),
+			consentPurposes: structuredClone(w)
+		} : d("changed");
+	}) : d("changed");
+};
+//#endregion
+export { u as SnapshotAppConsumerUnavailable, f as issueSnapshotAppGrant };

package/dist/snapshotAppExecution.js

@@ -0,0 +1,102 @@
+import { readVerifiedSnapshotResource as e } from "./buildSnapshot.js";
+import { copySnapshotAppCodePin as t } from "./snapshotDefinitions.js";
+import { copyFrontendOutputContext as n } from "./frontendBindings.js";
+import { coversSnapshotComponents as r } from "./snapshotFrontend.js";
+import { matchesSnapshotApplication as i } from "./snapshotApplication.js";
+import { Schema as a } from "effect";
+import { createHash as o } from "node:crypto";
+import { canonicalJson as s } from "@voltro/runtime";
+//#region src/snapshotAppExecution.ts
+var c = class extends a.TaggedError()("SnapshotAppUnavailable", { reason: a.Literals([
+	"app",
+	"receipt",
+	"declaration",
+	"definitions",
+	"renderer",
+	"routes"
+]) }) {}, l = (e) => {
+	throw new c({ reason: e });
+}, u = (e) => typeof e == "string" && /^[a-f0-9]{64}$/.test(e), d = (e) => o("sha256").update(s(e)).digest("hex"), f = (e) => typeof e != "object" || !e || Array.isArray(e) ? l("app") : e, p = async (a, o, c, d, p = [], m) => {
+	if (c.manifest.parts.find((e) => e.part === "app")?.format !== "voltro.app.build-inputs/v1" || c.manifest.parts.find((e) => e.part === "schema")?.format !== "voltro.cms.schema/v1") return l("app");
+	let g = (await e(a, o, c, "app", "configuration")).value, _ = (await e(a, o, c, "schema", "registry")).value, v = f(g.execution), y = f(g.app), b = f(v.runtime);
+	if (g.version !== 1 || !u(g.inputsId) || v.version !== 1 || !u(v.id) || v.profile !== "voltro.node-bundle/v1" || !u(b.binaryDigest) || ![
+		"node",
+		"platform",
+		"arch"
+	].every((e) => typeof b[e] == "string") || _.version !== 1 || s(y) !== s(_.app)) return l("app");
+	if (d !== void 0) {
+		let t = (await e(a, o, c, "schema", `type:${d}`)).value;
+		if (s(y) !== s(t.app)) return l("app");
+	}
+	let x = t({
+		commit: String(y.commit),
+		artifactDigest: String(y.artifactDigest),
+		configDigest: String(y.configDigest)
+	}), S = v.web === void 0 ? void 0 : f(v.web);
+	if (S !== void 0 && (Object.keys(S).sort().join(",") !== "id,namespace,version" || S.version !== 1 || !u(S.id) || !u(S.namespace) || v.nativePageEntry !== "pages.mjs")) return l("app");
+	let C = {
+		inputsId: g.inputsId,
+		executionId: v.id,
+		app: x,
+		runtime: b,
+		...S === void 0 ? {} : { web: {
+			id: S.id,
+			namespace: S.namespace
+		} }
+	};
+	if (v.declaration === void 0) return l("declaration");
+	let w = f(v.declaration);
+	if (!Object.hasOwn(w, "value")) return l("app");
+	let T = {
+		value: w.value,
+		receipt: f(w.receipt)
+	};
+	if (h(C, "describe", null, T), v.definitions === void 0) return l("definitions");
+	let E = f(v.definitions);
+	if (!Object.hasOwn(E, "value")) return l("definitions");
+	let D = {
+		value: E.value,
+		receipt: f(E.receipt)
+	};
+	if (h(C, "definitions", { app: x }, D), v.routes === void 0) return l("routes");
+	let O = f(v.routes);
+	if (!Object.hasOwn(O, "value")) return l("routes");
+	let k = {
+		value: O.value,
+		receipt: f(O.receipt)
+	};
+	if (h(C, "__voltro_routes", null, k), !await i(a, o, c, D.value, x, k.value)) return l("definitions");
+	let A = D.value, j;
+	if (m !== void 0) {
+		let e = A.site.locales.find((e) => e.enabled && e.id === m.id && e.contentLocale === m.contentLocale);
+		if (e === void 0) return l("renderer");
+		j = n({
+			...A.frontend.output,
+			localeId: e.id,
+			contentLocale: e.contentLocale,
+			languageTag: e.tag,
+			direction: e.direction
+		});
+	}
+	return r(A.frontend, p, j) ? {
+		...C,
+		nativePages: v.nativePageEntry === "pages.mjs",
+		declaration: T,
+		definitions: D,
+		routes: k,
+		...j === void 0 ? {} : { context: j }
+	} : l("renderer");
+}, m = async (e, t) => {
+	let n = await t({
+		inputsId: e.inputsId,
+		executionId: e.executionId,
+		exportName: "__voltro_routes",
+		inputJson: "null"
+	});
+	if (h(e, "__voltro_routes", null, n), s(n.value) !== s(e.routes.value)) return l("routes");
+}, h = (e, t, n, r) => {
+	let i = r.receipt;
+	return i.version !== 1 || i.profile !== "voltro.node-permission-json/v1" || i.inputsId !== e.inputsId || i.executionId !== e.executionId || i.exportName !== t || s(i.app) !== s(e.app) || s(i.runtime) !== s(e.runtime) || s(i.web ?? null) !== s(e.web ?? null) || i.inputDigest !== d(n) || i.resultDigest !== d(r.value) || !u(i.runnerDigest) ? l("receipt") : { runnerDigest: i.runnerDigest };
+};
+//#endregion
+export { c as SnapshotAppUnavailable, p as readSnapshotAppExecution, m as verifyRetainedSnapshotRoutes, h as verifySnapshotAppExecution };

package/dist/snapshotApplication.js

@@ -0,0 +1,75 @@
+import { compileSiteDelivery as e } from "./siteDelivery.js";
+import { readVerifiedSnapshotResource as t, snapshotStaticPartPin as n } from "./buildSnapshot.js";
+import { compileSnapshotRouting as r, copySnapshotRoutingDefinition as i } from "./snapshotRouting.js";
+import { copySnapshotAppCodePin as a, snapshotDefinitionSources as o } from "./snapshotDefinitions.js";
+import { copySnapshotConsentPurposes as s } from "./snapshotPresentation.js";
+import { snapshotPublicAccessSource as c } from "./snapshotPublicAccess.js";
+import { snapshotProjectionSource as l } from "./snapshotProjection.js";
+import { copySnapshotRenditionRequirements as u } from "./snapshotRenditions.js";
+import { matchesSnapshotFrontend as d, snapshotFrontendFromManifest as f, snapshotFrontendManifest as p } from "./snapshotFrontend.js";
+import { snapshotSiteConfiguration as m } from "./snapshotSite.js";
+import { readCapturedSnapshotConsentPurposes as h } from "./snapshotPresentationPolicy.js";
+import { canonicalJson as g } from "@voltro/runtime";
+//#region src/snapshotApplication.ts
+var _ = (t, r) => {
+	let d = a(r), { types: f } = t, p = {
+		...o(f, d),
+		policies: c(f, d, t.access, t.consentPurposes),
+		projection: l(f, d, t.projection)
+	};
+	if (typeof t.xDefault != "boolean") throw TypeError("Snapshot xDefault must be a boolean");
+	return {
+		version: 2,
+		app: d,
+		parts: [
+			"schema",
+			"components",
+			"policies",
+			"projection"
+		].map((e) => n(e, p[e])),
+		site: e(t.site).definition,
+		renditions: u(t.renditions),
+		xDefault: t.xDefault,
+		routing: i(t.routing),
+		consentPurposes: s(t.consentPurposes ?? [])
+	};
+}, v = (e, t) => ({
+	..._(e, t),
+	frontend: p(e.types, e.frontend, a(t), e.output)
+}), y = (e, t, n) => ({
+	..._(e, t),
+	frontend: e.frontend === void 0 ? f(e.types, n, a(t), e.output) : p(e.types, e.frontend, a(t), e.output)
+}), b = async (e, n, i, a, o, c) => {
+	if (typeof a != "object" || !a || Array.isArray(a)) return !1;
+	let l = a, f, p, _;
+	try {
+		f = m(n, l.site, o), p = u(l.renditions), _ = s(l.consentPurposes);
+	} catch {
+		return !1;
+	}
+	if (typeof l.xDefault != "boolean" || g(a) !== g({
+		version: 2,
+		app: o,
+		parts: [
+			"schema",
+			"components",
+			"policies",
+			"projection"
+		].map((e) => i.manifest.parts.find((t) => t.part === e)),
+		site: f.compiled.definition,
+		renditions: p,
+		xDefault: l.xDefault,
+		frontend: l.frontend,
+		routing: l.routing,
+		consentPurposes: _
+	}) || g(await h(e, n, i, o)) !== g(_) || !await d(e, n, i, l.frontend, o)) return !1;
+	let v = await t(e, n, i, "site", "configuration"), y = await t(e, n, i, "locales", "policy"), b = await t(e, n, i, "assets", "configuration"), x = await t(e, n, i, "seo", "configuration"), S = await t(e, n, i, "routes", "configuration");
+	try {
+		if (g(S.value.routing) !== g(r(l.routing, c, o))) return !1;
+	} catch {
+		return !1;
+	}
+	return g(v) === g(f.site) && g(y) === g(f.locales) && g(b.value.renditionRequirements) === g(p) && x.value.xDefault === l.xDefault;
+};
+//#endregion
+export { b as matchesSnapshotApplication, _ as snapshotApplicationConfigurationPins, v as snapshotApplicationPins, y as snapshotCaptureApplicationPins };

package/dist/snapshotApprovedRouteDispositions.js

@@ -0,0 +1,44 @@
+import { copyOutputActivationScope as e, outputActivationHash as t } from "./outputActivation.js";
+import { verifyPublicationState as n } from "./publicationState.js";
+import { copySnapshotResource as r } from "./buildSnapshot.js";
+import { routeDispositionFail as i } from "./routeDispositions.js";
+import { iterateApprovedRouteDispositions as a, readApprovedRouteDispositionPage as o } from "./routeDispositionStore.js";
+import { canonicalJson as s } from "@voltro/runtime";
+import { Buffer as c } from "node:buffer";
+//#region src/snapshotApprovedRouteDispositions.ts
+var l = (l, u, d = Date.now()) => {
+	let f = e(u);
+	return {
+		format: "voltro.cms.approved-route-dispositions/v1",
+		entries: async function* (e) {
+			await n(l, f, e, d);
+			let u = await o(l, f, { take: 1 });
+			yield r({
+				key: "configuration",
+				value: {
+					version: 1,
+					...f,
+					revision: u.revision,
+					count: u.count
+				}
+			});
+			let p = 0, m = 0;
+			for await (let e of a(l, f)) {
+				if (e.revision > u.revision || ++p > u.count) return i("state");
+				let n = r({
+					key: "url:" + t(e.definition.source.url),
+					value: {
+						version: 1,
+						...f,
+						...e
+					}
+				});
+				if (m += c.byteLength(s(n), "utf8"), m > 67108864) return i("bounds");
+				yield n;
+			}
+			if (p !== u.count) return i("state");
+		}
+	};
+};
+//#endregion
+export { l as snapshotApprovedRouteDispositionsSource };

package/dist/snapshotAssetAssembly.js

@@ -0,0 +1,70 @@
+import { SnapshotSeoReadUnavailable as e } from "./snapshotSeoRead.js";
+import { copySnapshotSeoDocumentsSelection as t } from "./snapshotSeoPathSets.js";
+import { readSnapshotSeoDocuments as n } from "./snapshotSeoDocuments.js";
+import { createHash as r } from "node:crypto";
+import { canonicalJson as i } from "@voltro/runtime";
+//#region src/snapshotAssetAssembly.ts
+var a = () => {
+	throw new e({ reason: "binding" });
+}, o = (e) => r("sha256").update(i(e)).digest("hex"), s = (e) => typeof e == "string" && /^[a-f0-9]{64}$/.test(e), c = (e) => {
+	let { store: r, provider: c } = e, l = { ...e.use }, u = {
+		tenantId: e.scope.tenantId,
+		site: e.scope.site,
+		environment: e.scope.environment
+	}, d = e.keys.map((e) => ({
+		id: e.id,
+		material: new Uint8Array(e.material)
+	})), f = e.now ?? Date.now;
+	return { render: async (e) => {
+		let p = {
+			snapshot: {
+				id: e.snapshot.id,
+				digest: e.snapshot.digest
+			},
+			token: e.token,
+			consumerId: e.consumerId,
+			buildId: e.buildId,
+			host: e.host
+		}, m = t(e.documents), h = c.composeAssets?.bind(c), g = c.read?.bind(c);
+		if (h === void 0 || g === void 0) return a();
+		let _ = () => r.transactional((e) => n(e, u, p, m, {
+			provider: c,
+			use: l,
+			keys: d,
+			now: f
+		})), v = await _(), y = v.paths.admission.app, b = v.inventory;
+		if (y.web === void 0) return a();
+		let x = await h({
+			snapshotDigest: p.snapshot.digest,
+			inputsId: y.inputsId,
+			executionId: y.executionId,
+			web: { ...y.web },
+			consentPurposes: b.consentPurposes,
+			presentations: b.presentations,
+			documents: b.records.map((e) => ({
+				url: e.url,
+				path: e.path,
+				routeId: e.routeId,
+				artifactId: e.artifactId,
+				presentation: e.presentation
+			}))
+		});
+		if (!s(x.id) || !Number.isSafeInteger(x.files) || x.files < 0 || !Number.isSafeInteger(x.bytes) || x.bytes < 0) return a();
+		let S = await g(x.id), C = S.manifest.subject;
+		if (S.id !== x.id || S.manifest.version !== 1 || o(S.manifest) !== x.id || S.manifest.files.length !== x.files || S.manifest.files.reduce((e, t) => e + t.size, 0) !== x.bytes || C.version !== 2 || C.profile !== "voltro.cms-public-assets/v2" || i(C.build) !== i({
+			snapshotDigest: p.snapshot.digest,
+			inputsId: y.inputsId,
+			executionId: y.executionId
+		}) || i(C.consentPurposes) !== i(b.consentPurposes) || i(C.presentations) !== i(b.presentations) || !s(C.webAssetsId)) return a();
+		let w = await g(C.webAssetsId), T = w.manifest.subject;
+		if (w.id !== C.webAssetsId || o(w.manifest) !== w.id || T.version !== 1 || T.profile !== "voltro.cms-client-assets/v1" || T.snapshotContent !== !1 || i(T.web) !== i(y.web) || T.source === null || typeof T.source != "object" || Reflect.get(T.source, "id") !== y.inputsId) return a();
+		let E = await _();
+		return i(E.inventory) !== i(v.inventory) || i(E.paths.selection) !== i(v.paths.selection) || i(E.paths.admission.context) !== i(v.paths.admission.context) ? a() : {
+			artifactId: x.id,
+			files: x.files,
+			bytes: x.bytes
+		};
+	} };
+};
+//#endregion
+export { c as createSnapshotAssetAssembly };

package/dist/snapshotAssetAssemblyRest.js

@@ -0,0 +1,50 @@
+import { cmsCredential as e, privateCmsHttpRoutes as t, privateCmsOperation as n } from "./privateCmsTransport.js";
+import { CmsBuildSnapshotUnavailable as r } from "./buildSnapshotService.js";
+import { Effect as i, Schema as a } from "effect";
+import { strictInput as o } from "@voltro/protocol";
+//#region src/snapshotAssetAssemblyRest.ts
+var s = (s) => {
+	let c = {
+		namespace: "cms.snapshotAssets",
+		path: "/v1/cms/snapshot-assets",
+		operationPrefix: "cmsSnapshotAssets",
+		tags: ["CMS snapshot assets"],
+		error: r,
+		errorStatus: { CmsBuildSnapshotUnavailable: 409 },
+		credentialError: "CmsBuildSnapshotUnavailable"
+	}, l = a.Struct({
+		snapshot: a.Struct({
+			id: a.String,
+			digest: a.String
+		}),
+		consumerId: a.String,
+		buildId: a.String,
+		host: a.String,
+		documents: a.Struct({
+			artifactId: a.String,
+			pathSets: a.Array(a.Struct({
+				id: a.String,
+				digest: a.String
+			}))
+		})
+	}), u = [n(c, "render", "Compose private captured web and media assets", "Render-read bearer. The server verifies complete signed paths, every document and consent class, original renderer receipts and current media rights. Its fixed retained archive supplies the exact production web bytes. All physical bytes are rehashed through EOF and authority is rechecked after composition. No caller filesystem path or web asset identity is accepted. Returned artifact IDs confer no activation or serving authority.", o(l, c.namespace + ".render", !0), a.Struct({
+		artifactId: a.String,
+		files: a.Int,
+		bytes: a.Int
+	}), (t, n) => {
+		let a = e(n, c.credentialError);
+		return i.tryPromise({
+			try: () => s.render({
+				...t,
+				token: a
+			}),
+			catch: () => new r({ reason: "render" })
+		});
+	})];
+	return {
+		routes: u,
+		httpRoutes: t(u)
+	};
+};
+//#endregion
+export { s as cmsSnapshotAssetsRest };

package/dist/snapshotBindingRead.js

@@ -0,0 +1,61 @@
+import { readVerifiedSnapshotResource as e } from "./buildSnapshot.js";
+import { copySnapshotPresentationValue as t } from "./snapshotPresentation.js";
+import { admitSnapshotPublicDocument as n } from "./snapshotPublicAccess.js";
+import { SnapshotRouteReadUnavailable as r } from "./snapshotRouteAdmission.js";
+import { projectSnapshotDocument as i } from "./snapshotDocumentProjection.js";
+import { readSnapshotRouteContext as a } from "./snapshotRouteRead.js";
+import { canonicalJson as o } from "@voltro/runtime";
+//#region src/snapshotBindingRead.ts
+var s = () => {
+	throw new r({ reason: "binding" });
+}, c = (e) => typeof e != "object" || !e || Array.isArray(e) ? s() : e, l = async (e, n, r, i, o) => {
+	let s = {
+		tenantId: n.tenantId,
+		site: n.site,
+		environment: n.environment
+	}, c = {
+		...i,
+		presentation: t(i.presentation)
+	}, l = o.now ?? Date.now(), d = await a(e, s, r, c, {
+		...o,
+		now: l
+	});
+	return d === null ? null : u(e, s, d, c.binding, l);
+}, u = async (t, r, a, l, u) => {
+	let { snapshot: d, output: f } = a;
+	if (typeof l != "string" || l.length === 0 || l.length > 256 || /[\x00-\x1f\x7f]/.test(l)) return s();
+	let p = (await e(t, r, d, "site", "configuration")).value, m = c(c(p.definition).bindings);
+	if (!Object.hasOwn(m, l)) return null;
+	let h = m[l];
+	if (typeof h != "string" || h.length === 0) return s();
+	let g = (await e(t, r, d, "site", `binding:${l}`)).value, _ = c(g.binding);
+	if (g.version !== 3 || g.definitionDigest !== p.definitionDigest || g.tenantId !== r.tenantId || g.site !== r.site || g.environment !== r.environment || _.contentType !== h || typeof _.documentId != "string") return s();
+	let v = await n(t, r, d, h, f.localeId, _.documentId, u);
+	if (v === null) return null;
+	let y = v.chain[0], b = (await e(t, r, d, "site", `binding:${l}:locale:${y.locale}`)).value, x = c(b.variant);
+	if (b.version !== 3 || b.locale !== y.locale || b.documentId !== y.documentId || x.id !== y.variantId || x.revisionId !== y.revisionId || x.revision !== y.revision) return s();
+	let S = (await e(t, r, d, "schema", `type:${h}`)).value;
+	if (o(S.app) !== o(p.app)) return s();
+	let { values: C, components: w, presentation: T } = await i(t, r, d, h, y, S, u, a.output.presentation);
+	return {
+		snapshot: d,
+		document: y,
+		binding: a.binding,
+		routeId: f.routeId,
+		components: w,
+		output: {
+			snapshotId: d.id,
+			snapshotDigest: d.digest,
+			binding: l,
+			contentType: h,
+			localeId: f.localeId,
+			requestedLocale: v.requestedLocale,
+			sourceLocale: y.locale,
+			fallback: y.locale !== v.requestedLocale,
+			values: C,
+			presentation: T
+		}
+	};
+}, d = async (...e) => (await l(...e))?.output ?? null;
+//#endregion
+export { u as readAdmittedSnapshotBindingContext, d as readSnapshotBinding, l as readSnapshotBindingContext };