emdash 0.32.0 → 0.33.0

package/src/database/migrations/055_content_translation_group_locale_index.ts

@@ -0,0 +1,67 @@
+import type { Kysely } from "kysely";
+import { sql } from "kysely";
+
+import { listTablesLike } from "../dialect-helpers.js";
+
+/**
+ * Migration: replace the single-column content `translation_group` index with
+ * one index per translation-group read shape.
+ *
+ * There are two shapes. Translation-group reads filter `deleted_at IS NULL`
+ * with `translation_group = ?` / `IN (...)` and order by locale; menu and
+ * reference resolution looks a group up by `translation_group` (+ `locale`)
+ * alone, with no `deleted_at` term.
+ *
+ * Neither shape can borrow the other's index. Seeking migration 041's
+ * `(deleted_at, locale, ...)` composites on `deleted_at` alone already returns
+ * rows in locale order, so a stats-blind planner prefers them over a
+ * single-column `translation_group` index and reads every non-deleted row in
+ * the table; the batched variant is worse still, because the `IN (...)` list
+ * multiplies the planner's row estimate for a `translation_group`-leading index
+ * and it falls back to a `deleted_at` composite from a handful of groups
+ * onward. Going the other way, an index leading with `deleted_at` cannot seek a
+ * lookup that never constrains that column. D1 never has `sqlite_stat1`, so the
+ * index shape is the only lever and each shape needs a prefix matching it term
+ * for term.
+ *
+ * Forward-only and idempotent (`IF NOT EXISTS`).
+ *
+ * Index names use short `tg_locale` / `del_tg_locale` suffixes rather than
+ * spelling out `translation_group`: Postgres truncates identifiers to 63 bytes,
+ * and the longer forms truncate to the same value for long collection slugs.
+ * Keep these identical to the names in `schema/registry.ts`.
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	const tableNames = await listTablesLike(db, "ec_%");
+
+	for (const tableName of tableNames) {
+		// D1 DDL is non-transactional: create the replacements before dropping the
+		// old index so an interrupted migration always leaves a
+		// translation_group-leading index in place.
+		await sql`
+			CREATE INDEX IF NOT EXISTS ${sql.ref(`idx_${tableName}_tg_locale`)}
+			ON ${sql.ref(tableName)} (translation_group, locale)
+		`.execute(db);
+
+		await sql`
+			CREATE INDEX IF NOT EXISTS ${sql.ref(`idx_${tableName}_del_tg_locale`)}
+			ON ${sql.ref(tableName)} (deleted_at, translation_group, locale)
+		`.execute(db);
+
+		await sql`DROP INDEX IF EXISTS ${sql.ref(`idx_${tableName}_translation_group`)}`.execute(db);
+	}
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	const tableNames = await listTablesLike(db, "ec_%");
+
+	for (const tableName of tableNames) {
+		await sql`
+			CREATE INDEX IF NOT EXISTS ${sql.ref(`idx_${tableName}_translation_group`)}
+			ON ${sql.ref(tableName)} (translation_group)
+		`.execute(db);
+
+		await sql`DROP INDEX IF EXISTS ${sql.ref(`idx_${tableName}_del_tg_locale`)}`.execute(db);
+		await sql`DROP INDEX IF EXISTS ${sql.ref(`idx_${tableName}_tg_locale`)}`.execute(db);
+	}
+}

package/src/database/migrations/056_taxonomy_term_sort_order.ts

@@ -0,0 +1,189 @@
+import { sql, type Kysely } from "kysely";
+
+import { columnExists } from "../dialect-helpers.js";
+
+/**
+ * Add `taxonomies.sort_order` and mint a position for every existing term.
+ *
+ * A position belongs to a `translation_group`, not a row: every row of a group
+ * carries the same value. Groups are numbered by `(label, id)` — the order term
+ * listings used before this migration — taking the label from the group's lowest
+ * row id. That locale's rendered order is unchanged; every other locale is
+ * re-sorted to match it, since only one locale's collation can win.
+ *
+ * Sibling groups are keyed on the raw `parent_id` column, which holds the
+ * parent's translation_group, so a group whose rows disagree about their parent
+ * is reconciled before numbering — otherwise it lands in whichever sibling group
+ * one arbitrary row happens to name.
+ *
+ * Only the `ALTER` is guarded; the passes below run unconditionally so a run that
+ * dies partway can be retried. Guarding the whole migration strands a partial
+ * numbering, because the retry early-returns on the column it added.
+ */
+
+/**
+ * Translation groups per `UPDATE`. Each costs three bound parameters — a CASE
+ * `WHEN`/`THEN` pair plus one slot in the `IN` list — which keeps a statement
+ * inside D1's 100-parameter ceiling. Writing one group per statement instead
+ * spends a subrequest per term, and a large taxonomy exhausts the 1,000 a
+ * Worker gets on the free plan before the migration finishes.
+ */
+const GROUPS_PER_UPDATE = 32;
+
+interface TermRow {
+	id: string;
+	name: string;
+	label: string | null;
+	parent_id: string | null;
+	translation_group: string;
+}
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+	const fresh = !(await columnExists(db, "taxonomies", "sort_order"));
+	if (fresh) {
+		await db.schema
+			.alterTable("taxonomies")
+			.addColumn("sort_order", "integer", (col) => col.notNull().defaultTo(0))
+			.execute();
+	}
+
+	// Migration 036 seeded `translation_group = id` on every row it rebuilt, and
+	// the repository has set it on every insert since, so this normally matches
+	// nothing. It runs anyway because everything below keys sibling groups on the
+	// column directly: a row that slipped through with a null would be numbered
+	// into no group at all, and would already be invisible to translation lookups
+	// and to `content_taxonomies`, which joins on the same value.
+	await sql`UPDATE taxonomies SET translation_group = id WHERE translation_group IS NULL`.execute(
+		db,
+	);
+
+	const { rows } = await sql<TermRow>`
+		SELECT id, name, label, parent_id, translation_group FROM taxonomies
+	`.execute(db);
+
+	await repairParents(db, rows);
+	await mintPositions(db, rows, fresh);
+}
+
+/**
+ * Give every row of a translation_group the same `parent_id`, mutating `rows` so
+ * the numbering below sees the reconciled tree.
+ *
+ * `parent_id` holds the parent's translation_group, so it is locale-agnostic and
+ * a group's rows should all agree. Reparenting used to write a single row, which
+ * left a term nested in the locale it was moved in and a root everywhere else.
+ * A non-null parent wins: it is the move somebody made, and the null is the row
+ * that missed it.
+ *
+ * The winner is copied from a sibling row, so it already satisfies the self-FK
+ * on `parent_id` and can't be rewritten into a dangling reference.
+ */
+async function repairParents(db: Kysely<unknown>, rows: TermRow[]): Promise<void> {
+	const byGroup = new Map<string, TermRow[]>();
+	for (const row of rows) {
+		const group = row.translation_group;
+		let members = byGroup.get(group);
+		if (!members) byGroup.set(group, (members = []));
+		members.push(row);
+	}
+
+	const winners = new Map<string, string>();
+	for (const [group, members] of byGroup) {
+		if (new Set(members.map((member) => member.parent_id)).size < 2) continue;
+
+		const parented = members.filter((member) => member.parent_id !== null);
+		// The anchor row decides when it names a parent, else the lowest row id
+		// that does, so the choice is the same however the rows come back.
+		const anchor = parented.find((member) => member.id === group);
+		const decider = anchor ?? parented.toSorted((a, b) => a.id.localeCompare(b.id))[0];
+		const winner = decider?.parent_id;
+		if (winner === undefined || winner === null) continue;
+
+		winners.set(group, winner);
+		for (const member of members) member.parent_id = winner;
+	}
+
+	await applyByGroup(db, "parent_id", winners);
+}
+
+/**
+ * Number each sibling group by `(label, id)`.
+ *
+ * When the column was just added every row already reads 0, so those positions
+ * are left to the default. On a retry the column is already there and may hold
+ * numbers from the run that failed, so every position is written explicitly.
+ */
+async function mintPositions(
+	db: Kysely<unknown>,
+	rows: readonly TermRow[],
+	fresh: boolean,
+): Promise<void> {
+	// One entry per translation_group: a group holds a single position, and its
+	// rows can disagree on label across locales, so the lowest row id decides for
+	// the whole group. Taxonomy names are `[a-z][a-z0-9_]*` and parents are
+	// ULIDs, so "/" can't appear in either half of the sibling key.
+	const groups = new Map<string, { sibling: string; label: string; id: string }>();
+	for (const row of rows) {
+		const group = row.translation_group;
+		const chosen = groups.get(group);
+		if (chosen && chosen.id <= row.id) continue;
+		groups.set(group, {
+			sibling: row.name + "/" + (row.parent_id ?? ""),
+			label: row.label ?? "",
+			id: row.id,
+		});
+	}
+
+	const siblings = new Map<string, { group: string; label: string; id: string }[]>();
+	for (const [group, { sibling, label, id }] of groups) {
+		let members = siblings.get(sibling);
+		if (!members) siblings.set(sibling, (members = []));
+		members.push({ group, label, id });
+	}
+
+	const positions = new Map<string, number>();
+	for (const members of siblings.values()) {
+		members.sort((a, b) => a.label.localeCompare(b.label) || a.id.localeCompare(b.id));
+		for (const [position, member] of members.entries()) {
+			if (position === 0 && fresh) continue;
+			positions.set(member.group, position);
+		}
+	}
+
+	await applyByGroup(db, "sort_order", positions);
+}
+
+/**
+ * Set one column per translation_group, chunked to stay inside the parameter
+ * ceiling.
+ */
+async function applyByGroup(
+	db: Kysely<unknown>,
+	column: "parent_id" | "sort_order",
+	values: ReadonlyMap<string, string | number>,
+): Promise<void> {
+	const entries = [...values];
+	// The CAST types the bound value. Postgres resolves a CASE whose THEN arms are
+	// all untyped parameters to text, then refuses to assign text to an integer
+	// column.
+	const valueType = column === "sort_order" ? sql`INTEGER` : sql`TEXT`;
+	for (let index = 0; index < entries.length; index += GROUPS_PER_UPDATE) {
+		const chunk = entries.slice(index, index + GROUPS_PER_UPDATE);
+		const arms = sql.join(
+			chunk.map(([group, value]) => sql`WHEN ${group} THEN CAST(${value} AS ${valueType})`),
+			sql` `,
+		);
+		const keys = sql.join(chunk.map(([group]) => sql`${group}`));
+		await sql`
+			UPDATE taxonomies
+			SET ${sql.ref(column)} = CASE translation_group ${arms} END
+			WHERE translation_group IN (${keys})
+		`.execute(db);
+	}
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	if (await columnExists(db, "taxonomies", "sort_order")) {
+		await db.schema.alterTable("taxonomies").dropColumn("sort_order").execute();
+	}
+}

