dineway 0.2.34 → 0.2.36

package/dist/submission-BLvkvewK.mjs

@@ -0,0 +1,411 @@
+import { AtomicWriteConflict, atomicBatch, prepareAtomicChecks, rowUnchanged } from "./database/batch.mjs";
+import { r as isI18nEnabled } from "./config-XW5tMrH8.mjs";
+import { t as DinewayValidationError } from "./types-BqxIv8Il.mjs";
+import { t as contentWriteChecks } from "./atomic-authority-CnBQJ14T.mjs";
+import { o as invalidateCollectionCache } from "./object-cache-BGjIlY9s.mjs";
+import { t as RevisionRepository } from "./revision-090sZyGc.mjs";
+import { t as ContentRepository } from "./content-D9xKUSno.mjs";
+import { t as buildStableHash } from "./stable-hash-DEtJgcp7.mjs";
+import { i as isSupersededReview, r as ReviewRequestRepository, t as REVIEW_SUPERSESSION_ACTOR } from "./review-requests-BF2eEKr8.mjs";
+import { t as RedirectRepository } from "./redirect-HLI3wT5Y.mjs";
+import { i as invalidateRedirectCache } from "./cache-DZDOBJv3.mjs";
+import { D as validateMediaFields, E as validateContentDataFields, T as prepareNonTranslatableFields, k as encodeRev, r as contentWriteConfiguration, t as ReviewPayloadBuilder } from "./review-payload-LLIi1sxO.mjs";
+import { i as reviewDraft } from "./evidence-krrA3uiG.mjs";
+import { sql } from "kysely";
+import { z } from "zod";
+
+//#region src/api/handlers/content-write.ts
+const fieldData = (data) => Object.fromEntries(Object.entries(data).filter(([key]) => !key.startsWith("_")));
+const reviews = /* @__PURE__ */ new WeakMap();
+function preparedContentReview(write) {
+	const stored = reviews.get(write);
+	if (!stored) throw new DinewayValidationError("Review requires an unmodified prepared content write.");
+	return structuredClone(stored);
+}
+/** Prepare a draft or direct backing-row edit without committing site-owned writes separately. */
+async function prepareContentWrite(db, collection, input) {
+	const configuration = await contentWriteConfiguration(db, collection);
+	const supports = JSON.parse(configuration.row?.supports ?? "[]");
+	const usesRevisions = Array.isArray(supports) && supports.includes("revisions");
+	if (input.status !== void 0 && input.status !== "draft") throw new DinewayValidationError("Prepared status changes must use publish or unpublish.");
+	if (input.publish && input.unpublish) throw new DinewayValidationError("Publish and unpublish cannot be combined.");
+	const validateData = async (data) => {
+		const fields = await validateContentDataFields(db, collection, fieldData(data));
+		if (fields && !fields.success) throw new DinewayValidationError(fields.error.message);
+		const media = await validateMediaFields(db, collection, fieldData(data));
+		if (!media.success) throw new DinewayValidationError(media.error.message);
+	};
+	if (input.data) await validateData(input.data);
+	const repo = new ContentRepository(db);
+	const checks = [...configuration.checks];
+	const statements = [];
+	let item;
+	let previousSlug = null;
+	let wasPublished = false;
+	let live = null;
+	let draft = null;
+	let now = (/* @__PURE__ */ new Date()).toISOString();
+	if (input.id) {
+		const snapshot = await repo.snapshot(collection, input.id);
+		if (!snapshot) throw new DinewayValidationError("Content item not found.");
+		if (input.expectedRev !== void 0 && encodeRev(snapshot.item) !== input.expectedRev) throw new AtomicWriteConflict();
+		previousSlug = snapshot.item.slug;
+		wasPublished = snapshot.item.status === "published";
+		item = {
+			...snapshot.item,
+			updatedAt: now,
+			version: snapshot.item.version + 1
+		};
+		checks.push(snapshot.check, ...contentWriteChecks(collection, item.id, "edit"));
+		for (const [kind, id] of [["live", item.liveRevisionId], ["draft", item.draftRevisionId]]) {
+			if (!id) continue;
+			const revision = await db.selectFrom("revisions").selectAll().where("id", "=", id).executeTakeFirst();
+			if (!revision || revision.collection !== collection || revision.entry_id !== item.id) throw new DinewayValidationError("Content revision is missing or belongs to another entry.");
+			checks.push(rowUnchanged("revisions", revision));
+			if (kind === "live") live = JSON.parse(revision.data);
+			else draft = JSON.parse(revision.data);
+		}
+		const stage = input.stageDraft !== false && usesRevisions;
+		const changedDraft = stage && (Object.keys(input.data ?? {}).length > 0 || input.slug !== void 0);
+		if (changedDraft) draft = {
+			...draft ?? item.data,
+			...input.data,
+			...input.slug === void 0 ? {} : { _slug: input.slug }
+		};
+		if (input.draftData) {
+			const previous = draft ?? live ?? item.data;
+			await validateData(Object.fromEntries(Object.entries(input.draftData).filter(([key, value]) => JSON.stringify(previous[key]) !== JSON.stringify(value))));
+			draft = structuredClone(input.draftData);
+		}
+		if (!stage) {
+			item.data = {
+				...item.data,
+				...await repo.normalizePreparedData(collection, fieldData(input.data ?? {}))
+			};
+			for (const [key, value] of Object.entries(item.data)) if (typeof value === "boolean") item.data[key] = Number(value);
+			for (const [key, value] of Object.entries(item.data)) if (value === null || value === void 0) delete item.data[key];
+			if (input.slug !== void 0) item.slug = input.slug;
+		}
+		if (!stage && input.slug && previousSlug && input.slug !== previousSlug) statements.push(...new RedirectRepository(db).prepareAutoRedirect(collection, previousSlug, input.slug, item.id, configuration.row?.url_pattern ?? null).statements);
+		if (!stage && isI18nEnabled() && input.data && item.translationGroup) {
+			const sync = prepareNonTranslatableFields(db, collection, item.id, item.translationGroup, fieldData(input.data), configuration.fields.filter((field) => field.translatable === 0).map((field) => field.slug));
+			if (sync) statements.push(sync);
+		}
+		if (input.status !== void 0) item.status = input.status;
+		if (input.authorId !== void 0) item.authorId = input.authorId;
+		statements.push(repo.prepareUpdate(collection, item.id, {
+			data: stage ? void 0 : input.data && fieldData(input.data),
+			slug: stage ? void 0 : input.slug,
+			status: input.status,
+			authorId: input.authorId
+		}, now));
+		if (changedDraft || input.draftData || input.unpublish && !draft && live) {
+			draft ??= live;
+			if (draft) {
+				const revision = new RevisionRepository(db).prepareCreateSnapshot({
+					collection,
+					entryId: item.id,
+					data: sql`${JSON.stringify(draft)}`,
+					authorId: input.authorId
+				});
+				item.draftRevisionId = revision.id;
+				statements.push(revision.statement, sql`UPDATE ${sql.table(`ec_${collection}`)} SET draft_revision_id=${revision.id} WHERE id=${item.id}`.compile(db));
+			}
+		}
+	} else {
+		if (input.expectedRev !== void 0 || input.unpublish) throw new DinewayValidationError("A new draft cannot reference an existing revision.");
+		const data = fieldData(input.data ?? {});
+		if (input.draftData) await validateData(input.draftData);
+		const slugSource = [data.title, data.name].find((value) => typeof value === "string" && value.length > 0);
+		const slug = input.slug ?? (slugSource ? await repo.generateUniqueSlug(collection, slugSource, input.locale) : void 0);
+		if (slug) checks.push(sql`NOT EXISTS(SELECT 1 FROM ${sql.table(`ec_${collection}`)} WHERE slug=${slug} ${input.locale ? sql`AND locale=${input.locale}` : sql``})`);
+		const created = await repo.prepareCreate({
+			type: collection,
+			data,
+			slug,
+			status: "draft",
+			authorId: input.authorId,
+			locale: input.locale
+		}, { captureDefaults: true });
+		item = created.item;
+		now = item.updatedAt;
+		checks.push(...created.batch.checks ?? []);
+		statements.push(...created.batch.statements);
+		if (usesRevisions || input.draftData) {
+			draft = structuredClone(input.draftData ?? {
+				...item.data,
+				...Object.fromEntries(Object.entries(input.data ?? {}).filter(([key]) => key.startsWith("_")))
+			});
+			const revision = new RevisionRepository(db).prepareCreateSnapshot({
+				collection,
+				entryId: item.id,
+				data: sql`${JSON.stringify(draft)}`,
+				authorId: input.authorId
+			});
+			item.draftRevisionId = revision.id;
+			statements.push(revision.statement, sql`UPDATE ${sql.table(`ec_${collection}`)} SET draft_revision_id=${revision.id} WHERE id=${item.id}`.compile(db));
+		}
+	}
+	if (input.publish) {
+		const authority = contentWriteChecks(collection, item.id, "publish");
+		if (input.id) checks.push(...authority);
+		else statements.push(...prepareAtomicChecks(db, authority));
+		const data = draft ?? live ?? item.data;
+		let revisionId = item.draftRevisionId ?? item.liveRevisionId;
+		if (!revisionId) {
+			const revision = new RevisionRepository(db).prepareCreateSnapshot({
+				collection,
+				entryId: item.id,
+				data: sql`${JSON.stringify(data)}`,
+				authorId: input.authorId
+			});
+			revisionId = revision.id;
+			statements.push(revision.statement);
+		}
+		const sync = repo.prepareSyncDataColumns(collection, item.id, data);
+		if (sync) statements.push(sync);
+		const slug = typeof data._slug === "string" ? data._slug : item.slug;
+		if (wasPublished && previousSlug && slug && previousSlug !== slug) statements.push(...new RedirectRepository(db).prepareAutoRedirect(collection, previousSlug, slug, item.id, configuration.row?.url_pattern ?? null).statements);
+		item = {
+			...item,
+			slug,
+			status: "published",
+			liveRevisionId: revisionId,
+			draftRevisionId: null,
+			scheduledAt: null,
+			publishedAt: item.publishedAt ?? now,
+			updatedAt: now,
+			data: {
+				...item.data,
+				...await repo.normalizePreparedData(collection, fieldData(data))
+			}
+		};
+		for (const [key, value] of Object.entries(item.data)) {
+			if (typeof value === "boolean") item.data[key] = Number(value);
+			if (value === null || value === void 0) delete item.data[key];
+		}
+		statements.push(sql`UPDATE ${sql.table(`ec_${collection}`)} SET slug=${slug},status='published',live_revision_id=${revisionId},draft_revision_id=NULL,scheduled_at=NULL,published_at=${item.publishedAt},updated_at=${now} WHERE id=${item.id}`.compile(db));
+		live = data;
+		draft = null;
+	}
+	if (input.unpublish) {
+		checks.push(...contentWriteChecks(collection, item.id, "publish"));
+		item.liveRevisionId = null;
+		item.status = "draft";
+		live = null;
+		statements.push(sql`UPDATE ${sql.table(`ec_${collection}`)} SET live_revision_id=NULL,status='draft' WHERE id=${item.id}`.compile(db));
+	}
+	const prepared = {
+		id: item.id,
+		item,
+		rev: encodeRev(item),
+		draftData: draft,
+		batch: {
+			checks,
+			statements
+		},
+		afterCommit: () => {
+			invalidateCollectionCache(collection);
+			if (previousSlug !== item.slug) invalidateRedirectCache();
+		}
+	};
+	reviews.set(prepared, structuredClone({
+		item,
+		live,
+		draft
+	}));
+	return prepared;
+}
+
+//#endregion
+//#region src/review-automation/submission.ts
+var ReviewSubmissionError = class extends Error {
+	constructor(message, code = "REVIEW_SUBMISSION_INVALID") {
+		super(message);
+		this.code = code;
+	}
+};
+async function prepareAutomatedReview(db, handlers, input, options = {}) {
+	const projected = options.draft ? preparedContentReview(options.draft) : null;
+	if (projected && (projected.item.id !== input.id || projected.item.type !== input.collection)) throw new ReviewSubmissionError("Prepared draft does not match the review target.");
+	const contentRepo = new ContentRepository(db);
+	const entry = projected ? projected.item : await contentRepo.findByIdOrSlug(input.collection, input.id);
+	const snapshot = projected ? {
+		item: projected.item,
+		check: sql`true`
+	} : entry ? await contentRepo.snapshot(input.collection, entry.id) : null;
+	if (!snapshot) throw new ReviewSubmissionError("The submitted content could not be read.");
+	const revisionIds = projected ? [] : [snapshot.item.liveRevisionId, snapshot.item.draftRevisionId].filter((id) => id !== null);
+	const revisions = revisionIds.length ? await db.selectFrom("revisions").selectAll().where("id", "in", revisionIds).execute() : [];
+	const built = await new ReviewPayloadBuilder(projected ? {
+		handleContentGet: async () => ({
+			success: true,
+			data: {
+				item: projected.item,
+				_rev: encodeRev(projected.item)
+			}
+		}),
+		handleContentCompare: async () => ({
+			success: true,
+			data: {
+				live: projected.live,
+				draft: projected.draft,
+				hasChanges: projected.item.draftRevisionId !== null && projected.item.draftRevisionId !== projected.item.liveRevisionId
+			}
+		})
+	} : handlers).buildContentReviewPayload(input);
+	if (input.expectedRev !== void 0 && input.expectedRev !== built.reviewedRev) throw new ReviewSubmissionError("Reload the latest draft before submitting it.", "REVIEW_REVISION_CHANGED");
+	const contentHash = await buildStableHash(reviewDraft(built));
+	const targetKey = await buildStableHash({
+		collection: built.collection,
+		id: built.entryId,
+		actionHash: built.actionHash
+	});
+	if (built.reviewedRev !== encodeRev(snapshot.item) || built.draftRevisionId !== snapshot.item.draftRevisionId || built.liveRevisionId !== snapshot.item.liveRevisionId) throw new ReviewSubmissionError("The submitted content changed. Review the latest draft.");
+	const scheduledAt = snapshot.item.scheduledAt;
+	const checks = [...options.draft?.batch.checks ?? [snapshot.check], ...revisions.map((revision) => rowUnchanged("revisions", revision))];
+	const projectedGuard = [];
+	if (projected) {
+		const future = sql`${rowUnchanged(`ec_${input.collection}`, {
+			id: projected.item.id,
+			version: projected.item.version,
+			updated_at: projected.item.updatedAt,
+			live_revision_id: projected.item.liveRevisionId,
+			draft_revision_id: projected.item.draftRevisionId,
+			status: projected.item.status,
+			scheduled_at: projected.item.scheduledAt
+		})} AND ${projected.item.draftRevisionId && projected.draft ? sql`EXISTS(SELECT 1 FROM revisions WHERE id=${projected.item.draftRevisionId} AND collection=${input.collection} AND entry_id=${input.id} AND json(data)=json(${JSON.stringify(projected.draft)}))` : sql`true`}`;
+		projectedGuard.push(...prepareAtomicChecks(db, [future]));
+	}
+	const reviews = new ReviewRequestRepository(db);
+	const prepareSupersession = async () => {
+		const statements = [];
+		if (!input.supersedePending) return {
+			checks: [],
+			statements
+		};
+		const query = db.selectFrom("_dineway_review_requests").where("collection", "=", built.collection).where("entry_id", "=", built.entryId).where("action_type", "=", built.actionType).where("requested_by_actor_type", "=", input.actor.actorType).where("requested_by_actor_id", "=", input.actor.actorId).where("status", "=", "pending").where("revoked_at", "is", null).where((eb) => eb.or([eb("reviewed_rev", "!=", built.reviewedRev), eb("action_hash", "!=", built.actionHash)]));
+		const previous = await query.select("id").execute();
+		const supersessionChecks = [sql`${query.select((eb) => eb.fn.countAll().as("count"))} = ${previous.length}`];
+		for (const prior of previous) {
+			const batch = await reviews.prepareResolve(prior.id, {
+				decision: "rejected",
+				resolvedByActorType: "system",
+				resolvedByActorId: REVIEW_SUPERSESSION_ACTOR,
+				reviewNote: "Superseded by a newer submission. This is not an editorial rejection."
+			});
+			if (!batch) throw new AtomicWriteConflict();
+			supersessionChecks.push(...batch.checks ?? []);
+			statements.push(...batch.statements);
+		}
+		return {
+			checks: supersessionChecks,
+			statements
+		};
+	};
+	const reuseReview = async (item) => {
+		const batch = await prepareSupersession();
+		return {
+			id: item.id,
+			targetKey,
+			created: false,
+			batch: {
+				checks: [
+					...checks,
+					rowUnchanged("_dineway_review_requests", {
+						id: item.id,
+						status: item.status,
+						revoked_at: item.revokedAt ?? null
+					}),
+					...batch.checks
+				],
+				statements: [...projectedGuard, ...batch.statements]
+			}
+		};
+	};
+	const findExisting = async () => {
+		const existing = await db.selectFrom("_dineway_review_jobs").select("review_id").where("target_key", "=", targetKey).executeTakeFirst();
+		if (existing) {
+			const item = await reviews.findById(existing.review_id);
+			if (!item || item.status === "rejected" || item.revokedAt) throw new ReviewSubmissionError("Edit the content before submitting a rejected or revoked target again.");
+			return item;
+		}
+		return null;
+	};
+	const existingReview = await findExisting();
+	if (existingReview) return reuseReview(existingReview);
+	const rejected = await db.selectFrom("_dineway_review_requests").select([
+		"id",
+		"status",
+		"review_payload",
+		"resolved_by_actor_type",
+		"resolved_by_actor_id"
+	]).where("collection", "=", built.collection).where("entry_id", "=", built.entryId).where("status", "=", "rejected").execute();
+	checks.push(sql`NOT EXISTS (SELECT 1 FROM _dineway_review_jobs WHERE target_key = ${targetKey})`, sql`(SELECT COUNT(*) FROM _dineway_review_requests WHERE collection = ${built.collection} AND entry_id = ${built.entryId} AND status = 'rejected') = ${rejected.length}`, ...rejected.map((row) => rowUnchanged("_dineway_review_requests", row)));
+	for (const row of rejected) {
+		if (isSupersededReview(row)) continue;
+		if (await buildStableHash(z.object({ diff: z.object({ draft: z.unknown().optional() }).optional() }).parse(JSON.parse(row.review_payload)).diff?.draft) === contentHash) throw new ReviewSubmissionError("This content was rejected. Change it before submitting a new review.");
+	}
+	const approved = await reviews.findApprovedForTarget(built);
+	if (approved) return reuseReview(approved);
+	const pendingQuery = db.selectFrom("_dineway_review_requests").where("collection", "=", built.collection).where("entry_id", "=", built.entryId).where("action_type", "=", built.actionType).where("reviewed_rev", "=", built.reviewedRev).where("action_hash", "=", built.actionHash).where("status", "=", "pending").where("revoked_at", "is", null);
+	const pending = await pendingQuery.selectAll().orderBy("created_at").orderBy("id").executeTakeFirst();
+	checks.push(pending ? rowUnchanged("_dineway_review_requests", pending) : sql`NOT EXISTS ${pendingQuery.select("id")}`);
+	const prepared = pending ? null : reviews.prepareCreate({
+		...built,
+		riskReason: input.riskReason,
+		requestedByActorType: input.actor.actorType,
+		requestedByActorId: input.actor.actorId,
+		requestedAuthMetadata: input.actor.authMetadata
+	});
+	const reviewId = pending?.id ?? prepared.id;
+	const supersession = await prepareSupersession();
+	checks.push(...supersession.checks);
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const job = db.insertInto("_dineway_review_jobs").values({
+		review_id: reviewId,
+		target_key: targetKey,
+		content_hash: contentHash,
+		state: "queued",
+		release_state: "none",
+		evidence_json: null,
+		reason: "Automated review in progress",
+		release_reason: null,
+		scheduled_at: scheduledAt,
+		created_at: now,
+		updated_at: now
+	}).compile();
+	return {
+		id: reviewId,
+		targetKey,
+		created: !pending,
+		batch: {
+			checks,
+			statements: [
+				...projectedGuard,
+				...supersession.statements,
+				...prepared ? [prepared.statement] : [],
+				job
+			]
+		}
+	};
+}
+async function submitAutomatedReview(db, handlers, input) {
+	let prepared = await prepareAutomatedReview(db, handlers, input);
+	try {
+		await atomicBatch(db, prepared.batch);
+	} catch (error) {
+		if (!(error instanceof AtomicWriteConflict)) throw error;
+		const existing = await prepareAutomatedReview(db, handlers, input);
+		if (existing.created || existing.targetKey !== prepared.targetKey) throw error;
+		await atomicBatch(db, existing.batch);
+		prepared = existing;
+	}
+	return {
+		item: await new ReviewRequestRepository(db).findById(prepared.id),
+		created: prepared.created
+	};
+}
+
+//#endregion
+export { prepareContentWrite as i, prepareAutomatedReview as n, submitAutomatedReview as r, ReviewSubmissionError as t };

