emdash 0.11.1 → 0.13.0

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

@@ -20,18 +20,26 @@ export async function up(db: Kysely<unknown>): Promise<void> {
 	const defaultLocale = getDefaultLocale();
 
 	if (isSqlite(db)) {
-		// FKs off: rebuilding `taxonomies` would CASCADE-wipe `content_taxonomies`.
-		await sql.raw(`PRAGMA foreign_keys = OFF`).execute(db);
-		try {
-			await rebuildMenus(db, defaultLocale);
-			await addItemColumns(db, defaultLocale);
-			await rebuildTaxonomies(db, defaultLocale);
-			await rebuildTaxonomyDefs(db, defaultLocale);
-			await rebuildContentTaxonomies(db);
-			await remapMenuItemRefs(db);
-		} finally {
-			await sql.raw(`PRAGMA foreign_keys = ON`).execute(db);
-		}
+		// Rebuild children before parents to drop FKs that would CASCADE
+		// on D1. D1 enforces FKs but ignores `PRAGMA foreign_keys = OFF`
+		// (the standard SQLite escape), and its replacement
+		// `PRAGMA defer_foreign_keys = ON` only defers constraint
+		// validation, not CASCADE actions — so DROP TABLE <parent> still
+		// wipes child rows (#1021). The FKs have to be physically removed
+		// before the drop.
+		// - `content_taxonomies.taxonomy_id` → `taxonomies(id) ON DELETE CASCADE`
+		// - `_emdash_menu_items.menu_id` → `_emdash_menus(id) ON DELETE CASCADE`
+		// - `_emdash_menu_items.parent_id` → `_emdash_menu_items(id) ON DELETE CASCADE`
+		// Both FKs on `_emdash_menu_items` are stripped during the rebuild.
+		// The runtime (`MenuRepository.delete` / `setItems`) already
+		// performs the child-delete explicitly, so the loss of the cascade
+		// is invisible to callers.
+		await rebuildContentTaxonomies(db);
+		await rebuildMenuItems(db, defaultLocale);
+		await rebuildMenus(db, defaultLocale);
+		await rebuildTaxonomies(db, defaultLocale);
+		await rebuildTaxonomyDefs(db, defaultLocale);
+		await remapMenuItemRefs(db);
 		return;
 	}
 
@@ -79,17 +87,62 @@ async function rebuildMenus(db: Kysely<unknown>, defaultLocale: string): Promise
 		.execute();
 }
 
-async function addItemColumns(db: Kysely<unknown>, defaultLocale: string): Promise<void> {
+async function rebuildMenuItems(db: Kysely<unknown>, defaultLocale: string): Promise<void> {
+	// Full table rebuild rather than ALTER TABLE ADD COLUMN: this strips
+	// the `menu_id` and `parent_id` FKs from migration 005 so the
+	// subsequent `DROP TABLE _emdash_menus` can't cascade-wipe menu items
+	// 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 db.schema
-		.alterTable("_emdash_menu_items")
+		.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.alterTable("_emdash_menu_items").addColumn("translation_group", "text").execute();
 
-	await sql`UPDATE _emdash_menu_items SET translation_group = id`.execute(db);
+	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,
+			created_at, locale, translation_group
+		)
+		SELECT
+			id, menu_id, parent_id, sort_order, type, reference_collection,
+			reference_id, custom_url, label, title_attr, target, css_classes,
+			created_at, ${defaultLocale}, id
+		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);
+
+	// Indexes from migration 005 are dropped with the underlying table; recreate.
+	await db.schema
+		.createIndex("idx_menu_items_menu")
+		.on("_emdash_menu_items")
+		.columns(["menu_id", "sort_order"])
+		.execute();
+	await db.schema
+		.createIndex("idx_menu_items_parent")
+		.on("_emdash_menu_items")
+		.column("parent_id")
+		.execute();
 	await db.schema
 		.createIndex("idx__emdash_menu_items_locale")
 		.on("_emdash_menu_items")
@@ -118,8 +171,16 @@ async function rebuildTaxonomies(db: Kysely<unknown>, defaultLocale: string): Pr
 		.addColumn("locale", "text", (c) => c.notNull().defaultTo(defaultLocale))
 		.addColumn("translation_group", "text")
 		.addUniqueConstraint("taxonomies_name_slug_locale_unique", ["name", "slug", "locale"])
