dineway 0.2.32 → 0.2.34

package/dist/request-context.d.mts

@@ -1,4 +1,6 @@
 import { QueryRecorder } from "./database/instrumentation.mjs";
+import { Kysely, RawBuilder } from "kysely";
+import { RoleLevel } from "@dineway-ai/auth";
 
 //#region src/request-context.d.ts
 /**
@@ -18,6 +20,12 @@ interface RequestMetrics {
 }
 declare function createRequestMetrics(start: number): RequestMetrics;
 interface DinewayRequestContext {
+  writePrincipal?: {
+    id: string;
+    role: RoleLevel;
+  };
+  /** Native route authorization, rechecked inside the same commit as writes. */
+  prepareWriteChecks?: <DB>(db: Kysely<DB>) => Promise<readonly RawBuilder<boolean>[]>;
   /** Publication notifications are released only after the owning transaction commits. */
   afterPublicationCommit?: Array<() => void>;
   /** Whether the current request is in visual editing mode */

package/dist/{request-meta-BW0the1R.mjs → request-meta-BOcuHAXD.mjs}

@@ -1,4 +1,4 @@
-import { n as normalizeTrustedHeaders, t as getTrustedProxyHeaders } from "./trusted-proxy-CdEl6g6B.mjs";
+import { n as normalizeTrustedHeaders, t as getTrustedProxyHeaders } from "./trusted-proxy-CAW9o4Dw.mjs";
 
 //#region src/plugins/request-meta.ts
 /**

package/dist/{resolve-pZ4NQM-X.mjs → resolve-C80Pm2DW.mjs}

@@ -1,5 +1,5 @@
-import { n as getI18nConfig, r as isI18nEnabled, t as getFallbackChain } from "./config-CVssduLe.mjs";
 import { getRequestContext } from "./request-context.mjs";
+import { n as getI18nConfig, r as isI18nEnabled, t as getFallbackChain } from "./config-XW5tMrH8.mjs";
 
 //#region src/i18n/resolve.ts
 /**

package/dist/{review-payload-f1L4lzQg.mjs → review-payload-DEylbssM.mjs}

@@ -1,5 +1,52 @@
-import { n as stableStringify, t as buildStableHash } from "./stable-hash-DF7R5eN8.mjs";
+import { r as encodeBase64, t as decodeBase64 } from "./base64-Cz-aU0X1.mjs";
+import { n as stableStringify, t as buildStableHash } from "./stable-hash-DEtJgcp7.mjs";
 
+//#region src/api/rev.ts
+/**
+* Generate a _rev token from a content item's version and updatedAt.
+*/
+function encodeRev(item) {
+	return encodeBase64(`${item.version}:${item.updatedAt}`);
+}
+/**
+* Decode a _rev token into its components.
+* Returns null if the token is malformed.
+*/
+function decodeRev(rev) {
+	try {
+		const decoded = decodeBase64(rev);
+		const colonIdx = decoded.indexOf(":");
+		if (colonIdx === -1) return null;
+		const version = parseInt(decoded.slice(0, colonIdx), 10);
+		const updatedAt = decoded.slice(colonIdx + 1);
+		if (isNaN(version) || !updatedAt) return null;
+		return {
+			version,
+			updatedAt
+		};
+	} catch {
+		return null;
+	}
+}
+/**
+* Validate a _rev token against a content item.
+* Returns null if valid (or if no _rev provided), or an error message if invalid.
+*/
+function validateRev(rev, item) {
+	if (!rev) return { valid: true };
+	const decoded = decodeRev(rev);
+	if (!decoded) return {
+		valid: false,
+		message: "Malformed _rev token"
+	};
+	if (decoded.version !== item.version || decoded.updatedAt !== item.updatedAt) return {
+		valid: false,
+		message: "Content has been modified since last read (version conflict)"
+	};
+	return { valid: true };
+}
+
+//#endregion
 //#region src/site-context/action-hash.ts
 async function buildStableActionHash(value) {
 	return buildStableHash(value);
@@ -17,6 +64,7 @@ var ReviewPayloadBuilder = class {
 		const compare = await this.loadCompare(input.collection, content.entryId);
 		const live = asRecord(compare.live);
 		const draft = asRecord(compare.draft) ?? content.data;
+		const displayTitle = stringOrNull(draft.title) ?? content.displayTitle;
 		const hasChanges = typeof compare.hasChanges === "boolean" ? compare.hasChanges : stableStringify(live) !== stableStringify(draft);
 		const actionHash = await buildStableActionHash({
 			actionType,
@@ -29,7 +77,7 @@ var ReviewPayloadBuilder = class {
 			draft
 		});
 		const scope = `content:${input.collection}:${content.entryId}`;
-		const summary = input.summary ?? `Review ${actionType} for ${input.collection}/${content.displayTitle ?? content.entryId}`;
+		const summary = input.summary ?? `Review ${actionType} for ${input.collection}/${displayTitle ?? content.entryId}`;
 		return {
 			collection: input.collection,
 			entryId: content.entryId,
@@ -56,7 +104,7 @@ var ReviewPayloadBuilder = class {
 					id: content.entryId,
 					slug: content.slug,
 					status: content.status,
-					title: content.displayTitle,
+					title: displayTitle,
 					updatedAt: content.updatedAt
 				},
 				diff: {
@@ -108,4 +156,4 @@ function stringOrNull(value) {
 }
 
 //#endregion
-export { buildStableActionHash as n, ReviewPayloadBuilder as t };
+export { validateRev as a, encodeRev as i, buildStableActionHash as n, decodeRev as r, ReviewPayloadBuilder as t };

package/dist/{review-requests-DICrYH2-.mjs → review-requests-BF2eEKr8.mjs}

@@ -1,5 +1,7 @@
-import { i as encodeCursor, r as decodeCursor } from "./types-BpSTdH1H.mjs";
-import { t as buildStableHash } from "./stable-hash-DF7R5eN8.mjs";
+import { AtomicWriteConflict, atomicBatch, rowUnchanged } from "./database/batch.mjs";
+import { i as encodeCursor, r as decodeCursor } from "./types-BqxIv8Il.mjs";
+import { t as buildStableHash } from "./stable-hash-DEtJgcp7.mjs";
+import { sql } from "kysely";
 import { ulid } from "ulidx";
 
 //#region src/database/repositories/review-requests.ts
@@ -8,15 +10,25 @@ var RejectedReviewContentError = class extends Error {
 		super("This content was rejected. Change the content before approving a new review.");
 	}
 };
-var ReviewRequestRepository = class ReviewRequestRepository {
+const REVIEW_SUPERSESSION_ACTOR = "review-supersession";
+function isSupersededReview(row) {
+	return row.resolved_by_actor_type === "system" && row.resolved_by_actor_id === REVIEW_SUPERSESSION_ACTOR;
+}
+var ReviewRequestRepository = class {
 	constructor(db) {
 		this.db = db;
 	}
-	async create(input) {
+	prepareCreate(input) {
 		const id = ulid();
-		const now = (/* @__PURE__ */ new Date()).toISOString();
-		await this.db.insertInto("_dineway_review_requests").values(toInsertableReviewRequest(id, input, now)).execute();
-		const request = await this.findById(id);
+		return {
+			id,
+			statement: this.db.insertInto("_dineway_review_requests").values(toInsertableReviewRequest(id, input, (/* @__PURE__ */ new Date()).toISOString())).compile()
+		};
+	}
+	async create(input) {
+		const prepared = this.prepareCreate(input);
+		await this.db.executeQuery(prepared.statement);
+		const request = await this.findById(prepared.id);
 		if (!request) throw new Error("Failed to create review request");
 		return request;
 	}
@@ -63,38 +75,81 @@ var ReviewRequestRepository = class ReviewRequestRepository {
 		const result = await query.executeTakeFirst();
 		return Number(result?.count ?? 0);
 	}
-	async resolve(id, input) {
-		if (!this.db.isTransaction) return this.db.transaction().execute((trx) => new ReviewRequestRepository(trx).resolve(id, input));
-		if (input.decision === "approved") {
-			const target = await this.findById(id);
-			if (!target || target.status !== "pending") return null;
-			const diff = target.reviewPayload.diff;
-			if (isRecord(diff) && isRecord(diff.draft)) {
-				const hash = await buildStableHash(diff.draft);
-				const rejected = await this.db.selectFrom("_dineway_review_requests").select("review_payload").where("collection", "=", target.collection).where("entry_id", "=", target.entryId).where("status", "=", "rejected").execute();
-				for (const row of rejected) {
-					const priorDiff = parseRecord(row.review_payload)?.diff;
-					if (isRecord(priorDiff) && isRecord(priorDiff.draft) && await buildStableHash(priorDiff.draft) === hash) throw new RejectedReviewContentError();
-				}
+	async rejectionChecks(target) {
+		const checks = [];
+		const diff = target.reviewPayload.diff;
+		if (isRecord(diff) && isRecord(diff.draft)) {
+			const hash = await buildStableHash(diff.draft);
+			const rejected = await this.db.selectFrom("_dineway_review_requests").select([
+				"id",
+				"status",
+				"review_payload",
+				"resolved_by_actor_type",
+				"resolved_by_actor_id"
+			]).where("collection", "=", target.collection).where("entry_id", "=", target.entryId).where("status", "=", "rejected").execute();
+			checks.push(sql`(SELECT COUNT(*) FROM _dineway_review_requests WHERE collection = ${target.collection} AND entry_id = ${target.entryId} AND status = 'rejected') = ${rejected.length}`, ...rejected.map((rejectedRow) => rowUnchanged("_dineway_review_requests", rejectedRow)));
+			for (const rejectedRow of rejected) {
+				if (isSupersededReview(rejectedRow)) continue;
+				const priorDiff = parseRecord(rejectedRow.review_payload)?.diff;
+				if (isRecord(priorDiff) && isRecord(priorDiff.draft) && await buildStableHash(priorDiff.draft) === hash) throw new RejectedReviewContentError();
 			}
 		}
+		return checks;
+	}
+	async prepareCreateApproved(input, resolution) {
+		const now = resolution.resolvedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+		const row = {
+			...toInsertableReviewRequest(ulid(), input, now),
+			status: "approved",
+			resolved_by_actor_type: resolution.resolvedByActorType,
+			resolved_by_actor_id: resolution.resolvedByActorId,
+			resolved_auth_metadata: jsonOrNull(resolution.resolvedAuthMetadata),
+			review_note: resolution.reviewNote ?? null,
+			resolved_at: now
+		};
+		const review = rowToReviewRequest(row);
+		return {
+			review,
+			batch: {
+				checks: await this.rejectionChecks(review),
+				statements: [this.db.insertInto("_dineway_review_requests").values(row).compile()]
+			}
+		};
+	}
+	async prepareResolve(id, input) {
+		const row = await this.db.selectFrom("_dineway_review_requests").selectAll().where("id", "=", id).executeTakeFirst();
+		if (!row || row.status !== "pending" || row.revoked_at) return null;
+		const target = rowToReviewRequest(row);
+		const checks = [rowUnchanged("_dineway_review_requests", row)];
+		if (input.decision === "approved") checks.push(...await this.rejectionChecks(target));
 		const resolvedAt = input.resolvedAt ?? (/* @__PURE__ */ new Date()).toISOString();
-		const result = await this.db.updateTable("_dineway_review_requests").set({
-			status: input.decision,
-			resolved_by_actor_type: input.resolvedByActorType,
-			resolved_by_actor_id: input.resolvedByActorId,
-			resolved_auth_metadata: jsonOrNull(input.resolvedAuthMetadata),
-			review_note: input.reviewNote ?? null,
-			resolved_at: resolvedAt,
-			updated_at: resolvedAt
-		}).where("id", "=", id).where("status", "=", "pending").executeTakeFirst();
-		if (Number(result.numUpdatedRows ?? 0) === 0) return null;
-		await this.db.updateTable("_dineway_review_jobs").set({
-			state: "complete",
-			release_state: input.decision === "approved" ? "queued" : "none",
-			reason: input.reviewNote ?? "Resolved by reviewer",
-			updated_at: resolvedAt
-		}).where("review_id", "=", id).execute();
+		return {
+			checks,
+			statements: [this.db.updateTable("_dineway_review_requests").set({
+				status: input.decision,
+				resolved_by_actor_type: input.resolvedByActorType,
+				resolved_by_actor_id: input.resolvedByActorId,
+				resolved_auth_metadata: jsonOrNull(input.resolvedAuthMetadata),
+				review_note: input.reviewNote ?? null,
+				resolved_at: resolvedAt,
+				updated_at: resolvedAt
+			}).where("id", "=", id).where("status", "=", "pending").compile(), this.db.updateTable("_dineway_review_jobs").set({
+				state: "complete",
+				release_state: input.decision === "approved" ? "queued" : "none",
+				reason: input.reviewNote ?? "Resolved by reviewer",
+				updated_at: resolvedAt
+			}).where("review_id", "=", id).compile()]
+		};
+	}
+	async resolve(id, input) {
+		const prepared = await this.prepareResolve(id, input);
+		if (!prepared) return null;
+		try {
+			await atomicBatch(this.db, prepared);
+		} catch (error) {
+			if (error instanceof AtomicWriteConflict) return null;
+			throw error;
+		}
 		return this.findById(id);
 	}
 	async findApprovedForTarget(target) {
@@ -138,6 +193,7 @@ var ReviewRequestRepository = class ReviewRequestRepository {
 function toInsertableReviewRequest(id, input, now) {
 	return {
 		id,
+		revoked_at: null,
 		status: "pending",
 		collection: input.collection,
 		entry_id: input.entryId,
@@ -208,4 +264,4 @@ function clampLimit(value) {
 }
 
 //#endregion
-export { ReviewRequestRepository as n, RejectedReviewContentError as t };
+export { isSupersededReview as i, RejectedReviewContentError as n, ReviewRequestRepository as r, REVIEW_SUPERSESSION_ACTOR as t };

package/dist/{review-requests-BTKfeWlS.mjs → review-requests-CyfWbJ6W.mjs}

@@ -1,5 +1,5 @@
-import { n as ReviewRequestRepository, t as RejectedReviewContentError } from "./review-requests-DICrYH2-.mjs";
-import { n as submitAutomatedReview, t as ReviewSubmissionError } from "./submission-C47cHBIg.mjs";
+import { n as RejectedReviewContentError, r as ReviewRequestRepository } from "./review-requests-BF2eEKr8.mjs";
+import { n as submitAutomatedReview, t as ReviewSubmissionError } from "./submission-BsHNfHc7.mjs";
 
 //#region src/api/handlers/review-requests.ts
 async function handleReviewRequestCreate(db, handlers, input) {

package/dist/{review-route-helpers-DaZBBps8.mjs → review-route-helpers-lKA-CXms.mjs}

@@ -1,5 +1,5 @@
-import { n as resolveActorIdentity } from "./actor-DrJJsvy6.mjs";
-import { p as logSiteActivitySafely } from "./activity-events-BVo9rMUz.mjs";
+import { i as resolveActorIdentity } from "./actor-DxUAJgQX.mjs";
+import { p as logSiteActivitySafely } from "./activity-events-D-yGV7cW.mjs";
 
 //#region src/api/review-route-helpers.ts
 function resolveReviewRouteActor(locals) {

package/dist/{revision-De7OmYVD.mjs → revision-090sZyGc.mjs}

@@ -1,4 +1,4 @@
-import { t as validateIdentifier } from "./validate-VPnKoIzW.mjs";
+import { t as validateIdentifier } from "./validate-Co3j6T_K.mjs";
 import { sql } from "kysely";
 import { monotonicFactory } from "ulidx";
 
@@ -17,17 +17,26 @@ var RevisionRepository = class {
 	/**
 	* Create a new revision
 	*/
-	async create(input) {
+	prepareCreateSnapshot(input) {
 		const id = monotonic();
-		const row = {
+		return {
 			id,
-			collection: input.collection,
-			entry_id: input.entryId,
-			data: JSON.stringify(input.data),
-			author_id: input.authorId ?? null
+			statement: this.db.insertInto("revisions").values({
+				id,
+				collection: input.collection,
+				entry_id: input.entryId,
+				data: input.data,
+				author_id: input.authorId ?? null
+			}).compile()
 		};
-		await this.db.insertInto("revisions").values(row).execute();
-		const revision = await this.findById(id);
+	}
+	async create(input) {
+		const prepared = this.prepareCreateSnapshot({
+			...input,
+			data: sql`${JSON.stringify(input.data)}`
+		});
+		await this.db.executeQuery(prepared.statement);
+		const revision = await this.findById(prepared.id);
 		if (!revision) throw new Error("Failed to create revision");
 		return revision;
 	}
@@ -75,21 +84,18 @@ var RevisionRepository = class {
 	* referenced by the content entry's live or draft pointers.
 	*/
 	async pruneOldRevisions(collection, entryId, keepCount) {
-		const keep = await this.db.selectFrom("revisions").select("id").where("collection", "=", collection).where("entry_id", "=", entryId).orderBy("created_at", "desc").orderBy("id", "desc").limit(keepCount).execute();
-		const keepIds = new Set(keep.map((r) => r.id));
-		if (keepIds.size === 0) return 0;
-		if (await this.db.selectFrom("_dineway_collections").select("slug").where("slug", "=", collection).executeTakeFirst()) {
+		if (keepCount <= 0) return 0;
+		const registeredCollection = await this.db.selectFrom("_dineway_collections").select("slug").where("slug", "=", collection).executeTakeFirst();
+		const latest = this.db.selectFrom("revisions").select("id").where("collection", "=", collection).where("entry_id", "=", entryId).orderBy("created_at", "desc").orderBy("id", "desc").limit(keepCount);
+		let query = this.db.deleteFrom("revisions").where("collection", "=", collection).where("entry_id", "=", entryId).where("id", "not in", latest);
+		if (registeredCollection) {
 			validateIdentifier(collection, "collection slug");
-			const tableName = `ec_${collection}`;
-			const row = (await sql`
-				SELECT live_revision_id, draft_revision_id
-				FROM ${sql.ref(tableName)}
-				WHERE id = ${entryId}
-			`.execute(this.db)).rows[0];
-			if (row?.live_revision_id) keepIds.add(row.live_revision_id);
-			if (row?.draft_revision_id) keepIds.add(row.draft_revision_id);
+			query = query.where(sql`NOT EXISTS (
+				SELECT 1 FROM ${sql.table(`ec_${collection}`)} AS content WHERE content.id = ${entryId}
+				AND (content.live_revision_id = revisions.id OR content.draft_revision_id = revisions.id)
+			)`);
 		}
-		const result = await this.db.deleteFrom("revisions").where("collection", "=", collection).where("entry_id", "=", entryId).where("id", "not in", [...keepIds]).executeTakeFirst();
+		const result = await query.executeTakeFirst();
 		return Number(result.numDeletedRows ?? 0);
 	}
 	/**

package/dist/revocation-B7GL5fMl.mjs

@@ -0,0 +1,53 @@
+import { AtomicWriteConflict, atomicBatch, rowUnchanged } from "./database/batch.mjs";
+import { t as SiteActivityRepository } from "./site-activity-BrN2NviL.mjs";
+import { r as ReviewRequestRepository } from "./review-requests-BF2eEKr8.mjs";
+import { sql } from "kysely";
+
+//#region src/review-automation/revocation.ts
+async function revokeReview(db, id, actor, reason, sourceType = "api_route") {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const original = await db.selectFrom("_dineway_review_requests").selectAll().where("id", "=", id).where("status", "=", "approved").where("revoked_at", "is", null).executeTakeFirst();
+	if (!original) return null;
+	const statements = [
+		db.updateTable("_dineway_review_requests").set({
+			revoked_at: now,
+			updated_at: now
+		}).where("id", "=", id).where("status", "=", "approved").where("revoked_at", "is", null).compile(),
+		db.updateTable("_dineway_review_jobs").set({
+			target_key: `revoked:${id}`,
+			release_state: sql`CASE WHEN release_state = 'published' THEN 'published' ELSE 'blocked' END`,
+			release_reason: `Approval revoked: ${reason}`,
+			updated_at: now
+		}).where("review_id", "=", id).compile(),
+		db.updateTable("_dineway_content_release_grants").set({
+			status: "revoked",
+			revoked_at: now,
+			revocation_reason: reason,
+			updated_at: now
+		}).where("editorial_review_request_id", "=", id).where("status", "=", "active").compile()
+	];
+	statements.push(new SiteActivityRepository(db).prepareCreate({
+		...actor,
+		actionType: "review.revoked",
+		subjectType: "review_request",
+		subjectId: id,
+		scope: original.scope,
+		summary: "Revoked editorial approval",
+		detail: { reason },
+		sourceType,
+		sourceName: "review-revoke"
+	}).statement);
+	try {
+		await atomicBatch(db, {
+			checks: [rowUnchanged("_dineway_review_requests", original)],
+			statements
+		});
+	} catch (error) {
+		if (error instanceof AtomicWriteConflict) return null;
+		throw error;
+	}
+	return new ReviewRequestRepository(db).findById(id);
+}
+
+//#endregion
+export { revokeReview as t };