package/dist/{taxonomies-4cnTcbD6.mjs → taxonomies-C5ayPp3T.mjs}

@@ -1,6 +1,6 @@
 import { c as __exportAll } from "./runner-CVeq0266.mjs";
 import { t as TaxonomyRepository } from "./taxonomy-DWxxLpp5.mjs";
-import { c as invalidateTaxonomyDefsCache, l as invalidateTermCache } from "./taxonomies-CllxqaH0.mjs";
+import { c as invalidateTaxonomyDefsCache, l as invalidateTermCache } from "./taxonomies-DW6Fps-w.mjs";
 import { ulid } from "ulidx";
 
 //#region src/api/handlers/taxonomies.ts

package/dist/{taxonomies-CllxqaH0.mjs → taxonomies-DW6Fps-w.mjs}

@@ -4,7 +4,7 @@ import { a as resetTaxonomyNamesCache, o as isMissingTableError, r as getDb } fr
 import { d as invalidateTaxonomyObjectCache, f as isObjectCacheActive, n as cachedQuery, t as CacheNamespace } from "./object-cache-BGjIlY9s.mjs";
 import { n as chunks, t as SQL_BATCH_SIZE } from "./chunks-BnG3LPMN.mjs";
 import { i as setRequestCacheEntry, n as peekRequestCache, r as requestCached } from "./request-cache-DPmV5nk4.mjs";