-		.addForeignKeyConstraint("taxonomies_parent_fk", ["parent_id"], "taxonomies", ["id"], (cb) =>
-			cb.onDelete("set null"),
+		// 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();
 
@@ -181,8 +242,13 @@ async function rebuildTaxonomyDefs(db: Kysely<unknown>, defaultLocale: string):
 }
 
 async function rebuildContentTaxonomies(db: Kysely<unknown>): Promise<void> {
-	// Drop the FK (taxonomy_id now points at translation_group, not a row id)
-	// and remap the values.
+	// Drops the FK so `taxonomy_id` can point at a translation_group rather
+	// than a row id. Runs before `rebuildTaxonomies` so the drop is safe on D1.
+	// No remap is needed here: `rebuildTaxonomies` later seeds `translation_group
+	// = id` for every preserved row, so the row-id values we copy resolve as
+	// 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.
 	const fks = await sql<{ id: number }>`PRAGMA foreign_key_list(content_taxonomies)`.execute(db);
 	if (fks.rows.length === 0) return;
 
@@ -197,15 +263,17 @@ async function rebuildContentTaxonomies(db: Kysely<unknown>): Promise<void> {
 
 	await sql`
 		INSERT OR IGNORE INTO content_taxonomies_new (collection, entry_id, taxonomy_id)
-		SELECT ct.collection, ct.entry_id, COALESCE(
-			(SELECT t.translation_group FROM taxonomies t WHERE t.id = ct.taxonomy_id),
-			ct.taxonomy_id
-		)
-		FROM content_taxonomies ct
+		SELECT collection, entry_id, taxonomy_id FROM content_taxonomies
 	`.execute(db);
 
 	await db.schema.dropTable("content_taxonomies").execute();
 	await sql`ALTER TABLE content_taxonomies_new RENAME TO content_taxonomies`.execute(db);
+
+	// SQLite drops indexes when the underlying table is dropped. Restore the
+	// taxonomy_id index from migration 015.
+	await sql`CREATE INDEX IF NOT EXISTS idx_content_taxonomies_term ON content_taxonomies(taxonomy_id)`.execute(
+		db,
+	);
 }
 
 async function remapMenuItemRefs(db: Kysely<unknown>): Promise<void> {
@@ -302,6 +370,34 @@ function validateSystemIdent(name: string): void {
 	if (!SYSTEM_IDENT.test(name)) throw new Error(`Invalid identifier: "${name}"`);
 }
 
+/**
+ * down() restores the FK on content_taxonomies. Rows whose taxonomy_id doesn't
+ * resolve to a (translation_group, defaultLocale) pair would fail the rebuild
+ * after other tables are already stripped — leaving the user mid-rollback.
+ * Surface dangling rows up front instead.
+ */
+async function assertContentTaxonomiesResolve(
+	db: Kysely<unknown>,
+	defaultLocale: string,
+): Promise<void> {
+	const result = await sql<{ count: number | string }>`
+		SELECT COUNT(*) AS count FROM content_taxonomies ct
+		WHERE NOT EXISTS (
+			SELECT 1 FROM taxonomies t
+			WHERE t.translation_group = ct.taxonomy_id AND t.locale = ${defaultLocale}
+		)
+	`.execute(db);
+	const count = Number(result.rows[0]?.count ?? 0);
+	if (count > 0) {
+		throw new Error(
+			`Cannot revert migration 036_i18n_menus_and_taxonomies: ` +
+				`${count} row(s) in "content_taxonomies" reference a translation_group ` +
+				`with no row in "taxonomies" at locale="${defaultLocale}". ` +
+				`Clean up the dangling associations before rolling back.`,
+		);
+	}
+}
+
 /**
  * down() is destructive on multi-locale installs (dropping `locale` collapses
  * translated rows onto an ambiguous unique key). Refuse to run when any row
@@ -331,6 +427,7 @@ async function assertSingleLocale(db: Kysely<unknown>, defaultLocale: string): P
 export async function down(db: Kysely<unknown>): Promise<void> {
 	const defaultLocale = getDefaultLocale();
 	await assertSingleLocale(db, defaultLocale);
+	await assertContentTaxonomiesResolve(db, defaultLocale);
 
 	const widenedTables = [
 		"_emdash_menus",
@@ -340,23 +437,28 @@ export async function down(db: Kysely<unknown>): Promise<void> {
 	];
 
 	if (isSqlite(db)) {
-		// FKs off — same reason as up().
-		await sql.raw(`PRAGMA foreign_keys = OFF`).execute(db);
-		try {
-			// Indexes first: a locale index blocks DROP COLUMN on _emdash_menu_items.
-			for (const t of widenedTables) {
-				await sql.raw(`DROP INDEX IF EXISTS idx_${t}_locale`).execute(db);
-				await sql.raw(`DROP INDEX IF EXISTS idx_${t}_translation_group`).execute(db);
-			}
-
-			await rebuildContentTaxonomiesDown(db, defaultLocale);
-			await rebuildMenusDown(db);
-			await rebuildMenuItemsDown(db);
-			await rebuildTaxonomiesDown(db);
-			await rebuildTaxonomyDefsDown(db);
-		} finally {
-			await sql.raw(`PRAGMA foreign_keys = ON`).execute(db);
+		// Indexes first: the locale index on _emdash_menu_items would
+		// otherwise block its DROP COLUMN.
+		for (const t of widenedTables) {
+			await sql.raw(`DROP INDEX IF EXISTS idx_${t}_locale`).execute(db);
+			await sql.raw(`DROP INDEX IF EXISTS idx_${t}_translation_group`).execute(db);
 		}
+
+		// Remap content_taxonomies values back to row ids while `taxonomies`
+		// still has `translation_group` + `locale`. No FK is restored yet, so
+		// the subsequent DROP TABLE taxonomies can't cascade on D1 (#1021).
+		await remapContentTaxonomiesDown(db, defaultLocale);
+		// Menus first: safe because up() stripped the cascade FK from
+		// _emdash_menu_items.menu_id, so dropping _emdash_menus doesn't
+		// cascade. The FK from migration 005 is NOT restored on
+		// _emdash_menu_items: the runtime deletes children explicitly,
+		// so the only observable effect of the FK was the #1021 cascade
+		// we're trying to avoid.
+		await rebuildMenusDown(db);
+		await rebuildMenuItemsDown(db);
+		await rebuildTaxonomiesDown(db);
+		await rebuildTaxonomyDefsDown(db);
+		await restoreContentTaxonomiesFk(db);
 		return;
 	}
 
@@ -368,10 +470,24 @@ export async function down(db: Kysely<unknown>): Promise<void> {
 	}
 }
 
-async function rebuildContentTaxonomiesDown(
+async function remapContentTaxonomiesDown(
 	db: Kysely<unknown>,
 	defaultLocale: string,
 ): Promise<void> {
+	// Map translation_group back to row id (assertSingleLocale guarantees 1:1)
+	// without restoring the FK — that happens after `taxonomies` is rebuilt.
+	await sql`
+		UPDATE content_taxonomies
+		SET taxonomy_id = COALESCE(
+			(SELECT t.id FROM taxonomies t
+			 WHERE t.translation_group = content_taxonomies.taxonomy_id
+				 AND t.locale = ${defaultLocale}),
+			taxonomy_id
+		)
+	`.execute(db);
+}
+
+async function restoreContentTaxonomiesFk(db: Kysely<unknown>): Promise<void> {
 	await sql.raw(`DROP TABLE IF EXISTS "content_taxonomies_new"`).execute(db);
 	await db.schema
 		.createTable("content_taxonomies_new")
@@ -388,18 +504,17 @@ async function rebuildContentTaxonomiesDown(
 		)
 		.execute();
 
-	// Map translation_group back to a row id (assertSingleLocale guarantees a 1:1 match).
 	await sql`
 		INSERT OR IGNORE INTO content_taxonomies_new (collection, entry_id, taxonomy_id)
-		SELECT ct.collection, ct.entry_id, COALESCE(
-			(SELECT t.id FROM taxonomies t WHERE t.translation_group = ct.taxonomy_id AND t.locale = ${defaultLocale}),
-			ct.taxonomy_id
-		)
-		FROM content_taxonomies ct
+		SELECT collection, entry_id, taxonomy_id FROM content_taxonomies
 	`.execute(db);
 
 	await db.schema.dropTable("content_taxonomies").execute();
 	await sql`ALTER TABLE content_taxonomies_new RENAME TO content_taxonomies`.execute(db);
+
+	await sql`CREATE INDEX IF NOT EXISTS idx_content_taxonomies_term ON content_taxonomies(taxonomy_id)`.execute(
+		db,
+	);
 }
 
 async function rebuildMenusDown(db: Kysely<unknown>): Promise<void> {
@@ -421,7 +536,9 @@ async function rebuildMenusDown(db: Kysely<unknown>): Promise<void> {
 }
 
 async function rebuildMenuItemsDown(db: Kysely<unknown>): Promise<void> {
-	// No UNIQUE on (locale,…) here, so DROP COLUMN is enough.
+	// No UNIQUE on (locale,…) here, so DROP COLUMN suffices. The migration-005
+	// FKs are NOT restored: up() removed them to fix #1021, and the runtime
+	// already deletes child rows explicitly so the cascade isn't needed.
 	await sql.raw(`ALTER TABLE _emdash_menu_items DROP COLUMN locale`).execute(db);
 	await sql.raw(`ALTER TABLE _emdash_menu_items DROP COLUMN translation_group`).execute(db);
 }

package/src/database/migrations/038_registry_plugin_state.ts

@@ -0,0 +1,130 @@
+import type { Kysely } from "kysely";
+import { sql } from "kysely";
+
+import { isSqlite } from "../dialect-helpers.js";
+
+interface ColumnInfo {
+	name: string;
+}
+
+interface IndexInfo {
+	name: string;
+}
+
+/**
+ * Migration: Add registry fields to _plugin_state
+ *
+ * Extends the marketplace columns added in 022 to support the
+ * experimental decentralized plugin registry (see RFC #694). Rather
+ * than introducing a separate `_registry_plugin_state` table, we
+ * reuse the same row shape and distinguish registry installs via the
+ * existing `source` column (now `'config' | 'marketplace' | 'registry'`).
+ *
+ * Registry plugins are addressed by `(publisher_did, slug)` in their
+ * lexicon records but stored under a hashed, opaque `plugin_id` for
+ * runtime compatibility -- see `packages/core/src/registry/plugin-id.ts`.
+ * The `(publisher_did, slug)` pair is preserved here for update
+ * resolution against the currently configured aggregator and for admin
+ * UI rendering ("by @example.dev").
+ *
+ * All new columns are nullable; existing marketplace and config rows
+ * keep working unchanged.
+ *
+ * Idempotency: D1 and SQLite don't honor the migration runner's
+ * advisory lock, so a partial re-apply (cold start race between two
+ * isolates, retry after a connection drop) can re-enter this `up`
+ * function with the columns or index already in place. Each step
+ * checks before adding to keep the migration safe under partial
+ * re-application. The same pattern is used in 019_i18n.ts.
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	if (isSqlite(db)) {
+		await upSqlite(db);
+	} else {
+		await upPostgres(db);
+	}
+}
+
+async function upSqlite(db: Kysely<unknown>): Promise<void> {
+	const cols = await sql<ColumnInfo>`PRAGMA table_info(_plugin_state)`.execute(db);
+	const colNames = new Set(cols.rows.map((c) => c.name));
+
+	if (!colNames.has("registry_publisher_did")) {
+		await sql`
+			ALTER TABLE _plugin_state
+			ADD COLUMN registry_publisher_did TEXT
+		`.execute(db);
+	}
+
+	if (!colNames.has("registry_slug")) {
+		await sql`
+			ALTER TABLE _plugin_state
+			ADD COLUMN registry_slug TEXT
+		`.execute(db);
+	}
+
+	const indexes = await sql<IndexInfo>`PRAGMA index_list(_plugin_state)`.execute(db);
+	const indexNames = new Set(indexes.rows.map((i) => i.name));
+
+	if (!indexNames.has("idx_plugin_state_registry")) {
+		await sql`
+			CREATE INDEX idx_plugin_state_registry
+			ON _plugin_state (source)
+			WHERE source = 'registry'
+		`.execute(db);
+	}
+}
+
+async function upPostgres(db: Kysely<unknown>): Promise<void> {
+	// Scope the column check to the connection's current schema.
+	// Without `table_schema = current_schema()`, a `_plugin_state` table
+	// in another schema (per-tenant Postgres, shared Postgres clusters,
+	// per-test schemas) makes this query see columns from the wrong
+	// table and skip the ALTERs entirely, leaving the active schema's
+	// `_plugin_state` missing the registry columns.
+	const cols = await sql<{ column_name: string }>`
+		SELECT column_name FROM information_schema.columns
+		WHERE table_name = '_plugin_state'
+		  AND table_schema = current_schema()
+	`.execute(db);
+	const colNames = new Set(cols.rows.map((c) => c.column_name));
+
+	if (!colNames.has("registry_publisher_did")) {
+		await sql`
+			ALTER TABLE _plugin_state
+			ADD COLUMN registry_publisher_did TEXT
+		`.execute(db);
+	}
+
+	if (!colNames.has("registry_slug")) {
+		await sql`
+			ALTER TABLE _plugin_state
+			ADD COLUMN registry_slug TEXT
+		`.execute(db);
+	}
+
+	// pg's CREATE INDEX IF NOT EXISTS handles the race natively; partial
+	// index syntax differs from SQLite (`WHERE` is supported), so the
+	// statement is otherwise identical.
+	await sql`
+		CREATE INDEX IF NOT EXISTS idx_plugin_state_registry
+		ON _plugin_state (source)
+		WHERE source = 'registry'
+	`.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	await sql`
+		DROP INDEX IF EXISTS idx_plugin_state_registry
+	`.execute(db);
+
+	await sql`
+		ALTER TABLE _plugin_state
+		DROP COLUMN registry_slug
+	`.execute(db);
+
+	await sql`
+		ALTER TABLE _plugin_state
+		DROP COLUMN registry_publisher_did
+	`.execute(db);
+}