@voltro/cms 0.85.0 → 0.87.0

package/dist/staticPathSetRest.js

@@ -0,0 +1,129 @@
+import { cmsCredential as e, privateCmsHttpRoutes as t, privateCmsOperation as n } from "./privateCmsTransport.js";
+import { StaticPathSetConflict as r, StaticPathSetUnavailable as i } from "./staticPathSet.js";
+import { Schema as a } from "effect";
+//#region src/staticPathSetRest.ts
+var o = a.Struct({
+	id: a.String,
+	digest: a.String
+}), s = a.Struct({
+	snapshot: o,
+	consumerId: a.String,
+	buildId: a.String,
+	host: a.String,
+	localeIds: a.optional(a.Array(a.String)),
+	owners: a.optional(a.Array(a.Literals(["cms", "code"])))
+}), c = a.Struct({
+	tenantId: a.String,
+	site: a.String,
+	environment: a.String,
+	snapshotId: a.String,
+	snapshotDigest: a.String,
+	releaseId: a.NullOr(a.String),
+	consumerId: a.String,
+	buildId: a.String,
+	inputsId: a.String,
+	executionId: a.String,
+	routesDigest: a.String,
+	domainsDigest: a.String,
+	localesDigest: a.String,
+	policyDigest: a.String,
+	projectionDigest: a.String,
+	host: a.String,
+	localeIds: a.Array(a.String),
+	owners: a.Array(a.Literals(["cms", "code"]))
+}), l = a.Struct({
+	id: a.String,
+	keyId: a.String,
+	signature: a.String,
+	manifest: a.Struct({
+		version: a.Literal(1),
+		context: c,
+		sort: a.Literal("host-nfc-path/v1"),
+		pageSize: a.Literal(200),
+		count: a.Number,
+		sources: a.Struct({
+			count: a.Number,
+			digest: a.String
+		}),
+		pages: a.Array(a.Struct({
+			count: a.Number,
+			digest: a.String,
+			first: a.String,
+			last: a.String
+		}))
+	})
+}), u = a.Struct({
+	id: a.String,
+	revision: a.Number,
+	phase: a.Literals([
+		"cms",
+		"code",
+		"seal",
+		"ready"
+	]),
+	enumerated: a.Number,
+	set: a.NullOr(l)
+}), d = a.Struct({
+	host: a.String,
+	path: a.String,
+	localeId: a.String,
+	routeId: a.String,
+	owner: a.Literals(["cms", "code"]),
+	file: a.NullOr(a.String),
+	sourceDigest: a.NullOr(a.String),
+	parameters: a.Record(a.String, a.String)
+}), f = {
+	namespace: "cms.staticPathSet",
+	path: "/v1/cms/static-path-sets",
+	operationPrefix: "cmsStaticPathSet",
+	tags: ["CMS static path sets"],
+	credentialError: "CmsBuildSnapshotUnavailable",
+	error: a.Union([i, r]),
+	errorStatus: {
+		StaticPathSetUnavailable: 409,
+		StaticPathSetConflict: 409
+	}
+}, p = (t, n) => ({
+	snapshot: t.snapshot,
+	token: e(n, "CmsBuildSnapshotUnavailable"),
+	consumerId: t.consumerId,
+	buildId: t.buildId,
+	host: t.host,
+	...t.localeIds === void 0 ? {} : { localeIds: t.localeIds },
+	...t.owners === void 0 ? {} : { owners: t.owners }
+}), m = (e) => {
+	let r = [
+		n(f, "begin", "Begin or resume a captured static path set", "Render-read bearer. Scope, snapshot, build, admitted host and exact locale selection identify the durable job. An id alone grants nothing.", s, u, (t, n) => e.begin(p(t, n))),
+		n(f, "advance", "Advance one bounded durable path enumeration step", "Render-read bearer for the same build. Captured CMS resources and retained native code are merged with captured ownership rules. Renew bounded grants through snapshot open when needed. URL conflicts include both admitted owners and a repair action.", a.Struct({
+			...s.fields,
+			id: a.String,
+			revision: a.Number
+		}), u, (t, n) => e.advance({
+			...p(t, n),
+			id: t.id,
+			revision: t.revision
+		})),
+		n(f, "page", "Read one authenticated immutable static path page", "Render-read bearer. The digest pins the complete signed set and its exact filter, count and ordered page digests. Index is interpreted only within this root. Repeating the same page is idempotent; there is no live fallback.", a.Struct({
+			...s.fields,
+			id: a.String,
+			digest: a.String,
+			index: a.Number
+		}), a.Struct({
+			set: l,
+			index: a.Number,
+			entries: a.Array(d),
+			next: a.NullOr(a.Number)
+		}), (t, n) => e.page({
+			...p(t, n),
+			id: t.id,
+			digest: t.digest,
+			index: t.index
+		}))
+	];
+	return {
+		routes: r,
+		httpRoutes: t(r)
+	};
+};
+//#endregion
+export { m as cmsStaticPathSetRest };

