dineway 0.2.33 → 0.2.35

package/dist/{content-CVCrcuvD.mjs → content-D9xKUSno.mjs}

@@ -1,15 +1,21 @@
-import { a as __exportAll } from "./runner-DJiRFyLI.mjs";
-import { t as validateIdentifier } from "./validate-VPnKoIzW.mjs";
-import { i as encodeCursor, n as ScheduledNotDueError, r as decodeCursor, t as DinewayValidationError } from "./types-BpSTdH1H.mjs";
-import { o as invalidateCollectionCache } from "./object-cache-D51qOseS.mjs";
-import { n as slugify } from "./slugify-KSsVD_D3.mjs";
-import { t as RevisionRepository } from "./revision-De7OmYVD.mjs";
+import { c as __exportAll } from "./runner-CVeq0266.mjs";
+import { atomicBatch, isD1Database, rowUnchanged } from "./database/batch.mjs";
+import { t as validateIdentifier } from "./validate-Co3j6T_K.mjs";
+import { o as isPostgres } from "./dialect-helpers-C6xtO-Ui.mjs";
+import { i as encodeCursor, n as ScheduledNotDueError, r as decodeCursor, 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 { n as slugify } from "./slugify-Di8Q_MFq.mjs";
+import { t as RevisionRepository } from "./revision-090sZyGc.mjs";
 import { sql } from "kysely";
 import { ulid } from "ulidx";
 
 //#region src/database/repositories/content.ts
 var content_exports = /* @__PURE__ */ __exportAll({ ContentRepository: () => ContentRepository });
 const ULID_PATTERN = /^[0-9A-Z]{26}$/;
+const NUMERIC_TEXT = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/;
+const BLOB_AFFINITY = /BLOB/i;
+const TEXT_AFFINITY = /TEXT|CHAR|CLOB/i;
 const LIKE_WILDCARD_RE = /[\\%_]/g;
 const DATE_FILTER_COLUMNS = {
 	createdAt: "created_at",
@@ -54,6 +60,17 @@ function serializeValue(value) {
 	if (typeof value === "object") return JSON.stringify(value);
 	return value;
 }
+function normalizeAffinity(value, type) {
+	if (value === null || value === void 0) return null;
+	if (TEXT_AFFINITY.test(type)) return typeof value === "number" ? String(value) : value;
+	if (!type || BLOB_AFFINITY.test(type)) return value;
+	if (typeof value === "string" && NUMERIC_TEXT.test(value.trim())) {
+		const number = Number(value);
+		if (!Number.isFinite(number) || Number.isInteger(number) && !Number.isSafeInteger(number)) throw new DinewayValidationError("Numeric content must fit the supported JavaScript precision.");
+		return number;
+	}
+	return value;
+}
 /**
 * Deserialize a value from database storage
 * Attempts to parse JSON strings that look like objects/arrays
@@ -86,20 +103,30 @@ var ContentRepository = class {
 	constructor(db) {
 		this.db = db;
 	}
+	async normalizePreparedData(type, data) {
+		if (isPostgres(this.db)) return data;
+		const columns = await sql`SELECT name,type FROM pragma_table_info(${getTableName(type)})`.execute(this.db);
+		return Object.fromEntries(Object.entries(data).map(([name, value]) => {
+			const column = columns.rows.find((candidate) => candidate.name === name);
+			return [name, deserializeValue(column ? normalizeAffinity(serializeValue(value), column.type) : value)];
+		}));
+	}
 	/**
 	* Create a new content item
 	*/
-	async create(input) {
+	async prepareCreate(input, options = {}) {
 		const id = ulid();
 		const now = (/* @__PURE__ */ new Date()).toISOString();
 		const { type, slug, data, status = "draft", authorId, primaryBylineId, locale, translationOf, publishedAt, createdAt } = input;
 		if (!type) throw new DinewayValidationError("Content type is required");
 		const tableName = getTableName(type);
+		const checks = [];
 		let translationGroup = id;
 		if (translationOf) {
-			const source = await this.findById(type, translationOf);
+			const source = (await sql`SELECT id, translation_group, deleted_at FROM ${sql.table(tableName)} WHERE id = ${translationOf} AND deleted_at IS NULL`.execute(this.db)).rows[0];
 			if (!source) throw new DinewayValidationError("Translation source content not found");
-			translationGroup = source.translationGroup || source.id;
+			translationGroup = String(source.translation_group || source.id);
+			checks.push(rowUnchanged(tableName, source));
 		}
 		const columns = [
 			"id",
@@ -134,17 +161,84 @@ var ContentRepository = class {
 				values.push(serializeValue(value));
 			}
 		}
+		let item;
+		if (options.captureDefaults) {
+			if (isPostgres(this.db)) throw new Error("Prepared content defaults require SQLite or D1.");
+			const schema = await sql`SELECT m.sql AS definition, p.name, p.type, p.dflt_value FROM sqlite_master m JOIN pragma_table_info(m.name) p WHERE m.name=${tableName} AND m.type='table'`.execute(this.db);
+			const definition = schema.rows[0]?.definition;
+			if (!definition) throw new DinewayValidationError("Content table not found");
+			const expressions = schema.rows.map((column) => {
+				const position = columns.indexOf(column.name);
+				const value = position >= 0 ? sql`${values[position]}` : column.dflt_value === null ? sql`NULL` : sql.raw(column.dflt_value);
+				return (TEXT_AFFINITY.test(column.type) ? sql`CAST(${value} AS TEXT)` : value).as(column.name);
+			});
+			const row = (await sql`SELECT ${sql.join(expressions)}`.execute(this.db)).rows[0];
+			for (const column of schema.rows) row[column.name] = normalizeAffinity(row[column.name], column.type);
+			columns.splice(0, columns.length, ...Object.keys(row));
+			values.splice(0, values.length, ...Object.values(row));
+			checks.push(sql`EXISTS (SELECT 1 FROM sqlite_master WHERE name=${tableName} AND sql=${definition})`);
+			item = this.mapRow(type, row);
+		}
 		const columnRefs = columns.map((c) => sql.ref(c));
 		const valuePlaceholders = values.map((v) => v === null ? sql`NULL` : sql`${v}`);
-		await sql`
+		return {
+			id,
+			item,
+			batch: {
+				checks,
+				statements: [sql`
 				INSERT INTO ${sql.ref(tableName)} (${sql.join(columnRefs, sql`, `)})
 				VALUES (${sql.join(valuePlaceholders, sql`, `)})
-			`.execute(this.db);
-		invalidateCollectionCache(type);
-		const item = await this.findById(type, id);
+			`.compile(this.db)]
+			}
+		};
+	}
+	async create(input) {
+		const prepared = await this.prepareCreate(input);
+		await atomicBatch(this.db, prepared.batch);
+		invalidateCollectionCache(input.type);
+		const item = await this.findById(input.type, prepared.id);
 		if (!item) throw new Error("Failed to create content");
 		return item;
 	}