-import { n as resolveLocaleChain, t as resolveLocale } from "./resolve-C80Pm2DW.mjs";
+import { n as resolveLocaleChain, t as resolveLocale } from "./resolve-CpOV2jt_.mjs";
 
 //#region src/taxonomies/index.ts
 /**
@@ -393,7 +393,7 @@ function primeFoldedEntryTerms(collection, perEntry, options = {}) {
 * Get entries by term.
 */
 async function getEntriesByTerm(collection, taxonomyName, termSlug, options = {}) {
-	const { getDinewayCollection } = await import("./query-CEn9HXnf.mjs").then((n) => n.o);
+	const { getDinewayCollection } = await import("./query-D6oNo9iz.mjs").then((n) => n.o);
 	const queryOptions = { where: { [taxonomyName]: termSlug } };
 	if (options.locale !== void 0) queryOptions.locale = options.locale;
 	const { entries } = await getDinewayCollection(collection, queryOptions);

package/dist/{trusted-proxy-CAW9o4Dw.mjs → trusted-proxy-CvDP0g0F.mjs}

@@ -1,4 +1,4 @@
-import { t as readRuntimeEnv } from "./runtime-env-CQVAWHzH.mjs";
+import { t as readRuntimeEnv } from "./runtime-env-v-1UXPAH.mjs";
 
 //#region src/auth/trusted-proxy.ts
 /**

package/dist/{types-CFgTpfPk.d.mts → types-BFoQ5a1v.d.mts}

@@ -1,4 +1,4 @@
-import { c as CustomFieldValue } from "./types-Bs-7Geuh.mjs";
+import { c as CustomFieldValue } from "./types-1qU0-N1P.mjs";
 
 //#region src/database/repositories/types.d.ts
 interface CreateContentInput {