package/dist/staticPathSetService.js

@@ -0,0 +1,249 @@
+import { defineSiteDelivery as e } from "./siteDelivery.js";
+import { normalizeHost as t } from "./domainHost.js";
+import { verifyPublicationState as n } from "./publicationState.js";
+import { findVerifiedSnapshotResources as r, pageSnapshotResources as i } from "./buildSnapshot.js";
+import { nativeSnapshotRouteId as a, readSnapshotRouting as o, snapshotCmsPage as s, snapshotRouteDispatch as c, verifySnapshotRouteOwnership as l } from "./snapshotRouting.js";
+import { StaticPathSetConflict as u, StaticPathSetUnavailable as d, copyStaticPathContext as f, copyStaticPathOwners as p, staticPathHash as m, staticPathUrl as h } from "./staticPathSet.js";
+import { readSnapshotAppExecution as g, verifySnapshotAppExecution as _ } from "./snapshotAppExecution.js";
+import { readSnapshotRouteAdmission as v, verifySnapshotContentRoute as y } from "./snapshotRouteAdmission.js";
+import { readAdmittedSnapshotContentRoute as b } from "./snapshotRouteRead.js";
+import { snapshotPathLocale as x } from "./snapshotPathLocale.js";
+import { appendStaticPathStage as S, beginStaticPathSet as C, pageStaticPathSet as w, readStaticPathSet as T, sealStaticPathSet as E } from "./staticPathSetStore.js";
+import { Effect as D } from "effect";
+import { canonicalJson as O } from "@voltro/runtime";
+//#region src/staticPathSetService.ts
+var k = (e) => {
+	throw new d({ reason: e });
+}, A = (e) => typeof e != "object" || !e || Array.isArray(e) ? k("integrity") : e, j = (e) => D.tryPromise({
+	try: e,
+	catch: (e) => e instanceof d || e instanceof u ? e : new d({ reason: "state" })
+}), M = (e) => ({
+	id: e.id,
+	revision: e.progress.revision,
+	phase: e.progress.phase,
+	enumerated: e.progress.inputCount,
+	set: e.sealed
+}), N = (e) => ({
+	snapshot: {
+		id: e.snapshot.id,
+		digest: e.snapshot.digest
+	},
+	token: e.token,
+	consumerId: e.consumerId,
+	buildId: e.buildId,
+	host: e.host,
+	...e.localeIds === void 0 ? {} : { localeIds: [...e.localeIds] },
+	...e.owners === void 0 ? {} : { owners: [...e.owners] }
+}), P = async (r, i, a, s) => {
+	let c = await v(r, i, a.snapshot, {
+		...a,
+		path: "/"
+	}, {
+		keys: s.keys,
+		now: s.now
+	}), l = await n(r, i, c.snapshot.manifest.publication, c.now), u = await g(r, i, c.snapshot), d = o(c.configuration), m = e(c.configuration.site), h = m.locales.filter((e) => e.enabled).map((e) => e.id).sort(), _ = a.localeIds === void 0 ? h : [...a.localeIds].sort();
+	if (_.length === 0 || _.some((e, t) => !h.includes(e) || t > 0 && _[t - 1] === e)) return k("input");
+	let y = p(a.owners ?? ["cms", "code"]), b = t(a.host);
+	if (b === null) return k("input");
+	let x = (e) => c.snapshot.manifest.parts.find((t) => t.part === e)?.digest ?? k("integrity"), S = f({
+		...i,
+		snapshotId: c.snapshot.id,
+		snapshotDigest: c.snapshot.digest,
+		releaseId: c.snapshot.manifest.publication.releaseId,
+		consumerId: a.consumerId,
+		buildId: a.buildId,
+		inputsId: u.inputsId,
+		executionId: u.executionId,
+		routesDigest: x("routes"),
+		domainsDigest: x("domains"),
+		localesDigest: x("locales"),
+		policyDigest: x("policies"),
+		projectionDigest: x("projection"),
+		host: b,
+		localeIds: _,
+		owners: y
+	}), C = d.discovery === null ? [] : d.discovery.pages;
+	if (!Array.isArray(C)) return k("integrity");
+	let w = C.map(A).sort((e, t) => String(e.file) < String(t.file) ? -1 : +(String(e.file) > String(t.file)));
+	return {
+		admission: c,
+		partitions: l,
+		app: u,
+		routing: d,
+		site: m,
+		context: S,
+		nativePages: w,
+		codePages: y.includes("code") ? w.filter((e) => {
+			let t = d.definition?.claims[String(e.file)];
+			return t?.kind !== "cms" && (u.web === void 0 || t?.kind === "code" && t.public === !0);
+		}) : []
+	};
+}, F = (e) => {
+	let { store: t, execution: n } = e, o = {
+		tenantId: e.scope.tenantId,
+		site: e.scope.site,
+		environment: e.scope.environment
+	}, u = e.now ?? Date.now, d = {
+		id: e.key.id,
+		material: new Uint8Array(e.key.material)
+	}, f = [d, ...(e.verificationKeys ?? []).map((e) => ({
+		id: e.id,
+		material: new Uint8Array(e.material)
+	}))], p = (e, t) => P(e, o, t, {
+		keys: f,
+		now: u()
+	}), g = (e, t, n) => {
+		if (t === null) return {};
+		let r = e.nativePages.find((e) => e.file === t);
+		if (r === void 0) return k("integrity");
+		let i = A(r.matcher), a = i.paramNames;
+		if (typeof i.source != "string" || i.flags !== "" || !Array.isArray(a) || a.some((e) => typeof e != "string") || new Set(a).size !== a.length) return k("integrity");
+		let o = new RegExp(i.source, "").exec(n);
+		if (o === null) return k("integrity");
+		try {
+			return Object.fromEntries(a.map((e, t) => [e, decodeURIComponent(o[t + 1] ?? "")]));
+		} catch {
+			return k("integrity");
+		}
+	}, v = (e, t) => {
+		if (O(e) !== O(t)) return k("changed");
+	};
+	return {
+		begin: (e) => j(async () => {
+			let n = N(e);
+			return t.transactional(async (e) => {
+				let t = await p(e, n), r = await C(e, t.context, f);
+				return await p(e, n), M(r);
+			});
+		}),
+		advance: (e) => j(async () => {
+			let u = N(e), C = e.id, w = e.revision;
+			if (!Number.isSafeInteger(w) || w < 0) return k("input");
+			let D = await t.transactional(async (e) => {
+				let t = await p(e, u), n = await T(e, t.context, C, f);
+				return {
+					...t,
+					set: n
+				};
+			});
+			if (w > D.set.progress.revision) return k("changed");
+			if (w < D.set.progress.revision || D.set.sealed !== null) return M(D.set);
+			if (D.set.progress.phase === "cms") return t.transactional(async (e) => {
+				let t = await p(e, u);
+				v(t.context, D.context);
+				let n = await i(e, o, t.admission.snapshot.id, "routes", {
+					now: t.admission.now,
+					limit: 200,
+					...D.set.progress.after === null ? {} : { after: D.set.progress.after }
+				}), r = [];
+				for (let i of n.items) {
+					if (!i.key.startsWith("path:")) continue;
+					let n = i.value, a = n.path;
+					if (typeof a != "string" || i.key !== "path:" + m(a)) return k("integrity");
+					if (y(o, a, n), l(t.admission.configuration, n).owner !== "cms" || !t.context.owners.includes("cms") || !t.context.localeIds.includes(String(n.localeId))) continue;
+					let c = await b(e, {
+						...t.admission,
+						input: {
+							...t.admission.input,
+							path: a
+						},
+						route: n
+					}, t.partitions);
+					if (c === null) continue;
+					if (x(t.site, a).id !== c.output.localeId) return k("integrity");
+					let u = t.app.nativePages ? s(t.routing, a) : null;
+					r.push({
+						host: t.context.host,
+						path: a,
+						localeId: c.output.localeId,
+						routeId: c.output.routeId,
+						owner: "cms",
+						file: u?.file ?? null,
+						sourceDigest: u?.sourceDigest ?? null,
+						parameters: g(t, u?.file ?? null, a)
+					});
+				}
+				let a = await S(e, D.set, {
+					source: "cms:" + D.set.progress.revision,
+					receiptDigest: m({
+						routesDigest: t.context.routesDigest,
+						items: n.items
+					}),
+					entries: r,
+					next: {
+						phase: n.next === null ? t.codePages.length === 0 ? "seal" : "code" : "cms",
+						after: n.next,
+						codeIndex: 0
+					}
+				}, d, f);
+				return await p(e, u), M(a);
+			});
+			if (D.set.progress.phase === "code") {
+				let e = D.codePages[D.set.progress.codeIndex];
+				if (e === void 0 || typeof e.file != "string" || typeof e.pattern != "string" || !D.app.nativePages) return k("state");
+				let i = {
+					version: 1,
+					file: e.file
+				}, s = await n.run({
+					inputsId: D.app.inputsId,
+					executionId: D.app.executionId,
+					exportName: "__voltro_staticPaths",
+					inputJson: O(i)
+				});
+				_(D.app, "__voltro_staticPaths", i, s);
+				let b = A(s.value);
+				return Object.keys(b).sort().join(",") !== "file,paths,pattern,version" || b.version !== 1 || b.file !== e.file || b.pattern !== e.pattern || !Array.isArray(b.paths) || b.paths.length > 1e4 ? k("integrity") : t.transactional(async (t) => {
+					let n = await p(t, u);
+					v(n.context, D.context);
+					let i = [], _ = b.paths.map((e) => typeof e == "string" ? (h(n.context.host, e), e) : k("integrity"));
+					for (let s = 0; s < _.length; s += 200) {
+						let u = _.slice(s, s + 200), d = await r(t, o, n.admission.snapshot, "routes", u.map((e) => "path:" + m(e)));
+						for (let t of u) {
+							let r = d.get("path:" + m(t))?.value;
+							r !== void 0 && y(o, t, r);
+							let s = r === void 0 ? c(n.routing, t, !1) : l(n.admission.configuration, r);
+							if (s?.owner !== "code" || s.code === null || s.code.file !== e.file) continue;
+							let u = x(n.site, t);
+							n.context.localeIds.includes(u.id) && i.push({
+								host: n.context.host,
+								path: t,
+								localeId: u.id,
+								routeId: a(o, u.id, s.code.file, t),
+								owner: "code",
+								file: s.code.file,
+								sourceDigest: s.code.sourceDigest,
+								parameters: g(n, s.code.file, t)
+							});
+						}
+					}
+					let C = D.set.progress.codeIndex + 1, w = await S(t, D.set, {
+						source: "code:" + e.file,
+						receiptDigest: m(s),
+						entries: i,
+						next: {
+							phase: C === n.codePages.length ? "seal" : "code",
+							after: null,
+							codeIndex: C
+						}
+					}, d, f);
+					return await p(t, u), M(w);
+				});
+			}
+			return t.transactional(async (e) => {
+				let t = await p(e, u);
+				v(t.context, D.context);
+				let n = await E(e, D.set, d, f);
+				return await p(e, u), M(n);
+			});
+		}),
+		page: (e) => j(async () => {
+			let n = N(e), r = e.id, i = e.index, a = e.digest;
+			return t.transactional(async (e) => {
+				let t = await p(e, n), o = await w(e, t.context, r, i, f);
+				return o.set.id === a ? (await p(e, n), o) : k("changed");
+			});
+		})
+	};
+};
+//#endregion
+export { F as createCmsStaticPathSets, P as readSnapshotStaticPathAdmission };