@voltro/cms 0.86.0 → 0.88.0

package/dist/snapshotRedirects.js

@@ -0,0 +1,131 @@
+import { readPublicationBoundary as e } from "./changes.js";
+import { CMS_PATHS_TABLE as t, CMS_REDIRECTS_TABLE as n } from "./redirects.js";
+import { verifyPublicationState as r } from "./publicationState.js";
+import { copySnapshotResource as i } from "./buildSnapshot.js";
+import { snapshotObservedRouteHistorySource as a } from "./snapshotObservedRouteHistory.js";
+import { snapshotPublicRouteHistorySource as o } from "./snapshotPublicRouteHistory.js";
+import { snapshotApprovedRouteDispositionsSource as s } from "./snapshotApprovedRouteDispositions.js";
+import { Schema as c } from "effect";
+import { and as l, eq as u, gt as d, inSet as f } from "@voltro/database";
+import { createHash as p } from "node:crypto";
+import { canonicalJson as m } from "@voltro/runtime";
+// src/snapshotRedirects.ts
+var h = class extends c.TaggedError()("SnapshotRedirectUnavailable", { reason: c.Literals([
+	"scope",
+	"checkpoint",
+	"row",
+	"history"
+]) }) {}, g = (e) => {
+	throw new h({ reason: e });
+}, _ = (e) => typeof e == "string" && e.length > 0, v = (c, h, v, y, b = Date.now()) => {
+	let x = {
+		tenantId: h.tenantId,
+		site: h.site,
+		environment: h.environment
+	};
+	if (!Object.values(x).every(_)) return g("scope");
+	let S = o(c, x, y);
+	return {
+		format: "voltro.cms.redirect-history/v4",
+		entries: async function* (o) {
+			let h = await e(c, x);
+			if (h.generation !== o.generation || h.releaseId !== o.releaseId || h.checkpoint !== o.checkpoint) return g("checkpoint");
+			let y = await r(c, x, o, b), C = !1;
+			for await (let e of a(c, x, b).entries(o)) if (e.key === "configuration") {
+				if (C || e.value.revision !== v.generation || e.value.sourceDigest !== v.sourceDigest || v.generation === 0 != (v.activationId === null)) return g("history");
+				C = !0, yield i({
+					key: "configuration",
+					value: {
+						...e.value,
+						version: 4,
+						coverage: "source-and-activated-output",
+						activationId: v.activationId,
+						status: v.generation === 0 ? "before-first-activation" : "observed"
+					}
+				});
+			} else {
+				if (!C) return g("history");
+				yield i({
+					key: "observed:" + e.key,
+					value: {
+						...e.value,
+						version: 2,
+						kind: "observed"
+					}
+				});
+			}
+			if (!C) return g("history");
+			for await (let e of S.entries(o)) yield i({
+				key: "source:" + e.key,
+				value: e.value
+			});
+			for await (let e of s(c, x, b).entries(o)) yield i({
+				key: "disposition:" + e.key,
+				value: {
+					...e.value,
+					kind: e.key === "configuration" ? "disposition-configuration" : "disposition"
+				}
+			});
+			for (let [e, r, a] of [[
+				"path",
+				t,
+				"path"
+			], [
+				"redirect",
+				n,
+				"fromPath"
+			]]) {
+				let t;
+				for (;;) {
+					let n = await c.query({
+						table: r,
+						predicate: l(u("tenantId", x.tenantId), u("site", x.site), u("environment", x.environment), f("contentType", y.types), f("locale", y.locales), ...t === void 0 ? [] : [d("id", t)]),
+						lock: "update",
+						order: [{
+							column: "id",
+							direction: "asc"
+						}],
+						take: 500,
+						skip: void 0,
+						projection: [
+							"id",
+							"contentType",
+							"locale",
+							"documentId",
+							a
+						]
+					});
+					if (n.length === 0) break;
+					for (let t of n) {
+						if (![
+							t.id,
+							t.contentType,
+							t.locale,
+							t.documentId
+						].every(_) || typeof t[a] != "string") return g("row");
+						let n = [
+							t.contentType,
+							t.locale,
+							e === "path" ? t.documentId : t[a]
+						], r = `${e}:${p("sha256").update(m(n)).digest("hex")}`;
+						yield i({
+							key: r,
+							value: {
+								version: 1,
+								kind: e,
+								...x,
+								id: t.id,
+								contentType: t.contentType,
+								locale: t.locale,
+								documentId: t.documentId,
+								path: t[a]
+							}
+						});
+					}
+					t = String(n[n.length - 1].id);
+				}
+			}
+		}
+	};
+};
+export { h as SnapshotRedirectUnavailable, v as snapshotRedirectSource };

