emdash 0.9.0 → 0.11.0

package/src/seed/apply.ts

@@ -19,6 +19,7 @@ import { TaxonomyRepository } from "../database/repositories/taxonomy.js";
 import { withTransaction } from "../database/transaction.js";
 import type { Database } from "../database/types.js";
 import type { MediaValue } from "../fields/types.js";
+import { getI18nConfig } from "../i18n/config.js";
 import { ssrfSafeFetch, validateExternalUrl } from "../import/ssrf.js";
 import { SchemaRegistry } from "../schema/registry.js";
 import { FTSManager } from "../search/fts-manager.js";
@@ -219,17 +220,30 @@ export async function applySeed(
 
 	// 4-5. Taxonomies
 	if (seed.taxonomies) {
+		// seed-local id -> resolved info, used to wire `translationOf` refs.
+		const defSeedIdMap = new Map<string, { id: string; translationGroup: string }>();
+		const termSeedIdMap = new Map<string, string>();
+		const fallbackLocale = getI18nConfig()?.defaultLocale ?? "en";
+
 		for (const taxonomy of seed.taxonomies) {
-			// Check if taxonomy definition exists
+			const defLocale = taxonomy.locale ?? fallbackLocale;
+
+			// (name, locale) is the UNIQUE key after migration 036.
 			const existingDef = await db
 				.selectFrom("_emdash_taxonomy_defs")
 				.selectAll()
 				.where("name", "=", taxonomy.name)
+				.where("locale", "=", defLocale)
 				.executeTakeFirst();
 
+			let defId: string;
+			let defTranslationGroup: string;
+
 			if (existingDef) {
+				defId = existingDef.id;
+				defTranslationGroup = existingDef.translation_group ?? existingDef.id;
 				if (onConflict === "error") {
-					throw new Error(`Conflict: taxonomy "${taxonomy.name}" already exists`);
+					throw new Error(`Conflict: taxonomy "${taxonomy.name}" (${defLocale}) already exists`);
 				}
 				if (onConflict === "update") {
 					await db
@@ -242,40 +256,59 @@ export async function applySeed(
 						})
 						.where("id", "=", existingDef.id)
 						.execute();
-					// Taxonomy defs don't track an "updated" counter -- just the definition is updated
 				}
-				// skip: do nothing for the definition
 			} else {
-				// Create taxonomy definition
+				defId = ulid();
+				defTranslationGroup = defId;
+				if (taxonomy.translationOf) {
+					const source = defSeedIdMap.get(taxonomy.translationOf);
+					if (source) defTranslationGroup = source.translationGroup;
+					else
+						console.warn(
+							`taxonomy "${taxonomy.name}" (${defLocale}): translationOf "${taxonomy.translationOf}" not found yet; minting a fresh group.`,
+						);
+				}
 				await db
 					.insertInto("_emdash_taxonomy_defs")
 					.values({
-						id: ulid(),
+						id: defId,
 						name: taxonomy.name,
 						label: taxonomy.label,
 						label_singular: taxonomy.labelSingular ?? null,
 						hierarchical: taxonomy.hierarchical ? 1 : 0,
 						collections: JSON.stringify(taxonomy.collections),
+						locale: defLocale,
+						translation_group: defTranslationGroup,
 					})
 					.execute();
 				result.taxonomies.created++;
 			}
 
+			if (taxonomy.id)
+				defSeedIdMap.set(taxonomy.id, { id: defId, translationGroup: defTranslationGroup });
+
 			// Create terms (if provided)
 			if (taxonomy.terms && taxonomy.terms.length > 0) {
 				const termRepo = new TaxonomyRepository(db);
 
-				// For hierarchical taxonomies, we need to create parents before children
 				if (taxonomy.hierarchical) {
-					await applyHierarchicalTerms(termRepo, taxonomy.name, taxonomy.terms, result, onConflict);
+					await applyHierarchicalTerms(
+						termRepo,
+						taxonomy.name,
+						defLocale,
+						taxonomy.terms,
+						termSeedIdMap,
+						result,
+						onConflict,
+					);
 				} else {
-					// Flat taxonomy - create all terms
 					for (const term of taxonomy.terms) {
-						const existing = await termRepo.findBySlug(taxonomy.name, term.slug);
+						const termLocale = term.locale ?? defLocale;
+						const existing = await termRepo.findBySlug(taxonomy.name, term.slug, termLocale);
 						if (existing) {
 							if (onConflict === "error") {
 								throw new Error(
-									`Conflict: taxonomy term "${term.slug}" in "${taxonomy.name}" already exists`,
+									`Conflict: taxonomy term "${term.slug}" in "${taxonomy.name}" (${termLocale}) already exists`,
 								);
 							}
 							if (onConflict === "update") {
@@ -285,14 +318,20 @@ export async function applySeed(
 								});
 								result.taxonomies.terms++;
 							}
-							// skip: do nothing
+							if (term.id) termSeedIdMap.set(term.id, existing.id);
 						} else {
-							await termRepo.create({
+							const translationOf = term.translationOf
+								? termSeedIdMap.get(term.translationOf)
+								: undefined;
+							const created = await termRepo.create({
 								name: taxonomy.name,
 								slug: term.slug,
 								label: term.label,
 								data: term.description ? { description: term.description } : undefined,
+								locale: termLocale,
+								translationOf,
 							});
+							if (term.id) termSeedIdMap.set(term.id, created.id);
 							result.taxonomies.terms++;
 						}
 					}
@@ -471,23 +510,41 @@ export async function applySeed(
 
 	// 8. Menus and Menu Items (after content so refs can resolve)
 	if (seed.menus) {
+		// seed-local id -> resolved info, used to wire `translationOf` refs.
+		const menuSeedIdMap = new Map<string, { id: string; translationGroup: string }>();
+		// Shared across menus: translated items reference anchor items in sibling menus.
+		const itemSeedIdMap = new Map<string, { id: string; translationGroup: string }>();
+		const fallbackLocale = getI18nConfig()?.defaultLocale ?? "en";
+
 		for (const menu of seed.menus) {
-			// Check if menu exists
-			const existingMenu = await db
+			const locale = menu.locale ?? fallbackLocale;
+			let lookup = db
 				.selectFrom("_emdash_menus")
 				.selectAll()
 				.where("name", "=", menu.name)
-				.executeTakeFirst();
+				.where("locale", "=", locale);
+			const existingMenu = await lookup.executeTakeFirst();
 
 			let menuId: string;
+			let translationGroup: string;
 
 			if (existingMenu) {
 				menuId = existingMenu.id;
+				translationGroup = existingMenu.translation_group ?? existingMenu.id;
 				// Clear existing items (menus are recreated)
 				await db.deleteFrom("_emdash_menu_items").where("menu_id", "=", menuId).execute();
 			} else {
-				// Create menu
 				menuId = ulid();
+				// Resolve translationOf to the source menu's translation_group.
+				translationGroup = menuId;
+				if (menu.translationOf) {
+					const source = menuSeedIdMap.get(menu.translationOf);
+					if (source) translationGroup = source.translationGroup;
+					else
+						console.warn(
+							`menu "${menu.name}" (${locale}): translationOf "${menu.translationOf}" not found yet; minting a fresh group.`,
+						);
+				}
 				await db
 					.insertInto("_emdash_menus")
 					.values({
@@ -496,19 +553,25 @@ export async function applySeed(
 						label: menu.label,
 						created_at: new Date().toISOString(),
 						updated_at: new Date().toISOString(),
+						locale,
+						translation_group: translationGroup,
 					})
 					.execute();
 				result.menus.created++;
 			}
 
+			if (menu.id) menuSeedIdMap.set(menu.id, { id: menuId, translationGroup });
+
 			// Create menu items
 			const itemCount = await applyMenuItems(
 				db,
 				menuId,
+				locale,
 				menu.items,
 				null, // parent_id
 				0, // sort_order
 				seedIdMap,
+				itemSeedIdMap,
 			);
 			result.menus.items += itemCount;
 		}
@@ -692,64 +755,75 @@ export async function applySeed(
 async function applyHierarchicalTerms(
 	termRepo: TaxonomyRepository,
 	taxonomyName: string,
+	defLocale: string,
 	terms: SeedTaxonomyTerm[],
+	termSeedIdMap: Map<string, string>,
 	result: SeedApplyResult,
 	onConflict: "skip" | "update" | "error" = "skip",
 ): Promise<void> {
-	// Map slugs to IDs
+	// "locale::slug" -> id, so the same slug can resolve per locale.
 	const slugToId = new Map<string, string>();
 
-	// Multiple passes to handle deep nesting
+	// Multiple passes — handles deep nesting and translationOf forward refs.
 	let remaining = [...terms];
-	let maxPasses = 10; // Prevent infinite loop
+	let maxPasses = 10;
 
 	while (remaining.length > 0 && maxPasses > 0) {
 		const processedThisPass: string[] = [];
 
 		for (const term of remaining) {
-			// Check if parent exists (or no parent)
-			if (!term.parent || slugToId.has(term.parent)) {
-				const parentId = term.parent ? slugToId.get(term.parent) : undefined;
+			const termLocale = term.locale ?? defLocale;
+			const parentReady = !term.parent || slugToId.has(`${termLocale}::${term.parent}`);
+			const translationReady = !term.translationOf || termSeedIdMap.has(term.translationOf);
 
-				const existing = await termRepo.findBySlug(taxonomyName, term.slug);
-				if (existing) {
-					if (onConflict === "error") {
-						throw new Error(
-							`Conflict: taxonomy term "${term.slug}" in "${taxonomyName}" already exists`,
-						);
-					}
-					if (onConflict === "update") {
-						await termRepo.update(existing.id, {
-							label: term.label,
-							parentId,
-							data: term.description ? { description: term.description } : {},
-						});
-						result.taxonomies.terms++;
-					}
-					slugToId.set(term.slug, existing.id);
-				} else {
-					const created = await termRepo.create({
-						name: taxonomyName,
-						slug: term.slug,
+			if (!parentReady || !translationReady) continue;
+
+			const parentId = term.parent ? slugToId.get(`${termLocale}::${term.parent}`) : undefined;
+			const translationOf = term.translationOf ? termSeedIdMap.get(term.translationOf) : undefined;
+
+			const existing = await termRepo.findBySlug(taxonomyName, term.slug, termLocale);
+			if (existing) {
+				if (onConflict === "error") {
+					throw new Error(
+						`Conflict: taxonomy term "${term.slug}" in "${taxonomyName}" (${termLocale}) already exists`,
+					);
+				}
+				if (onConflict === "update") {
+					await termRepo.update(existing.id, {
 						label: term.label,
 						parentId,
-						data: term.description ? { description: term.description } : undefined,
+						data: term.description ? { description: term.description } : {},
 					});
-					slugToId.set(term.slug, created.id);
 					result.taxonomies.terms++;
 				}
-
-				processedThisPass.push(term.slug);
+				slugToId.set(`${termLocale}::${term.slug}`, existing.id);
+				if (term.id) termSeedIdMap.set(term.id, existing.id);
+			} else {
+				const created = await termRepo.create({
+					name: taxonomyName,
+					slug: term.slug,
+					label: term.label,
+					parentId,
+					data: term.description ? { description: term.description } : undefined,
+					locale: termLocale,
+					translationOf,
+				});
+				slugToId.set(`${termLocale}::${term.slug}`, created.id);
+				if (term.id) termSeedIdMap.set(term.id, created.id);
+				result.taxonomies.terms++;
 			}
+
+			processedThisPass.push(term.slug + "::" + termLocale);
 		}
 
-		// Remove processed terms
-		remaining = remaining.filter((t) => !processedThisPass.includes(t.slug));
+		remaining = remaining.filter(
+			(t) => !processedThisPass.includes(t.slug + "::" + (t.locale ?? defLocale)),
+		);
 		maxPasses--;
 	}
 
 	if (remaining.length > 0) {
-		console.warn(`Could not process ${remaining.length} terms due to missing parents`);
+		console.warn(`Could not process ${remaining.length} terms due to missing parents/translations`);
 	}
 }
 
@@ -847,21 +921,29 @@ async function applyContentTaxonomies(
 }
 
 /**
- * Apply menu items recursively
+ * Apply menu items recursively.
+ *
+ * When a `SeedMenuItem` carries `id`/`translationOf`, the import resolves the
+ * source item's `translation_group` so cross-locale "same nav entry" links
+ * survive export → apply. Items without `translationOf` get a fresh group
+ * (= their own id).
  */
 async function applyMenuItems(
 	db: Kysely<Database>,
 	menuId: string,
+	locale: string,
 	items: SeedMenuItem[],
 	parentId: string | null,
 	startOrder: number,
 	seedIdMap: Map<string, string>,
+	itemSeedIdMap: Map<string, { id: string; translationGroup: string }>,
 ): Promise<number> {
 	let count = 0;
 	let order = startOrder;
 
 	for (const item of items) {
 		const itemId = ulid();
+		const itemLocale = item.locale ?? locale;
 
 		// Resolve reference if needed
 		let referenceId: string | null = null;
@@ -877,7 +959,16 @@ async function applyMenuItems(
 			// If not in map, the content might not exist yet (will be broken link)
 		}
 
-		// Insert menu item
+		let translationGroup = itemId;
+		if (item.translationOf) {
+			const source = itemSeedIdMap.get(item.translationOf);
+			if (source) translationGroup = source.translationGroup;
+			else
+				console.warn(
+					`menu item "${item.label ?? item.url ?? item.ref ?? "(unlabeled)"}" (${itemLocale}): translationOf "${item.translationOf}" not found yet; minting a fresh group.`,
+				);
+		}
+
 		await db
 			.insertInto("_emdash_menu_items")
 			.values({
@@ -894,15 +985,27 @@ async function applyMenuItems(
 				target: item.target ?? null,
 				css_classes: item.cssClasses ?? null,
 				created_at: new Date().toISOString(),
+				locale: itemLocale,
+				translation_group: translationGroup,
 			})
 			.execute();
 
+		if (item.id) itemSeedIdMap.set(item.id, { id: itemId, translationGroup });
+
 		count++;
 		order++;
 
-		// Process children
 		if (item.children && item.children.length > 0) {
-			const childCount = await applyMenuItems(db, menuId, item.children, itemId, 0, seedIdMap);
+			const childCount = await applyMenuItems(
+				db,
+				menuId,
+				itemLocale,
+				item.children,
+				itemId,
+				0,
+				seedIdMap,
+				itemSeedIdMap,
+			);
 			count += childCount;
 		}
 	}

package/src/seed/types.ts

@@ -87,14 +87,19 @@ export interface SeedField {
 }
 
 /**
- * Taxonomy definition in seed
+ * Taxonomy definition in seed. For multi-locale exports each locale variant
+ * is its own entry, linked via `translationOf` (referencing another entry's `id`).
  */
 export interface SeedTaxonomy {
+	/** Optional seed-local id, e.g. "tax:category:en". Target of `translationOf`. */
+	id?: string;
 	name: string;
 	label: string;
 	labelSingular?: string;
 	hierarchical: boolean;
 	collections: string[];
+	locale?: string;
+	translationOf?: string;
 	terms?: SeedTaxonomyTerm[];
 }
 
@@ -102,18 +107,26 @@ export interface SeedTaxonomy {
  * Taxonomy term in seed
  */
 export interface SeedTaxonomyTerm {
+	/** Optional seed-local id, e.g. "term:category:news:en". */
+	id?: string;
 	slug: string;
 	label: string;
 	description?: string;
 	parent?: string; // Slug of parent term (for hierarchical taxonomies)
+	locale?: string;
+	translationOf?: string;
 }
 
 /**
  * Menu definition in seed
  */
 export interface SeedMenu {
+	/** Optional seed-local id, e.g. "menu:primary:en". */
+	id?: string;
 	name: string;
 	label: string;
+	locale?: string;
+	translationOf?: string;
 	items: SeedMenuItem[];
 }
 
@@ -121,6 +134,8 @@ export interface SeedMenu {
  * Menu item in seed
  */
 export interface SeedMenuItem {
+	/** Optional seed-local id, e.g. "item:primary:home:en". */
+	id?: string;
 	type: string;
 	label?: string;
 	url?: string; // For custom type
@@ -129,6 +144,8 @@ export interface SeedMenuItem {
 	target?: "_blank" | "_self";
 	titleAttr?: string;
 	cssClasses?: string;
+	locale?: string;
+	translationOf?: string;
 	children?: SeedMenuItem[];
 }
 

package/src/seed/validate.ts

@@ -147,11 +147,16 @@ export function validateSeed(data: unknown): ValidationResult {
 				if (!taxonomy.name) {
 					errors.push(`${prefix}: name is required`);
 				} else {
-					// Check for duplicate taxonomy names
-					if (taxonomyNames.has(taxonomy.name)) {
-						errors.push(`${prefix}.name: duplicate taxonomy name "${taxonomy.name}"`);
+					// Uniqueness is per (name, locale).
+					const key = `${taxonomy.name}::${taxonomy.locale ?? ""}`;
+					if (taxonomyNames.has(key)) {
+						errors.push(
+							taxonomy.locale
+								? `${prefix}.name: duplicate taxonomy "${taxonomy.name}" in locale "${taxonomy.locale}"`
+								: `${prefix}.name: duplicate taxonomy name "${taxonomy.name}"`,
+						);
 					}
-					taxonomyNames.add(taxonomy.name);
+					taxonomyNames.add(key);
 				}
 
 				if (!taxonomy.label) {
@@ -184,13 +189,15 @@ export function validateSeed(data: unknown): ValidationResult {
 							if (!term.slug) {
 								errors.push(`${termPrefix}: slug is required`);
 							} else {
-								// Check for duplicate term slugs
-								if (termSlugs.has(term.slug)) {
+								// Uniqueness is per (slug, locale) so the same slug can repeat
+								// across locale variants of the def.
+								const key = `${term.slug}::${term.locale ?? taxonomy.locale ?? ""}`;
+								if (termSlugs.has(key)) {
 									errors.push(
 										`${termPrefix}.slug: duplicate term slug "${term.slug}" in taxonomy "${taxonomy.name}"`,
 									);
 								}
-								termSlugs.add(term.slug);
+								termSlugs.add(key);
 							}
 
 							if (!term.label) {
@@ -207,11 +214,12 @@ export function validateSeed(data: unknown): ValidationResult {
 							}
 						}
 
-						// Second pass: validate parent references
+						// Second pass: validate parent references (within the same locale).
 						if (taxonomy.hierarchical && taxonomy.terms) {
 							for (let j = 0; j < taxonomy.terms.length; j++) {
 								const term = taxonomy.terms[j];
-								if (term.parent && !termSlugs.has(term.parent)) {
+								const termLocale = term.locale ?? taxonomy.locale ?? "";
+								if (term.parent && !termSlugs.has(`${term.parent}::${termLocale}`)) {
 									errors.push(
 										`${prefix}.terms[${j}].parent: parent term "${term.parent}" not found in taxonomy`,
 									);
@@ -243,11 +251,17 @@ export function validateSeed(data: unknown): ValidationResult {
 				if (!menu.name) {
 					errors.push(`${prefix}: name is required`);
 				} else {
-					// Check for duplicate menu names
-					if (menuNames.has(menu.name)) {
-						errors.push(`${prefix}.name: duplicate menu name "${menu.name}"`);
+					// Uniqueness is per (name, locale) — siblings of a translation
+					// group share name but differ in locale.
+					const key = `${menu.name}::${menu.locale ?? ""}`;
+					if (menuNames.has(key)) {
+						errors.push(
+							menu.locale
+								? `${prefix}.name: duplicate menu "${menu.name}" in locale "${menu.locale}"`
+								: `${prefix}.name: duplicate menu name "${menu.name}"`,
+						);
 					}
-					menuNames.add(menu.name);
+					menuNames.add(key);
 				}
 
 				if (!menu.label) {