@voltro/cms 0.85.0 → 0.87.0

package/dist/outputActivationTables.js

@@ -0,0 +1,11 @@
+import { outputActivationTables as e } from "./outputActivationStore.js";
+import { outputDeploymentTables as t } from "./outputDeployment.js";
+import { outputActivationTargetsTable as n } from "./outputActivationTargetTable.js";
+//#region src/outputActivationTables.ts
+var r = Object.freeze([
+	...e,
+	...t,
+	n
+]);
+//#endregion
+export { r as cmsOutputActivationTables };

package/dist/outputActivationTarget.js

@@ -0,0 +1,81 @@
+import { copyOutputActivationScope as e, copyOutputActivationSet as t, outputActivationFail as n } from "./outputActivation.js";
+import { copySnapshotResource as r } from "./buildSnapshot.js";
+import { readStaticPathSetEvidence as i } from "./staticPathSetStore.js";
+import { OUTPUT_ACTIVATION_TARGETS as a } from "./outputActivationTargetTable.js";
+import { and as o, eq as s } from "@voltro/database";
+import { canonicalJson as c } from "@voltro/protocol";
+//#region src/outputActivationTarget.ts
+var l = (e, t) => typeof e != "object" || !e || Array.isArray(e) || Object.keys(e).sort().join(",") !== t ? n("input") : e, u = (e) => {
+	let i = l(r({
+		key: "output-target",
+		value: e
+	}).value, "outputs,pathSets,set"), a = t(i.set);
+	if (!Array.isArray(i.pathSets) || i.pathSets.length !== a.manifest.paths.length || !Array.isArray(i.outputs) || i.outputs.length !== a.manifest.regions.required.length) return n("input");
+	let o = i.pathSets.map((e) => {
+		let t = l(e, "host,jobId");
+		return typeof t.host != "string" || typeof t.jobId != "string" || !/^[A-Za-z0-9_-]{1,64}$/.test(t.jobId) ? n("input") : {
+			host: t.host,
+			jobId: t.jobId
+		};
+	}).sort((e, t) => e.host < t.host ? -1 : +(e.host > t.host)), s = i.outputs.map((e) => {
+		let t = l(e, "outputId,region");
+		return typeof t.region != "string" || typeof t.outputId != "string" || !/^[a-f0-9]{64}$/.test(t.outputId) ? n("input") : {
+			region: t.region,
+			outputId: t.outputId
+		};
+	}).sort((e, t) => e.region < t.region ? -1 : +(e.region > t.region));
+	return o.some((e, t) => e.host !== a.manifest.paths[t].host) || s.some((e, t) => e.region !== a.manifest.regions.required[t]) ? n("changed") : {
+		set: a,
+		pathSets: o,
+		outputs: s
+	};
+}, d = (e, t) => o(s("tenantId", e.tenantId), s("site", e.site), s("environment", e.environment), s("targetId", t)), f = async (t, r, i) => {
+	let o = e(r);
+	if (typeof i != "string" || !/^[a-f0-9]{64}$/.test(i)) return n("input");
+	let s = await t.query({
+		table: a,
+		predicate: d(o, i),
+		order: [],
+		take: 2,
+		skip: void 0,
+		projection: void 0
+	});
+	if (s.length === 0) return null;
+	if (s.length !== 1) return n("state");
+	let l = s[0], f = u({
+		set: {
+			id: i,
+			manifest: l.manifest
+		},
+		pathSets: l.pathSets,
+		outputs: l.outputs
+	});
+	return l.deploymentId !== f.set.manifest.app.deploymentId || c(f.set.manifest.scope) !== c(o) ? n("changed") : f;
+}, p = async (t, r, o, s) => {
+	let l = e(r), d = u(o), p = d.set;
+	if (c(p.manifest.scope) !== c(l)) return n("changed");
+	for (let e of d.pathSets) {
+		let r = p.manifest.paths.find((t) => t.host === e.host), a = await i(t, l, {
+			id: e.jobId,
+			digest: r.setId
+		}, s), o = a.set.manifest.context;
+		if (o.host !== e.host || o.snapshotId !== p.manifest.snapshot.id || o.snapshotDigest !== p.manifest.snapshot.digest || o.releaseId !== p.manifest.snapshot.releaseId || o.inputsId !== p.manifest.app.inputsId || o.executionId !== p.manifest.app.executionId || o.policyDigest !== p.manifest.renderPolicyDigest || a.set.manifest.count !== r.count) return n("changed");
+	}
+	await t.insertIgnore(a, {
+		...l,
+		targetId: p.id,
+		deploymentId: p.manifest.app.deploymentId,
+		manifest: p.manifest,
+		pathSets: d.pathSets,
+		outputs: d.outputs
+	}, { conflictColumns: [
+		"tenantId",
+		"site",
+		"environment",
+		"targetId"
+	] });
+	let m = await f(t, l, p.id);
+	return c(m) === c(d) ? m : n("changed");
+};
+//#endregion
+export { f as readOutputActivationTarget, p as retainOutputActivationTarget };

