emdash 0.9.0 → 0.10.0

package/src/mcp/server.ts

@@ -1667,16 +1667,19 @@ export function createMcpServer(): McpServer {
 			description:
 				"List all taxonomy definitions (e.g. categories, tags). Taxonomies are " +
 				"classification systems applied to content. Each has a name, label, and " +
-				"can be hierarchical (categories) or flat (tags).",
-			inputSchema: z.object({}),
+				"can be hierarchical (categories) or flat (tags). Optionally filter by " +
+				"locale.",
+			inputSchema: z.object({
+				locale: z.string().optional().describe("Filter by locale (omit for all)"),
+			}),
 			annotations: { readOnlyHint: true },
 		},
-		async (_args, extra) => {
+		async (args, extra) => {
 			requireScope(extra, "content:read");
 			const ec = getEmDash(extra);
 			try {
 				const { handleTaxonomyList } = await import("../api/handlers/taxonomies.js");
-				return unwrap(await handleTaxonomyList(ec.db));
+				return unwrap(await handleTaxonomyList(ec.db, { locale: args.locale }));
 			} catch (error) {
 				return respondHandlerError(error, "TAXONOMY_LIST_ERROR");
 			}
@@ -1695,6 +1698,7 @@ export function createMcpServer(): McpServer {
 				taxonomy: z.string().describe("Taxonomy name (e.g. 'categories', 'tags')"),
 				limit: z.number().int().min(1).max(100).optional().describe("Max items (default 50)"),
 				cursor: z.string().min(1).max(2048).optional().describe("Pagination cursor"),
+				locale: z.string().optional().describe("Filter by locale (omit for all)"),
 			}),
 			annotations: { readOnlyHint: true },
 		},
@@ -1702,9 +1706,8 @@ export function createMcpServer(): McpServer {
 			requireScope(extra, "content:read");
 			const ec = getEmDash(extra);
 			try {
-				// Verify taxonomy exists via handler layer
 				const { handleTaxonomyList } = await import("../api/handlers/taxonomies.js");
-				const listResult = await handleTaxonomyList(ec.db);
+				const listResult = await handleTaxonomyList(ec.db, { locale: args.locale });
 				if (!listResult.success) return unwrap(listResult);
 
 				const taxonomies = (listResult.data as { taxonomies: Array<{ name: string; id?: string }> })
@@ -1712,13 +1715,12 @@ export function createMcpServer(): McpServer {
 				const taxonomy = taxonomies.find((t: { name: string }) => t.name === args.taxonomy);
 				if (!taxonomy) return respondError("NOT_FOUND", `Taxonomy '${args.taxonomy}' not found`);
 
-				// Paginated term query via repository (avoids N+1 of handleTermList)
 				const { TaxonomyRepository } = await import("../database/repositories/taxonomy.js");
 				const { decodeCursor, encodeCursor, InvalidCursorError } =
 					await import("../database/repositories/types.js");
 				const repo = new TaxonomyRepository(ec.db);
 				const limit = Math.min(args.limit ?? 50, 100);
-				const terms = await repo.findByName(args.taxonomy);
+				const terms = await repo.findByName(args.taxonomy, { locale: args.locale });
 
 				// Manual keyset pagination over the sorted-by-label results.
 				// Using a base64-encoded `(label, id)` cursor matches the
@@ -1760,6 +1762,8 @@ export function createMcpServer(): McpServer {
 						label: t.label,
 						parentId: t.parentId,
 						description: typeof t.data?.description === "string" ? t.data.description : undefined,
+						locale: t.locale,
+						translationGroup: t.translationGroup,
 					})),
 					nextCursor,
 				});
