emdash 0.38.0 → 0.39.0

package/src/database/migrations/080_content_translation_locale_unique.ts

@@ -0,0 +1,88 @@
+import type { Kysely } from "kysely";
+import { sql } from "kysely";
+
+import { indexExists, isPostgres, listTablesLike } from "../dialect-helpers.js";
+
+const DUPLICATE_GROUP_BATCH_SIZE = 50;
+
+interface DuplicateContentRow {
+	id: string;
+	translation_group: string;
+	locale_key: string;
+}
+
+async function splitDuplicateLocales(db: Kysely<unknown>, tableName: string): Promise<void> {
+	const collection = tableName.slice(3);
+
+	while (true) {
+		const duplicates = await sql<DuplicateContentRow>`
+			WITH duplicate_groups AS (
+				SELECT translation_group, lower(locale) AS locale_key
+				FROM ${sql.ref(tableName)}
+				WHERE deleted_at IS NULL AND translation_group IS NOT NULL
+				GROUP BY translation_group, lower(locale)
+				HAVING COUNT(*) > 1
+				ORDER BY translation_group, lower(locale)
+				LIMIT ${DUPLICATE_GROUP_BATCH_SIZE}
+			)
+			SELECT content.id, content.translation_group, lower(content.locale) AS locale_key
+			FROM ${sql.ref(tableName)} AS content
+			INNER JOIN duplicate_groups AS duplicate
+				ON duplicate.translation_group = content.translation_group
+				AND duplicate.locale_key = lower(content.locale)
+			WHERE content.deleted_at IS NULL
+			ORDER BY content.translation_group, lower(content.locale),
+				CASE WHEN content.id = content.translation_group THEN 0 ELSE 1 END,
+				content.created_at, content.id
+		`.execute(db);
+
+		if (duplicates.rows.length === 0) return;
+
+		let previousGroupLocale: string | null = null;
+		for (const row of duplicates.rows) {
+			const groupLocale = `${row.translation_group}\0${row.locale_key}`;
+			if (groupLocale !== previousGroupLocale) {
+				previousGroupLocale = groupLocale;
+				continue;
+			}
+
+			await sql`
+				INSERT INTO content_taxonomies (collection, entry_id, taxonomy_id)
+				SELECT collection, ${row.id}, taxonomy_id
+				FROM content_taxonomies
+				WHERE collection = ${collection} AND entry_id = ${row.translation_group}
+				ON CONFLICT (collection, entry_id, taxonomy_id) DO NOTHING
+			`.execute(db);
+			await sql`
+				UPDATE ${sql.ref(tableName)}
+				SET translation_group = ${row.id}
+				WHERE id = ${row.id}
+					AND deleted_at IS NULL
+					AND translation_group = ${row.translation_group}
+					AND lower(locale) = ${row.locale_key}
+			`.execute(db);
+		}
+	}
+}
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+	for (const tableName of await listTablesLike(db, "ec_%")) {
+		const indexName = `uidx_${tableName}_active_tg_locale`;
+		const storedIndexName = isPostgres(db) ? indexName.slice(0, 63) : indexName;
+		if (await indexExists(db, storedIndexName)) continue;
+		await splitDuplicateLocales(db, tableName);
+		await sql`
+			CREATE UNIQUE INDEX IF NOT EXISTS ${sql.ref(indexName)}
+			ON ${sql.ref(tableName)} (translation_group, lower(locale))
+			WHERE deleted_at IS NULL AND translation_group IS NOT NULL
+		`.execute(db);
+	}
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	for (const tableName of await listTablesLike(db, "ec_%")) {
+		const indexName = `uidx_${tableName}_active_tg_locale`;
+		const storedIndexName = isPostgres(db) ? indexName.slice(0, 63) : indexName;
+		await sql`DROP INDEX IF EXISTS ${sql.ref(storedIndexName)}`.execute(db);
+	}
+}

package/src/database/migrations/081_redirect_write_guards.ts

