@voltro/cms 0.86.0 → 0.88.0

package/dist/snapshotAssetAssemblyRest.js

@@ -0,0 +1,49 @@
+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";
+// 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)
+	};
+};
+export { s as cmsSnapshotAssetsRest };

package/dist/snapshotBindingRead.js

@@ -0,0 +1,60 @@
+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";
+// 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;
+export { u as readAdmittedSnapshotBindingContext, d as readSnapshotBinding, l as readSnapshotBindingContext };

package/dist/snapshotCodeSeo.js

@@ -0,0 +1,28 @@
+import { copySnapshotResource as e } from "./buildSnapshot.js";
+// src/snapshotCodeSeo.ts
+var t = () => {
+	throw Error("Invalid retained code SEO");
+}, n = (e, t) => typeof e == "string" && e.length > 0 && e.length <= t && !/[\x00-\x1f\x7f]/.test(e), r = (r) => {
+	let i = e({
+		key: "native-seo",
+		value: { metadata: r }
+	}).value.metadata;
+	if (typeof i != "object" || !i || Array.isArray(i)) return t();
+	let a = i;
+	if (Object.keys(a).sort().join(",") !== "alternates,canonical,noIndex,version" || a.version !== 1 || a.canonical !== null && !n(a.canonical, 8192) || typeof a.noIndex != "boolean" || !Array.isArray(a.alternates) || a.alternates.length > 1024) return t();
+	let o = a.alternates.map((e) => {
+		if (typeof e != "object" || !e || Array.isArray(e)) return t();
+		let r = e;
+		return Object.keys(r).sort().join(",") !== "href,locale" || !n(r.href, 8192) || !n(r.locale, 128) ? t() : {
+			href: r.href,
+			locale: r.locale
+		};
+	});
+	return new Set(o.map((e) => e.locale)).size === o.length ? {
+		version: 1,
+		canonical: a.canonical,
+		noIndex: a.noIndex,
+		alternates: o
+	} : t();
+};
+export { r as copySnapshotCodeSeo };

package/dist/snapshotComponent.js

@@ -0,0 +1,33 @@
+import { renderCapturedFrontendComponent as e } from "./frontendBindings.js";
+import { snapshotComponentSource as t } from "./snapshotComponentSource.js";
+import { snapshotObserver as n, snapshotProjectedValue as r } from "./snapshotObservation.js";
+// src/snapshotComponent.ts
+var i = (i, a, o, s = "content") => {
+	let c = r(i, o), l = n(i), u = [...o];
+	if (typeof c != "object" || !c || Array.isArray(c)) throw Error("Snapshot component unavailable");
+	let d = c;
+	if (typeof d.componentId != "string" || d.props === null || typeof d.props != "object" || Array.isArray(d.props)) throw Error("Snapshot component unavailable");
+	return e(a, {
+		componentId: d.componentId,
+		props: d.props,
+		context: i.context,
+		state: s,
+		presentation: i.presentation,
+		consentPurposes: i.consentPurposes,
+		source: t(i, u, d),
+		observe: (e) => l({
+			kind: "component",
+			fieldPath: u,
+			...e
+		}),
+		media: {
+			entries: i.media,
+			fieldPath: [...u, "props"],
+			observe: (e) => l({
+				kind: "media",
+				...e
+			})
+		}
+	});
+};
+export { i as renderSnapshotComponent };

package/dist/snapshotComponentSource.js

@@ -0,0 +1,23 @@
+import { snapshotReference as e } from "./snapshotReference.js";
+import { snapshotLink as t } from "./snapshotLink.js";
+import { copySnapshotContentIdentity as n } from "./snapshotContentIdentity.js";
+// src/snapshotComponentSource.ts
+var r = (r, i, a) => {
+	let o = Object.freeze([...i]), s = a.type === "component" ? a.id : a.instanceId;
+	return Object.freeze({
+		content: Object.freeze(n(r.content)),
+		fieldPath: o,
+		instanceId: typeof s == "string" && s.length > 0 ? s : null,
+		link: (e) => t(r, [
+			...o,
+			"props",
+			...e
+		]),
+		reference: (t) => e(r, [
+			...o,
+			"props",
+			...t
+		])
+	});
+};
+export { r as snapshotComponentSource };

package/dist/snapshotConsumer.js

