emdash 1.3.0 → 1.3.1

package/src/database/migrations/content-sized.ts

@@ -0,0 +1,82 @@
+import { sql, type Kysely, type RawBuilder } from "kysely";
+
+import { isMissingTableError } from "../../utils/db-errors.js";
+import type { Database } from "../types.js";
+import { validateIdentifier } from "../validate.js";
+
+/**
+ * A migration whose work grows with the site's content. A caller that cannot
+ * finish a long run, such as auto mode inside a Worker request, compares the
+ * row count with its limit before it takes the migration lock.
+ */
+export interface ContentSizedMigration {
+	/**
+	 * Counts the rows the migration writes, with rows it only reads weighted by
+	 * their share of a statement. Stops once `cap` is reached.
+	 */
+	countRows(db: Kysely<Database>, cap: number): Promise<number>;
+}
+
+async function countCapped(
+	db: Kysely<Database>,
+	rows: RawBuilder<unknown>,
+	cap: number,
+): Promise<number> {
+	try {
+		const result = await sql<{ count: number | string | bigint }>`
+			SELECT COUNT(*) AS count FROM (${rows} LIMIT ${cap}) AS capped
+		`.execute(db);
+		return Number(result.rows[0]?.count ?? 0);
+	} catch (error) {
+		if (isMissingTableError(error)) return 0;
+		throw error;
+	}
+}
+
+const DATETIME_COLLECTIONS = sql`
+	SELECT collection.slug FROM _emdash_collections AS collection
+	INNER JOIN _emdash_fields AS field ON field.collection_id = collection.id
+	WHERE field.type IN ('datetime', 'repeater')
+`;
+
+/**
+ * 079 can update every content entry, and every revision of a collection with
+ * datetime or repeater fields, one statement each. It only reads the other
+ * revisions, 50 per statement in each of its three passes, so about 16 of them
+ * cost what one written row does.
+ */
+const READ_ONLY_REVISIONS_PER_ROW = 16;
+
+async function countDatetimeNormalizationRows(db: Kysely<Database>, cap: number): Promise<number> {
+	let slugs: string[];
+	try {
+		const collections = await db.selectFrom("_emdash_collections").select("slug").execute();
+		slugs = collections.map((collection) => collection.slug);
+	} catch (error) {
+		if (isMissingTableError(error)) return 0;
+		throw error;
+	}
+	let rows = await countCapped(
+		db,
+		sql`SELECT 1 FROM revisions WHERE collection IN (${DATETIME_COLLECTIONS})`,
+		cap,
+	);
+	for (const slug of slugs) {
+		if (rows >= cap) return rows;
+		validateIdentifier(slug, "collection slug");
+		// oxlint-disable-next-line no-await-in-loop -- each count is capped by what the previous ones left
+		rows += await countCapped(db, sql`SELECT 1 FROM ${sql.ref(`ec_${slug}`)}`, cap - rows);
+	}
+	if (rows >= cap) return rows;
+	const readOnly = await countCapped(
+		db,
+		sql`SELECT 1 FROM revisions WHERE collection NOT IN (${DATETIME_COLLECTIONS})`,
+		(cap - rows) * READ_ONLY_REVISIONS_PER_ROW,
+	);
+	return rows + Math.ceil(readOnly / READ_ONLY_REVISIONS_PER_ROW);
+}
+
+/** Keyed by migration name, since a published migration's module must not change. */
+export const CONTENT_SIZED_MIGRATIONS: ReadonlyMap<string, ContentSizedMigration> = new Map([
+	["079_datetime_normalization", { countRows: countDatetimeNormalizationRows }],
+]);

package/src/database/migrations/policy.ts

@@ -1,7 +1,12 @@
 import type { Kysely } from "kysely";
 
 import type { Database } from "../types.js";
-import { getExactMigrationStatus, runMigrations } from "./runner.js";
+import {
+	getExactMigrationStatus,
+	MigrationLockHeldError,
+	MigrationRowLimitError,
+	runMigrations,
+} from "./runner.js";
 
 export type RuntimeMigrationMode = "auto" | "check" | "manual";
 
@@ -53,13 +58,34 @@ export class PendingMigrationsError extends Error {
 	}
 }
 