+	/** Capture database defaults and JSON values from the saved row inside the write batch. */
+	async prepareDraftSnapshot(type, id, authorId) {
+		const tableName = getTableName(type);
+		const checks = [];
+		let snapshot;
+		if (isPostgres(this.db)) snapshot = sql`(SELECT COALESCE(jsonb_object_agg(field.key, field.value), '{}'::jsonb)::text
+ FROM ${sql.table(tableName)} AS entry CROSS JOIN LATERAL jsonb_each(to_jsonb(entry)) AS field(key, value)
+ WHERE entry.id = ${id} AND field.value <> 'null'::jsonb
+ AND field.key NOT IN (${sql.join(Array.from(SYSTEM_COLUMNS, (name) => sql`${name}`))}))`;
+		else {
+			const schema = await sql`
+			SELECT m.sql AS definition, p.name FROM sqlite_master m
+			JOIN pragma_table_info(m.name) p WHERE m.name = ${tableName} AND m.type = 'table'
+		`.execute(this.db);
+			const definition = schema.rows[0]?.definition;
+			if (!definition) throw new DinewayValidationError("Content table not found");
+			const pairs = schema.rows.map((row) => row.name).filter((name) => !SYSTEM_COLUMNS.has(name)).map((name) => {
+				const column = sql.ref(name);
+				return sql`SELECT ${sql.lit(name)} AS name,
+				CASE WHEN typeof(${column}) = 'text' AND substr(${column}, 1, 1) IN ('{', '[') AND json_valid(${column})
+				THEN ${column} ELSE json_quote(${column}) END AS value
+				FROM candidate WHERE ${column} IS NOT NULL`;
+			});
+			snapshot = pairs.length ? sql`(WITH candidate AS (SELECT * FROM ${sql.table(tableName)} WHERE id = ${id})
+				SELECT json_group_object(name, json(value)) FROM (${sql.join(pairs, sql` UNION ALL `)}))` : sql`'{}'`;
+			checks.push(sql`EXISTS (SELECT 1 FROM sqlite_master WHERE name = ${tableName} AND sql = ${definition})`);
+		}
+		const revision = new RevisionRepository(this.db).prepareCreateSnapshot({
+			collection: type,
+			entryId: id,
+			data: snapshot,
+			authorId
+		});
+		return {
+			checks,
+			statements: [revision.statement, sql`UPDATE ${sql.table(tableName)} SET draft_revision_id = ${revision.id}, updated_at = ${(/* @__PURE__ */ new Date()).toISOString()} WHERE id = ${id}`.compile(this.db)]
+		};
+	}
 	/**
 	* Generate a unique slug for a content item within a collection.
 	*
@@ -169,13 +263,15 @@ var ContentRepository = class {
 					LIMIT 1
 				`.execute(this.db)).rows.length === 0) return baseSlug;
 		const pattern = `${baseSlug}-%`;
+		const prefix = `${baseSlug}-`;
+		const prefixMatch = isD1Database(this.db) ? sql`substr(slug, 1, length(${prefix})) = ${prefix}` : sql`slug LIKE ${pattern}`;
 		const candidates = locale ? await sql`
 					SELECT slug FROM ${sql.ref(tableName)}
-					WHERE (slug = ${baseSlug} OR slug LIKE ${pattern})
+					WHERE (slug = ${baseSlug} OR ${prefixMatch})
 					AND locale = ${locale}
 				`.execute(this.db) : await sql`
 					SELECT slug FROM ${sql.ref(tableName)}
-					WHERE slug = ${baseSlug} OR slug LIKE ${pattern}
+					WHERE slug = ${baseSlug} OR ${prefixMatch}
 				`.execute(this.db);
 		let maxSuffix = 0;
 		const suffixPattern = new RegExp(`^${escapeRegExp(baseSlug)}-(\\d+)$`);
@@ -193,21 +289,42 @@ var ContentRepository = class {
 	* Creates a new draft copy with "(Copy)" appended to the title.
 	* A slug is auto-generated from the new title by the handler layer.
 	*/