@@ -0,0 +1,86 @@
+import { readVerifiedSnapshotResource as e } from "./buildSnapshot.js";
+import { copyRenderReadAuthority as t, readRenderReadAuthority as n } from "./renderReadAuthority.js";
+import { resolveSnapshotReadBinding as r } from "./snapshotReadAdmission.js";
+import { issueRenderReadGrant as i, verifyRenderReadRenewal as a } from "./renderReadGrant.js";
+import { Schema as o } from "effect";
+import { generateId as s } from "@voltro/database";
+import { dataStoreApiKeyStore as c, makeApiKeyService as l } from "@voltro/runtime";
+// src/snapshotConsumer.ts
+var u = class extends o.TaggedError()("SnapshotConsumerUnavailable", { reason: o.Literals([
+	"configuration",
+	"credential",
+	"projection",
+	"expiry"
+]) }) {}, d = (e) => {
+	throw new u({ reason: e });
+}, f = (e) => Number.isSafeInteger(e) && Number.isFinite(new Date(e).getTime()), p = (e, t) => {
+	if (typeof e != "object" || !e || Array.isArray(e)) return d("configuration");
+	let n = e;
+	if (Object.keys(n).length !== 3 || Object.keys(n).some((e) => ![
+		"id",
+		"requiredScope",
+		"maxGrantMs"
+	].includes(e))) return d("configuration");
+	let { id: r, requiredScope: i, maxGrantMs: a } = n;
+	return !f(t) || typeof r != "string" || !/^[A-Za-z][A-Za-z0-9_-]{0,63}$/.test(r) || typeof i != "string" || !/^[A-Za-z][A-Za-z0-9:_.-]{0,127}$/.test(i) || typeof a != "number" || !Number.isSafeInteger(a) || a <= 0 || !f(t + a) ? d("configuration") : {
+		id: r,
+		requiredScope: i,
+		maxGrantMs: a
+	};
+}, m = async (o, u, m, h) => {
+	let g = {
+		tenantId: u.tenantId,
+		site: u.site,
+		environment: u.environment
+	}, _ = {
+		id: m.snapshot.id,
+		digest: m.snapshot.digest
+	}, v = m.apiKey, y = m.resume === void 0 ? void 0 : {
+		token: m.resume.token,
+		buildId: m.resume.buildId
+	}, b = h.now ?? Date.now(), x = p(h.consumer, b), S = {
+		id: h.key.id,
+		material: new Uint8Array(h.key.material)
+	}, C = (h.verificationKeys ?? []).map((e) => ({
+		id: e.id,
+		material: new Uint8Array(e.material)
+	}));
+	if (typeof v != "string" || v.length === 0 || v.length > 512) return d("credential");
+	let w = await l(c(o)).verify(v, b);
+	if (w === null) return d("credential");
+	let T = t({
+		kind: "apiKey",
+		id: w.id,
+		scope: x.requiredScope
+	});
+	if (T === null) return d("credential");
+	let E = await n(o, g, T, b);
+	if (E === null) return d("credential");
+	let D = y?.buildId ?? s({
+		kind: "typeid",
+		prefix: "cmsbuild"
+	}, "_voltro_cms_render_read_grants"), { snapshot: O, binding: k } = await r(o, g, _, {
+		consumerId: x.id,
+		buildId: D
+	}, b), A = (await e(o, g, O, "projection", "registry")).value;
+	if (A.version !== 1 || A.id !== x.id) return d("projection");
+	y !== void 0 && await a(o, y.token, k, T, {
+		keys: [S, ...C],
+		now: b
+	});
+	let j = Math.min(b + x.maxGrantMs, O.expiresAt, E.expiresAt ?? 2 ** 53 - 1);
+	return !f(j) || j <= b ? d("expiry") : {
+		...await i(o, k, {
+			key: S,
+			now: b,
+			expiresAt: j,
+			maxExpiresAt: j,
+			authority: T
+		}),
+		consumerId: x.id,
+		buildId: D,
+		snapshotId: O.id,
+		snapshotDigest: O.digest
+	};
+};
+export { u as SnapshotConsumerUnavailable, p as copySnapshotConsumer, m as issueSnapshotReadGrant };

package/dist/snapshotContentIdentity.js

@@ -0,0 +1,9 @@
+// src/snapshotContentIdentity.ts
+var e = ({ contentType: e, documentId: t, variantId: n, revisionId: r, revision: i }) => ({
+	contentType: e,
+	documentId: t,
+	variantId: n,
+	revisionId: r,
+	revision: i
+});
+export { e as copySnapshotContentIdentity };

package/dist/snapshotDefinitions.js