@@ -1785,6 +1789,11 @@ export function createMcpServer(): McpServer {
 				label: z.string().describe("Display name"),
 				parentId: z.string().optional().describe("Parent term ID for hierarchical taxonomies"),
 				description: z.string().optional().describe("Description of the term"),
+				locale: z.string().optional().describe("Locale for the new term (e.g. 'es')"),
+				translationOf: z
+					.string()
+					.optional()
+					.describe("Term id to join as a translation (same translation_group)"),
 			}),
 		},
 		async (args, extra) => {
@@ -1799,6 +1808,8 @@ export function createMcpServer(): McpServer {
 						label: args.label,
 						parentId: args.parentId,
 						description: args.description,
+						locale: args.locale,
+						translationOf: args.translationOf,
 					}),
 				);
 			} catch (error) {
@@ -1875,6 +1886,29 @@ export function createMcpServer(): McpServer {
 		},
 	);
 
+	server.registerTool(
+		"taxonomy_term_translations",
+		{
+			title: "List Term Translations",
+			description:
+				"Return every locale variant of a taxonomy term, identified via its shared translation_group.",
+			inputSchema: z.object({
+				id: z.string().describe("Term id (or translation_group)"),
+			}),
+			annotations: { readOnlyHint: true },
+		},
+		async (args, extra) => {
+			requireScope(extra, "content:read");
+			const ec = getEmDash(extra);
+			try {
+				const { handleTermTranslations } = await import("../api/handlers/taxonomies.js");
+				return unwrap(await handleTermTranslations(ec.db, args.id));
+			} catch (error) {
+				return respondHandlerError(error, "TERM_TRANSLATIONS_ERROR");
+			}
+		},
+	);
+
 	// =====================================================================
 	// Menu tools
 	// =====================================================================