@@ -0,0 +1,257 @@
+import { type Kysely, sql } from "kysely";
+
+import { columnExists, isPostgres } from "../dialect-helpers.js";
+
+const DUPLICATE_COLUMN_REGEX =
+	/(?:duplicate column|column .* already exists|already exists.*column)/i;
+
+async function addColumnIfMissing(
+	db: Kysely<unknown>,
+	column: "config_revision" | "source_guard" | "write_generation",
+): Promise<void> {
+	if (await columnExists(db, "_emdash_redirects", column)) return;
+	try {
+		await db.schema
+			.alterTable("_emdash_redirects")
+			.addColumn(column, column === "config_revision" ? "text" : "integer", (builder) =>
+				builder.notNull().defaultTo(column === "config_revision" ? "0" : 0),
+			)
+			.execute();
+	} catch (error) {
+		if (
+			error instanceof Error &&
+			DUPLICATE_COLUMN_REGEX.test(error.message) &&
+			(await columnExists(db, "_emdash_redirects", column))
+		) {
+			return;
+		}
+		throw error;
+	}
+}
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+	await addColumnIfMissing(db, "config_revision");
+	await addColumnIfMissing(db, "source_guard");
+	await addColumnIfMissing(db, "write_generation");
+
+	// Preserve any historical duplicate rows, but nominate one existing row
+	// per source for the uniqueness constraint. New rows and source-changing
+	// updates set this flag, so they are database-enforced without deleting old data.
+	await sql`
+		UPDATE _emdash_redirects
+		SET source_guard = 1
+		WHERE id IN (
+			SELECT MIN(id) FROM _emdash_redirects GROUP BY source
+		)
+		AND source_guard = 0
+	`.execute(db);
+	await sql`
+		CREATE UNIQUE INDEX IF NOT EXISTS idx_redirects_managed_source
+		ON _emdash_redirects (source)
+		WHERE source_guard = 1
+	`.execute(db);
+
+	await db.schema
+		.createTable("_emdash_redirect_write_lock")
+		.ifNotExists()
+		.addColumn("id", "integer", (column) => column.primaryKey())
+		.addColumn("token", "text", (column) => column.notNull())
+		.addColumn("expires_at", isPostgres(db) ? "bigint" : "integer", (column) => column.notNull())
+		.addColumn("generation", "integer", (column) => column.notNull())
+		.execute();
+	await sql`
+		INSERT INTO _emdash_redirect_write_lock (id, token, expires_at, generation)
+		VALUES (1, '', 0, 0)
+		ON CONFLICT (id) DO NOTHING
+	`.execute(db);
+
+	if (isPostgres(db)) {
+		await sql`
+			CREATE OR REPLACE FUNCTION emdash_redirect_validate_write()
+			RETURNS trigger
+			LANGUAGE plpgsql
+			AS $$
+			BEGIN
+				PERFORM pg_advisory_xact_lock(1168624763);
+				IF TG_OP = 'INSERT' THEN
+					NEW.source_guard := 1;
+				ELSIF NEW.source <> OLD.source THEN
+					NEW.source_guard := 1;
+				END IF;
+				IF TG_OP = 'UPDATE'
+					AND NEW.config_revision IS NOT DISTINCT FROM OLD.config_revision
+					AND (
+						NEW.source IS DISTINCT FROM OLD.source OR
+						NEW.destination IS DISTINCT FROM OLD.destination OR
+						NEW.enabled IS DISTINCT FROM OLD.enabled OR
+						NEW.is_pattern IS DISTINCT FROM OLD.is_pattern OR
+						NEW.type IS DISTINCT FROM OLD.type OR
+						NEW.group_name IS DISTINCT FROM OLD.group_name
+					)
+				THEN
+					NEW.config_revision := md5(random()::text || clock_timestamp()::text || NEW.id);
+				END IF;
+				IF NEW.write_generation <> 0 AND TG_OP = 'INSERT' THEN
+					IF NOT EXISTS (
+						SELECT 1 FROM _emdash_redirect_write_lock
+						WHERE id = 1 AND token <> '' AND generation = NEW.write_generation
+					) THEN
+						RAISE EXCEPTION 'redirect write lease expired';
+					END IF;
+				ELSIF TG_OP = 'UPDATE' AND NEW.write_generation IS DISTINCT FROM OLD.write_generation THEN
+					IF NOT EXISTS (
+						SELECT 1 FROM _emdash_redirect_write_lock
+						WHERE id = 1 AND token <> '' AND generation = NEW.write_generation
+					) THEN
+						RAISE EXCEPTION 'redirect write lease expired';
+					END IF;
+				END IF;
+				IF NEW.enabled = 1 AND NEW.destination <> ''
+					AND (TG_OP = 'INSERT' OR NEW.source <> OLD.source OR NEW.destination <> OLD.destination)
+					AND EXISTS (
+					WITH RECURSIVE chain(source, destination) AS (
+						SELECT source, destination FROM _emdash_redirects
+						WHERE source = NEW.destination AND enabled = 1
+							AND (TG_OP = 'INSERT' OR id <> NEW.id)
+						UNION
+						SELECT redirect.source, redirect.destination
+						FROM _emdash_redirects AS redirect
+						JOIN chain ON redirect.source = chain.destination
+						WHERE redirect.enabled = 1
+							AND (TG_OP = 'INSERT' OR redirect.id <> NEW.id)
+					)
+					SELECT 1 FROM chain WHERE destination = NEW.source
+				) THEN
+					RAISE EXCEPTION 'redirect loop';
+				END IF;
+				RETURN NEW;
+			END;
+			$$
+		`.execute(db);
+		await sql`DROP TRIGGER IF EXISTS emdash_redirect_validate_write ON _emdash_redirects`.execute(
+			db,
+		);
+		await sql`
+			CREATE TRIGGER emdash_redirect_validate_write
+			BEFORE INSERT OR UPDATE OF source, destination, enabled, is_pattern, type, group_name
+			ON _emdash_redirects
+			FOR EACH ROW EXECUTE FUNCTION emdash_redirect_validate_write()
+		`.execute(db);
+		await sql`
+			CREATE OR REPLACE FUNCTION emdash_redirect_serialize_delete()
+			RETURNS trigger
+			LANGUAGE plpgsql
+			AS $$
+			BEGIN
+				PERFORM pg_advisory_xact_lock(1168624763);
+				RETURN OLD;
+			END;
+			$$
+		`.execute(db);
+		await sql`DROP TRIGGER IF EXISTS emdash_redirect_serialize_delete ON _emdash_redirects`.execute(
+			db,
+		);
+		await sql`
+			CREATE TRIGGER emdash_redirect_serialize_delete
+			BEFORE DELETE ON _emdash_redirects
+			FOR EACH ROW EXECUTE FUNCTION emdash_redirect_serialize_delete()
+		`.execute(db);
+	} else {
+		await sql`
+			CREATE TRIGGER IF NOT EXISTS emdash_redirect_fence_insert
+			BEFORE INSERT ON _emdash_redirects
+			WHEN NEW.write_generation <> 0 AND NOT EXISTS (
+				SELECT 1 FROM _emdash_redirect_write_lock
+				WHERE id = 1 AND token <> '' AND generation = NEW.write_generation
+			)
+			BEGIN
+				SELECT RAISE(ABORT, 'redirect write lease expired');
+			END
+		`.execute(db);
+		await sql`
+			CREATE TRIGGER IF NOT EXISTS emdash_redirect_fence_update
+			BEFORE UPDATE OF source, destination, enabled, is_pattern, type, group_name ON _emdash_redirects
+			WHEN NEW.write_generation <> OLD.write_generation
+			AND NEW.write_generation <> 0 AND NOT EXISTS (
+				SELECT 1 FROM _emdash_redirect_write_lock
+				WHERE id = 1 AND token <> '' AND generation = NEW.write_generation
+			)
+			BEGIN
+				SELECT RAISE(ABORT, 'redirect write lease expired');
+			END
+		`.execute(db);
+		await sql`
+			CREATE TRIGGER IF NOT EXISTS emdash_redirect_loop_insert
+			BEFORE INSERT ON _emdash_redirects
+			WHEN NEW.enabled = 1 AND NEW.destination <> ''
+			BEGIN
+				SELECT CASE WHEN EXISTS (
+					WITH RECURSIVE chain(source, destination) AS (
+						SELECT source, destination FROM _emdash_redirects
+						WHERE source = NEW.destination AND enabled = 1
+						UNION
+						SELECT redirect.source, redirect.destination
+						FROM _emdash_redirects AS redirect
+						JOIN chain ON redirect.source = chain.destination
+						WHERE redirect.enabled = 1
+					)
+					SELECT 1 FROM chain WHERE destination = NEW.source
+				) THEN RAISE(ABORT, 'redirect loop') END;
+			END
+		`.execute(db);
+		await sql`
+			CREATE TRIGGER IF NOT EXISTS emdash_redirect_loop_update
+			BEFORE UPDATE OF source, destination ON _emdash_redirects
+			WHEN NEW.enabled = 1 AND NEW.destination <> ''
+			BEGIN
+				SELECT CASE WHEN EXISTS (
+					WITH RECURSIVE chain(source, destination) AS (
+						SELECT source, destination FROM _emdash_redirects
+						WHERE source = NEW.destination AND enabled = 1 AND id <> NEW.id
+						UNION
+						SELECT redirect.source, redirect.destination
+						FROM _emdash_redirects AS redirect
+						JOIN chain ON redirect.source = chain.destination
+						WHERE redirect.enabled = 1 AND redirect.id <> NEW.id
+					)
+					SELECT 1 FROM chain WHERE destination = NEW.source
+				) THEN RAISE(ABORT, 'redirect loop') END;
+			END
+		`.execute(db);
+		await sql`
+			CREATE TRIGGER IF NOT EXISTS emdash_redirect_guard_insert
+			AFTER INSERT ON _emdash_redirects
+			WHEN NEW.source_guard = 0
+			BEGIN
+				UPDATE _emdash_redirects SET source_guard = 1 WHERE id = NEW.id;
+			END
+		`.execute(db);
+		await sql`
+			CREATE TRIGGER IF NOT EXISTS emdash_redirect_guard_update
+			AFTER UPDATE OF source ON _emdash_redirects
+			WHEN NEW.source_guard = 0 AND NEW.source <> OLD.source
+			BEGIN
+				UPDATE _emdash_redirects SET source_guard = 1 WHERE id = NEW.id;
+			END
+		`.execute(db);
+		await sql`
+			CREATE TRIGGER IF NOT EXISTS emdash_redirect_revision_update
+			AFTER UPDATE OF source, destination, enabled, is_pattern, type, group_name ON _emdash_redirects
+			WHEN NEW.config_revision = OLD.config_revision AND (
+				NEW.source IS NOT OLD.source OR
+				NEW.destination IS NOT OLD.destination OR
+				NEW.enabled IS NOT OLD.enabled OR
+				NEW.is_pattern IS NOT OLD.is_pattern OR
+				NEW.type IS NOT OLD.type OR
+				NEW.group_name IS NOT OLD.group_name
+			)
+			BEGIN
+				UPDATE _emdash_redirects
+				SET config_revision = lower(hex(randomblob(16)))
+				WHERE id = NEW.id;
+			END
+		`.execute(db);
+	}
+}
+
+export async function down(_db: Kysely<unknown>): Promise<void> {}

