dineway 0.2.33 → 0.2.35

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-C7prIbCo.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 { r as submitAutomatedReview, t as ReviewSubmissionError } from "./submission-BLvkvewK.mjs";
 
 //#region src/api/handlers/review-requests.ts
 async function handleReviewRequestCreate(db, handlers, input) {

package/dist/{review-route-helpers-DaZBBps8.mjs → review-route-helpers-BYx3Px90.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-CiFN61xq.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-DZ8e4JCS.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 };