package/dist/snapshotReference.js

@@ -0,0 +1,7 @@
+// src/snapshotReference.ts
+var e = (e, t) => {
+	let n = Object.getOwnPropertyDescriptor(e, Symbol.for("voltro.cms.snapshot.reference/v1"));
+	if (n === void 0 || n.enumerable || n.writable || typeof n.value != "function") throw Error("Snapshot reference unavailable");
+	return n.value(t);
+};
+export { e as snapshotReference };

package/dist/snapshotReferenceAddress.js

@@ -0,0 +1,9 @@
+import { readCapturedPublicAddress as e } from "./snapshotAddressRead.js";
+// src/snapshotReferenceAddress.ts
+var t = (t, n, r, i, a, o) => e(t, n, r.snapshot, {
+	contentType: i.targetType,
+	documentId: i.targetDocumentId,
+	localeId: r.output.localeId,
+	mappingId: a
+}, o);
+export { t as readPlannedSnapshotReferenceAddress };

package/dist/snapshotReferenceGraph.js

@@ -0,0 +1,78 @@
+import { readVerifiedSnapshotResource as e } from "./buildSnapshot.js";
+import { copySnapshotReferenceTypes as t } from "./snapshotProjection.js";
+import { coversSnapshotComponents as n } from "./snapshotFrontend.js";
+import { SnapshotRouteReadUnavailable as r } from "./snapshotRouteAdmission.js";
+import { readAdmittedSnapshotFieldPlan as i } from "./snapshotFieldPlan.js";
+import { readPlannedSnapshotReferenceContext as a } from "./snapshotReferenceRead.js";
+import { createHash as o } from "node:crypto";
+import { canonicalJson as s } from "@voltro/runtime";
+// src/snapshotReferenceGraph.ts
+var c = (e) => {
+	throw new r({ reason: e });
+}, l = (e) => o("sha256").update(s(e)).digest("hex"), u = async (r, o, u, d, f, p) => {
+	if (u.length === 0 || u.length > 65 || u[0]?.source !== null || new Set(u.map((e) => e.source)).size !== u.length) return c("bounds");
+	let m = u[0].context.snapshot;
+	if (u.some((e) => e.context.snapshot.id !== m.id || e.context.snapshot.digest !== m.digest || e.context.output.localeId !== f.localeId || e.source?.startsWith("@ref:"))) return c("binding");
+	let h = (await e(r, o, m, "projection", "registry")).value;
+	if (!Array.isArray(h.types) || !h.types.every((e) => typeof e == "string")) return c("binding");
+	let g = new Set(t(h.referenceTypes, h.types)), _ = Object.create(null), v = [], y = /* @__PURE__ */ new Map(), b = u.map((e) => ({
+		...e,
+		selection: {
+			...e.source === null ? {} : { binding: e.source },
+			references: []
+		}
+	})), x = u.reduce((e, t) => e + t.fields.media.length, 0);
+	if (x > 1024) return c("bounds");
+	if (g.size === 0) return {
+		nodes: _,
+		edges: v
+	};
+	for (let e = 0; e < b.length; e++) {
+		let t = b[e];
+		for (let e of t.fields.references) {
+			if (!g.has(e.targetType)) continue;
+			if (v.length >= 8192) return c("bounds");
+			let s = l([
+				e.targetType,
+				e.targetDocumentId,
+				t.context.output.localeId
+			]), u = y.get(s);
+			if (!y.has(s)) {
+				if (y.size >= 256 || t.selection.references.length >= 16) return c("bounds");
+				let l = await a(r, o, t.context, e, p);
+				if (l === null) u = null;
+				else {
+					if (!n(d, l.components, f)) return c("binding");
+					let a = await i(r, o, l, p);
+					if (x += a.media.length, x > 1024) return c("bounds");
+					u = "@ref:" + s;
+					let m = {
+						...t.selection,
+						references: [...t.selection.references, [...e.path]]
+					};
+					_[u] = {
+						selection: m,
+						output: l.output,
+						fields: a
+					}, b.push({
+						source: u,
+						context: l,
+						fields: a,
+						selection: m
+					});
+				}
+				y.set(s, u);
+			}
+			v.push({
+				source: t.source,
+				fieldPath: [...e.path],
+				target: u ?? null
+			});
+		}
+	}
+	return v.sort((e, t) => s(e) < s(t) ? -1 : +(s(e) > s(t))), {
+		nodes: _,
+		edges: v
+	};
+};
+export { u as readAdmittedSnapshotReferenceGraph };