+/**
+ * Whether a runtime init error leaves the database waiting for migrations that
+ * this request cannot apply. A backed-off init carries the original error as
+ * its cause.
+ */
+export function isMigrationRequiredError(error: unknown): boolean {
+	const cause = error instanceof Error ? error.cause : undefined;
+	return [error, cause].some(
+		(candidate) =>
+			candidate instanceof PendingMigrationsError ||
+			candidate instanceof MigrationLockHeldError ||
+			candidate instanceof MigrationRowLimitError,
+	);
+}
+
+export interface RuntimeMigrationPolicyOptions {
+	/** In auto mode, see `MigrationOptions.contentRowLimit`. */
+	contentRowLimit?: number;
+}
+
 export async function enforceRuntimeMigrationPolicy(
 	db: Kysely<Database>,
 	mode: RuntimeMigrationMode,
+	options: RuntimeMigrationPolicyOptions = {},
 ): Promise<void> {
 	if (mode === "manual") return;
 	if (mode === "auto") {
-		await runMigrations(db);
+		await runMigrations(db, { contentRowLimit: options.contentRowLimit });
 		return;
 	}
 

package/src/database/migrations/runner.ts

@@ -99,6 +99,7 @@ import * as m088 from "./088_cron_oneshot_utc.js";
 import * as m089 from "./089_auto_seed_completion.js";
 import * as m090 from "./090_redirect_enable_loop_guard.js";
 import * as m091 from "./091_redirect_artifacts.js";
+import { CONTENT_SIZED_MIGRATIONS } from "./content-sized.js";
 
 const MIGRATIONS: Readonly<Record<string, Migration>> = Object.freeze({
 	"001_initial": m001,
@@ -265,6 +266,27 @@ export class MigrationFailedError extends Error {
 	}
 }
 
+/**
+ * Thrown before the migration lock is taken when the pending content-sized
+ * migrations process more rows than the caller's `contentRowLimit`. Nothing
+ * has been applied; `emdash migrate` applies them outside a request.
+ */
+export class MigrationRowLimitError extends Error {
+	readonly migrations: string[];
+	readonly rowLimit: number;
+
+	constructor(migrations: readonly string[], rowLimit: number) {
+		super(
+			`Pending migration ${migrations.join(", ")} processes more than ${rowLimit} content rows, ` +
+				"too many to apply while serving a request. Apply it with `emdash migrate`: " +
+				"https://docs.emdashcms.com/deployment/core-migrations/#apply-large-content-migrations-from-the-cli",
+		);
+		this.name = "MigrationRowLimitError";
+		this.migrations = [...migrations];
+		this.rowLimit = rowLimit;
+	}
+}
+
 /** Custom migration table name */
 const MIGRATION_TABLE = "_emdash_migrations";
 
@@ -276,6 +298,11 @@ export interface MigrationOptions {
 	 * give-up path doesn't take 10 seconds per case.
 	 */
 	raceWaitMs?: number;
+	/**
+	 * Refuse with MigrationRowLimitError, before taking the migration lock, when
+	 * the pending content-sized migrations process more rows than this.
+	 */
+	contentRowLimit?: number;
 }
 
 export function createMigrator(db: Kysely<Database>, options?: MigrationOptions): Migrator {
@@ -486,6 +513,23 @@ export async function getExactMigrationStatus(
 	return { knownApplied, pending, unknownApplied };
 }
 
+async function assertWithinContentRowLimit(
+	db: Kysely<Database>,
+	rowLimit: number,
+	options: MigrationOptions | undefined,
+): Promise<void> {
+	const { pending } = await getExactMigrationStatus(db, options);
+	const sized = pending.filter((name) => CONTENT_SIZED_MIGRATIONS.has(name));
+	let rows = 0;
+	for (const name of sized) {
+		const migration = CONTENT_SIZED_MIGRATIONS.get(name);
+		if (!migration) continue;
+		// oxlint-disable-next-line no-await-in-loop -- each count is capped by what the previous ones left
+		rows += await migration.countRows(db, rowLimit + 1 - rows);
+		if (rows > rowLimit) throw new MigrationRowLimitError(sized, rowLimit);
+	}
+}
+
 /**
  * Run all pending migrations.
  *
@@ -524,6 +568,10 @@ export async function runMigrations(
 		}
 	}
 
+	if (options?.contentRowLimit !== undefined) {
+		await assertWithinContentRowLimit(db, options.contentRowLimit, options);
+	}
+
 	const migrator = createMigrator(db, options);
 
 	const { error, results } = await migrator.migrateToLatest();

package/src/database/repositories/byline.ts

@@ -2,6 +2,8 @@ import { sql, type Kysely, type Selectable } from "kysely";
 import { ulid } from "ulidx";
 
 import { getBylineFieldDefs } from "../../bylines/field-defs-cache.js";
+import { getLocaleRank } from "../../i18n/config.js";
+import { localeMatches, localeOrder } from "../../i18n/query.js";
 import {
 	invalidateBylineObjectCache,
 	invalidateCollectionCache,
@@ -28,6 +30,33 @@ import {
 
 type BylineRow = Selectable<BylineTable>;
 
+type LocalizedBylineRow = {
+	id: string;
+	locale: string;
+	translation_group: string | null;
+	content_id?: string;
+};
+
+function preferLocalizedRows<T extends LocalizedBylineRow>(rows: T[], locale?: string): T[] {
+	if (locale === undefined) return rows;
+	const selected = new Map<string, T>();
+	for (const row of rows) {
+		const key = `${row.content_id ?? ""}:${row.translation_group ?? row.id}`;
+		const existing = selected.get(key);
+		if (
+			!existing ||
+			getLocaleRank(row.locale, locale) < getLocaleRank(existing.locale, locale) ||
+			(getLocaleRank(row.locale, locale) === getLocaleRank(existing.locale, locale) &&
+				row.id < existing.id)
+		) {
+			selected.set(key, row);
+		}
+	}
+	return rows.filter(
+		(row) => selected.get(`${row.content_id ?? ""}:${row.translation_group ?? row.id}`) === row,
+	);
+}
+
 /**
  * A byline row optionally augmented with the avatar's media columns, folded in
  * by the `LEFT JOIN media` in the credit-hydration and single-row finder
@@ -536,8 +565,15 @@ export class BylineRepository {
 	 */
 	async findBySlug(slug: string, options?: { locale?: string }): Promise<BylineSummary | null> {
 		let query = this.selectBylineWithAvatar().where("b.slug", "=", slug);
-		if (options?.locale !== undefined) query = query.where("b.locale", "=", options.locale);
-		const row = await query.orderBy("b.locale", "asc").executeTakeFirst();
+		if (options?.locale !== undefined)
+			query = query.where(localeMatches("b.locale", options.locale));
+		const row = await query
+			.orderBy(
+				options?.locale !== undefined ? localeOrder("b.locale", options.locale) : "b.locale",
+				"asc",
+			)
+			.orderBy("b.id", "asc")
+			.executeTakeFirst();
 		return this.withCustomFieldsOne(row);
 	}
 
@@ -549,8 +585,15 @@ export class BylineRepository {
 	 */
 	async findByUserId(userId: string, options?: { locale?: string }): Promise<BylineSummary | null> {
 		let query = this.selectBylineWithAvatar().where("b.user_id", "=", userId);
-		if (options?.locale !== undefined) query = query.where("b.locale", "=", options.locale);
-		const row = await query.orderBy("b.locale", "asc").executeTakeFirst();
+		if (options?.locale !== undefined)
+			query = query.where(localeMatches("b.locale", options.locale));
+		const row = await query
+			.orderBy(
+				options?.locale !== undefined ? localeOrder("b.locale", options.locale) : "b.locale",
+				"asc",
+			)
+			.orderBy("b.id", "asc")
+			.executeTakeFirst();
 		return this.withCustomFieldsOne(row);
 	}
 
@@ -591,7 +634,7 @@ export class BylineRepository {
 		}
 
 		if (options?.locale !== undefined) {
-			query = query.where("locale", "=", options.locale);
+			query = query.where(localeMatches("locale", options.locale));
 		}
 
 		if (options?.cursor) {
@@ -980,9 +1023,10 @@ export class BylineRepository {
 			.where("cb.collection_slug", "=", collectionSlug)
 			.where("cb.content_id", "=", contentId)
 			.orderBy("cb.sort_order", "asc");
-		if (options?.locale !== undefined) query = query.where("b.locale", "=", options.locale);
+		if (options?.locale !== undefined)
+			query = query.where(localeMatches("b.locale", options.locale));
 
-		const rows = await query.execute();
+		const rows = preferLocalizedRows(await query.execute(), options?.locale);
 		// Reconstruct byline rows to feed `withCustomFields`. The JOIN selects
 		// the `BylineRow` columns under the `b.` alias plus the avatar media
 		// columns from the `media` LEFT JOIN; carry both through so
@@ -1120,9 +1164,10 @@ export class BylineRepository {
 				.where("cb.collection_slug", "=", collectionSlug)
 				.where("cb.content_id", "in", chunk)
 				.orderBy("cb.sort_order", "asc");
-			if (options?.locale !== undefined) query = query.where("b.locale", "=", options.locale);
+			if (options?.locale !== undefined)
+				query = query.where(localeMatches("b.locale", options.locale));
 
-			const rows = await query.execute();
+			const rows = preferLocalizedRows(await query.execute(), options?.locale);
 			// Carry the avatar media columns from the LEFT JOIN through the
 			// reshape so `rowToByline` can populate avatarStorageKey/avatarAlt.
 			const bylineRows: BylineRowWithAvatar[] = rows.map((row) => ({
@@ -1224,7 +1269,8 @@ export class BylineRepository {
 					"b.translation_group as translation_group",
 				])
 				.where("b.user_id", "in", chunk);
-			if (options?.locale !== undefined) query = query.where("b.locale", "=", options.locale);
+			if (options?.locale !== undefined)
+				query = query.where(localeMatches("b.locale", options.locale));
 
 			const rows = await query.execute();
 			let bylines: BylineSummary[];
@@ -1239,7 +1285,18 @@ export class BylineRepository {
 				const row = rows[i];
 				const summary = bylines[i];
 				if (!row || !summary || !row.user_id) continue;
-				result.set(row.user_id, summary);
+				const existing = result.get(row.user_id);
+				if (
+					!existing ||
+					options?.locale === undefined ||
+					getLocaleRank(row.locale, options.locale) <
+						getLocaleRank(existing.locale, options.locale) ||
+					(getLocaleRank(row.locale, options.locale) ===
+						getLocaleRank(existing.locale, options.locale) &&
+						row.id < existing.id)
+				) {
+					result.set(row.user_id, summary);
+				}
 			}
 		}
 		return result;
@@ -1341,17 +1398,16 @@ export class BylineRepository {
 		// actually lands in the junction. Deduping by wire row id BEFORE
 		// resolving would let two locale siblings of the same byline slip
 		// through and trigger a UNIQUE(collection, content, byline_id)
-		// failure at insert time. A single SELECT keeps this O(1) DB
-		// calls regardless of how many credits are being set.
+		// failure at insert time.
 		const idToGroup = new Map<string, string>();
-		if (inputBylines.length > 0) {
-			const wireIds = [...new Set(inputBylines.map((item) => item.bylineId))];
+		const wireIds = [...new Set(inputBylines.map((item) => item.bylineId))];
+		for (const batch of chunks(wireIds, SQL_BATCH_SIZE)) {
 			const rows = await this.db
 				.selectFrom("_emdash_bylines")
 				.select(["id", "translation_group"])
-				.where("id", "in", wireIds)
+				.where("id", "in", batch)
 				.execute();
-			if (rows.length !== wireIds.length) {
+			if (rows.length !== batch.length) {
 				throw new Error("One or more byline IDs do not exist");
 			}
 			for (const row of rows) {

package/src/database/repositories/comment.ts

@@ -2,6 +2,8 @@ import { sql, type ExpressionBuilder, type Kysely } from "kysely";
 import { ulid } from "ulidx";
 
 import { invalidateCommentObjectCache } from "../../object-cache/index.js";
+import { chunks, SQL_BATCH_SIZE } from "../../utils/chunks.js";
+import { withTransaction } from "../transaction.js";
 import type { Database } from "../types.js";
 import { encodeCursor, decodeCursor, type FindManyResult } from "./types.js";
 
@@ -354,14 +356,22 @@ export class CommentRepository {
 
 		const now = new Date().toISOString();
 
-		const result = await this.db
-			.updateTable("_emdash_comments")
-			.set({ status, updated_at: now })
-			.where("id", "in", ids)
-			.executeTakeFirst();
-
+		const updatedCount = await withTransaction(this.db, async (db) => {
+			let updated = 0;
+			for (const batch of chunks([...new Set(ids)], SQL_BATCH_SIZE)) {
+				const result = await db
+					.updateTable("_emdash_comments")
+					.set({ status, updated_at: now })
+					.where("id", "in", batch)
+					.executeTakeFirst();
+
+				if (!db.isTransaction) invalidateCommentObjectCache();
+				updated += Number(result.numUpdatedRows ?? 0);
+			}
+			return updated;
+		});
 		invalidateCommentObjectCache();
-		return Number(result.numUpdatedRows ?? 0);
+		return updatedCount;
 	}
 
 	/**

package/src/database/repositories/content.ts

@@ -4,6 +4,8 @@ import { ulid } from "ulidx";
 import type { ContentFieldFilterValue, ContentFieldFilters } from "../../content-list-query.js";
 import { keepKnownFields, staleStoredKeys } from "../../content/known-fields.js";
 import { normalizeExplicitDatetime } from "../../datetime-normalization.js";
+import { getLocaleCandidates } from "../../i18n/config.js";
+import { canonicalLocaleColumn, localeMatches, localeOrder } from "../../i18n/query.js";
 import { invalidateCollectionCache } from "../../object-cache/index.js";
 import { isIndexableFieldType, isStoragelessFieldRow, type FieldType } from "../../schema/types.js";
 import { buildFtsPrefixMatch, buildSlugGlobPrefix } from "../../search/match.js";
@@ -28,6 +30,7 @@ import type {
 import {
 	ContentCollectionNotFoundError,
 	ContentMutationConflictError,
+	ContentSlugConflictError,
 	EmDashValidationError,
 	InvalidCursorError,
 	ScheduledNotDueError,
@@ -381,6 +384,30 @@ export class ContentRepository {
 		this.datetimes = new ContentDatetimeNormalizer(db, datetimeContexts);
 	}
 
+	private async assertAliasAwareSlugAvailable(
+		type: string,
+		slug: string | null | undefined,
+		locale: string | undefined,
+		excludeId?: string,
+	): Promise<void> {
+		if (!slug || !locale || getLocaleCandidates(locale).length <= 1) return;
+
+		const tableName = getTableName(type);
+		const result = await sql<{ id: string }>`
+			SELECT id FROM ${sql.ref(tableName)}
+			WHERE slug = ${slug}
+			AND ${localeMatches("locale", locale)}
+			${
+				excludeId === undefined
+					? sql``
+					: sql`AND id <> ${excludeId}
+				AND coalesce((SELECT existing_row.slug FROM ${sql.ref(tableName)} AS existing_row WHERE existing_row.id = ${excludeId}), '') <> ${slug}`
+			}
+			LIMIT 1
+		`.execute(this.db);
+		if (result.rows.length > 0) throw new ContentSlugConflictError();
+	}
+
 	/**
 	 * Create a new content item
 	 */
@@ -415,6 +442,22 @@ export class ContentRepository {
 		}
 
 		const tableName = getTableName(type);
+		if (translationOf && getLocaleCandidates(locale ?? "en").length > 1) {
+			const existing = await sql<{ id: string }>`
+				SELECT sibling.id FROM ${sql.ref(tableName)} AS sibling
+				INNER JOIN ${sql.ref(tableName)} AS source
+					ON coalesce(source.translation_group, source.id) = sibling.translation_group
+				WHERE source.id = ${translationOf} AND source.deleted_at IS NULL
+					AND sibling.deleted_at IS NULL AND ${localeMatches("sibling.locale", locale ?? "en")}
+				LIMIT 1
+			`.execute(this.db);
+			if (existing.rows.length > 0) {
+				throw new ContentMutationConflictError(
+					`Translation already exists in locale "${locale ?? "en"}" for this content item`,
+				);
+			}
+		}
+		await this.assertAliasAwareSlugAvailable(type, slug, locale);
 
 		// Build column names and values
 		const columns: string[] = [
@@ -524,7 +567,7 @@ export class ContentRepository {
 			? await sql<{ slug: string }>`
 					SELECT slug FROM ${sql.ref(tableName)}
 					WHERE slug = ${baseSlug}
-					AND locale = ${locale}
+					AND ${localeMatches("locale", locale)}
 					LIMIT 1
 				`.execute(this.db)
 			: await sql<{ slug: string }>`
@@ -543,7 +586,7 @@ export class ContentRepository {
 			? await sql<{ slug: string }>`
 					SELECT slug FROM ${sql.ref(tableName)}
 					WHERE (slug = ${baseSlug} OR slug LIKE ${pattern})
-					AND locale = ${locale}
+					AND ${localeMatches("locale", locale)}
 				`.execute(this.db)
 			: await sql<{ slug: string }>`
 					SELECT slug FROM ${sql.ref(tableName)}
@@ -655,20 +698,22 @@ export class ContentRepository {
 		type: string,
 		slugs: string[],
 		locale: string,
-		options: { includeTrashed?: boolean } = {},
+		options: { includeTrashed?: boolean; publishedOnly?: boolean } = {},
 	): Promise<Map<string, ContentItem>> {
 		const items = new Map<string, ContentItem>();
 		if (slugs.length === 0) return items;
 		const tableName = getTableName(type);
 		const deletedFilter = options.includeTrashed ? sql`` : sql`AND deleted_at IS NULL`;
+		const statusFilter = options.publishedOnly ? sql`AND status = ${"published"}` : sql``;
 		for (const batch of chunks([...new Set(slugs)], SQL_BATCH_SIZE)) {
 			const result = await sql<Record<string, unknown>>`
 				SELECT * FROM ${sql.ref(tableName)}
-				WHERE slug IN (${sql.join(batch)}) AND locale = ${locale} ${deletedFilter}
+				WHERE slug IN (${sql.join(batch)}) AND ${localeMatches("locale", locale)} ${deletedFilter} ${statusFilter}
+				ORDER BY ${localeOrder("locale", locale)}, id ASC
 			`.execute(this.db);
 			for (const row of result.rows) {
 				const item = this.mapRow(type, row);
-				if (item.slug !== null) items.set(item.slug, item);
+				if (item.slug !== null && !items.has(item.slug)) items.set(item.slug, item);
 			}
 		}
 		return items;
@@ -787,8 +832,9 @@ export class ContentRepository {
 			? await sql<Record<string, unknown>>`
 					SELECT * FROM ${sql.ref(tableName)}
 					WHERE slug = ${slug}
-					AND locale = ${locale}
+					AND ${localeMatches("locale", locale)}
 					AND deleted_at IS NULL
+					ORDER BY ${localeOrder("locale", locale)}, id ASC
 				`.execute(this.db)
 			: await sql<Record<string, unknown>>`
 					SELECT * FROM ${sql.ref(tableName)}
@@ -821,7 +867,8 @@ export class ContentRepository {
 			? await sql<Record<string, unknown>>`
 					SELECT * FROM ${sql.ref(tableName)}
 					WHERE slug = ${slug}
-					AND locale = ${locale}
+					AND ${localeMatches("locale", locale)}
+					ORDER BY ${localeOrder("locale", locale)}, id ASC
 				`.execute(this.db)
 			: await sql<Record<string, unknown>>`
 					SELECT * FROM ${sql.ref(tableName)}
@@ -882,7 +929,7 @@ export class ContentRepository {
 		}
 
 		if (options.where?.locale) {
-			query = query.where("locale" as any, "=", options.where.locale);
+			query = query.where(localeMatches("locale", options.where.locale));
 		}
 
 		query = this.applySearchFilter(query, options.where, type);
@@ -1027,6 +1074,8 @@ export class ContentRepository {
 		const tableName = getTableName(type);
 		const now = new Date().toISOString();
 
+		await this.assertAliasAwareSlugAvailable(type, input.slug, input.locale, id);
+
 		// Every update advances the optimistic-concurrency version. updated_at
 		// advances only when a content-row column actually changes.
 		const updates: Record<string, unknown> = {};
@@ -1073,6 +1122,9 @@ export class ContentRepository {
 		if (hasColumnWrites) {
 			updates.updated_at = now;
 		}
+		if (input.draftRevisionId === null) {
+			updates.draft_revision_id = null;
+		}
 		updates.version = sql`version + 1`;
 
 		await this.db
@@ -1298,7 +1350,8 @@ export class ContentRepository {
 		const supportsRaw = collectionRows[0]?.supports;
 		const supports: unknown = supportsRaw ? JSON.parse(supportsRaw) : [];
 		if (!Array.isArray(supports) || !supports.includes("revisions")) {
-			return this.update(type, id, { ...input, data });
+			// Reads show any draft revision over the columns this writes.
+			return this.update(type, id, { ...input, data, draftRevisionId: null });
 		}
 
 		const fieldSlugs = new Set(
@@ -1726,7 +1779,7 @@ export class ContentRepository {
 			.where("deleted_at" as never, "is not", null);
 
 		if (options.where?.locale) {
-			query = query.where("locale" as any, "=", options.where.locale);
+			query = query.where(localeMatches("locale", options.where.locale));
 		}
 
 		// Handle cursor pagination — decodeCursor throws on invalid input.
@@ -1797,7 +1850,7 @@ export class ContentRepository {
 			.where("deleted_at" as never, "is not", null);
 
 		if (options.locale) {
-			query = query.where("locale" as any, "=", options.locale);
+			query = query.where(localeMatches("locale", options.locale));
 		}
 
 		const result = await query.executeTakeFirst();
@@ -1923,8 +1976,10 @@ export class ContentRepository {
 				.where("cb.collection_slug", "=", type)
 				.whereRef("cb.content_id", "=", idColumn);
 			sub = filter.locale
-				? sub.where("b.locale", "=", filter.locale)
-				: sub.whereRef("b.locale", "=", localeColumn);
+				? sub.where(localeMatches("b.locale", filter.locale))
+				: sub.where(
+						sql<boolean>`${canonicalLocaleColumn("b.locale")} = ${canonicalLocaleColumn(localeColumn)}`,
+					);
 			if (bylineIds) sub = sub.where("cb.byline_id", "in", bylineIds);
 			return eb.exists(sub);
 		};
@@ -1956,8 +2011,10 @@ export class ContentRepository {
 				.select("b.id")
 				.whereRef("b.user_id", "=", authorColumn);
 			sub = filter.locale
-				? sub.where("b.locale", "=", filter.locale)
-				: sub.whereRef("b.locale", "=", localeColumn);
+				? sub.where(localeMatches("b.locale", filter.locale))
+				: sub.where(
+						sql<boolean>`${canonicalLocaleColumn("b.locale")} = ${canonicalLocaleColumn(localeColumn)}`,
+					);
 			if (bylineIds) sub = sub.where("b.translation_group", "in", bylineIds);
 			return eb.exists(sub);
 		};
@@ -2020,7 +2077,7 @@ export class ContentRepository {
 		}
 
 		if (where?.locale) {
-			query = query.where("locale" as any, "=", where.locale);
+			query = query.where(localeMatches("locale", where.locale));
 		}
 
 		query = this.applySearchFilter(query, where, type);
@@ -2723,13 +2780,16 @@ export class ContentRepository {
 	 * Unpublish content
 	 *
 	 * Removes live pointer and cancels any pending schedule, but preserves the
-	 * draft and publication date. If no draft exists, creates one from the live
-	 * version so the content isn't lost.
+	 * draft and publication date. If no draft exists and `draftFromLive` is set,
+	 * creates one from the live version so the content isn't lost. Collections
+	 * without revisions save to the columns, and a draft revision would hide
+	 * those saves.
 	 */
 	async unpublish(
 		type: string,
 		id: string,
 		expectedRevision?: ContentRevisionPrecondition,
+		draftFromLive = true,
 	): Promise<ContentItem> {
 		const tableName = getTableName(type);
 		const now = new Date().toISOString();
@@ -2747,7 +2807,7 @@ export class ContentRepository {
 		let provisionalRevisionId: string | null = null;
 		try {
 			let draftRevisionId = existing.draftRevisionId;
-			if (!draftRevisionId && existing.liveRevisionId) {
+			if (draftFromLive && !draftRevisionId && existing.liveRevisionId) {
 				const liveRevision = await revisionRepo.findById(existing.liveRevisionId);
 				if (liveRevision) {
 					const draft = await revisionRepo.create({