emdash 0.9.0 → 0.11.0

package/src/api/handlers/menus.ts

@@ -1,29 +1,30 @@
 /**
- * Menu CRUD handlers
+ * Menu CRUD handlers.
  *
- * Business logic for menu and menu-item endpoints.
- * Routes are thin wrappers that parse input, check auth, and call these.
+ * Business logic for menu and menu-item endpoints. Routes are thin wrappers
+ * that parse input, check auth, and call these.
+ *
+ * i18n: Menus are per-locale. `(name, locale)` is unique, so the same `name`
+ * (e.g. "primary") can exist in several locales within one translation_group.
+ * Menu items carry a `locale` + `translation_group` as well, and their
+ * `reference_id` points at the referenced content's translation_group (not a
+ * specific row id), so a single menu item target survives content translations.
  */
 
-import type { Kysely } from "kysely";
+import type { Kysely, Selectable } from "kysely";
 import { ulid } from "ulidx";
 
 import { withTransaction } from "../../database/transaction.js";
 import type { Database, MenuItemTable, MenuTable } from "../../database/types.js";
+import { getI18nConfig } from "../../i18n/config.js";
 import type { ApiResult } from "../types.js";
 
 // ---------------------------------------------------------------------------
 // Response types
 // ---------------------------------------------------------------------------
 