package/dist/snapshotReferenceRead.js

@@ -0,0 +1,64 @@
+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 { readAdmittedSnapshotBindingContext as o } from "./snapshotBindingRead.js";
+import { readAdmittedSnapshotFieldPlan as s } from "./snapshotFieldPlan.js";
+import { canonicalJson as c } from "@voltro/runtime";
+// src/snapshotReferenceRead.ts
+var l = () => {
+	throw new r({ reason: "binding" });
+}, u = (e) => !Array.isArray(e) || e.length === 0 || e.length > 128 || e.some((e) => typeof e == "number" ? !Number.isSafeInteger(e) || e < 0 : typeof e != "string" || e.length === 0 || e.length > 256) ? l() : [...e], d = async (e, t, n, r, i) => {
+	let a = await f(e, t, n, r, i);
+	return a === null ? null : p(e, t, n, a, i);
+}, f = async (e, t, n, r, i) => {
+	let a = u(r);
+	return (await s(e, t, n, i)).references.find((e) => c(e.path) === c(a)) ?? null;
+}, p = async (t, r, a, o, s) => {
+	let c = await n(t, r, a.snapshot, o.targetType, a.output.localeId, o.targetDocumentId, s);
+	if (c === null) return null;
+	let l = c.chain[0], u = (await e(t, r, a.snapshot, "schema", `type:${o.targetType}`)).value, d = await i(t, r, a.snapshot, o.targetType, l, u, s, a.output.presentation);
+	return {
+		snapshot: a.snapshot,
+		document: l,
+		binding: a.binding,
+		routeId: a.routeId,
+		components: d.components,
+		output: {
+			contentType: o.targetType,
+			localeId: a.output.localeId,
+			requestedLocale: c.requestedLocale,
+			sourceLocale: l.locale,
+			fallback: l.locale !== c.requestedLocale,
+			values: d.values,
+			presentation: d.presentation
+		}
+	};
+}, m = async (e, n, r, i, s) => {
+	let c = {
+		...i,
+		presentation: t(i.presentation)
+	}, f = s.now ?? Date.now();
+	if (!Array.isArray(c.references) || c.references.length > 16) return l();
+	let p = c.references.map(u), m = {
+		tenantId: n.tenantId,
+		site: n.site,
+		environment: n.environment
+	}, h = await a(e, m, r, c, {
+		...s,
+		now: f
+	});
+	if (h === null) return null;
+	let g = c.binding === void 0 ? {
+		...h,
+		routeId: h.output.routeId
+	} : await o(e, m, h, c.binding, f);
+	for (let t of p) {
+		if (g === null) return null;
+		g = await d(e, m, g, t, f);
+	}
+	return g;
+}, h = async (...e) => !Array.isArray(e[3].references) || e[3].references.length === 0 ? l() : m(...e);
+export { d as readAdmittedSnapshotReferenceContext, f as readAdmittedSnapshotReferenceUse, p as readPlannedSnapshotReferenceContext, h as readSnapshotReferenceContext, m as readSnapshotReferenceSourceContext };

