dineway 0.2.40 → 0.2.42

package/dist/submission-DJmRejGR.mjs

@@ -1,411 +0,0 @@
-import { AtomicWriteConflict, atomicBatch, prepareAtomicChecks, rowUnchanged } from "./database/batch.mjs";
-import { r as isI18nEnabled } from "./config-XW5tMrH8.mjs";
-import { t as DinewayValidationError } from "./types-RFzE_V1M.mjs";
-import { t as contentWriteChecks } from "./atomic-authority-CnBQJ14T.mjs";
-import { o as invalidateCollectionCache } from "./object-cache-mxCW-Rpt.mjs";
-import { t as RevisionRepository } from "./revision-W6FDfDqx.mjs";
-import { t as ContentRepository } from "./content-CIKsrvU9.mjs";
-import { t as buildStableHash } from "./stable-hash-B9Tbb2f_.mjs";
-import { i as isSupersededReview, r as ReviewRequestRepository, t as REVIEW_SUPERSESSION_ACTOR } from "./review-requests-CUVn0RBl.mjs";
-import { t as RedirectRepository } from "./redirect-BQFa1THe.mjs";
-import { i as invalidateRedirectCache } from "./cache-B5NSHhxG.mjs";
-import { D as validateMediaFields, E as validateContentDataFields, T as prepareNonTranslatableFields, k as encodeRev, r as contentWriteConfiguration, t as ReviewPayloadBuilder } from "./review-payload-Bap86e75.mjs";
-import { i as reviewDraft } from "./evidence-Vnp_fQbC.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/version-CISd4wX_.mjs

@@ -1,6 +0,0 @@
-//#region src/version.ts
-const VERSION = "0.2.40";
-const COMMIT = "a7e28ecbe";
-
-//#endregion
-export { VERSION as n, COMMIT as t };