@@ -1884,18 +1918,20 @@ export function createMcpServer(): McpServer {
 		{
 			title: "List Menus",
 			description:
-				"List all navigation menus defined in the CMS. Menus are named " +
-				"navigation structures (e.g. 'main', 'footer') containing ordered " +
-				"items with labels, URLs, and optional nesting.",
-			inputSchema: z.object({}),
+				"List navigation menus. Menus are per-locale: filter by `locale` to " +
+				"get just one locale's worth, or omit to list every row (one per " +
+				"locale per menu name).",
+			inputSchema: z.object({
+				locale: z.string().optional().describe("Filter by locale (omit for all)"),
+			}),
 			annotations: { readOnlyHint: true },
 		},
-		async (_args, extra) => {
+		async (args, extra) => {
 			requireScope(extra, "content:read");
 			const ec = getEmDash(extra);
 			try {
 				const { handleMenuList } = await import("../api/handlers/menus.js");
-				return unwrap(await handleMenuList(ec.db));
+				return unwrap(await handleMenuList(ec.db, { locale: args.locale }));
 			} catch (error) {
 				return respondHandlerError(error, "MENU_LIST_ERROR");
 			}
@@ -1907,11 +1943,11 @@ export function createMcpServer(): McpServer {
 		{
 			title: "Get Menu with Items",
 			description:
-				"Get a menu by name including all its items in order. Items have a " +
-				"label, URL, type (custom/content/collection), and optional parent " +
-				"for nesting.",
+				"Get a menu by name, including its items. When multiple locales exist, " +
+				"pass `locale` to pick the right one.",
 			inputSchema: z.object({
 				name: z.string().describe("Menu name (e.g. 'main', 'footer')"),
+				locale: z.string().optional().describe("Locale to resolve the menu for"),
 			}),
 			annotations: { readOnlyHint: true },
 		},
@@ -1920,13 +1956,36 @@ export function createMcpServer(): McpServer {
 			const ec = getEmDash(extra);
 			try {
 				const { handleMenuGet } = await import("../api/handlers/menus.js");
-				return unwrap(await handleMenuGet(ec.db, args.name));
+				return unwrap(await handleMenuGet(ec.db, args.name, { locale: args.locale }));
 			} catch (error) {
 				return respondHandlerError(error, "MENU_GET_ERROR");
 			}
 		},
 	);
 
+	server.registerTool(
+		"menu_translations",
+		{
+			title: "List Menu Translations",
+			description:
+				"Return every locale variant of a menu, identified via the shared translation_group.",
+			inputSchema: z.object({
+				id: z.string().describe("Menu id (or translation_group)"),
+			}),
+			annotations: { readOnlyHint: true },
+		},
+		async (args, extra) => {
+			requireScope(extra, "content:read");
+			const ec = getEmDash(extra);
+			try {
+				const { handleMenuTranslations } = await import("../api/handlers/menus.js");
+				return unwrap(await handleMenuTranslations(ec.db, args.id));
+			} catch (error) {
+				return respondHandlerError(error, "MENU_TRANSLATIONS_ERROR");
+			}
+		},
+	);
+
 	server.registerTool(
 		"menu_create",
 		{

package/src/menus/index.ts

@@ -1,7 +1,11 @@
 /**
- * Navigation menu runtime functions
+ * Navigation menu runtime functions.
  *
- * These are called from templates to query menus and resolve URLs.
+ * These are called from templates to query menus and resolve URLs. All queries
+ * are locale-aware: when a locale is configured (or passed explicitly) items
+ * are filtered to that locale, and menu item references resolve against the
+ * referenced content's translation_group so the URL points at the right
+ * per-locale row.
  */
 
 import type { Kysely } from "kysely";
@@ -9,50 +13,61 @@ import { sql } from "kysely";
 
 import type { Database } from "../database/types.js";
 import { validateIdentifier } from "../database/validate.js";
+import { resolveLocale, resolveLocaleChain } from "../i18n/resolve.js";
 import { getDb } from "../loader.js";
 import { requestCached } from "../request-cache.js";
 import { sanitizeHref } from "../utils/url.js";
 import type { Menu, MenuItem, MenuItemRow } from "./types.js";
 
+export interface MenuQueryOptions {
+	/** Override the locale used for the lookup. When omitted, the locale comes
+	 * from the request context or the configured defaultLocale. */
+	locale?: string;
+}
+
 /**
- * Get menu by name with resolved URLs
+ * Get a menu by name with resolved URLs.
  *
  * @example
  * ```ts
- * import { getMenu } from "emdash";
- *
  * const menu = await getMenu("primary");
- * if (menu) {
- *   console.log(menu.items); // Array of MenuItem with resolved URLs
- * }
+ * const menuEs = await getMenu("primary", { locale: "es" });
  * ```
  */
-export function getMenu(name: string): Promise<Menu | null> {
-	return requestCached(`menu:${name}`, async () => {
+export function getMenu(name: string, options: MenuQueryOptions = {}): Promise<Menu | null> {
+	const locale = resolveLocale(options.locale);
+	return requestCached(`menu:${name}:${locale ?? "*"}`, async () => {
 		const db = await getDb();
-		return getMenuWithDb(name, db);
+		return getMenuWithDb(name, db, { locale });
 	});
 }
 
 /**
- * Get menu by name with resolved URLs (with explicit db)
- *
- * @internal Use `getMenu()` in templates. This variant is for admin routes
- * that already have a database handle.
+ * Get menu by name with resolved URLs (with explicit db). Internal helper for
+ * admin routes that already have a database handle.
  */
-export async function getMenuWithDb(name: string, db: Kysely<Database>): Promise<Menu | null> {
-	// Get menu
-	const menuRow = await db
-		.selectFrom("_emdash_menus")
-		.selectAll()
-		.where("name", "=", name)
-		.executeTakeFirst();
-
-	if (!menuRow) {
-		return null;
+export async function getMenuWithDb(
+	name: string,
+	db: Kysely<Database>,
+	options: MenuQueryOptions = {},
+): Promise<Menu | null> {
+	const chain = resolveLocaleChain(options.locale);
+
+	const selectMenu = () => db.selectFrom("_emdash_menus").selectAll().where("name", "=", name);
+
+	let menuRow: Awaited<ReturnType<ReturnType<typeof selectMenu>["executeTakeFirst"]>>;
+	if (chain.length === 0) {
+		menuRow = await selectMenu().orderBy("locale", "asc").executeTakeFirst();
+	} else {
+		menuRow = undefined;
+		for (const locale of chain) {
+			menuRow = await selectMenu().where("locale", "=", locale).executeTakeFirst();
+			if (menuRow) break;
+		}
 	}
 
-	// Get all menu items
+	if (!menuRow) return null;
+
 	const itemRows = await db
 		.selectFrom("_emdash_menu_items")
 		.selectAll()
@@ -61,31 +76,27 @@ export async function getMenuWithDb(name: string, db: Kysely<Database>): Promise
 		.orderBy("sort_order", "asc")
 		.execute();
 
-	// Resolve URLs and build tree
-	const items = await buildMenuTree(itemRows, db);
+	const items = await buildMenuTree(itemRows, db, menuRow.locale);
 
 	return {
 		id: menuRow.id,
 		name: menuRow.name,
 		label: menuRow.label,
 		items,
+		locale: menuRow.locale,
+		translationGroup: menuRow.translation_group,
 	};
 }
 
 /**
- * Get all menus (without items - for admin list)
- *
- * @example
- * ```ts
- * import { getMenus } from "emdash";
- *
- * const menus = await getMenus();
- * console.log(menus); // [{ id, name, label }]
- * ```
+ * Get all menus (without items, locale-filtered — for admin list / site nav
+ * summaries). When no locale is configured, returns menus across all locales.
  */
-export async function getMenus(): Promise<Array<{ id: string; name: string; label: string }>> {
+export async function getMenus(
+	options: MenuQueryOptions = {},
+): Promise<Array<{ id: string; name: string; label: string; locale: string }>> {
 	const db = await getDb();
-	return getMenusWithDb(db);
+	return getMenusWithDb(db, options);
 }
 
 /**
@@ -96,26 +107,30 @@ export async function getMenus(): Promise<Array<{ id: string; name: string; labe
  */
 export async function getMenusWithDb(
 	db: Kysely<Database>,
-): Promise<Array<{ id: string; name: string; label: string }>> {
-	const rows = await db
+	options: MenuQueryOptions = {},
+): Promise<Array<{ id: string; name: string; label: string; locale: string }>> {
+	const locale = resolveLocale(options.locale);
+	let query = db
 		.selectFrom("_emdash_menus")
-		.select(["id", "name", "label"])
-		.orderBy("name", "asc")
-		.execute();
-
-	return rows;
+		.select(["id", "name", "label", "locale"])
+		.orderBy("name", "asc");
+	if (locale !== undefined) query = query.where("locale", "=", locale);
+	return query.execute();
 }
 
 /**
- * Build hierarchical menu tree from flat array of items
+ * Build a hierarchical menu tree from a flat list of items. Items are
+ * resolved against the given `locale` so references land on the right
+ * per-locale content rows.
  */
-async function buildMenuTree(items: MenuItemRow[], db: Kysely<Database>): Promise<MenuItem[]> {
-	// Pre-load URL patterns for all collections referenced in this menu
+async function buildMenuTree(
+	items: MenuItemRow[],
+	db: Kysely<Database>,
+	locale: string,
+): Promise<MenuItem[]> {
 	const collectionSlugs = new Set<string>();
 	for (const item of items) {
-		if (item.reference_collection) {
-			collectionSlugs.add(item.reference_collection);
-		}
+		if (item.reference_collection) collectionSlugs.add(item.reference_collection);
 		if (item.type === "page" || item.type === "post") {
 			collectionSlugs.add(item.reference_collection || `${item.type}s`);
 		}
@@ -128,41 +143,28 @@ async function buildMenuTree(items: MenuItemRow[], db: Kysely<Database>): Promis
 			.select(["slug", "url_pattern"])
 			.where("slug", "in", [...collectionSlugs])
 			.execute();
-		for (const row of rows) {
-			urlPatterns.set(row.slug, row.url_pattern);
-		}
+		for (const row of rows) urlPatterns.set(row.slug, row.url_pattern);
 	}
 
-	// Resolve all URLs first
 	const resolvedItems = await Promise.all(
-		items.map((item) => resolveMenuItem(item, db, urlPatterns)),
+		items.map((item) => resolveMenuItem(item, db, urlPatterns, locale)),
 	);
+	const validItems = resolvedItems.filter((item): item is MenuItem => item !== null);
 
-	// Filter out items that couldn't be resolved (e.g., deleted content)
-	const validItems = resolvedItems.filter((item) => item !== null);
-
-	// Build tree structure
 	const itemMap = new Map<string, MenuItem & { children: MenuItem[] }>();
 	const rootItems: MenuItem[] = [];
 
-	// First pass: create all items
 	for (const item of validItems) {
 		itemMap.set(item.id, { ...item, children: [] });
 	}
 
-	// Second pass: build parent-child relationships
 	for (const item of items) {
 		const menuItem = itemMap.get(item.id);
 		if (!menuItem) continue;
-
 		if (item.parent_id) {
 			const parent = itemMap.get(item.parent_id);
-			if (parent) {
-				parent.children.push(menuItem);
-			} else {
-				// Parent not found, treat as root
-				rootItems.push(menuItem);
-			}
+			if (parent) parent.children.push(menuItem);
+			else rootItems.push(menuItem);
 		} else {
 			rootItems.push(menuItem);
 		}
@@ -172,14 +174,15 @@ async function buildMenuTree(items: MenuItemRow[], db: Kysely<Database>): Promis
 }
 
 /**
- * Resolve a single menu item's URL
- *
- * Returns null if the referenced content no longer exists (item should be skipped)
+ * Resolve a single menu item's URL. `reference_id` is a translation_group
+ * (migration 036 remapped all existing references); we join it against
+ * the per-locale ec_* row or per-locale taxonomy row.
  */
 async function resolveMenuItem(
 	item: MenuItemRow,
 	db: Kysely<Database>,
 	urlPatterns: Map<string, string | null>,
+	locale: string,
 ): Promise<MenuItem | null> {
 	let url: string | null;
 
@@ -192,24 +195,18 @@ async function resolveMenuItem(
 			case "page":
 			case "post":
 				url = await resolveContentUrl(
-					// Default to plural collection name (pages/posts) if not specified
 					item.reference_collection || `${item.type}s`,
 					item.reference_id,
 					db,
 					urlPatterns,
+					locale,
 				);
-				// Skip items where content no longer exists
-				if (url === null) {
-					return null;
-				}
+				if (url === null) return null;
 				break;
 
 			case "taxonomy":
-				url = await resolveTaxonomyUrl(item.reference_id, db);
-				// Skip items where taxonomy no longer exists
-				if (url === null) {
-					return null;
-				}
+				url = await resolveTaxonomyUrl(item.reference_id, db, locale);
+				if (url === null) return null;
 				break;
 
 			case "collection":
@@ -223,16 +220,14 @@ async function resolveMenuItem(
 						item.reference_id,
 						db,
 						urlPatterns,
+						locale,
 					);
-					if (url === null) {
-						return null;
-					}
+					if (url === null) return null;
 				} else {
 					url = "#";
 				}
 		}
 	} catch (error) {
-		// If resolution fails, skip this item
 		console.error(`Failed to resolve menu item ${item.id}:`, error);
 		return null;
 	}
@@ -244,7 +239,7 @@ async function resolveMenuItem(
 		target: item.target || undefined,
 		titleAttr: item.title_attr || undefined,
 		cssClasses: item.css_classes || undefined,
-		children: [], // Will be populated by buildMenuTree
+		children: [],
 	};
 }
 
@@ -261,72 +256,96 @@ function interpolateUrlPattern(pattern: string, slug: string, id: string): strin
 }
 
 /**
- * Resolve URL for a content entry (page/post)
- *
- * Uses the collection's url_pattern if set, otherwise falls back to /{collection}/{slug}.
- * Returns null if content not found (item should be skipped).
+ * Resolve the URL for a content reference. `referenceGroup` is the content
+ * row's translation_group; we look up the row in the requested locale
+ * (falling back to the source if no translation exists so the menu link is
+ * still clickable).
  */
 async function resolveContentUrl(
 	collection: string,
-	entryId: string | null,
+	referenceGroup: string | null,
 	db: Kysely<Database>,
 	urlPatterns: Map<string, string | null>,
+	locale: string,
 ): Promise<string | null> {
-	if (!entryId) {
-		return null;
-	}
+	if (!referenceGroup) return null;
 
 	try {
-		// Validate collection name before interpolating into table reference
 		validateIdentifier(collection, "menu item collection");
 
-		// Dynamic content tables (ec_*) aren't in the Database type, so use sql
-		const result = await sql<{ slug: string }>`
-			SELECT slug FROM ${sql.ref(`ec_${collection}`)} WHERE id = ${entryId} LIMIT 1
+		// Try the requested locale first, then any locale (deterministic).
+		let result = await sql<{ id: string; slug: string }>`
+			SELECT id, slug FROM ${sql.ref(`ec_${collection}`)}
+			WHERE translation_group = ${referenceGroup} AND locale = ${locale}
+			LIMIT 1
 		`.execute(db);
-
-		const row = result.rows[0];
-		if (row) {
-			const pattern = urlPatterns.get(collection);
-			if (pattern) {
-				return interpolateUrlPattern(pattern, row.slug, entryId);
-			}
-			return `/${collection}/${row.slug}`;
+		let row = result.rows[0];
+		if (!row) {
+			result = await sql<{ id: string; slug: string }>`
+				SELECT id, slug FROM ${sql.ref(`ec_${collection}`)}
+				WHERE translation_group = ${referenceGroup}
+				ORDER BY locale ASC LIMIT 1
+			`.execute(db);
+			row = result.rows[0];
 		}
+		if (!row) {
+			// Legacy rows whose reference_id still points at an id directly
+			// (defensive — migration 036 normalised these, but a row inserted
+			// between migrations could predate the remap).
+			const legacy = await sql<{ id: string; slug: string }>`
+				SELECT id, slug FROM ${sql.ref(`ec_${collection}`)}
+				WHERE id = ${referenceGroup} LIMIT 1
+			`.execute(db);
+			row = legacy.rows[0];
+		}
+		if (!row) return null;
 
-		// Content not found, skip item
-		return null;
+		const pattern = urlPatterns.get(collection);
+		if (pattern) return interpolateUrlPattern(pattern, row.slug, row.id);
+		return `/${collection}/${row.slug}`;
 	} catch (error) {
-		// Table might not exist or query failed
-		console.error(`Failed to resolve content URL for ${collection}/${entryId}:`, error);
+		console.error(`Failed to resolve content URL for ${collection}/${referenceGroup}:`, error);
 		return null;
 	}
 }
 
 /**
- * Resolve URL for a taxonomy term
- *
- * Returns null if taxonomy not found (item should be skipped)
+ * Resolve URL for a taxonomy term reference. `referenceGroup` is the term's
+ * translation_group; we pick the row in the active locale (or fall back).
  */
 async function resolveTaxonomyUrl(
-	taxonomyId: string | null,
+	referenceGroup: string | null,
 	db: Kysely<Database>,
+	locale: string,
 ): Promise<string | null> {
-	if (!taxonomyId) {
-		return null;
-	}
+	if (!referenceGroup) return null;
 
-	const taxonomy = await db
+	let taxonomy = await db
 		.selectFrom("taxonomies")
 		.select(["name", "slug"])
-		.where("id", "=", taxonomyId)
+		.where("translation_group", "=", referenceGroup)
+		.where("locale", "=", locale)
 		.executeTakeFirst();
 
 	if (!taxonomy) {
-		// Taxonomy not found, skip item
-		return null;
+		taxonomy = await db
+			.selectFrom("taxonomies")
+			.select(["name", "slug"])
+			.where("translation_group", "=", referenceGroup)
+			.orderBy("locale", "asc")
+			.executeTakeFirst();
 	}
 
-	// Use taxonomy name as base (e.g., "categories" or "tags")
+	if (!taxonomy) {
+		// Legacy: id-based reference that predates the migration remap.
+		taxonomy = await db
+			.selectFrom("taxonomies")
+			.select(["name", "slug"])
+			.where("id", "=", referenceGroup)
+			.executeTakeFirst();
+	}
+
+	if (!taxonomy) return null;
+
 	return `/${taxonomy.name}/${taxonomy.slug}`;
 }