@@ -0,0 +1,263 @@
+import { copySnapshotResource as e } from "./buildSnapshot.js";
+import { Schema as t } from "effect";
+import { createHash as n } from "node:crypto";
+import { canonicalJson as r } from "@voltro/runtime";
+// src/snapshotDefinitions.ts
+var i = class extends t.TaggedError()("SnapshotDefinitionUnavailable", { reason: t.Literals([
+	"app",
+	"definition",
+	"duplicate",
+	"component-conflict",
+	"cycle",
+	"bounds"
+]) }) {}, a = (e) => {
+	throw new i({ reason: e });
+}, o = (e) => n("sha256").update(r(e)).digest("hex"), s = (e) => typeof e == "string" && e.trim().length > 0, c = (e) => !/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(e.commit) || ![e.artifactDigest, e.configDigest].every((e) => /^[0-9a-f]{64}$/.test(e)) ? a("app") : {
+	commit: e.commit,
+	artifactDigest: e.artifactDigest,
+	configDigest: e.configDigest
+}, l = {
+	kind: "data",
+	editorHint: "data",
+	isOptional: "data",
+	publishRequired: "data",
+	maxLength: "data",
+	pattern: "data",
+	literals: "data",
+	literalLabels: "data",
+	token: "data",
+	action: "data",
+	fraction: "data",
+	unique: "data",
+	richText: "richText",
+	referenceType: "data",
+	element: "field",
+	struct: "fields",
+	components: "components",
+	derived: "derived"
+}, u = {
+	id: "data",
+	displayName: "data",
+	props: "fields",
+	fingerprint: "data",
+	description: "data",
+	jobs: "data",
+	variants: "data",
+	fixtures: "data",
+	migrations: "migrations",
+	consent: "data"
+}, d = {
+	name: "data",
+	displayName: "data",
+	pluralName: "data",
+	fields: "fields",
+	asset: "data",
+	list: "data",
+	idPrefix: "data",
+	revalidate: "data",
+	tree: "data",
+	address: "data",
+	locations: "data",
+	seo: "data",
+	seoSites: "data",
+	review: "review",
+	availability: "data",
+	lifecycle: "data",
+	templates: "templates",
+	changeFeed: "data",
+	search: "data",
+	quality: "quality",
+	taxonomy: "data",
+	derivedFields: "data",
+	uniqueFields: "data"
+}, f = {
+	name: "data",
+	version: "data",
+	id: "data",
+	blocks: "data",
+	headings: "data",
+	marks: "data",
+	styles: "data",
+	components: "components",
+	contactPoints: "data",
+	contactLiterals: "data"
+}, p = {
+	id: "data",
+	displayName: "data",
+	values: "data",
+	sections: "sections",
+	required: "components",
+	first: "component",
+	max: "limits",
+	regions: "regions",
+	widths: "widths",
+	maxDepth: "data"
+}, m = {
+	id: "data",
+	label: "data",
+	approverScope: "data",
+	after: "data",
+	when: "implementation",
+	slaHours: "data",
+	evidence: "data"
+}, h = {
+	id: "data",
+	field: "data",
+	message: "data",
+	blocking: "data",
+	pack: "data",
+	sites: "data",
+	locales: "data",
+	check: "implementation"
+}, g = {
+	source: "data",
+	transform: "implementation"
+}, _ = {
+	images: "data",
+	files: "data",
+	links: "data",
+	profile: "profile"
+}, v = {
+	field: "data",
+	components: "data",
+	width: "data",
+	list: "templateList"
+}, y = {
+	allowed: "components",
+	required: "components",
+	maxItems: "data"
+}, b = {
+	id: "data",
+	version: "data",
+	steps: "steps"
+}, x = (t, n, i = []) => {
+	let x = c(n);
+	if (t.length === 0 && i.length === 0 || t.some((e) => !s(e.name))) return a("definition");
+	if (new Set(t.map((e) => e.name)).size !== t.length) return a("duplicate");
+	let S = /* @__PURE__ */ new Set(), C = /* @__PURE__ */ new Map(), w = /* @__PURE__ */ new Map(), T = (e, t) => {
+		if (typeof e != "object" || !e || Array.isArray(e) || ![Object.prototype, null].includes(Object.getPrototypeOf(e))) return a("definition");
+		if (S.has(e)) return a("cycle");
+		if (S.size >= 64) return a("bounds");
+		if (Object.getOwnPropertySymbols(e).length > 0) return a("definition");
+		let n = Object.getOwnPropertyDescriptors(e);
+		if (Object.values(n).some((e) => !e.enumerable || !("value" in e))) return a("definition");
+		S.add(e);
+		try {
+			return t(Object.fromEntries(Object.entries(n).map(([e, t]) => [e, t.value])));
+		} finally {
+			S.delete(e);
+		}
+	}, E = (t) => e({
+		key: "metadata",
+		value: { data: t }
+	}).value.data, D = (e, t) => {
+		if (typeof e != "function") return a("definition");
+		let n = r(t), i = w.get(n);
+		return i !== void 0 && i !== e ? a("component-conflict") : (w.set(n, e), {
+			kind: "app-implementation",
+			app: x,
+			path: [...t]
+		});
+	}, O = (e, t, n) => {
+		if (!Array.isArray(e) || Object.getOwnPropertySymbols(e).length > 0 || Object.keys(e).length !== e.length || Object.keys(e).some((e, t) => e !== String(t))) return a("definition");
+		let r = Object.getOwnPropertyDescriptors(e);
+		return Object.entries(r).some(([e, t]) => e !== "length" && (!t.enumerable || !("value" in t))) ? a("definition") : Array.from({ length: e.length }, (e, i) => n(r[String(i)].value, [...t, String(i)]));
+	}, k = (e, t, n) => T(e, (e) => Object.fromEntries(Object.keys(e).sort().map((r) => [r, n(e[r], [...t, r])]))), A = (e, t, n, r = !1) => T(e, (e) => Object.fromEntries(Object.keys(e).sort().flatMap((i) => r && [
+		"pipe",
+		"optional",
+		"requiredToPublish"
+	].includes(i) ? typeof e[i] == "function" ? [] : a("definition") : Object.hasOwn(t, i) ? e[i] === void 0 ? [] : [[i, M(t[i], e[i], [...n, i])]] : a("definition")))), j = (t) => {
+		let n = typeof t == "object" && t ? Object.getOwnPropertyDescriptor(t, "id")?.value : void 0;
+		if (!s(n)) return a("definition");
+		let r = {
+			version: 1,
+			app: x,
+			definition: A(t, u, ["components", n])
+		}, i = e({
+			key: `component:${n}`,
+			value: r
+		}), c = o(i.value), l = C.get(n);
+		return l !== void 0 && l.digest !== c ? a("component-conflict") : (C.set(n, {
+			resource: i,
+			digest: c
+		}), {
+			id: n,
+			digest: c
+		});
+	}, M = (e, t, n) => {
+		switch (e) {
+			case "data": return E(t);
+			case "implementation": return D(t, n);
+			case "migrations": return k(t, n, D);
+			case "fields": return k(t, n, (e, t) => A(e, l, t, !0));
+			case "field": return A(t, l, n, !0);
+			case "component": return j(t);
+			case "components": return O(t, n, j);
+			case "richText": return A(t, _, n);
+			case "profile": return A(t, f, n);
+			case "derived": return A(t, g, n);
+			case "review": return A(t, {
+				required: "data",
+				workflow: "workflow"
+			}, n);
+			case "workflow": return A(t, b, n);
+			case "steps": return O(t, n, (e, t) => A(e, m, t));
+			case "quality": return O(t, n, (e, t) => A(e, h, t));
+			case "templates": return A(t, v, n);
+			case "templateList": return O(t, n, (e, t) => A(e, p, t));
+			case "sections": return O(t, n, (e, t) => A(e, {
+				component: "component",
+				props: "data"
+			}, t));
+			case "limits": return O(t, n, (e, t) => A(e, {
+				component: "component",
+				count: "data"
+			}, t));
+			case "widths": return O(t, n, (e, t) => A(e, {
+				component: "component",
+				allowed: "data"
+			}, t));
+			case "regions": return k(t, n, (e, t) => A(e, y, t));
+		}
+	}, N = [...t].sort((e, t) => e.name < t.name ? -1 : +(e.name > t.name)).map((t) => e({
+		key: `type:${t.name}`,
+		value: {
+			version: 1,
+			app: x,
+			definition: A(t, d, ["types", t.name])
+		}
+	}));
+	for (let e of i) j(e);
+	let P = (t, n) => {
+		let r = [e({
+			key: "registry",
+			value: {
+				version: 1,
+				app: x,
+				count: n.length
+			}
+		}), ...n];
+		return {
+			format: `voltro.cms.${t}/v1`,
+			entries: () => structuredClone(r)
+		};
+	};
+	return {
+		schema: P("schema", N),
+		components: P("components", [...C.keys()].sort().map((e) => C.get(e).resource)),
+		definition: (t) => {
+			let n = N.find((e) => e.key === `type:${t}`);
+			return n === void 0 ? a("definition") : e(n);
+		}
+	};
+}, S = (e, t) => {
+	let { schema: n, components: r } = x(e, t);
+	return {
+		schema: n,
+		components: r
+	};
+}, C = (e, t) => x([e], t).definition(e.name), w = (e, t) => {
+	for (let n of x([], t, [e]).components.entries()) if (n.key === `component:${e.id}`) return n;
+	return a("definition");
+};
+export { i as SnapshotDefinitionUnavailable, c as copySnapshotAppCodePin, w as snapshotComponentDefinition, C as snapshotContentTypeDefinition, S as snapshotDefinitionSources };