package/dist/snapshotRelease.js

@@ -0,0 +1,98 @@
+import { readPublicationBoundary as e } from "./changes.js";
+import { readCapturedPublication as t } from "./publicationState.js";
+import { copySnapshotResource as n } from "./buildSnapshot.js";
+import { CMS_RELEASES_TABLE as r, CMS_RELEASE_ITEMS_TABLE as i } from "./release.js";
+import { Schema as a } from "effect";
+import { and as o, eq as s, gt as c } from "@voltro/database";
+// src/snapshotRelease.ts
+var l = class extends a.TaggedError()("SnapshotReleaseUnavailable", { reason: a.Literals([
+	"scope",
+	"release",
+	"checkpoint",
+	"item"
+]) }) {}, u = (e) => {
+	throw new l({ reason: e });
+}, d = (e) => typeof e == "string" && e.trim().length > 0, f = (e) => e === null || d(e), p = (a, l, p, m = Date.now()) => {
+	let h = {
+		tenantId: l.tenantId,
+		site: l.site,
+		environment: l.environment
+	};
+	return ![
+		h.tenantId,
+		h.site,
+		h.environment,
+		p
+	].every(d) || !Number.isSafeInteger(m) ? u("scope") : {
+		format: "voltro.cms.release/v1",
+		entries: async function* (l) {
+			let g = await e(a, h);
+			if (g.generation !== l.generation || g.releaseId !== p || l.releaseId !== p || g.checkpoint !== l.checkpoint) return u("checkpoint");
+			let [_] = await a.query({
+				table: r,
+				predicate: o(s("tenantId", h.tenantId), s("site", h.site), s("environment", h.environment), s("id", p)),
+				lock: "update",
+				order: [],
+				take: 1,
+				skip: void 0,
+				projection: void 0
+			});
+			if (_ === void 0 || _.publicationGeneration !== l.generation || _.publicationCheckpoint !== l.checkpoint || _.status !== "published" || !d(_.name) || !f(_.rollbackOf)) return u("release");
+			let v = _.publishedAt instanceof Date ? _.publishedAt.getTime() : typeof _.publishedAt == "string" ? Date.parse(_.publishedAt) : NaN;
+			if (!Number.isSafeInteger(v) || v > m) return u("release");
+			yield n({
+				key: "release",
+				value: {
+					id: p,
+					name: _.name,
+					...h,
+					publishedAt: v,
+					rollbackOf: _.rollbackOf,
+					publication: { ...l }
+				}
+			});
+			let y;
+			for (;;) {
+				let e = await a.query({
+					table: i,
+					predicate: o(s("tenantId", h.tenantId), s("releaseId", p), ...y === void 0 ? [] : [c("id", y)]),
+					lock: "update",
+					order: [{
+						column: "id",
+						direction: "asc"
+					}],
+					take: 128,
+					skip: void 0,
+					projection: void 0
+				});
+				if (e.length === 0) break;
+				for (let r of e) {
+					if (![
+						r.id,
+						r.contentType,
+						r.variantId,
+						r.locale
+					].every(d) || !Number.isSafeInteger(r.position) || Number(r.position) < 0 || !f(r.previousRevisionId) || !(r.action === "publish" ? d(r.revisionId) : r.action === "unpublish" && r.revisionId === null)) return u("item");
+					let e = await t(a, h, l.id, String(r.contentType), String(r.locale), String(r.variantId), m);
+					if (r.action === "publish" ? e?.revisionId !== r.revisionId : e !== null) return u("item");
+					yield n({
+						key: `item:${String(r.id)}`,
+						value: {
+							id: r.id,
+							contentType: r.contentType,
+							variantId: r.variantId,
+							locale: r.locale,
+							action: r.action,
+							revisionId: r.revisionId,
+							previousRevisionId: r.previousRevisionId,
+							position: r.position,
+							inherited: r.inherited ?? null
+						}
+					});
+				}
+				y = String(e[e.length - 1].id);
+			}
+		}
+	};
+};
+export { l as SnapshotReleaseUnavailable, p as snapshotReleaseSource };