package/src/database/migrations/057_collection_hidden.ts

@@ -0,0 +1,24 @@
+import type { Kysely } from "kysely";
+
+import { columnExists } from "../dialect-helpers.js";
+
+/**
+ * Migration: hide a collection from the admin sidebar.
+ *
+ * Adds `hidden` to `_emdash_collections`. A hidden collection stays fully
+ * functional (REST API, MCP, plugin hooks, direct `/content/:collection`
+ * URLs) — only its auto-generated sidebar entry is omitted, so plugins that
+ * own a collection end to end can steer editors to their own admin UI.
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	if (!(await columnExists(db, "_emdash_collections", "hidden"))) {
+		await db.schema
+			.alterTable("_emdash_collections")
+			.addColumn("hidden", "integer", (col) => col.notNull().defaultTo(0))
+			.execute();
+	}
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	await db.schema.alterTable("_emdash_collections").dropColumn("hidden").execute();
+}

package/src/database/migrations/058_collection_sort_order.ts

@@ -0,0 +1,20 @@
+import type { Kysely } from "kysely";
+
+import { columnExists } from "../dialect-helpers.js";
+
+/**
+ * Migration: explicit collection order in the admin sidebar.
+ *
+ * Adds `sort_order` to `_emdash_collections`. A NULL `sort_order` means no
+ * explicit position: those collections sort after the ordered ones, keeping
+ * the alphabetical-by-slug order.
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	if (!(await columnExists(db, "_emdash_collections", "sort_order"))) {
+		await db.schema.alterTable("_emdash_collections").addColumn("sort_order", "integer").execute();
+	}
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	await db.schema.alterTable("_emdash_collections").dropColumn("sort_order").execute();
+}

package/src/database/migrations/059_revision_prune_queue.ts

@@ -0,0 +1,36 @@
+import { sql, type Kysely } from "kysely";
+
+const REVISION_KEEP_COUNT = 50;
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+	await db.schema
+		.createTable("_emdash_revision_prune_queue")
+		.ifNotExists()
+		.addColumn("collection", "text", (column) => column.notNull())
+		.addColumn("entry_id", "text", (column) => column.notNull())
+		.addColumn("revision_id", "text", (column) => column.notNull())
+		.addPrimaryKeyConstraint("revision_prune_queue_pk", ["collection", "entry_id"])
+		.execute();
+
+	await db.schema
+		.createIndex("idx_revision_prune_queue_revision_id")
+		.ifNotExists()
+		.on("_emdash_revision_prune_queue")
+		.column("revision_id")
+		.execute();
+
+	await sql`
+		INSERT INTO _emdash_revision_prune_queue (collection, entry_id, revision_id)
+		SELECT collection, entry_id, MAX(id)
+		FROM revisions
+		WHERE true
+		GROUP BY collection, entry_id
+		HAVING COUNT(*) > ${REVISION_KEEP_COUNT}
+		ON CONFLICT (collection, entry_id)
+		DO UPDATE SET revision_id = excluded.revision_id
+	`.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	await db.schema.dropTable("_emdash_revision_prune_queue").ifExists().execute();
+}

package/src/database/migrations/runner.ts

@@ -57,6 +57,11 @@ import * as m051 from "./051_content_taxonomies_denorm.js";
 import * as m052 from "./052_media_usage_read_index.js";
 import * as m053 from "./053_plugin_mcp_tools.js";
 import * as m054 from "./054_media_upload_attempts.js";
+import * as m055 from "./055_content_translation_group_locale_index.js";
+import * as m056 from "./056_taxonomy_term_sort_order.js";
+import * as m057 from "./057_collection_hidden.js";
+import * as m058 from "./058_collection_sort_order.js";
+import * as m059 from "./059_revision_prune_queue.js";
 
 const MIGRATIONS: Readonly<Record<string, Migration>> = Object.freeze({
 	"001_initial": m001,
@@ -112,6 +117,11 @@ const MIGRATIONS: Readonly<Record<string, Migration>> = Object.freeze({
 	"052_media_usage_read_index": m052,
 	"053_plugin_mcp_tools": m053,
 	"054_media_upload_attempts": m054,
+	"055_content_translation_group_locale_index": m055,
+	"056_taxonomy_term_sort_order": m056,
+	"057_collection_hidden": m057,
+	"058_collection_sort_order": m058,
+	"059_revision_prune_queue": m059,
 });
 
 /** Total number of registered migrations. Exported for use in tests. */