package/src/database/migrations/082_taxonomy_translation_locale_unique.ts

@@ -0,0 +1,49 @@
+import { sql, type Kysely } from "kysely";
+
+const INDEX_NAME = "idx_taxonomies_translation_group_locale_unique";
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+	const duplicates = await sql<{ id: string; translation_group: string }>`
+		SELECT id, translation_group
+		FROM (
+			SELECT
+				id,
+				translation_group,
+				ROW_NUMBER() OVER (
+					PARTITION BY translation_group, locale
+					ORDER BY id ASC
+				) AS duplicate_rank
+			FROM taxonomies
+			WHERE translation_group IS NOT NULL
+		) ranked
+		WHERE duplicate_rank > 1
+	`.execute(db);
+
+	for (const duplicate of duplicates.rows) {
+		// oxlint-disable-next-line no-await-in-loop -- each assignment copy must precede its group's update for restart safety
+		await sql`
+			INSERT INTO content_taxonomies (collection, entry_id, taxonomy_id)
+			SELECT collection, entry_id, ${duplicate.id}
+			FROM content_taxonomies
+			WHERE taxonomy_id = ${duplicate.translation_group}
+			ON CONFLICT DO NOTHING
+		`.execute(db);
+		// oxlint-disable-next-line no-await-in-loop -- preserve the copy-before-update ordering above
+		await sql`
+			UPDATE taxonomies
+			SET translation_group = ${duplicate.id}
+			WHERE id = ${duplicate.id}
+				AND translation_group = ${duplicate.translation_group}
+		`.execute(db);
+	}
+
+	await sql`
+		CREATE UNIQUE INDEX IF NOT EXISTS ${sql.ref(INDEX_NAME)}
+		ON taxonomies (translation_group, locale)
+		WHERE translation_group IS NOT NULL
+	`.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	await sql`DROP INDEX IF EXISTS ${sql.ref(INDEX_NAME)}`.execute(db);
+}

