emdash 0.31.1 → 0.33.0

package/dist/{content-BC43pICM.mjs → content-CJ94NEx5.mjs}

@@ -1,10 +1,10 @@
-import { o as __exportAll } from "./runner-BdeLEgad.mjs";
-import { t as validateIdentifier } from "./validate-VPnKoIzW.mjs";
-import { o as invalidateCollectionCache } from "./object-cache-Bok5j2ae.mjs";
-import { n as chunks, t as SQL_BATCH_SIZE } from "./chunks-Bq-5DPrD.mjs";
+import { o as __exportAll } from "./runner-BFTrkYhu.mjs";
+import { t as validateIdentifier } from "./validate-BpwoDOgt.mjs";
+import { c as invalidateCollectionCache } from "./object-cache-71tPfV4A.mjs";
+import { n as chunks, t as SQL_BATCH_SIZE } from "./chunks-DbYzib_k.mjs";
 import { n as isMissingTableError } from "./db-errors-CcWLaRiR.mjs";
 import { n as slugify } from "./slugify-C_tqlU4G.mjs";
-import { a as encodeCursor, i as decodeCursor, r as ScheduledNotDueError, t as EmDashValidationError } from "./types-CrRUFdej.mjs";
+import { a as decodeCursor, i as ScheduledNotDueError, n as EmDashValidationError, o as encodeCursor, t as ContentMutationConflictError } from "./types-Cd8iuS1J.mjs";
 import { sql } from "kysely";
 import { monotonicFactory, ulid } from "ulidx";
 
@@ -76,6 +76,15 @@ var RevisionRepository = class {
 		await this.db.insertInto("revisions").values(row).execute();
 		const revision = await this.findById(id);
 		if (!revision) throw new Error("Failed to create revision");
+		try {
+			await this.db.insertInto("_emdash_revision_prune_queue").values({
+				collection: input.collection,
+				entry_id: input.entryId,
+				revision_id: id
+			}).onConflict((conflict) => conflict.columns(["collection", "entry_id"]).doUpdateSet({ revision_id: id })).execute();
+		} catch (error) {
+			console.error(`[revisions] Failed to queue revision pruning for ${input.collection}/${input.entryId}:`, error);
+		}
 		return revision;
 	}
 	/**
@@ -115,23 +124,53 @@ var RevisionRepository = class {
 	*/
 	async deleteByEntry(collection, entryId) {
 		const result = await this.db.deleteFrom("revisions").where("collection", "=", collection).where("entry_id", "=", entryId).executeTakeFirst();
+		try {
+			await this.db.deleteFrom("_emdash_revision_prune_queue").where("collection", "=", collection).where("entry_id", "=", entryId).execute();
+		} catch (error) {
+			console.error(`[revisions] Failed to clear queued revision pruning for ${collection}/${entryId}:`, error);
+		}
 		return Number(result.numDeletedRows ?? 0);
 	}
 	/**
 	* Delete old revisions, keeping the most recent N
 	*/
 	async pruneOldRevisions(collection, entryId, keepCount) {
+		validateIdentifier(collection, "collection");
+		const tableName = `ec_${collection}`;
 		const keepIds = (await this.db.selectFrom("revisions").select("id").where("collection", "=", collection).where("entry_id", "=", entryId).orderBy("created_at", "desc").orderBy("id", "desc").limit(keepCount).execute()).map((r) => r.id);
 		if (keepIds.length === 0) return 0;
-		const result = await this.db.deleteFrom("revisions").where("collection", "=", collection).where("entry_id", "=", entryId).where("id", "not in", keepIds).executeTakeFirst();
-		return Number(result.numDeletedRows ?? 0);
+		const result = await sql`
+			DELETE FROM revisions
+			WHERE collection = ${collection}
+			AND entry_id = ${entryId}
+			AND id NOT IN (${sql.join(keepIds.map((id) => sql`${id}`))})
+			AND NOT EXISTS (
+				SELECT 1 FROM ${sql.ref(tableName)} AS content
+				WHERE content.live_revision_id = revisions.id
+				OR content.draft_revision_id = revisions.id
+			)
+		`.execute(this.db);
+		return Number(result.numAffectedRows ?? 0);
 	}
