emdash 0.40.1 → 0.42.0

package/src/database/migrations/036_i18n_menus_and_taxonomies.ts

@@ -2,7 +2,7 @@ import type { Kysely } from "kysely";
 import { sql } from "kysely";
 
 import { getI18nConfig } from "../../i18n/config.js";
-import { currentTimestamp, isSqlite } from "../dialect-helpers.js";
+import { currentTimestamp, isSqlite, tableExists } from "../dialect-helpers.js";
 import { validateIdentifier } from "../validate.js";
 
 /**
@@ -51,37 +51,53 @@ export async function up(db: Kysely<unknown>): Promise<void> {
 	await remapMenuItemRefs(db);
 }
 
+/**
+ * D1 commits each statement of a rebuild on its own. A run that stopped
+ * between dropping `table` and renaming `<table>_new` leaves the staged copy
+ * as the only one, and the guards below read the old table, so rename the
+ * staged copy back before they run.
+ */
+async function resumeStagedRebuild(db: Kysely<unknown>, table: string): Promise<void> {
+	const staged = `${table}_new`;
+	if ((await tableExists(db, table)) || !(await tableExists(db, staged))) return;
+	await db.schema.alterTable(staged).renameTo(table).execute();
+}
+
 async function rebuildMenus(db: Kysely<unknown>, defaultLocale: string): Promise<void> {
-	if (await hasColumn(db, "_emdash_menus", "locale")) return;
-	await sql.raw(`DROP TABLE IF EXISTS "_emdash_menus_new"`).execute(db);
+	await resumeStagedRebuild(db, "_emdash_menus");
+	if (!(await hasColumn(db, "_emdash_menus", "locale"))) {
+		await sql.raw(`DROP TABLE IF EXISTS "_emdash_menus_new"`).execute(db);
 
-	await db.schema
-		.createTable("_emdash_menus_new")
-		.addColumn("id", "text", (c) => c.primaryKey())
-		.addColumn("name", "text", (c) => c.notNull())
-		.addColumn("label", "text", (c) => c.notNull())
-		.addColumn("created_at", "text", (c) => c.defaultTo(currentTimestamp(db)))
-		.addColumn("updated_at", "text", (c) => c.defaultTo(currentTimestamp(db)))
-		.addColumn("locale", "text", (c) => c.notNull().defaultTo(defaultLocale))
-		.addColumn("translation_group", "text")
-		.addUniqueConstraint("_emdash_menus_name_locale_unique", ["name", "locale"])
-		.execute();
+		await db.schema
+			.createTable("_emdash_menus_new")
+			.addColumn("id", "text", (c) => c.primaryKey())
+			.addColumn("name", "text", (c) => c.notNull())
+			.addColumn("label", "text", (c) => c.notNull())
+			.addColumn("created_at", "text", (c) => c.defaultTo(currentTimestamp(db)))
+			.addColumn("updated_at", "text", (c) => c.defaultTo(currentTimestamp(db)))
+			.addColumn("locale", "text", (c) => c.notNull().defaultTo(defaultLocale))
+			.addColumn("translation_group", "text")
+			.addUniqueConstraint("_emdash_menus_name_locale_unique", ["name", "locale"])
+			.execute();
 
-	await sql`
-		INSERT INTO _emdash_menus_new (id, name, label, created_at, updated_at, locale, translation_group)
-		SELECT id, name, label, created_at, updated_at, ${defaultLocale}, id FROM _emdash_menus
-	`.execute(db);
+		await sql`
+			INSERT INTO _emdash_menus_new (id, name, label, created_at, updated_at, locale, translation_group)
+			SELECT id, name, label, created_at, updated_at, ${defaultLocale}, id FROM _emdash_menus
+		`.execute(db);
 
-	await db.schema.dropTable("_emdash_menus").execute();
-	await sql`ALTER TABLE _emdash_menus_new RENAME TO _emdash_menus`.execute(db);
+		await db.schema.dropTable("_emdash_menus").execute();
+		await sql`ALTER TABLE _emdash_menus_new RENAME TO _emdash_menus`.execute(db);
+	}
 
 	await db.schema
 		.createIndex("idx__emdash_menus_locale")
+		.ifNotExists()
 		.on("_emdash_menus")
 		.column("locale")
 		.execute();
 	await db.schema
 		.createIndex("idx__emdash_menus_translation_group")
+		.ifNotExists()
 		.on("_emdash_menus")
 		.column("translation_group")
 		.execute();
@@ -94,29 +110,30 @@ async function rebuildMenuItems(db: Kysely<unknown>, defaultLocale: string): Pro
 	// on D1 (#1021). The FKs were never load-bearing at runtime — D1
 	// disables FK enforcement, and `MenuRepository` always deletes
 	// children explicitly. Mirrors `rebuildContentTaxonomies` below.
-	if (await hasColumn(db, "_emdash_menu_items", "locale")) return;
-	await sql.raw(`DROP TABLE IF EXISTS "_emdash_menu_items_new"`).execute(db);
+	await resumeStagedRebuild(db, "_emdash_menu_items");
+	if (!(await hasColumn(db, "_emdash_menu_items", "locale"))) {
+		await sql.raw(`DROP TABLE IF EXISTS "_emdash_menu_items_new"`).execute(db);
 
-	await db.schema
-		.createTable("_emdash_menu_items_new")
-		.addColumn("id", "text", (c) => c.primaryKey())
-		.addColumn("menu_id", "text", (c) => c.notNull())
-		.addColumn("parent_id", "text")
-		.addColumn("sort_order", "integer", (c) => c.notNull().defaultTo(0))
-		.addColumn("type", "text", (c) => c.notNull())
-		.addColumn("reference_collection", "text")
-		.addColumn("reference_id", "text")
-		.addColumn("custom_url", "text")
-		.addColumn("label", "text", (c) => c.notNull())
-		.addColumn("title_attr", "text")
-		.addColumn("target", "text")
-		.addColumn("css_classes", "text")
-		.addColumn("created_at", "text", (c) => c.defaultTo(currentTimestamp(db)))
-		.addColumn("locale", "text", (c) => c.notNull().defaultTo(defaultLocale))
-		.addColumn("translation_group", "text")
-		.execute();
+		await db.schema
+			.createTable("_emdash_menu_items_new")
+			.addColumn("id", "text", (c) => c.primaryKey())
+			.addColumn("menu_id", "text", (c) => c.notNull())
+			.addColumn("parent_id", "text")
+			.addColumn("sort_order", "integer", (c) => c.notNull().defaultTo(0))
+			.addColumn("type", "text", (c) => c.notNull())
+			.addColumn("reference_collection", "text")
+			.addColumn("reference_id", "text")
+			.addColumn("custom_url", "text")
+			.addColumn("label", "text", (c) => c.notNull())
+			.addColumn("title_attr", "text")
+			.addColumn("target", "text")
+			.addColumn("css_classes", "text")
+			.addColumn("created_at", "text", (c) => c.defaultTo(currentTimestamp(db)))
+			.addColumn("locale", "text", (c) => c.notNull().defaultTo(defaultLocale))
+			.addColumn("translation_group", "text")
+			.execute();
 
-	await sql`
+		await sql`
 		INSERT INTO _emdash_menu_items_new (
 			id, menu_id, parent_id, sort_order, type, reference_collection,
 			reference_id, custom_url, label, title_attr, target, css_classes,
@@ -129,73 +146,91 @@ async function rebuildMenuItems(db: Kysely<unknown>, defaultLocale: string): Pro
 		FROM _emdash_menu_items
 	`.execute(db);
 
-	await db.schema.dropTable("_emdash_menu_items").execute();
-	await sql`ALTER TABLE _emdash_menu_items_new RENAME TO _emdash_menu_items`.execute(db);
+		await db.schema.dropTable("_emdash_menu_items").execute();
+		await sql`ALTER TABLE _emdash_menu_items_new RENAME TO _emdash_menu_items`.execute(db);
+	}
 
 	// Indexes from migration 005 are dropped with the underlying table; recreate.
 	await db.schema
 		.createIndex("idx_menu_items_menu")
+		.ifNotExists()
 		.on("_emdash_menu_items")
 		.columns(["menu_id", "sort_order"])
 		.execute();
 	await db.schema
 		.createIndex("idx_menu_items_parent")
+		.ifNotExists()
 		.on("_emdash_menu_items")
 		.column("parent_id")
 		.execute();
 	await db.schema
 		.createIndex("idx__emdash_menu_items_locale")
+		.ifNotExists()
 		.on("_emdash_menu_items")
 		.column("locale")
 		.execute();
 	await db.schema
 		.createIndex("idx__emdash_menu_items_translation_group")
+		.ifNotExists()
 		.on("_emdash_menu_items")
 		.column("translation_group")
 		.execute();
 }
 
 async function rebuildTaxonomies(db: Kysely<unknown>, defaultLocale: string): Promise<void> {
-	if (await hasColumn(db, "taxonomies", "locale")) return;
-	await sql.raw(`DROP TABLE IF EXISTS "taxonomies_new"`).execute(db);
-	await sql`DROP INDEX IF EXISTS idx_taxonomies_name`.execute(db);
+	await resumeStagedRebuild(db, "taxonomies");
+	if (!(await hasColumn(db, "taxonomies", "locale"))) {
+		await sql.raw(`DROP TABLE IF EXISTS "taxonomies_new"`).execute(db);
+		await sql`DROP INDEX IF EXISTS idx_taxonomies_name`.execute(db);
 
-	await db.schema
-		.createTable("taxonomies_new")
-		.addColumn("id", "text", (c) => c.primaryKey())
-		.addColumn("name", "text", (c) => c.notNull())
-		.addColumn("slug", "text", (c) => c.notNull())
-		.addColumn("label", "text", (c) => c.notNull())
-		.addColumn("parent_id", "text")
-		.addColumn("data", "text")
-		.addColumn("locale", "text", (c) => c.notNull().defaultTo(defaultLocale))
-		.addColumn("translation_group", "text")
-		.addUniqueConstraint("taxonomies_name_slug_locale_unique", ["name", "slug", "locale"])
-		// Self-FK points at `taxonomies_new` (not `taxonomies`) so dropping
-		// the old table doesn't fire ON DELETE SET NULL against parent_id
-		// values on D1. SQLite's RENAME rewrites the FK target to the new
-		// name automatically.
-		.addForeignKeyConstraint(
-			"taxonomies_parent_fk",
-			["parent_id"],
-			"taxonomies_new",
-			["id"],
-			(cb) => cb.onDelete("set null"),
-		)
-		.execute();
+		await db.schema
+			.createTable("taxonomies_new")
+			.addColumn("id", "text", (c) => c.primaryKey())
+			.addColumn("name", "text", (c) => c.notNull())
+			.addColumn("slug", "text", (c) => c.notNull())
+			.addColumn("label", "text", (c) => c.notNull())
+			.addColumn("parent_id", "text")
+			.addColumn("data", "text")
+			.addColumn("locale", "text", (c) => c.notNull().defaultTo(defaultLocale))
+			.addColumn("translation_group", "text")
+			.addUniqueConstraint("taxonomies_name_slug_locale_unique", ["name", "slug", "locale"])
+			// Self-FK points at `taxonomies_new` (not `taxonomies`) so dropping
+			// the old table doesn't fire ON DELETE SET NULL against parent_id
+			// values on D1. SQLite's RENAME rewrites the FK target to the new
+			// name automatically.
+			.addForeignKeyConstraint(
+				"taxonomies_parent_fk",
+				["parent_id"],
+				"taxonomies_new",
+				["id"],
+				(cb) => cb.onDelete("set null"),
+			)
+			.execute();
 
-	await sql`
+		await sql`
 		INSERT INTO taxonomies_new (id, name, slug, label, parent_id, data, locale, translation_group)
 		SELECT id, name, slug, label, parent_id, data, ${defaultLocale}, id FROM taxonomies
 	`.execute(db);
 
-	await db.schema.dropTable("taxonomies").execute();
-	await sql`ALTER TABLE taxonomies_new RENAME TO taxonomies`.execute(db);
+		await db.schema.dropTable("taxonomies").execute();
+		await sql`ALTER TABLE taxonomies_new RENAME TO taxonomies`.execute(db);
+	}
 
-	await db.schema.createIndex("idx_taxonomies_name").on("taxonomies").column("name").execute();
-	await db.schema.createIndex("idx_taxonomies_locale").on("taxonomies").column("locale").execute();
+	await db.schema
+		.createIndex("idx_taxonomies_name")
+		.ifNotExists()
+		.on("taxonomies")
+		.column("name")
+		.execute();
+	await db.schema
+		.createIndex("idx_taxonomies_locale")
+		.ifNotExists()
+		.on("taxonomies")
+		.column("locale")
+		.execute();
 	await db.schema
 		.createIndex("idx_taxonomies_translation_group")
+		.ifNotExists()
 		.on("taxonomies")
 		.column("translation_group")
 		.execute();
@@ -211,40 +246,44 @@ async function rebuildTaxonomies(db: Kysely<unknown>, defaultLocale: string): Pr
 }
 
 async function rebuildTaxonomyDefs(db: Kysely<unknown>, defaultLocale: string): Promise<void> {
-	if (await hasColumn(db, "_emdash_taxonomy_defs", "locale")) return;
-	await sql.raw(`DROP TABLE IF EXISTS "_emdash_taxonomy_defs_new"`).execute(db);
+	await resumeStagedRebuild(db, "_emdash_taxonomy_defs");
+	if (!(await hasColumn(db, "_emdash_taxonomy_defs", "locale"))) {
+		await sql.raw(`DROP TABLE IF EXISTS "_emdash_taxonomy_defs_new"`).execute(db);
 
-	await db.schema
-		.createTable("_emdash_taxonomy_defs_new")
-		.addColumn("id", "text", (c) => c.primaryKey())
-		.addColumn("name", "text", (c) => c.notNull())
-		.addColumn("label", "text", (c) => c.notNull())
-		.addColumn("label_singular", "text")
-		.addColumn("hierarchical", "integer", (c) => c.defaultTo(0))
-		.addColumn("collections", "text")
-		.addColumn("created_at", "text", (c) => c.defaultTo(currentTimestamp(db)))
-		.addColumn("locale", "text", (c) => c.notNull().defaultTo(defaultLocale))
-		.addColumn("translation_group", "text")
-		.addUniqueConstraint("_emdash_taxonomy_defs_name_locale_unique", ["name", "locale"])
-		.execute();
+		await db.schema
+			.createTable("_emdash_taxonomy_defs_new")
+			.addColumn("id", "text", (c) => c.primaryKey())
+			.addColumn("name", "text", (c) => c.notNull())
+			.addColumn("label", "text", (c) => c.notNull())
+			.addColumn("label_singular", "text")
+			.addColumn("hierarchical", "integer", (c) => c.defaultTo(0))
+			.addColumn("collections", "text")
+			.addColumn("created_at", "text", (c) => c.defaultTo(currentTimestamp(db)))
+			.addColumn("locale", "text", (c) => c.notNull().defaultTo(defaultLocale))
+			.addColumn("translation_group", "text")
+			.addUniqueConstraint("_emdash_taxonomy_defs_name_locale_unique", ["name", "locale"])
+			.execute();
 
-	await sql`
+		await sql`
 		INSERT INTO _emdash_taxonomy_defs_new
 			(id, name, label, label_singular, hierarchical, collections, created_at, locale, translation_group)
 		SELECT id, name, label, label_singular, hierarchical, collections, created_at, ${defaultLocale}, id
 		FROM _emdash_taxonomy_defs
 	`.execute(db);
 
-	await db.schema.dropTable("_emdash_taxonomy_defs").execute();
-	await sql`ALTER TABLE _emdash_taxonomy_defs_new RENAME TO _emdash_taxonomy_defs`.execute(db);
+		await db.schema.dropTable("_emdash_taxonomy_defs").execute();
+		await sql`ALTER TABLE _emdash_taxonomy_defs_new RENAME TO _emdash_taxonomy_defs`.execute(db);
+	}
 
 	await db.schema
 		.createIndex("idx__emdash_taxonomy_defs_locale")
+		.ifNotExists()
 		.on("_emdash_taxonomy_defs")
 		.column("locale")
 		.execute();
 	await db.schema
 		.createIndex("idx__emdash_taxonomy_defs_translation_group")
+		.ifNotExists()
 		.on("_emdash_taxonomy_defs")
 		.column("translation_group")
 		.execute();
@@ -258,6 +297,7 @@ async function rebuildContentTaxonomies(db: Kysely<unknown>): Promise<void> {
 	// translation_group references after the migration completes. This coupling
 	// is load-bearing — if the translation_group seed ever changes, this needs
 	// an explicit remap *after* `rebuildTaxonomies` runs.
+	await resumeStagedRebuild(db, "content_taxonomies");
 	const fks = await sql<{ id: number }>`PRAGMA foreign_key_list(content_taxonomies)`.execute(db);
 	if (fks.rows.length > 0) {
 		await sql.raw(`DROP TABLE IF EXISTS "content_taxonomies_new"`).execute(db);

package/src/database/migrations/086_relations_structural.ts

@@ -0,0 +1,197 @@
+import type { Kysely } from "kysely";
+import { sql } from "kysely";
+
+import { columnExists, currentTimestamp, tableExists } from "../dialect-helpers.js";
+
+/**
+ * Rebuilds `_emdash_relations` with one row per relation instead of one per
+ * locale. A relation is schema, like `_emdash_collections` and
+ * `_emdash_fields`, whose labels are not localized either.
+ *
+ * A slug identifies exactly one relation. `UNIQUE(name, locale)` let two
+ * unrelated relations share a slug in different locales, so a reference field,
+ * which addresses its relation by slug from any locale, could not resolve it.
+ *
+ * `id` is preserved from the old `translation_group`, so values already stored
+ * in `_emdash_content_references` stay valid and that column is renamed rather
+ * than remapped.
+ *
+ * Link limits and singular labels are per side of the relation, not per field:
+ * a reference field binds to a relation and a side, and every field bound to
+ * that side shares its limit.
+ *
+ * Migration 043 cannot re-run after this one: it indexes `locale` and
+ * `translation_group`, which no longer exist.
+ */
+
+interface OldRelationRow {
+	id: string;
+	name: string;
+	parent_collection: string;
+	child_collection: string;
+	parent_label: string;
+	child_label: string;
+	locale: string;
+	translation_group: string;
+}
+
+interface CollapsedRelation {
+	id: string;
+	slug: string;
+	parent_collection: string;
+	child_collection: string;
+	parent_label: string;
+	child_label: string;
+}
+
+/**
+ * Collapse the per-locale rows to one row per relation, with a slug unique
+ * across all of them.
+ *
+ * `UNIQUE(name, locale)` allowed two groups to share a name, so the collapse
+ * can collide; a colliding relation takes a numeric suffix rather than failing
+ * the migration. Groups are processed in a fixed order so every replica lands
+ * on the same result.
+ */
+function collapseGroups(rows: OldRelationRow[]): CollapsedRelation[] {
+	const byGroup = new Map<string, OldRelationRow[]>();
+	for (const row of rows) {
+		const group = byGroup.get(row.translation_group);
+		if (group) group.push(row);
+		else byGroup.set(row.translation_group, [row]);
+	}
+
+	const collapsed: CollapsedRelation[] = [];
+	const takenSlugs = new Set<string>();
+
+	// Fixed order so every replica lands on the same slug suffixes.
+	for (const translationGroup of [...byGroup.keys()].toSorted()) {
+		const groupRows = byGroup.get(translationGroup) ?? [];
+		// Structural fields are identical across a group by construction; the
+		// labels are not, so the lowest locale code wins — deterministic, and it
+		// keeps the default locale's wording on a two-locale site.
+		const canonical = groupRows.toSorted((a, b) => (a.locale < b.locale ? -1 : 1))[0];
+		if (!canonical) continue;
+
+		let slug = canonical.name;
+		for (let suffix = 2; takenSlugs.has(slug); suffix++) {
+			slug = `${canonical.name.slice(0, 63 - String(suffix).length - 1)}_${suffix}`;
+		}
+		takenSlugs.add(slug);
+
+		collapsed.push({
+			id: translationGroup,
+			slug,
+			parent_collection: canonical.parent_collection,
+			child_collection: canonical.child_collection,
+			parent_label: canonical.parent_label,
+			child_label: canonical.child_label,
+		});
+	}
+
+	return collapsed;
+}
+
+async function createRelationsTable(db: Kysely<unknown>, name: string): Promise<void> {
+	await db.schema
+		.createTable(name)
+		.addColumn("id", "text", (c) => c.primaryKey())
+		.addColumn("slug", "text", (c) => c.notNull())
+		.addColumn("parent_collection", "text", (c) => c.notNull())
+		.addColumn("child_collection", "text", (c) => c.notNull())
+		.addColumn("parent_label", "text", (c) => c.notNull())
+		.addColumn("child_label", "text", (c) => c.notNull())
+		.addColumn("parent_label_singular", "text")
+		.addColumn("child_label_singular", "text")
+		// NULL means unlimited on that side.
+		.addColumn("max_children_per_parent", "integer")
+		.addColumn("max_parents_per_child", "integer")
+		.addColumn("created_at", "text", (c) => c.defaultTo(currentTimestamp(db)))
+		.addColumn("updated_at", "text", (c) => c.defaultTo(currentTimestamp(db)))
+		.addUniqueConstraint("_emdash_relations_slug_unique", ["slug"])
+		.execute();
+}
+
+async function createRelationIndexes(db: Kysely<unknown>): Promise<void> {
+	await db.schema
+		.createIndex("idx__emdash_relations_parent_collection")
+		.ifNotExists()
+		.on("_emdash_relations")
+		.column("parent_collection")
+		.execute();
+	await db.schema
+		.createIndex("idx__emdash_relations_child_collection")
+		.ifNotExists()
+		.on("_emdash_relations")
+		.column("child_collection")
+		.execute();
+}
+
+/**
+ * Rename the edge table's relation column. The column holds a relation id now,
+ * not a translation group. Values are unchanged — `id` was preserved from the
+ * group — so this is a rename, not a remap. SQLite and Postgres both carry
+ * indexes and constraints across `RENAME COLUMN`.
+ */
+async function renameEdgeRelationColumn(db: Kysely<unknown>): Promise<void> {
+	if (!(await columnExists(db, "_emdash_content_references", "relation_group"))) return;
+	await sql
+		.raw(`ALTER TABLE "_emdash_content_references" RENAME COLUMN "relation_group" TO "relation_id"`)
+		.execute(db);
+}
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+	// The rebuild drops the old table before renaming the new one into place, so
+	// a run interrupted between those two statements leaves the data in
+	// `_emdash_relations_new` and no `_emdash_relations` at all. Finish that
+	// rename before anything else looks for the old table.
+	if (
+		(await tableExists(db, "_emdash_relations_new")) &&
+		!(await tableExists(db, "_emdash_relations"))
+	) {
+		await sql.raw(`ALTER TABLE "_emdash_relations_new" RENAME TO "_emdash_relations"`).execute(db);
+	}
+
+	if (await columnExists(db, "_emdash_relations", "slug")) {
+		// The table is already rebuilt. The edge-column rename is the last
+		// statement and has its own guard, so a run interrupted between the two
+		// still completes here rather than leaving `relation_group` behind
+		// forever.
+		await createRelationIndexes(db);
+		await renameEdgeRelationColumn(db);
+		return;
+	}
+
+	const existing = await sql<OldRelationRow>`
+		SELECT id, name, parent_collection, child_collection,
+		       parent_label, child_label, locale, translation_group
+		FROM ${sql.ref("_emdash_relations")}
+	`.execute(db);
+	const collapsed = collapseGroups(existing.rows);
+
+	await sql.raw(`DROP TABLE IF EXISTS "_emdash_relations_new"`).execute(db);
+	await createRelationsTable(db, "_emdash_relations_new");
+
+	for (const row of collapsed) {
+		// oxlint-disable-next-line no-await-in-loop -- one statement per relation; the table holds a handful of rows
+		await sql`
+			INSERT INTO ${sql.ref("_emdash_relations_new")}
+				(id, slug, parent_collection, child_collection, parent_label, child_label)
+			VALUES (${row.id}, ${row.slug}, ${row.parent_collection}, ${row.child_collection},
+			        ${row.parent_label}, ${row.child_label})
+		`.execute(db);
+	}
+
+	await db.schema.dropTable("_emdash_relations").execute();
+	await sql.raw(`ALTER TABLE "_emdash_relations_new" RENAME TO "_emdash_relations"`).execute(db);
+
+	await createRelationIndexes(db);
+	await renameEdgeRelationColumn(db);
+}
+
+export async function down(_db: Kysely<unknown>): Promise<void> {
+	// no-op: the collapse is not reversible. Each relation's per-locale rows were
+	// merged into one, so the locale variants they carried no longer exist to be
+	// restored — rebuilding the old shape would fabricate a single locale's
+	// labels for every language.
+}