-	async duplicate(type, id, authorId) {
-		const original = await this.findById(type, id);
-		if (!original) throw new DinewayValidationError("Content item not found");
+	async prepareDuplicate(type, id, authorId) {
+		const snapshot = await this.snapshot(type, id);
+		if (!snapshot) throw new DinewayValidationError("Content item not found");
+		const original = snapshot.item;
 		const newData = { ...original.data };
 		if (typeof newData.title === "string") newData.title = `${newData.title} (Copy)`;
 		else if (typeof newData.name === "string") newData.name = `${newData.name} (Copy)`;
 		const slugSource = typeof newData.title === "string" ? newData.title : typeof newData.name === "string" ? newData.name : null;
 		const slug = slugSource ? await this.generateUniqueSlug(type, slugSource, original.locale ?? void 0) : null;
-		return this.create({
+		const prepared = await this.prepareCreate({
 			type,
 			slug,
 			data: newData,
 			status: "draft",
-			authorId: authorId || original.authorId || void 0
+			authorId: authorId || original.authorId || void 0,
+			locale: original.locale ?? void 0
 		});
+		return {
+			id: prepared.id,
+			batch: {
+				checks: [
+					snapshot.check,
+					...contentWriteChecks(type, id, "edit"),
+					...prepared.batch.checks ?? []
+				],
+				statements: prepared.batch.statements
+			}
+		};
+	}
+	async duplicate(type, id, authorId) {
+		const prepared = await this.prepareDuplicate(type, id, authorId);
+		await atomicBatch(this.db, prepared.batch);
+		invalidateCollectionCache(type);
+		const item = await this.findById(type, prepared.id);
+		if (!item) throw new Error("Failed to reload duplicate");
+		return item;
 	}
 	/**
 	* Find content by ID
@@ -343,10 +460,10 @@ var ContentRepository = class {
 	/**
 	* Update content
 	*/
-	async update(type, id, input) {
+	prepareUpdate(type, id, input, now = (/* @__PURE__ */ new Date()).toISOString()) {
 		const tableName = getTableName(type);
 		const updates = {
-			updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+			updated_at: now,
 			version: sql`version + 1`
 		};
 		if (input.status !== void 0) updates.status = input.status;
@@ -361,7 +478,21 @@ var ContentRepository = class {
 				updates[key] = serializeValue(value);
 			}
 		}
-		await this.db.updateTable(tableName).set(updates).where("id", "=", id).where("deleted_at", "is", null).execute();
+		return this.db.updateTable(tableName).set(updates).where("id", "=", id).where("deleted_at", "is", null).compile();
+	}
+	async snapshot(type, id, includeTrashed = false) {
+		const row = (await sql`SELECT * FROM ${sql.table(getTableName(type))} WHERE id = ${id} AND ${includeTrashed ? sql`true` : sql`deleted_at IS NULL`}`.execute(this.db)).rows[0];
+		return row ? {
+			item: this.mapRow(type, row),
+			deleted: row.deleted_at !== null,
+			check: rowUnchanged(getTableName(type), row)
+		} : null;
+	}
+	async update(type, id, input) {
+		await atomicBatch(this.db, {
+			checks: contentWriteChecks(type, id, "edit"),
+			statements: [this.prepareUpdate(type, id, input)]
+		});
 		invalidateCollectionCache(type);
 		const updated = await this.findById(type, id);
 		if (!updated) throw new Error("Content not found");
@@ -370,15 +501,22 @@ var ContentRepository = class {
 	/**
 	* Delete content (soft delete - moves to trash)
 	*/
-	async delete(type, id) {
+	prepareDelete(type, id) {
 		const tableName = getTableName(type);
 		const now = (/* @__PURE__ */ new Date()).toISOString();
-		const changed = ((await sql`
+		return {
+			checks: contentWriteChecks(type, id, "delete"),
+			statements: [sql`
 			UPDATE ${sql.ref(tableName)}
 			SET deleted_at = ${now}
 			WHERE id = ${id}
 			AND deleted_at IS NULL
-		`.execute(this.db)).numAffectedRows ?? 0n) > 0n;
+		`.compile(this.db)]
+		};
+	}
+	async delete(type, id) {
+		const [result] = await atomicBatch(this.db, this.prepareDelete(type, id));
+		const changed = (result?.numAffectedRows ?? 0n) > 0n;
 		if (changed) invalidateCollectionCache(type);
 		return changed;
 	}
@@ -387,13 +525,17 @@ var ContentRepository = class {
 	*/
 	async restore(type, id) {
 		const tableName = getTableName(type);
-		const restored = (await sql`
+		const [result] = await atomicBatch(this.db, {
+			checks: contentWriteChecks(type, id, "edit"),
+			statements: [sql`
 			UPDATE ${sql.ref(tableName)}
 			SET deleted_at = NULL
 			WHERE id = ${id}
 			AND deleted_at IS NOT NULL
 			RETURNING *
-		`.execute(this.db)).rows[0];
+		`.compile(this.db)]
+		});
+		const restored = result?.rows[0];
 		if (!restored) return null;
 		invalidateCollectionCache(type);
 		return this.mapRow(type, restored);
@@ -403,11 +545,15 @@ var ContentRepository = class {
 	*/
 	async permanentDelete(type, id) {
 		const tableName = getTableName(type);
-		const changed = ((await sql`
+		const [result] = await atomicBatch(this.db, {
+			checks: contentWriteChecks(type, id, "permanent"),
+			statements: [sql`
 			DELETE FROM ${sql.ref(tableName)}
 			WHERE id = ${id}
 			AND deleted_at IS NOT NULL
-		`.execute(this.db)).numAffectedRows ?? 0n) > 0n;
+		`.compile(this.db)]
+		});
+		const changed = (result?.numAffectedRows ?? 0n) > 0n;
 		if (changed) invalidateCollectionCache(type);
 		return changed;
 	}
@@ -488,7 +634,7 @@ var ContentRepository = class {
 		const pattern = `%${term.replace(LIKE_WILDCARD_RE, (character) => `\\${character}`)}%`;
 		return query.where((eb) => eb.or(columns.map((column) => {
 			validateIdentifier(column, "search column");
-			return eb(sql`lower(${sql.ref(column)})`, "like", sql`lower(${pattern}) escape '\\'`);
+			return isD1Database(this.db) ? sql`instr(lower(${sql.ref(column)}), lower(${term})) > 0` : eb(sql`lower(${sql.ref(column)})`, "like", sql`lower(${pattern}) escape '\\'`);
 		})));
 	}
 	applyDateFilter(query, where) {
@@ -528,17 +674,20 @@ var ContentRepository = class {
 		const scheduledDate = new Date(scheduledAt);
 		if (isNaN(scheduledDate.getTime())) throw new DinewayValidationError("Invalid scheduled date");
 		if (scheduledDate <= /* @__PURE__ */ new Date()) throw new DinewayValidationError("Scheduled date must be in the future");
-		const existing = await this.findById(type, id);
-		if (!existing) throw new DinewayValidationError("Content item not found");
-		const newStatus = existing.status === "published" ? "published" : "scheduled";
-		await sql`
+		const snapshot = await this.snapshot(type, id);
+		if (!snapshot) throw new DinewayValidationError("Content item not found");
+		const newStatus = snapshot.item.status === "published" ? "published" : "scheduled";
+		await atomicBatch(this.db, {
+			checks: [snapshot.check, ...contentWriteChecks(type, id, "publish")],
+			statements: [sql`
 				UPDATE ${sql.ref(tableName)}
 				SET status = ${newStatus},
 					scheduled_at = ${scheduledAt},
 				updated_at = ${now}
 			WHERE id = ${id}
 				AND deleted_at IS NULL
-			`.execute(this.db);
+			`.compile(this.db)]
+		});
 		invalidateCollectionCache(type);
 		const updated = await this.findById(type, id);
 		if (!updated) throw new Error("Content not found");
@@ -553,10 +702,12 @@ var ContentRepository = class {
 	async unschedule(type, id) {
 		const tableName = getTableName(type);
 		const now = (/* @__PURE__ */ new Date()).toISOString();
-		const existing = await this.findById(type, id);
-		if (!existing) throw new DinewayValidationError("Content item not found");
-		const newStatus = existing.status === "published" ? "published" : "draft";
-		await sql`
+		const snapshot = await this.snapshot(type, id);
+		if (!snapshot) throw new DinewayValidationError("Content item not found");
+		const newStatus = snapshot.item.status === "published" ? "published" : "draft";
+		await atomicBatch(this.db, {
+			checks: [snapshot.check, ...contentWriteChecks(type, id, "publish")],
+			statements: [sql`
 				UPDATE ${sql.ref(tableName)}
 				SET status = ${newStatus},
 					scheduled_at = NULL,
@@ -564,7 +715,8 @@ var ContentRepository = class {
 			WHERE id = ${id}
 			AND scheduled_at IS NOT NULL
 				AND deleted_at IS NULL
-			`.execute(this.db);
+			`.compile(this.db)]
+		});
 		invalidateCollectionCache(type);
 		const updated = await this.findById(type, id);
 		if (!updated) throw new Error("Content not found");
@@ -613,88 +765,55 @@ var ContentRepository = class {
 	* `publishedAt` overrides the publication timestamp. If omitted, an existing
 	* `published_at` is preserved and first publish falls back to the current time.
 	*/
-	async publish(type, id, publishedAt, requireScheduledDue = false) {
+	async preparePublish(type, id, publishedAt, requireScheduledDue = false) {
 		const tableName = getTableName(type);
 		const now = (/* @__PURE__ */ new Date()).toISOString();
-		const existing = await this.findById(type, id);
-		if (!existing) throw new DinewayValidationError("Content item not found");
-		let claimedScheduledAt = null;
-		let claimedUpdatedAt = null;
-		if (requireScheduledDue) {
-			const claim = await sql`
-				UPDATE ${sql.ref(tableName)}
-				SET scheduled_at = NULL,
-					updated_at = ${now}
-				WHERE id = ${id}
-				AND scheduled_at IS NOT NULL
-				AND scheduled_at <= ${now}
-				AND deleted_at IS NULL
-			`.execute(this.db);
-			if (Number(claim.numAffectedRows ?? 0) === 0) throw new ScheduledNotDueError();
-			claimedScheduledAt = existing.scheduledAt;
-			claimedUpdatedAt = existing.updatedAt;
-		}
-		let publishCommitted = false;
-		try {
-			const revisionRepo = new RevisionRepository(this.db);
-			let revisionToPublish = existing.draftRevisionId || existing.liveRevisionId;
-			if (!revisionToPublish) revisionToPublish = (await revisionRepo.create({
+		const snapshot = await this.snapshot(type, id);
+		if (!snapshot) throw new DinewayValidationError("Content item not found");
+		const existing = snapshot.item;
+		if (requireScheduledDue && (!existing.scheduledAt || existing.scheduledAt > now)) throw new ScheduledNotDueError();
+		const checks = [snapshot.check];
+		const statements = [];
+		let revisionId = existing.draftRevisionId || existing.liveRevisionId;
+		let data = existing.data;
+		if (revisionId) {
+			const revision = await this.db.selectFrom("revisions").selectAll().where("id", "=", revisionId).executeTakeFirst();
+			if (!revision || revision.collection !== type || revision.entry_id !== id) throw new DinewayValidationError("Revision does not belong to the specified content item");
+			checks.push(rowUnchanged("revisions", revision));
+			data = JSON.parse(revision.data);
+		} else {
+			const revision = new RevisionRepository(this.db).prepareCreateSnapshot({
 				collection: type,
 				entryId: id,
-				data: existing.data
-			})).id;
-			const revision = await revisionRepo.findById(revisionToPublish);
-			if (revision) {
-				await this.syncDataColumns(type, id, revision.data);
-				if (typeof revision.data._slug === "string") await sql`
-						UPDATE ${sql.ref(tableName)}
-						SET slug = ${revision.data._slug}
-						WHERE id = ${id}
-					`.execute(this.db);
-			}
-			if (publishedAt !== void 0) await sql`
-					UPDATE ${sql.ref(tableName)}
-					SET live_revision_id = ${revisionToPublish},
-						draft_revision_id = NULL,
-						status = 'published',
-						scheduled_at = NULL,
-						published_at = ${publishedAt},
-						updated_at = ${now}
-					WHERE id = ${id}
-					AND deleted_at IS NULL
-				`.execute(this.db);
-			else await sql`
-					UPDATE ${sql.ref(tableName)}
-					SET live_revision_id = ${revisionToPublish},
-						draft_revision_id = NULL,
-						status = 'published',
-						scheduled_at = NULL,
-						published_at = COALESCE(published_at, ${now}),
-						updated_at = ${now}
-					WHERE id = ${id}
-					AND deleted_at IS NULL
-				`.execute(this.db);
-			publishCommitted = true;
-			const updated = await this.findById(type, id);
-			if (!updated) throw new Error("Content not found");
-			invalidateCollectionCache(type);
-			return updated;
-		} catch (error) {
-			if (requireScheduledDue && claimedScheduledAt && !publishCommitted) try {
-				await sql`
-						UPDATE ${sql.ref(tableName)}
-						SET scheduled_at = ${claimedScheduledAt},
-							updated_at = ${claimedUpdatedAt ?? now}
-						WHERE id = ${id}
-						AND scheduled_at IS NULL
-						AND deleted_at IS NULL
-						AND (status != 'published' OR draft_revision_id IS NOT NULL)
-					`.execute(this.db);
-			} catch (restoreError) {
-				console.error(`[content] Failed to restore schedule for ${type}/${id} after publish failure:`, restoreError);
-			}
-			throw error;
+				data: sql`${JSON.stringify(data)}`
+			});
+			revisionId = revision.id;
+			statements.push(revision.statement);
 		}
+		const sync = this.prepareSyncDataColumns(type, id, data);
+		if (sync) statements.push(sync);
+		const slug = typeof data._slug === "string" ? data._slug : existing.slug;
+		statements.push(sql`UPDATE ${sql.table(tableName)} SET slug = ${slug},
+			live_revision_id = ${revisionId}, draft_revision_id = NULL,
+			status = 'published', scheduled_at = NULL,
+			published_at = ${publishedAt !== void 0 ? sql`${publishedAt}` : sql`COALESCE(published_at, ${now})`}, updated_at = ${now}
+			WHERE id = ${id} AND deleted_at IS NULL`.compile(this.db));
+		return {
+			batch: {
+				checks,
+				statements
+			},
+			previous: existing,
+			slug
+		};
+	}
+	async publish(type, id, publishedAt, requireScheduledDue = false) {
+		const prepared = await this.preparePublish(type, id, publishedAt, requireScheduledDue);
+		await atomicBatch(this.db, prepared.batch);
+		invalidateCollectionCache(type);
+		const item = await this.findById(type, id);
+		if (!item) throw new Error("Content not found");
+		return item;
 	}
 	/**
 	* Stage an existing revision as the draft for a content item.
@@ -704,18 +823,19 @@ var ContentRepository = class {
 	*/
 	async setDraftRevision(type, id, revisionId) {
 		const tableName = getTableName(type);
-		const now = (/* @__PURE__ */ new Date()).toISOString();
-		if (!await this.findById(type, id)) throw new DinewayValidationError("Content item not found");
-		const revision = await new RevisionRepository(this.db).findById(revisionId);
+		const snapshot = await this.snapshot(type, id);
+		if (!snapshot) throw new DinewayValidationError("Content item not found");
+		const revision = await this.db.selectFrom("revisions").selectAll().where("id", "=", revisionId).executeTakeFirst();
 		if (!revision) throw new DinewayValidationError("Revision not found");
-		if (revision.collection !== type || revision.entryId !== id) throw new DinewayValidationError("Revision does not belong to the specified content item");
-		await sql`
-				UPDATE ${sql.ref(tableName)}
-				SET draft_revision_id = ${revisionId},
-					updated_at = ${now}
-			WHERE id = ${id}
-				AND deleted_at IS NULL
-			`.execute(this.db);
+		if (revision.collection !== type || revision.entry_id !== id) throw new DinewayValidationError("Revision does not belong to the specified content item");
+		await atomicBatch(this.db, {
+			checks: [
+				snapshot.check,
+				rowUnchanged("revisions", revision),
+				...contentWriteChecks(type, id, "edit")
+			],
+			statements: [sql`UPDATE ${sql.table(tableName)} SET draft_revision_id = ${revisionId}, updated_at = ${(/* @__PURE__ */ new Date()).toISOString()} WHERE id = ${id} AND deleted_at IS NULL`.compile(this.db)]
+		});
 		invalidateCollectionCache(type);
 	}
 	/**
@@ -726,37 +846,35 @@ var ContentRepository = class {
 	*/
 	async unpublish(type, id) {
 		const tableName = getTableName(type);
-		const now = (/* @__PURE__ */ new Date()).toISOString();
-		const existing = await this.findById(type, id);
-		if (!existing) throw new DinewayValidationError("Content item not found");
-		if (!existing.draftRevisionId && existing.liveRevisionId) {
-			const revisionRepo = new RevisionRepository(this.db);
-			const liveRevision = await revisionRepo.findById(existing.liveRevisionId);
-			if (liveRevision) {
-				const draft = await revisionRepo.create({
-					collection: type,
-					entryId: id,
-					data: liveRevision.data
-				});
-				await sql`
-					UPDATE ${sql.ref(tableName)}
-					SET draft_revision_id = ${draft.id}
-					WHERE id = ${id}
-				`.execute(this.db);
-			}
+		const snapshot = await this.snapshot(type, id);
+		if (!snapshot) throw new DinewayValidationError("Content item not found");
+		const existing = snapshot.item;
+		const checks = [snapshot.check, ...contentWriteChecks(type, id, "publish")];
+		const statements = [];
+		let draftId = existing.draftRevisionId;
+		if (!draftId && existing.liveRevisionId) {
+			const live = await this.db.selectFrom("revisions").selectAll().where("id", "=", existing.liveRevisionId).executeTakeFirst();
+			if (!live || live.collection !== type || live.entry_id !== id) throw new DinewayValidationError("Live revision not found");
+			checks.push(rowUnchanged("revisions", live));
+			const draft = new RevisionRepository(this.db).prepareCreateSnapshot({
+				collection: type,
+				entryId: id,
+				data: sql`${live.data}`
+			});
+			draftId = draft.id;
+			statements.push(draft.statement);
 		}
-		await sql`
-				UPDATE ${sql.ref(tableName)}
-				SET live_revision_id = NULL,
-					status = 'draft',
-				updated_at = ${now}
-			WHERE id = ${id}
-				AND deleted_at IS NULL
-			`.execute(this.db);
+		statements.push(sql`UPDATE ${sql.table(tableName)} SET live_revision_id = NULL,
+			draft_revision_id = ${draftId}, status = 'draft', updated_at = ${(/* @__PURE__ */ new Date()).toISOString()}
+			WHERE id = ${id} AND deleted_at IS NULL`.compile(this.db));
+		await atomicBatch(this.db, {
+			checks,
+			statements
+		});
 		invalidateCollectionCache(type);
-		const updated = await this.findById(type, id);
-		if (!updated) throw new Error("Content not found");
-		return updated;
+		const item = await this.findById(type, id);
+		if (!item) throw new Error("Content not found");
+		return item;
 	}
 	/**
 	* Discard pending draft changes
@@ -767,16 +885,20 @@ var ContentRepository = class {
 	async discardDraft(type, id) {
 		const tableName = getTableName(type);
 		const now = (/* @__PURE__ */ new Date()).toISOString();
-		const existing = await this.findById(type, id);
-		if (!existing) throw new DinewayValidationError("Content item not found");
+		const snapshot = await this.snapshot(type, id);
+		if (!snapshot) throw new DinewayValidationError("Content item not found");
+		const existing = snapshot.item;
 		if (!existing.draftRevisionId) return existing;
-		await sql`
+		await atomicBatch(this.db, {
+			checks: [snapshot.check, ...contentWriteChecks(type, id, "edit")],
+			statements: [sql`
 				UPDATE ${sql.ref(tableName)}
 				SET draft_revision_id = NULL,
 				updated_at = ${now}
 			WHERE id = ${id}
 				AND deleted_at IS NULL
-			`.execute(this.db);
+			`.compile(this.db)]
+		});
 		invalidateCollectionCache(type);
 		const updated = await this.findById(type, id);
 		if (!updated) throw new Error("Content not found");
@@ -787,7 +909,7 @@ var ContentRepository = class {
 	* Used to promote revision data into the content table on publish.
 	* Keys starting with _ are revision metadata (e.g. _slug) and are skipped.
 	*/
-	async syncDataColumns(type, id, data) {
+	prepareSyncDataColumns(type, id, data) {
 		const tableName = getTableName(type);
 		const updates = {};
 		for (const [key, value] of Object.entries(data)) {
@@ -796,8 +918,8 @@ var ContentRepository = class {
 			validateIdentifier(key, "content field name");
 			updates[key] = serializeValue(value);
 		}
-		if (Object.keys(updates).length === 0) return;
-		await this.db.updateTable(tableName).set(updates).where("id", "=", id).execute();
+		if (Object.keys(updates).length === 0) return null;
+		return this.db.updateTable(tableName).set(updates).where("id", "=", id).compile();
 	}
 	/**
 	* Count content items with a pending schedule.