-	/**
-	* Update revision data in place
-	* Used for autosave to avoid creating many small revisions.
-	*/
-	async updateData(id, data) {
-		await this.db.updateTable("revisions").set({ data: JSON.stringify(data) }).where("id", "=", id).execute();
+	async pruneQueuedEntry(collection, entryId, queuedRevisionId, keepCount) {
+		const pruned = await this.pruneOldRevisions(collection, entryId, keepCount);
+		await this.db.deleteFrom("_emdash_revision_prune_queue").where("collection", "=", collection).where("entry_id", "=", entryId).where("revision_id", "=", queuedRevisionId).execute();
+		return pruned;
+	}
+	async deleteIfUnreferenced(collection, entryId, revisionId) {
+		validateIdentifier(collection, "collection");
+		const tableName = `ec_${collection}`;
+		return ((await sql`
+			DELETE FROM revisions
+			WHERE id = ${revisionId}
+			AND collection = ${collection}
+			AND entry_id = ${entryId}
+			AND NOT EXISTS (
+				SELECT 1 FROM ${sql.ref(tableName)} AS content
+				WHERE content.live_revision_id = revisions.id
+				OR content.draft_revision_id = revisions.id
+			)
+		`.execute(this.db)).numAffectedRows ?? 0n) > 0n;
 	}
 	/**
 	* Convert database row to Revision object
@@ -152,7 +191,27 @@ var RevisionRepository = class {
 //#region src/database/repositories/content.ts
 var content_exports = /* @__PURE__ */ __exportAll({ ContentRepository: () => ContentRepository });
 const ULID_PATTERN = /^[0-9A-Z]{26}$/;
+const SQLSTATE_PATTERN = /^[0-9A-Z]{5}$/;
 const LIKE_WILDCARD_RE = /[\\%_]/g;
+function nullableColumnMatch(column, value) {
+	validateIdentifier(column, "content column");
+	return value === null ? sql`${sql.ref(column)} IS NULL` : sql`${sql.ref(column)} = ${value}`;
+}
+function sameStoredValue(left, right) {
+	return Object.is(serializeValue(left), serializeValue(right));
+}
+function matchesPublication(observed, existing, revision, revisionId, slug, publishedAt, updatedAt) {
+	if (observed.version !== existing.version + 1 || observed.status !== "published" || observed.slug !== slug || observed.liveRevisionId !== revisionId || observed.draftRevisionId !== null || observed.scheduledAt !== null || observed.publishedAt !== publishedAt || observed.updatedAt !== updatedAt) return false;
+	return Object.entries(revision.data).every(([key, value]) => SYSTEM_COLUMNS.has(key) || key.startsWith("_") || sameStoredValue(observed.data[key], value));
+}
+function matchesPublicationFence(observed, existing) {
+	return observed.version === existing.version && observed.status === existing.status && observed.liveRevisionId === existing.liveRevisionId && observed.draftRevisionId === existing.draftRevisionId && observed.scheduledAt === existing.scheduledAt;
+}
+function isConfirmedStatementFailure(error) {
+	if (typeof error !== "object" || error === null || !("code" in error)) return false;
+	const code = error.code;
+	return typeof code === "string" && (code.startsWith("SQLITE_") || SQLSTATE_PATTERN.test(code));
+}
 /**
 * Whitelist mapping a public date-filter field to its physical column. Keeping
 * this separate from `mapOrderField` makes the filterable set explicit and
@@ -353,7 +412,8 @@ var ContentRepository = class {
 			slug,
 			data: newData,
 			status: "draft",
-			authorId: authorId || original.authorId || void 0
+			authorId: authorId || original.authorId || void 0,
+			locale: original.locale ?? void 0
 		});
 	}
 	/**
@@ -508,11 +568,12 @@ var ContentRepository = class {
 				updates[key] = serializeValue(value);
 			}
 		}
-		if (Object.keys(updates).length > 0) updates.updated_at = now;
+		const hasColumnWrites = Object.keys(updates).length > 0;
+		if (hasColumnWrites) updates.updated_at = now;
 		updates.version = sql`version + 1`;
 		await this.db.updateTable(tableName).set(updates).where("id", "=", id).where("deleted_at", "is", null).execute();
 		if (input.status !== void 0 || input.publishedAt !== void 0 || input.scheduledAt !== void 0) await this.restampEntryPivot(type, id);
-		invalidateCollectionCache(type);
+		if (hasColumnWrites) invalidateCollectionCache(type);
 		const updated = await this.findById(type, id);
 		if (!updated) throw new Error("Content not found");
 		return updated;
@@ -833,6 +894,10 @@ var ContentRepository = class {
 	* Lets callers resolve many edge groups without an N+1 per group. The caller
 	* groups the flat result by `translationGroup` itself.
 	*
+	* `translation_group` leads the sort so the ordering follows
+	* `idx_{table}_del_tg_locale` past its `deleted_at` equality; callers group by
+	* `translationGroup`, so the per-group locale order they rely on is preserved.
+	*
 	* `publishedOnly` restricts the result to `status = 'published'` — reference
 	* reads pass this for callers without `content:read_drafts` so draft/scheduled
 	* entries never leak through an edge traversal.
@@ -854,7 +919,7 @@ var ContentRepository = class {
 					WHERE translation_group IN (${sql.join(chunk)})
 					AND deleted_at IS NULL
 					${publishedFilter}
-					ORDER BY locale ASC
+					ORDER BY translation_group ASC, locale ASC
 				`.execute(this.db);
 				for (const row of result.rows) items.push(this.mapRow(type, row));
 			}
@@ -930,98 +995,91 @@ var ContentRepository = class {
 	* an explicit value to backdate a publish (e.g. when migrating content from
 	* another CMS).
 	*
-	* `requireDue` (optional) gates the publish on the row still being due:
-	* `scheduled_at` non-null and in the past. Used by the scheduled-publishing
-	* sweep to avoid publishing content an editor unscheduled or rescheduled
-	* between selection and publish. It claims the row with a single conditional
-	* UPDATE (clearing `scheduled_at`) before any other write, so it is atomic
-	* even on D1 (no multi-statement transactions) and serialises against
-	* `unschedule()` and concurrent sweeps — no TOCTOU and no double publish.
+	* `requireDue` gates the final update on the row still being due.
+	* `expectedScheduledAt` additionally fences changes made after a sweep
+	* selected the row but before publication preparation began.
 	*/
-	async publish(type, id, publishedAt, requireDue = false) {
+	async publish(type, id, publishedAt, requireDue = false, expectedScheduledAt) {
 		const tableName = getTableName(type);
 		const now = (/* @__PURE__ */ new Date()).toISOString();
 		const existing = await this.findById(type, id);
 		if (!existing) throw new EmDashValidationError("Content item not found");
-		let claimedScheduledAt = null;
-		let claimedUpdatedAt = null;
-		if (requireDue) {
-			if (((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)).numAffectedRows ?? 0n) === 0n) throw new ScheduledNotDueError();
-			claimedScheduledAt = existing.scheduledAt;
-			claimedUpdatedAt = existing.updatedAt;
-		}
-		let publishCommitted = false;
+		if (requireDue && expectedScheduledAt !== void 0 && existing.scheduledAt !== expectedScheduledAt) throw new ScheduledNotDueError();
+		const revisionRepo = new RevisionRepository(this.db);
+		let provisionalRevisionId = null;
 		try {
-			const revisionRepo = new RevisionRepository(this.db);
 			let revisionToPublish = existing.draftRevisionId || existing.liveRevisionId;
-			if (!revisionToPublish) revisionToPublish = (await revisionRepo.create({
-				collection: type,
-				entryId: id,
-				data: existing.data
-			})).id;
+			if (!revisionToPublish) {
+				const revision = await revisionRepo.create({
+					collection: type,
+					entryId: id,
+					data: existing.data
+				});
+				revisionToPublish = revision.id;
+				provisionalRevisionId = revision.id;
+			}
 			const revision = await revisionRepo.findById(revisionToPublish);
-			if (revision) {
-				const stagedSlug = typeof revision.data._slug === "string" ? revision.data._slug : null;
-				if (stagedSlug !== null && stagedSlug !== existing.slug && existing.locale !== null) {
-					const conflict = await this.findBySlugIncludingTrashed(type, stagedSlug, existing.locale);
-					if (conflict && conflict.id !== id) throw new EmDashValidationError(`Cannot publish: slug '${stagedSlug}' is already used by another entry in this collection (id: ${conflict.id}). Choose a different slug.`, { code: "SLUG_CONFLICT" });
-				}
-				if (stagedSlug !== null) await sql`
-						UPDATE ${sql.ref(tableName)}
-						SET slug = ${stagedSlug}
-						WHERE id = ${id}
-					`.execute(this.db);
-				await this.syncDataColumns(type, id, revision.data);
+			if (!revision || revision.collection !== type || revision.entryId !== id) throw new EmDashValidationError("Revision does not belong to the specified content item");
+			const stagedSlug = typeof revision.data._slug === "string" ? revision.data._slug : null;
+			const intendedSlug = stagedSlug ?? existing.slug;
+			const intendedPublishedAt = publishedAt ?? existing.publishedAt ?? now;
+			if (stagedSlug !== null && stagedSlug !== existing.slug && existing.locale !== null) {
+				const conflict = await this.findBySlugIncludingTrashed(type, stagedSlug, existing.locale);
+				if (conflict && conflict.id !== id) throw new EmDashValidationError(`Cannot publish: slug '${stagedSlug}' is already used by another entry in this collection (id: ${conflict.id}). Choose a different slug.`, { code: "SLUG_CONFLICT" });
 			}
-			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`
+			const assignments = [];
+			if (stagedSlug !== null) assignments.push(sql`slug = ${stagedSlug}`);
+			for (const [key, value] of Object.entries(revision.data)) {
+				if (SYSTEM_COLUMNS.has(key) || key.startsWith("_")) continue;
+				validateIdentifier(key, "content field name");
+				assignments.push(sql`${sql.ref(key)} = ${serializeValue(value)}`);
+			}
+			assignments.push(sql`live_revision_id = ${revisionToPublish}`, sql`draft_revision_id = NULL`, sql`status = 'published'`, sql`scheduled_at = NULL`, sql`published_at = ${intendedPublishedAt}`, sql`updated_at = ${now}`, sql`version = version + 1`);
+			const duePredicate = requireDue ? sql`AND scheduled_at IS NOT NULL AND scheduled_at <= ${now}` : sql``;
+			let promoted = false;
+			try {
+				promoted = ((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}
+					SET ${sql.join(assignments, sql`, `)}
 					WHERE id = ${id}
 					AND deleted_at IS NULL
-				`.execute(this.db);
-			publishCommitted = true;
+					AND version = ${existing.version}
+					AND status = ${existing.status}
+					AND ${nullableColumnMatch("live_revision_id", existing.liveRevisionId)}
+					AND ${nullableColumnMatch("draft_revision_id", existing.draftRevisionId)}
+					AND ${nullableColumnMatch("scheduled_at", existing.scheduledAt)}
+					${duePredicate}
+					AND EXISTS (
+						SELECT 1 FROM revisions
+						WHERE revisions.id = ${revisionToPublish}
+						AND revisions.collection = ${type}
+						AND revisions.entry_id = ${id}
+					)
+				`.execute(this.db)).numAffectedRows ?? 0n) > 0n;
+			} catch (error) {
+				if (isConfirmedStatementFailure(error)) throw error;
+				let observed;
+				try {
+					observed = await this.findById(type, id);
+				} catch (reconciliationError) {
+					throw new Error("Unable to confirm whether content publication completed", { cause: reconciliationError });
+				}
+				if (!observed) throw new Error("Unable to confirm whether content publication completed", { cause: error });
+				promoted = matchesPublication(observed, existing, revision, revisionToPublish, intendedSlug, intendedPublishedAt, now);
+				if (!promoted && matchesPublicationFence(observed, existing)) throw error;
+				if (!promoted) throw new Error("Unable to confirm whether content publication completed", { cause: error });
+			}
+			if (!promoted) throw requireDue ? new ScheduledNotDueError() : new ContentMutationConflictError();
+			invalidateCollectionCache(type);
 			await this.restampEntryPivot(type, id);
 			const updated = await this.findById(type, id);
 			if (!updated) throw new Error("Content not found");
-			invalidateCollectionCache(type);
 			return updated;
 		} catch (error) {
-			if (requireDue && 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);
+			if (provisionalRevisionId) try {
+				await revisionRepo.deleteIfUnreferenced(type, id, provisionalRevisionId);
+			} catch (cleanupError) {
+				console.error(`[content] Failed to clean up provisional revision ${provisionalRevisionId}:`, cleanupError);
 			}
 			throw error;
 		}
@@ -1080,18 +1138,31 @@ var ContentRepository = class {
 	* content row pointing at a missing or unrelated revision.
 	*/
 	async setDraftRevision(type, id, revisionId) {
-		const tableName = getTableName(type);
-		if (!await this.findById(type, id)) throw new EmDashValidationError("Content item not found");
+		const existing = await this.findById(type, id);
+		if (!existing) throw new EmDashValidationError("Content item not found");
 		const revision = await new RevisionRepository(this.db).findById(revisionId);
 		if (!revision) throw new EmDashValidationError("Revision not found");
 		if (revision.collection !== type || revision.entryId !== id) throw new EmDashValidationError("Revision does not belong to the specified content item");
-		await sql`
+		if (!await this.replaceDraftRevision(type, id, revisionId, existing)) throw new ContentMutationConflictError();
+	}
+	async replaceDraftRevision(type, id, revisionId, expected) {
+		const tableName = getTableName(type);
+		return ((await sql`
 			UPDATE ${sql.ref(tableName)}
-			SET draft_revision_id = ${revisionId}
+			SET draft_revision_id = ${revisionId},
+				version = version + 1
 			WHERE id = ${id}
 			AND deleted_at IS NULL
-		`.execute(this.db);
-		invalidateCollectionCache(type);
+			AND version = ${expected.version}
+			AND ${nullableColumnMatch("live_revision_id", expected.liveRevisionId)}
+			AND ${nullableColumnMatch("draft_revision_id", expected.draftRevisionId)}
+			AND EXISTS (
+				SELECT 1 FROM revisions
+				WHERE revisions.id = ${revisionId}
+				AND revisions.collection = ${type}
+				AND revisions.entry_id = ${id}
+			)
+		`.execute(this.db)).numAffectedRows ?? 0n) > 0n;
 	}
 	/**
 	* Discard pending draft changes
@@ -1110,29 +1181,11 @@ var ContentRepository = class {
 			WHERE id = ${id}
 			AND deleted_at IS NULL
 		`.execute(this.db);
-		invalidateCollectionCache(type);
 		const updated = await this.findById(type, id);
 		if (!updated) throw new Error("Content not found");
 		return updated;
 	}
 	/**
-	* Sync data columns in the content table from a data object.
-	* 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) {
-		const tableName = getTableName(type);
-		const updates = {};
-		for (const [key, value] of Object.entries(data)) {
-			if (SYSTEM_COLUMNS.has(key)) continue;
-			if (key.startsWith("_")) continue;
-			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();
-	}
-	/**
 	* Count content items with a pending schedule.
 	* Includes both draft-scheduled (status='scheduled') and published
 	* posts with scheduled draft changes (status='published', scheduled_at set).
@@ -1197,4 +1250,4 @@ var ContentRepository = class {
 
 //#endregion
 export { content_exports as n, RevisionRepository as r, ContentRepository as t };
-//# sourceMappingURL=content-BC43pICM.mjs.map
+//# sourceMappingURL=content-CJ94NEx5.mjs.map