package/src/database/migrations/runner.ts

@@ -1,6 +1,11 @@
 import { type Kysely, sql } from "kysely";
 import { type Migration, type MigrationProvider, Migrator } from "kysely/migration";
 
+import {
+	busyLockHeldSince,
+	MIGRATION_LOCK_TABLE,
+	migrationLockHeldMessage,
+} from "../migration-lock.js";
 import { MIGRATION_LOCK_BUSY_MESSAGE } from "../pg-migration-lock.js";
 import type { Database } from "../types.js";
 // Import migrations statically for bundling
@@ -80,6 +85,11 @@ import * as m074 from "./074_content_deleted_scheduled_index.js";
 import * as m075 from "./075_entry_edit_locks.js";
 import * as m076 from "./076_collection_nav_group.js";
 import * as m077 from "./077_plugin_storage_revisions.js";
+import * as m078 from "./078_menu_item_translation_groups.js";
+import * as m079 from "./079_datetime_normalization.js";
+import * as m080 from "./080_content_translation_locale_unique.js";
+import * as m081 from "./081_redirect_write_guards.js";
+import * as m082 from "./082_taxonomy_translation_locale_unique.js";
 
 const MIGRATIONS: Readonly<Record<string, Migration>> = Object.freeze({
 	"001_initial": m001,
@@ -158,6 +168,11 @@ const MIGRATIONS: Readonly<Record<string, Migration>> = Object.freeze({
 	"075_entry_edit_locks": m075,
 	"076_collection_nav_group": m076,
 	"077_plugin_storage_revisions": m077,
+	"078_menu_item_translation_groups": m078,
+	"079_datetime_normalization": m079,
+	"080_content_translation_locale_unique": m080,
+	"081_redirect_write_guards": m081,
+	"082_taxonomy_translation_locale_unique": m082,
 });
 
 /** Ordered names from the statically registered migration set. */
@@ -205,9 +220,23 @@ export class ConcurrentMigrationTimeoutError extends Error {
 	}
 }
 
+/**
+ * Thrown without waiting when the migration lock is older than
+ * MIGRATION_LOCK_WAIT_MAX_AGE_MS. Callers with failure backoff apply it: the
+ * holder has most likely stopped, and only a person can release its lock.
+ */
+export class MigrationLockHeldError extends Error {
+	readonly heldSince: number;
+
+	constructor(heldSince: number) {
+		super(migrationLockHeldMessage(heldSince));
+		this.name = "MigrationLockHeldError";
+		this.heldSince = heldSince;
+	}
+}
+
 /** Custom migration table name */
 const MIGRATION_TABLE = "_emdash_migrations";
-const MIGRATION_LOCK_TABLE = "_emdash_migrations_lock";
 
 export interface MigrationOptions {
 	migrationTableSchema?: string;
@@ -264,11 +293,12 @@ function escapeRegExp(value: string): string {
 
 /**
  * Pattern used to detect the concurrent-migration race. The Kysely
- * `SqliteAdapter.acquireMigrationLock` is a no-op (inherited by `kysely-d1`
- * and our `EmDashD1Dialect`), so two isolates running migrations against the
- * same database can both attempt `INSERT INTO _emdash_migrations` for the
- * same migration name. The losing insert fails with a UNIQUE constraint
- * error, which is benign: the other isolate is applying the same schema.
+ * `SqliteAdapter.acquireMigrationLock` is a no-op, so two processes migrating
+ * the same SQLite database (or the same D1 database, when one of them runs a
+ * build whose D1 adapter takes no lock) can both attempt
+ * `INSERT INTO _emdash_migrations` for the same migration name. The losing
+ * insert fails with a UNIQUE constraint error, which is benign: the other
+ * process is applying the same schema.
  *
  * We match on the table name (not the full error text) because different
  * SQLite drivers phrase the message differently
@@ -292,6 +322,13 @@ export const MIGRATION_RACE_WAIT_MS = 10_000;
 /** Polling interval while waiting for a concurrent migrator. */
 const MIGRATION_RACE_POLL_MS = 100;
 
+/**
+ * A migration lock older than this is not waited on. Its holder has most
+ * likely stopped, and polling a lock that only a person can release would add
+ * a 10-second stall and a hundred queries to every runtime init until then.
+ */
+const MIGRATION_LOCK_WAIT_MAX_AGE_MS = 60_000;
+
 /**
  * Pattern used to detect "table does not exist" errors across the dialects
  * EmDash supports. The phrasing differs by driver:
@@ -430,9 +467,10 @@ export async function getExactMigrationStatus(
  * tables exist. On D1 with ~57 tables, that's ~116 queries saved per init.
  *
  * Concurrent-migration safety: the Kysely Migrator's `acquireMigrationLock`
- * is a no-op for SQLite (and therefore D1), so two callers running this
- * concurrently against the same database will both try to apply pending
- * migrations. SQLite serializes the writes, but the loser still surfaces a
+ * is a no-op for SQLite, so two callers running this concurrently against the
+ * same database will both try to apply pending migrations. (D1 and Postgres
+ * take a lock, and the loser gets the busy error handled below.) SQLite
+ * serializes the writes, but the loser still surfaces a
  * `UNIQUE constraint failed: _emdash_migrations.name` error. We treat that
  * specific error as benign: another caller is already applying the same
  * schema. We wait for the concurrent migrator to finish, then return
@@ -469,13 +507,17 @@ export async function runMigrations(
 		const failedMigration = results?.find((r) => r.status === "Error");
 
 		// Concurrent-migration race: another caller is applying (or just
-		// applied) the same migration. SQLite/D1 surface it as the
-		// bookkeeping UNIQUE violation (their migration lock is a no-op);
-		// Postgres surfaces it as the fail-fast advisory try-lock reporting
-		// busy (see pg-migration-lock.ts). Either way: wait for the
-		// concurrent migrator to finish, then verify the schema is fully
-		// migrated and treat as success.
+		// applied) the same migration. SQLite surfaces it as the bookkeeping
+		// UNIQUE violation (its migration lock is a no-op); D1 and Postgres
+		// surface it as their lock reporting busy (see migration-lock.ts and
+		// pg-migration-lock.ts). Either way: wait for the concurrent migrator
+		// to finish, then verify the schema is fully migrated and treat as
+		// success.
 		const lockBusy = msg.includes(MIGRATION_LOCK_BUSY_MESSAGE);
+		const heldSince = lockBusy ? busyLockHeldSince(error) : undefined;
+		if (heldSince !== undefined && Date.now() - heldSince > MIGRATION_LOCK_WAIT_MAX_AGE_MS) {
+			throw new MigrationLockHeldError(heldSince);
+		}
 		if (MIGRATION_RACE_PATTERN.test(msg) || lockBusy) {
 			const settled = await waitForConcurrentMigrator(db, options?.raceWaitMs);
 			if (settled) {

package/src/database/pg-migration-lock.ts

@@ -14,7 +14,7 @@
  * `pg_try_advisory_xact_lock`: when another migrator holds the lock, the
  * adapter throws `MIGRATION_LOCK_BUSY_MESSAGE` immediately instead of
  * queueing inside the database. `runMigrations` treats that error like the
- * SQLite/D1 concurrent-migration race — it polls the migration table with
+ * SQLite concurrent-migration race — it polls the migration table with
  * cheap bounded SELECTs until the concurrent migrator finishes (or the
  * wait deadline passes), without holding a transaction open.
  */
@@ -23,7 +23,7 @@ import type { DialectAdapter, Kysely, MigrationLockOptions } from "kysely";
 import { PostgresAdapter as KyselyPostgresAdapter, PostgresDialect, sql } from "kysely";
 
 /**
- * Sentinel message thrown when another migrator holds the advisory lock.
+ * Sentinel message thrown when another migrator holds the migration lock.
  * `runMigrations` matches on it to route into the concurrent-migrator wait.
  */
 export const MIGRATION_LOCK_BUSY_MESSAGE = "EMDASH_MIGRATION_LOCK_BUSY";

package/src/database/repositories/byline.ts

@@ -1410,4 +1410,13 @@ export class BylineRepository {
 
 		return await this.getContentBylines(collectionSlug, contentId);
 	}
+
+	async deleteContentBylines(collectionSlug: string, contentId: string): Promise<number> {
+		const result = await this.db
+			.deleteFrom("_emdash_content_bylines")
+			.where("collection_slug", "=", collectionSlug)
+			.where("content_id", "=", contentId)
+			.executeTakeFirst();
+		return Number(result.numDeletedRows ?? 0);
+	}
 }

package/src/database/repositories/comment.ts

@@ -66,6 +66,20 @@ export interface CommentFindOptions {
 	cursor?: string;
 }
 
+export interface PluginCommentFindOptions {
+	status?: Exclude<CommentStatus, "trash">;
+	collection?: string;
+	contentId?: string;
+	limit?: number;
+	cursor?: string;
+}
+
+export type ConditionalCommentStatusResult =
+	| { state: "updated"; comment: Comment }
+	| { state: "unchanged"; comment: Comment }
+	| { state: "conflict"; comment: Comment }
+	| { state: "not_found" };
+
 // ---------------------------------------------------------------------------
 // Repository
 // ---------------------------------------------------------------------------
@@ -230,6 +244,50 @@ export class CommentRepository {
 		return result;
 	}
 
+	/** List non-trashed comments for capability-gated plugin administration. */
+	async findForPlugin(options: PluginCommentFindOptions = {}): Promise<FindManyResult<Comment>> {
+		const limit = Math.max(1, Math.min(options.limit ?? 50, 100));
+		let query = this.db.selectFrom("_emdash_comments").selectAll().where("status", "!=", "trash");
+
+		if (options.status) query = query.where("status", "=", options.status);
+		if (options.collection) query = query.where("collection", "=", options.collection);
+		if (options.contentId) query = query.where("content_id", "=", options.contentId);
+		if (options.cursor) {
+			const decoded = decodeCursor(options.cursor);
+			query = query.where((eb: ExpressionBuilder<Database, "_emdash_comments">) =>
+				eb.or([
+					eb("created_at", "<", decoded.orderValue),
+					eb.and([eb("created_at", "=", decoded.orderValue), eb("id", "<", decoded.id)]),
+				]),
+			);
+		}
+
+		const rows = await query
+			.orderBy("created_at", "desc")
+			.orderBy("id", "desc")
+			.limit(limit + 1)
+			.execute();
+		const items = rows.slice(0, limit).map((row) => this.rowToComment(row));
+		const result: FindManyResult<Comment> = { items };
+		if (rows.length > limit && items.length > 0) {
+			const last = items.at(-1)!;
+			result.nextCursor = encodeCursor(last.createdAt, last.id);
+		}
+		return result;
+	}
+
+	async countForPlugin(options: Omit<PluginCommentFindOptions, "limit" | "cursor"> = {}) {
+		let query = this.db
+			.selectFrom("_emdash_comments")
+			.select((eb) => eb.fn.count("id").as("count"))
+			.where("status", "!=", "trash");
+		if (options.status) query = query.where("status", "=", options.status);
+		if (options.collection) query = query.where("collection", "=", options.collection);
+		if (options.contentId) query = query.where("content_id", "=", options.contentId);
+		const result = await query.executeTakeFirst();
+		return Number(result?.count ?? 0);
+	}
+
 	/**
 	 * Update comment status
 	 */
@@ -246,6 +304,34 @@ export class CommentRepository {
 		return this.findById(id);
 	}
 
+	/** Atomically change status only when the caller's observed state is current. */
+	async updateStatusIf(
+		id: string,
+		status: CommentStatus,
+		expectedStatus: CommentStatus,
+	): Promise<ConditionalCommentStatusResult> {
+		const existing = await this.findById(id);
+		if (!existing) return { state: "not_found" };
+		if (existing.status !== expectedStatus) return { state: "conflict", comment: existing };
+		if (status === expectedStatus) return { state: "unchanged", comment: existing };
+
+		const now = new Date().toISOString();
+		const result = await this.db
+			.updateTable("_emdash_comments")
+			.set({ status, updated_at: now })
+			.where("id", "=", id)
+			.where("status", "=", expectedStatus)
+			.returningAll()
+			.executeTakeFirst();
+		if (result) {
+			invalidateCommentObjectCache();
+			return { state: "updated", comment: this.rowToComment(result) };
+		}
+
+		const current = await this.findById(id);
+		return !current ? { state: "not_found" } : { state: "conflict", comment: current };
+	}
+
 	/**
 	 * Bulk update comment statuses
 	 */