-type MenuRow = Omit<MenuTable, "created_at" | "updated_at"> & {
-	created_at: string;
-	updated_at: string;
-};
-
-type MenuItemRow = Omit<MenuItemTable, "created_at"> & {
-	created_at: string;
-};
+export type MenuRow = Selectable<MenuTable>;
+export type MenuItemRow = Selectable<MenuItemTable>;
 
 export interface MenuListItem extends MenuRow {
 	itemCount: number;
@@ -33,18 +34,56 @@ export interface MenuWithItems extends MenuRow {
 	items: MenuItemRow[];
 }
 
+export interface MenuTranslationsResponse {
+	translationGroup: string | null;
+	translations: Array<{
+		id: string;
+		name: string;
+		locale: string;
+		label: string;
+		updatedAt: string;
+	}>;
+}
+
+/**
+ * Error returned when a menu lookup by `name` matches multiple locale
+ * variants and the caller did not pass `locale` to disambiguate. Maps to
+ * HTTP 400 via `mapErrorStatus`. The available locales are surfaced in the
+ * message so MCP/REST callers can recover by re-issuing with `locale`.
+ */
+function ambiguousMenuLocaleError(
+	name: string,
+	locales: readonly string[],
+): { success: false; error: { code: "AMBIGUOUS_LOCALE"; message: string } } {
+	const sortedLocales = locales.toSorted();
+	return {
+		success: false,
+		error: {
+			code: "AMBIGUOUS_LOCALE",
+			message: `Menu '${name}' exists in multiple locales (${sortedLocales.join(
+				", ",
+			)}); pass 'locale' to disambiguate.`,
+		},
+	};
+}
+
 // ---------------------------------------------------------------------------
 // Menu handlers
 // ---------------------------------------------------------------------------
 
 /**
- * List all menus with item counts.
+ * List menus with item counts. Filter by `locale` when provided; otherwise
+ * return every menu row (each locale counts as its own menu for admin listing
+ * purposes).
  */
-export async function handleMenuList(db: Kysely<Database>): Promise<ApiResult<MenuListItem[]>> {
+export async function handleMenuList(
+	db: Kysely<Database>,
+	options: { locale?: string } = {},
+): Promise<ApiResult<MenuListItem[]>> {
 	try {
 		// Single query: LEFT JOIN + GROUP BY for the per-menu item count.
 		// Avoids the N+1 of one count query per menu.
-		const rows = await db
+		let query = db
 			.selectFrom("_emdash_menus as m")
 			.leftJoin("_emdash_menu_items as i", "i.menu_id", "m.id")
 			.select(({ fn }) => [
@@ -53,11 +92,22 @@ export async function handleMenuList(db: Kysely<Database>): Promise<ApiResult<Me
 				"m.label",
 				"m.created_at",
 				"m.updated_at",
+				"m.locale",
+				"m.translation_group",
 				fn.count<number>("i.id").as("itemCount"),
 			])
-			.groupBy(["m.id", "m.name", "m.label", "m.created_at", "m.updated_at"])
-			.orderBy("m.name", "asc")
-			.execute();
+			.groupBy([
+				"m.id",
+				"m.name",
+				"m.label",
+				"m.created_at",
+				"m.updated_at",
+				"m.locale",
+				"m.translation_group",
+			])
+			.orderBy("m.name", "asc");
+		if (options.locale !== undefined) query = query.where("m.locale", "=", options.locale);
+		const rows = await query.execute();
 
 		// SQLite returns count as `number`, but some dialects (Postgres)
 		// return `string` from a count() aggregate. Normalize to number.
@@ -67,6 +117,8 @@ export async function handleMenuList(db: Kysely<Database>): Promise<ApiResult<Me
 			label: row.label,
 			created_at: row.created_at,
 			updated_at: row.updated_at,
+			locale: row.locale,
+			translation_group: row.translation_group,
 			itemCount: typeof row.itemCount === "string" ? Number(row.itemCount) : row.itemCount,
 		}));
 
@@ -80,42 +132,132 @@ export async function handleMenuList(db: Kysely<Database>): Promise<ApiResult<Me
 }
 
 /**
- * Create a new menu.
+ * Create a new menu. When `translationOf` is supplied the new menu joins the
+ * source menu's translation_group (and gets the source's items cloned).
  */
 export async function handleMenuCreate(
 	db: Kysely<Database>,
-	input: { name: string; label: string },
+	input: { name: string; label: string; locale?: string; translationOf?: string },
 ): Promise<ApiResult<MenuRow>> {
 	try {
+		// Translating from a source menu only makes sense when the caller
+		// names the target locale: otherwise we'd silently clone into the
+		// configured default, which is almost never what's intended (and
+		// will collide if the source is already the default-locale menu).
+		// Enforced here so REST/SDK callers get the same guard as MCP.
+		if (input.translationOf && !input.locale) {
+			return {
+				success: false,
+				error: {
+					code: "VALIDATION_ERROR",
+					message: "`locale` is required when `translationOf` is provided",
+				},
+			};
+		}
+
+		// Resolve translation group + source (if we're creating a translation).
+		let translationGroup: string | null = null;
+		let sourceMenu: MenuRow | null = null;
+		if (input.translationOf) {
+			const src = await db
+				.selectFrom("_emdash_menus")
+				.selectAll()
+				.where("id", "=", input.translationOf)
+				.executeTakeFirst();
+			if (!src) {
+				return {
+					success: false,
+					error: { code: "NOT_FOUND", message: "Source menu for translation not found" },
+				};
+			}
+			sourceMenu = src;
+			translationGroup = src.translation_group ?? src.id;
+		}
+
+		// Duplicate guard: same (name, locale). Falls back to the configured
+		// defaultLocale to match the column DEFAULT set by migration 036.
+		const effectiveLocale = input.locale ?? getI18nConfig()?.defaultLocale ?? "en";
 		const existing = await db
 			.selectFrom("_emdash_menus")
 			.select("id")
 			.where("name", "=", input.name)
+			.where("locale", "=", effectiveLocale)
 			.executeTakeFirst();
-
 		if (existing) {
 			return {
 				success: false,
-				error: { code: "CONFLICT", message: `Menu with name "${input.name}" already exists` },
+				error: {
+					code: "CONFLICT",
+					message: `Menu "${input.name}" already exists${
+						input.locale ? ` in locale "${input.locale}"` : ""
+					}`,
+				},
 			};
 		}
 
 		const id = ulid();
-		await db
-			.insertInto("_emdash_menus")
-			.values({
-				id,
-				name: input.name,
-				label: input.label,
-			})
-			.execute();
+
+		await withTransaction(db, async (trx) => {
+			await trx
+				.insertInto("_emdash_menus")
+				.values({
+					id,
+					name: input.name,
+					label: input.label,
+					...(input.locale !== undefined ? { locale: input.locale } : {}),
+					translation_group: translationGroup ?? id,
+				})
+				.execute();
+
+			// Clone items from the source menu (same reference_ids — they are
+			// translation_groups, which are locale-agnostic). Each clone
+			// inherits the source item's translation_group so a nav entry
+			// identifies as the same logical item across menu translations.
+			if (sourceMenu) {
+				const sourceItems = await trx
+					.selectFrom("_emdash_menu_items")
+					.selectAll()
+					.where("menu_id", "=", sourceMenu.id)
+					.orderBy("sort_order", "asc")
+					.execute();
+				if (sourceItems.length > 0) {
+					// Build old-id → new-id map so parent pointers land on the clones.
+					const idMap = new Map<string, string>();
+					for (const item of sourceItems) idMap.set(item.id, ulid());
+
+					await trx
+						.insertInto("_emdash_menu_items")
+						.values(
+							sourceItems.map((item) => {
+								const newId = idMap.get(item.id)!;
+								return {
+									id: newId,
+									menu_id: id,
+									parent_id: item.parent_id ? (idMap.get(item.parent_id) ?? null) : null,
+									sort_order: item.sort_order,
+									type: item.type,
+									reference_collection: item.reference_collection,
+									reference_id: item.reference_id,
+									custom_url: item.custom_url,
+									label: item.label,
+									title_attr: item.title_attr,
+									target: item.target,
+									css_classes: item.css_classes,
+									...(input.locale !== undefined ? { locale: input.locale } : {}),
+									translation_group: item.translation_group ?? item.id,
+								};
+							}),
+						)
+						.execute();
+				}
+			}
+		});
 
 		const menu = await db
 			.selectFrom("_emdash_menus")
 			.selectAll()
 			.where("id", "=", id)
 			.executeTakeFirstOrThrow();
-
 		return { success: true, data: menu };
 	} catch {
 		return {
@@ -126,18 +268,18 @@ export async function handleMenuCreate(
 }
 
 /**
- * Get a single menu with all its items.
+ * Get a single menu by name. Honours an optional `locale` filter; when two
+ * menus share a name across locales, the locale distinguishes them.
  */
 export async function handleMenuGet(
 	db: Kysely<Database>,
 	name: string,
+	options: { locale?: string } = {},
 ): Promise<ApiResult<MenuWithItems>> {
 	try {
-		const menu = await db
-			.selectFrom("_emdash_menus")
-			.selectAll()
-			.where("name", "=", name)
-			.executeTakeFirst();
+		let query = db.selectFrom("_emdash_menus").selectAll().where("name", "=", name);
+		if (options.locale !== undefined) query = query.where("locale", "=", options.locale);
+		const menu = await query.orderBy("locale", "asc").executeTakeFirst();
 
 		if (!menu) {
 			return {
@@ -163,26 +305,73 @@ export async function handleMenuGet(
 }
 
 /**
- * Update a menu's metadata.
+ * Get a menu by id. Useful when the caller already has the id (e.g. after
+ * creating a translation and navigating to it).
  */
-export async function handleMenuUpdate(
+export async function handleMenuGetById(
 	db: Kysely<Database>,
-	name: string,
-	input: { label?: string },
-): Promise<ApiResult<MenuRow>> {
+	id: string,
+): Promise<ApiResult<MenuWithItems>> {
 	try {
 		const menu = await db
 			.selectFrom("_emdash_menus")
-			.select("id")
-			.where("name", "=", name)
+			.selectAll()
+			.where("id", "=", id)
 			.executeTakeFirst();
-
 		if (!menu) {
 			return {
 				success: false,
-				error: { code: "NOT_FOUND", message: `Menu '${name}' not found` },
+				error: { code: "NOT_FOUND", message: `Menu '${id}' not found` },
+			};
+		}
+		const items = await db
+			.selectFrom("_emdash_menu_items")
+			.selectAll()
+			.where("menu_id", "=", menu.id)
+			.orderBy("sort_order", "asc")
+			.execute();
+		return { success: true, data: { ...menu, items } };
+	} catch {
+		return {
+			success: false,
+			error: { code: "MENU_GET_ERROR", message: "Failed to fetch menu" },
+		};
+	}
+}
+
+/**
+ * Update a menu's label. The name + locale are immutable.
+ */
+export async function handleMenuUpdate(
+	db: Kysely<Database>,
+	name: string,
+	input: { label?: string; locale?: string },
+): Promise<ApiResult<MenuRow>> {
+	try {
+		// Fetch every row matching the name (filtered by locale if supplied)
+		// so we can fail loud when an omitted-locale lookup is ambiguous.
+		// (name, locale) is unique, so length > 1 only happens when the
+		// caller didn't pass `locale` and the menu exists in >1 translation.
+		let query = db.selectFrom("_emdash_menus").select(["id", "locale"]).where("name", "=", name);
+		if (input.locale !== undefined) query = query.where("locale", "=", input.locale);
+		const matches = await query.execute();
+
+		if (matches.length === 0) {
+			return {
+				success: false,
+				error: {
+					code: "NOT_FOUND",
+					message: `Menu '${name}' not found${input.locale ? ` in locale '${input.locale}'` : ""}`,
+				},
 			};
 		}
+		if (matches.length > 1) {
+			return ambiguousMenuLocaleError(
+				name,
+				matches.map((m) => m.locale),
+			);
+		}
+		const menu = matches[0]!;
 
 		if (input.label) {
 			await db
@@ -197,7 +386,6 @@ export async function handleMenuUpdate(
 			.selectAll()
 			.where("id", "=", menu.id)
 			.executeTakeFirstOrThrow();
-
 		return { success: true, data: updated };
 	} catch {
 		return {
@@ -208,32 +396,43 @@ export async function handleMenuUpdate(
 }
 
 /**
- * Delete a menu and its items (cascade).
+ * Delete a menu (and items, via cascade).
  */
 export async function handleMenuDelete(
 	db: Kysely<Database>,
 	name: string,
+	options: { locale?: string } = {},
 ): Promise<ApiResult<{ deleted: true }>> {
 	try {
-		const menu = await db
-			.selectFrom("_emdash_menus")
-			.select("id")
-			.where("name", "=", name)
-			.executeTakeFirst();
+		// See ambiguousMenuLocaleError for why we fetch all matches.
+		let query = db.selectFrom("_emdash_menus").select(["id", "locale"]).where("name", "=", name);
+		if (options.locale !== undefined) query = query.where("locale", "=", options.locale);
+		const matches = await query.execute();
 
-		if (!menu) {
+		if (matches.length === 0) {
 			return {
 				success: false,
-				error: { code: "NOT_FOUND", message: `Menu '${name}' not found` },
+				error: {
+					code: "NOT_FOUND",
+					message: `Menu '${name}' not found${
+						options.locale ? ` in locale '${options.locale}'` : ""
+					}`,
+				},
 			};
 		}
+		if (matches.length > 1) {
+			return ambiguousMenuLocaleError(
+				name,
+				matches.map((m) => m.locale),
+			);
+		}
+		const menu = matches[0]!;
 
 		// D1 has FOREIGN KEYS off by default, so the migration's `ON DELETE
 		// CASCADE` won't fire there. Delete items explicitly first — this is
 		// idempotent on SQLite/Postgres where the cascade also fires.
 		await db.deleteFrom("_emdash_menu_items").where("menu_id", "=", menu.id).execute();
 		await db.deleteFrom("_emdash_menus").where("id", "=", menu.id).execute();
-
 		return { success: true, data: { deleted: true } };
 	} catch {
 		return {
@@ -243,6 +442,53 @@ export async function handleMenuDelete(
 	}
 }
 
+/**
+ * List every translation of a menu (by id or translation_group).
+ */
+export async function handleMenuTranslations(
+	db: Kysely<Database>,
+	idOrGroup: string,
+): Promise<ApiResult<MenuTranslationsResponse>> {
+	try {
+		const anchor = await db
+			.selectFrom("_emdash_menus")
+			.selectAll()
+			.where((eb) => eb.or([eb("id", "=", idOrGroup), eb("translation_group", "=", idOrGroup)]))
+			.executeTakeFirst();
+		if (!anchor) {
+			return {
+				success: false,
+				error: { code: "NOT_FOUND", message: "Menu not found" },
+			};
+		}
+		const group = anchor.translation_group ?? anchor.id;
+		const rows = await db
+			.selectFrom("_emdash_menus")
+			.selectAll()
+			.where("translation_group", "=", group)
+			.orderBy("locale", "asc")
+			.execute();
+		return {
+			success: true,
+			data: {
+				translationGroup: group,
+				translations: rows.map((row) => ({
+					id: row.id,
+					name: row.name,
+					locale: row.locale,
+					label: row.label,
+					updatedAt: row.updated_at,
+				})),
+			},
+		};
+	} catch {
+		return {
+			success: false,
+			error: { code: "MENU_TRANSLATIONS_ERROR", message: "Failed to list menu translations" },
+		};
+	}
+}
+
 // ---------------------------------------------------------------------------
 // Menu item handlers
 // ---------------------------------------------------------------------------
@@ -261,26 +507,38 @@ export interface CreateMenuItemInput {
 }
 
 /**
- * Add an item to a menu.
+ * Add an item to a menu. The item inherits the menu's locale (so listing
+ * items by locale stays trivial).
  */
 export async function handleMenuItemCreate(
 	db: Kysely<Database>,
 	menuName: string,
 	input: CreateMenuItemInput,
+	options: { locale?: string } = {},
 ): Promise<ApiResult<MenuItemRow>> {
 	try {
-		const menu = await db
+		// Same fail-loud rule as handleMenuUpdate / Delete / SetItems —
+		// see ambiguousMenuLocaleError for the rationale.
+		let menuQuery = db
 			.selectFrom("_emdash_menus")
-			.select("id")
-			.where("name", "=", menuName)
-			.executeTakeFirst();
+			.select(["id", "locale"])
+			.where("name", "=", menuName);
+		if (options.locale !== undefined) menuQuery = menuQuery.where("locale", "=", options.locale);
+		const matches = await menuQuery.execute();
 
-		if (!menu) {
+		if (matches.length === 0) {
 			return {
 				success: false,
 				error: { code: "NOT_FOUND", message: "Menu not found" },
 			};
 		}
+		if (matches.length > 1) {
+			return ambiguousMenuLocaleError(
+				menuName,
+				matches.map((m) => m.locale),
+			);
+		}
+		const menu = matches[0]!;
 
 		let sortOrder = input.sortOrder ?? 0;
 		if (input.sortOrder === undefined) {
@@ -290,7 +548,6 @@ export async function handleMenuItemCreate(
 				.where("menu_id", "=", menu.id)
 				.where("parent_id", "is", input.parentId ?? null)
 				.executeTakeFirst();
-
 			// eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- Kysely fn.max returns unknown; always a number for sort_order column
 			sortOrder = ((maxOrder?.max as number) ?? -1) + 1;
 		}
@@ -311,6 +568,8 @@ export async function handleMenuItemCreate(
 				title_attr: input.titleAttr ?? null,
 				target: input.target ?? null,
 				css_classes: input.cssClasses ?? null,
+				locale: menu.locale,
+				translation_group: id,
 			})
 			.execute();
 
@@ -319,7 +578,6 @@ export async function handleMenuItemCreate(
 			.selectAll()
 			.where("id", "=", id)
 			.executeTakeFirstOrThrow();
-
 		return { success: true, data: item };
 	} catch {
 		return {
@@ -347,20 +605,30 @@ export async function handleMenuItemUpdate(
 	menuName: string,
 	itemId: string,
 	input: UpdateMenuItemInput,
+	options: { locale?: string } = {},
 ): Promise<ApiResult<MenuItemRow>> {
 	try {
-		const menu = await db
+		// See ambiguousMenuLocaleError for the rationale.
+		let menuQuery = db
 			.selectFrom("_emdash_menus")
-			.select("id")
-			.where("name", "=", menuName)
-			.executeTakeFirst();
+			.select(["id", "locale"])
+			.where("name", "=", menuName);
+		if (options.locale !== undefined) menuQuery = menuQuery.where("locale", "=", options.locale);
+		const matches = await menuQuery.execute();
 
-		if (!menu) {
+		if (matches.length === 0) {
 			return {
 				success: false,
 				error: { code: "NOT_FOUND", message: "Menu not found" },
 			};
 		}
+		if (matches.length > 1) {
+			return ambiguousMenuLocaleError(
+				menuName,
+				matches.map((m) => m.locale),
+			);
+		}
+		const menu = matches[0]!;
 
 		const item = await db
 			.selectFrom("_emdash_menu_items")
@@ -394,7 +662,6 @@ export async function handleMenuItemUpdate(
 			.selectAll()
 			.where("id", "=", itemId)
 			.executeTakeFirstOrThrow();
-
 		return { success: true, data: updated };
 	} catch {
 		return {
@@ -411,20 +678,30 @@ export async function handleMenuItemDelete(
 	db: Kysely<Database>,
 	menuName: string,
 	itemId: string,
+	options: { locale?: string } = {},
 ): Promise<ApiResult<{ deleted: true }>> {
 	try {
-		const menu = await db
+		// See ambiguousMenuLocaleError for the rationale.
+		let menuQuery = db
 			.selectFrom("_emdash_menus")
-			.select("id")
-			.where("name", "=", menuName)
-			.executeTakeFirst();
+			.select(["id", "locale"])
+			.where("name", "=", menuName);
+		if (options.locale !== undefined) menuQuery = menuQuery.where("locale", "=", options.locale);
+		const matches = await menuQuery.execute();
 
-		if (!menu) {
+		if (matches.length === 0) {
 			return {
 				success: false,
 				error: { code: "NOT_FOUND", message: "Menu not found" },
 			};
 		}
+		if (matches.length > 1) {
+			return ambiguousMenuLocaleError(
+				menuName,
+				matches.map((m) => m.locale),
+			);
+		}
+		const menu = matches[0]!;
 
 		const result = await db
 			.deleteFrom("_emdash_menu_items")
@@ -486,6 +763,7 @@ export async function handleMenuSetItems(
 	db: Kysely<Database>,
 	menuName: string,
 	items: MenuSetItemsInput[],
+	options: { locale?: string } = {},
 ): Promise<ApiResult<{ name: string; itemCount: number }>> {
 	// Validate parentIndex references — must be strictly earlier so
 	// the array can be inserted in order with parents resolved first.
@@ -508,24 +786,38 @@ export async function handleMenuSetItems(
 	}
 
 	try {
-		// Sentinel for "menu not found" thrown from inside the transaction
-		// so the rollback fires before we return the structured error.
+		// Sentinels thrown from inside the transaction so the rollback
+		// fires before we return the structured error.
 		const notFoundSentinel = Symbol("menu-not-found");
+		// We capture the locale list rather than constructing the error
+		// inside the transaction, so the helper stays the single source
+		// of truth for AMBIGUOUS_LOCALE message shape.
+		let ambiguousLocales: string[] | null = null;
+		const ambiguousSentinel = Symbol("menu-ambiguous-locale");
 
 		try {
 			await withTransaction(db, async (trx) => {
 				// Existence check INSIDE the transaction so a concurrent
 				// menu_delete between lookup and write can't leave orphan
-				// items on D1 (FKs disabled by default).
-				const menu = await trx
+				// items on D1 (FKs disabled by default). Same fail-loud
+				// rule as handleMenuUpdate / handleMenuDelete.
+				let menuQuery = trx
 					.selectFrom("_emdash_menus")
-					.select("id")
-					.where("name", "=", menuName)
-					.executeTakeFirst();
+					.select(["id", "locale"])
+					.where("name", "=", menuName);
+				if (options.locale !== undefined) {
+					menuQuery = menuQuery.where("locale", "=", options.locale);
+				}
+				const matches = await menuQuery.execute();
 
-				if (!menu) {
+				if (matches.length === 0) {
 					throw notFoundSentinel;
 				}
+				if (matches.length > 1) {
+					ambiguousLocales = matches.map((m) => m.locale);
+					throw ambiguousSentinel;
+				}
+				const menu = matches[0]!;
 
 				await trx.deleteFrom("_emdash_menu_items").where("menu_id", "=", menu.id).execute();
 
@@ -551,6 +843,7 @@ export async function handleMenuSetItems(
 							title_attr: item.titleAttr ?? null,
 							target: item.target ?? null,
 							css_classes: item.cssClasses ?? null,
+							locale: menu.locale,
 						})
 						.execute();
 					insertedIds.push(id);
@@ -566,9 +859,17 @@ export async function handleMenuSetItems(
 			if (error === notFoundSentinel) {
 				return {
 					success: false,
-					error: { code: "NOT_FOUND", message: `Menu '${menuName}' not found` },
+					error: {
+						code: "NOT_FOUND",
+						message: `Menu '${menuName}' not found${
+							options.locale ? ` in locale '${options.locale}'` : ""
+						}`,
+					},
 				};
 			}
+			if (error === ambiguousSentinel && ambiguousLocales) {
+				return ambiguousMenuLocaleError(menuName, ambiguousLocales);
+			}
 			throw error;
 		}
 
@@ -589,20 +890,30 @@ export async function handleMenuItemReorder(
 	db: Kysely<Database>,
 	menuName: string,
 	items: ReorderItem[],
+	options: { locale?: string } = {},
 ): Promise<ApiResult<MenuItemRow[]>> {
 	try {
-		const menu = await db
+		// See ambiguousMenuLocaleError for the rationale.
+		let menuQuery = db
 			.selectFrom("_emdash_menus")
-			.select("id")
-			.where("name", "=", menuName)
-			.executeTakeFirst();
+			.select(["id", "locale"])
+			.where("name", "=", menuName);
+		if (options.locale !== undefined) menuQuery = menuQuery.where("locale", "=", options.locale);
+		const matches = await menuQuery.execute();
 
-		if (!menu) {
+		if (matches.length === 0) {
 			return {
 				success: false,
 				error: { code: "NOT_FOUND", message: "Menu not found" },
 			};
 		}
+		if (matches.length > 1) {
+			return ambiguousMenuLocaleError(
+				menuName,
+				matches.map((m) => m.locale),
+			);
+		}
+		const menu = matches[0]!;
 
 		const updatedItems = await withTransaction(db, async (trx) => {
 			for (const item of items) {