package/dist/outputActivationTargetTable.js

@@ -0,0 +1,25 @@
+import { id as e, json as t, table as n, text as r } from "@voltro/database";
+import { tenant as i } from "@voltro/plugin-multitenancy/mixin";
+//#region src/outputActivationTargetTable.ts
+var a = "_voltro_cms_output_targets", o = n("_voltro_cms_output_targets", {
+	id: e({ prefix: "coutt" }),
+	site: r().maxLength(64),
+	environment: r().maxLength(64),
+	targetId: r().maxLength(64),
+	deploymentId: r().maxLength(64),
+	manifest: t(),
+	pathSets: t(),
+	outputs: t()
+}).with(i()).unique("cms_output_target_scope", [
+	"tenantId",
+	"site",
+	"environment",
+	"targetId"
+]).unique("cms_output_target_deployment", [
+	"tenantId",
+	"site",
+	"environment",
+	"deploymentId"
+]);
+//#endregion
+export { a as OUTPUT_ACTIVATION_TARGETS, o as outputActivationTargetsTable };

package/dist/outputDeployment.js

@@ -0,0 +1,174 @@
+import { lockSiteState as e, lockSiteStateForRead as t } from "./siteState.js";
+import { lockPublicationStream as n, readPublicationBoundary as r } from "./changes.js";
+import { OutputActivationUnavailable as i, copyOutputActivationApp as a, copyOutputActivationScope as o, outputActivationContractDigest as s, outputActivationFail as c } from "./outputActivation.js";
+import { StaticPathSetUnavailable as l } from "./staticPathSet.js";
+import { lockOutputRouteHistoryCapture as u } from "./outputActivationStore.js";
+import { AssetUseRightsUnavailable as d } from "./assetUseRights.js";
+import { admitOutputRouteGraph as f } from "./outputRouteGraph.js";
+import { and as p, eq as m, generateId as h, id as g, integer as _, json as v, table as y, text as b } from "@voltro/database";
+import { tenant as x } from "@voltro/plugin-multitenancy/mixin";
+import { canonicalJson as S } from "@voltro/runtime";
+//#region src/outputDeployment.ts
+var C = "_voltro_cms_output_deployments", w = "_voltro_cms_output_deployment_builds", T = y(C, {
+	id: g({ prefix: "coutdep" }),
+	site: b().maxLength(64),
+	environment: b().maxLength(64),
+	revision: _(),
+	app: v(),
+	renderPolicyDigest: b().maxLength(64)
+}).with(x()).unique("cms_output_deployment_scope", [
+	"tenantId",
+	"site",
+	"environment"
+]), E = y(w, {
+	id: g({ prefix: "coutapp" }),
+	site: b().maxLength(64),
+	environment: b().maxLength(64),
+	deploymentId: b().maxLength(64),
+	app: v()
+}).with(x()).unique("cms_output_deployment_identity", [
+	"tenantId",
+	"site",
+	"environment",
+	"deploymentId"
+]), D = Object.freeze([T, E]), O = (e) => p(m("tenantId", e.tenantId), m("site", e.site), m("environment", e.environment)), k = async (e, t, n = "update") => {
+	let [r] = await e.query({
+		table: C,
+		predicate: O(t),
+		lock: n,
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	return r === void 0 ? null : typeof r.id != "string" || !Number.isSafeInteger(r.revision) || Number(r.revision) < 1 || typeof r.renderPolicyDigest != "string" || !/^[a-f0-9]{64}$/.test(r.renderPolicyDigest) ? c("state") : {
+		id: r.id,
+		revision: Number(r.revision),
+		app: a(r.app),
+		renderPolicyDigest: r.renderPolicyDigest
+	};
+}, A = async (e, t, n = "update") => await k(e, t, n) ?? c("state"), j = async (e, t, n = {}) => {
+	let r = await k(e, o(t), n.lock ?? "share");
+	return r === null ? null : {
+		revision: r.revision,
+		app: r.app,
+		renderPolicyDigest: r.renderPolicyDigest
+	};
+}, M = async (e, t, n, r = "update") => {
+	let [i] = await e.query({
+		table: w,
+		predicate: p(O(t), m("deploymentId", n)),
+		lock: r,
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (i === void 0) return c("state");
+	let o = a(i.app);
+	return o.deploymentId === n ? o : c("integrity");
+}, N = async (t, n, r) => {
+	let i = o(n), s = a(r.app);
+	if (!Number.isSafeInteger(r.expectedRevision) || r.expectedRevision < 0 || r.expectedRevision >= 2147483647 || !/^[a-f0-9]{64}$/.test(r.renderPolicyDigest)) return c("input");
+	await e(t, i);
+	let l = h({
+		kind: "typeid",
+		prefix: "coutapp"
+	}, w);
+	if (l === null) return c("state");
+	if (await t.insertIgnore(w, {
+		id: l,
+		...i,
+		deploymentId: s.deploymentId,
+		app: s
+	}, { conflictColumns: [
+		"tenantId",
+		"site",
+		"environment",
+		"deploymentId"
+	] }), S(await M(t, i, s.deploymentId)) !== S(s)) return c("changed");
+	if (r.expectedRevision === 0) {
+		let e = h({
+			kind: "typeid",
+			prefix: "coutdep"
+		}, C);
+		if (e === null) return c("state");
+		await t.insertIgnore(C, {
+			id: e,
+			...i,
+			revision: 1,
+			app: s,
+			renderPolicyDigest: r.renderPolicyDigest
+		}, { conflictColumns: [
+			"tenantId",
+			"site",
+			"environment"
+		] });
+		let n = await A(t, i);
+		return n.revision !== 1 || S(n.app) !== S(s) || n.renderPolicyDigest !== r.renderPolicyDigest ? c("changed") : {
+			revision: n.revision,
+			app: n.app,
+			renderPolicyDigest: n.renderPolicyDigest
+		};
+	}
+	let u = await A(t, i);
+	if (u.revision !== r.expectedRevision) return c("changed");
+	let d = u.revision + 1;
+	return await t.updateMany("_voltro_cms_output_deployments", {
+		revision: d,
+		app: s,
+		renderPolicyDigest: r.renderPolicyDigest
+	}, { where: p(O(i), m("id", u.id), m("revision", u.revision)) }) === 1 ? {
+		revision: d,
+		app: s,
+		renderPolicyDigest: r.renderPolicyDigest
+	} : c("changed");
+}, P = (e, t) => {
+	if (s(e.app) !== s(t.manifest.app) || e.renderPolicyDigest !== t.manifest.renderPolicyDigest) return c("changed");
+}, F = (t) => async (n, i) => {
+	let a = o(i.manifest.scope);
+	await e(n, a);
+	let l = await A(n, a), u = await r(n, a);
+	return S(await M(n, a, i.manifest.app.deploymentId)) === S(i.manifest.app) ? (P(l, i), await t(n, i), {
+		publicationGeneration: u.generation,
+		releaseId: u.releaseId,
+		deploymentId: l.app.deploymentId,
+		renderPolicyDigest: l.renderPolicyDigest,
+		contractDigest: s(l.app)
+	}) : c("changed");
+}, I = (e) => {
+	if (typeof e != "object" || !e || !Array.isArray(e.pathKeys) || e.pathKeys.length < 1 || e.pathKeys.length > 64 || typeof e.verifyArtifacts != "function" || typeof e.use != "function" || e.now !== void 0 && typeof e.now != "function") return c("input");
+	let t = {
+		...e,
+		pathKeys: e.pathKeys.map((e) => ({
+			id: e.id,
+			material: new Uint8Array(e.material)
+		}))
+	};
+	return async (e, r, a) => {
+		try {
+			let i = await u(e, r.manifest.scope);
+			return await F(async (e, r) => {
+				await n(e, r.manifest.scope);
+				let a = await t.verifyArtifacts(e, r);
+				await f(e, r, a, {
+					observed: i,
+					keys: t.pathKeys,
+					use: t.use,
+					...t.now === void 0 ? {} : { now: t.now }
+				});
+			})(e, r, a);
+		} catch (e) {
+			if (e instanceof i) throw e;
+			return e instanceof l ? c("integrity") : e instanceof d ? c("denied") : c("changed");
+		}
+	};
+}, L = (e) => async (n, r, i, a) => {
+	let s = o(r.manifest.scope);
+	await t(n, s);
+	let l = await A(n, s, "share");
+	if (S(await M(n, s, r.manifest.app.deploymentId, "share")) !== S(r.manifest.app)) return c("changed");
+	P(l, r), await e(n, r, i, a);
+};
+//#endregion
+export { C as OUTPUT_DEPLOYMENTS, w as OUTPUT_DEPLOYMENT_BUILDS, N as bindOutputDeployment, I as makeOutputActivationAdmission, F as makeOutputDeploymentAdmission, L as makeOutputServingAdmission, E as outputDeploymentBuildsTable, D as outputDeploymentTables, T as outputDeploymentsTable, j as readOutputDeployment };

package/dist/outputDeploymentRest.js

@@ -0,0 +1,168 @@
+import { cmsCredential as e, privateCmsHttpRoutes as t, privateCmsOperation as n } from "./privateCmsTransport.js";
+import { CmsOutputDeploymentUnavailable as r } from "./outputDeploymentService.js";
+import { Schema as i } from "effect";
+import { strictInput as a } from "@voltro/protocol";
+//#region src/outputDeploymentRest.ts
+var o = i.String.pipe(i.check(i.isPattern(/^[a-f0-9]{64}$/))), s = i.String.pipe(i.check(i.isPattern(/^[A-Za-z0-9_-]{1,64}$/))), c = i.String.pipe(i.check(i.isPattern(/^\d{20}$/))), l = i.Struct({
+	tenantId: s,
+	site: s,
+	environment: s
+}), u = i.Struct({
+	deploymentId: s,
+	inputsId: o,
+	executionId: o,
+	contractVersion: i.Int,
+	bindingsDigest: o,
+	schemaDigest: o,
+	cacheKeyDigest: o
+}), d = i.Struct({
+	publicationGeneration: c,
+	releaseId: i.NullOr(s),
+	deploymentId: s,
+	renderPolicyDigest: o,
+	contractDigest: o
+}), f = i.Struct({
+	version: i.Literal(1),
+	id: o,
+	targetId: o,
+	scope: l,
+	expectedGeneration: i.Int,
+	mode: i.Literals(["forward", "rollback"]),
+	observation: d,
+	expiresAt: i.Int,
+	keyId: s,
+	signature: o
+}), p = i.Struct({
+	version: i.Literal(1),
+	probeId: o,
+	targetId: o,
+	generation: i.Int,
+	region: s,
+	outputId: o,
+	keyId: s,
+	signature: o
+}), m = i.Array(p).pipe(i.check(i.isMaxLength(64))), h = i.String.pipe(i.check(i.isMaxLength(253))), g = i.Struct({
+	version: i.Literal(2),
+	scope: l,
+	snapshot: i.Struct({
+		id: s,
+		digest: o,
+		releaseId: s,
+		publicationGeneration: c
+	}),
+	app: u,
+	renderPolicyDigest: o,
+	paths: i.Array(i.Struct({
+		host: h,
+		setId: o,
+		count: i.Int
+	})).pipe(i.check(i.isMaxLength(256))),
+	artifacts: i.Array(i.Struct({
+		host: h,
+		documents: o,
+		assets: o,
+		redirects: o,
+		sitemap: o,
+		robots: o,
+		deny: o
+	})).pipe(i.check(i.isMaxLength(256))),
+	cacheNamespace: o,
+	regions: i.Struct({
+		required: i.Array(s).pipe(i.check(i.isMaxLength(64))),
+		quorum: i.Int
+	})
+}), _ = g, v = i.Struct({
+	id: s,
+	generation: i.Int,
+	set: i.Struct({
+		id: o,
+		manifest: _
+	}),
+	probe: f,
+	receipts: m,
+	activatedAt: i.Int
+}), y = i.Struct({
+	targetId: o,
+	expectedRevision: i.Int,
+	expectedGeneration: i.Int,
+	mode: i.Literals(["forward", "rollback"]),
+	outputs: i.Array(i.Struct({
+		region: s,
+		outputId: o
+	})).pipe(i.check(i.isMaxLength(64)))
+}), b = i.Struct({
+	deployment: i.Struct({
+		revision: i.Int,
+		app: u,
+		renderPolicyDigest: o
+	}),
+	activation: v
+}), x = (t) => e(t, "CmsOutputDeploymentUnavailable"), S = (e, t, i, o, s, c) => ({
+	...n({
+		namespace: "cms.outputDeployment",
+		path: "/v1/cms/output-deployments",
+		operationPrefix: "cmsOutputDeployment",
+		tags: ["CMS output deployment"],
+		error: r,
+		credentialError: "CmsOutputDeploymentUnavailable",
+		errorStatus: { CmsOutputDeploymentUnavailable: 409 }
+	}, e, t, i, a(o, "cms.outputDeployment." + e, !0), s, c),
+	maxBodyBytes: 65536
+}), C = (e) => {
+	let n = [
+		S("inspect", "Read current deployment and activation epochs", "Fresh scoped cms:deploy authority. Metadata only; no output, provider or serving authority. Retain these exact epochs with the original deployment intent.", i.Struct({}), i.Struct({
+			revision: i.Int,
+			generation: i.Int
+		}), (t, n) => e.inspect({ credential: x(n) })),
+		S("deploy", "Atomically bind and publish one complete output target", "Fresh scoped cms:deploy authority. Verify every required physical region before a single transaction binds the original app and policy, admits the current graph, signs regional custody and activates the complete set. Failure rolls back the binding and activation together. Exact current lost acknowledgements return the same epochs and result.", y, b, (t, n) => e.deploy({
+			...t,
+			credential: x(n)
+		})),
+		S("confirm", "Confirm one exact current native publication", "Fresh scoped cms:deploy authority. Acknowledge only the already committed original target, epochs, mode and complete regional output identity. This operation never stages, binds, probes, signs or activates a target. Missing, displaced or changed publications refuse; expired original private inputs do not prevent confirmation. The acknowledgement grants no public serving or Cloud readiness.", y, b, (t, n) => e.confirm({
+			...t,
+			credential: x(n)
+		})),
+		S("bind", "Bind one admitted output deployment", "Dedicated scoped cms:deploy credential. The server resolves the original deployment contract and policy; the request supplies only its ID and expected revision. No execution, provider allocation or app contract comes from HTTP.", i.Struct({
+			deploymentId: s,
+			expectedRevision: i.Int
+		}), i.Struct({
+			revision: i.Int,
+			app: u,
+			renderPolicyDigest: o
+		}), (t, n) => e.bind({
+			...t,
+			credential: x(n)
+		})),
+		S("probe", "Probe one complete output activation target", "Dedicated scoped deployment credential. The server resolves the immutable target, verifies current deployment/publication/graph/rights and signs a probe valid for at most 30 seconds. Target IDs grant no authority.", i.Struct({
+			targetId: o,
+			expectedGeneration: i.Int,
+			mode: i.Literals(["forward", "rollback"])
+		}), f, (t, n) => e.probe({
+			...t,
+			credential: x(n)
+		})),
+		S("observeRegion", "Verify physical regional custody and sign its original probe", "The server reads the exact target/output through its fixed regional adapter and rehashes every role/file. Current scoped credential and original unexpired probe are checked after physical IO. No filesystem paths, signer keys, replacement probe or serving authority is accepted.", i.Struct({
+			targetId: o,
+			probe: f,
+			region: s,
+			outputId: o
+		}), p, (t, n) => e.observeRegion({
+			...t,
+			credential: x(n)
+		})),
+		S("activate", "Atomically activate one fully admitted output set", "Fresh scoped deployment credential, current graph/rights and original probe/region policy guard the generation CAS. Exact recovery of an already committed current marker returns that same result without renewing its probe or advancing generation. It grants no public read permission; serving still enforces current denials and rights.", i.Struct({
+			targetId: o,
+			probe: f,
+			receipts: m
+		}), v, (t, n) => e.activate({
+			...t,
+			credential: x(n)
+		}))
+	];
+	return {
+		routes: n,
+		httpRoutes: t(n)
+	};
+};
+//#endregion
+export { C as cmsOutputDeploymentRest, g as outputDeploymentManifestSchema };