emdash 0.11.1 → 0.13.0

package/src/api/handlers/menus.ts

@@ -11,28 +11,32 @@
  * specific row id), so a single menu item target survives content translations.
  */
 
-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 type { Kysely } from "kysely";
+
+import {
+	MenuGoneError,
+	MenuRepository,
+	type CreateMenuItemInput as CreateMenuItemRepoInput,
+	type Menu,
+	type MenuItem,
+	type MenuListItem,
+	type MenuWithItems,
+	type SetMenuItem,
+	type UpdateMenuItemInput as UpdateMenuItemRepoInput,
+} from "../../database/repositories/menu.js";
+import type { Database } from "../../database/types.js";
 import { getI18nConfig } from "../../i18n/config.js";
 import type { ApiResult } from "../types.js";
 
-// ---------------------------------------------------------------------------
-// Response types
-// ---------------------------------------------------------------------------
-
-export type MenuRow = Selectable<MenuTable>;
-export type MenuItemRow = Selectable<MenuItemTable>;
-
-export interface MenuListItem extends MenuRow {
-	itemCount: number;
-}
-
-export interface MenuWithItems extends MenuRow {
-	items: MenuItemRow[];
-}
+// Re-export entity types so route files and tests can import them from the
+// handler module without having to know about the repository layout.
+export type {
+	Menu,
+	MenuItem,
+	MenuListItem,
+	MenuTranslation,
+	MenuWithItems,
+} from "../../database/repositories/menu.js";
 
 export interface MenuTranslationsResponse {
 	translationGroup: string | null;
@@ -45,6 +49,10 @@ export interface MenuTranslationsResponse {
 	}>;
 }
 
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+
 /**
  * Error returned when a menu lookup by `name` matches multiple locale
  * variants and the caller did not pass `locale` to disambiguate. Maps to
@@ -67,62 +75,57 @@ function ambiguousMenuLocaleError(
 	};
 }
 
+type ResolveMenuResult =
+	| { success: true; menu: Menu }
+	| { success: false; error: { code: "NOT_FOUND" | "AMBIGUOUS_LOCALE"; message: string } };
+
+/**
+ * Resolve a menu by name + optional locale to a single Menu, surfacing the
+ * canonical NOT_FOUND / AMBIGUOUS_LOCALE errors. Every item handler relies on
+ * this to translate (name, locale) into an unambiguous menu row.
+ */
+async function resolveMenu(
+	repo: MenuRepository,
+	name: string,
+	options: { locale?: string },
+): Promise<ResolveMenuResult> {
+	const matches = await repo.findByName(name, options);
+	if (matches.length === 0) {
+		return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Menu '${name}' not found${options.locale ? ` in locale '${options.locale}'` : ""}`,
+			},
+		};
+	}
+	if (matches.length > 1) {
+		return {
+			success: false,
+			error: ambiguousMenuLocaleError(
+				name,
+				matches.map((m) => m.locale),
+			).error,
+		};
+	}
+	return { success: true, menu: matches[0] };
+}
+
 // ---------------------------------------------------------------------------
 // Menu handlers
 // ---------------------------------------------------------------------------
 
 /**
- * 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).
+ * List menus with item counts. Filter by `locale` when provided.
  */
 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.
-		let query = db
-			.selectFrom("_emdash_menus as m")
-			.leftJoin("_emdash_menu_items as i", "i.menu_id", "m.id")
-			.select(({ fn }) => [
-				"m.id",
-				"m.name",
-				"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",
-				"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.
-		const menusWithCounts: MenuListItem[] = rows.map((row) => ({
-			id: row.id,
-			name: row.name,
-			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,
-		}));
-
-		return { success: true, data: menusWithCounts };
+		const repo = new MenuRepository(db);
+		const items = await repo.findMany(options);
+		return { success: true, data: items };
 	} catch {
 		return {
 			success: false,
@@ -133,12 +136,13 @@ export async function handleMenuList(
 
 /**
  * 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).
+ * source menu's translation_group (and gets the source's items cloned by the
+ * repository).
  */
 export async function handleMenuCreate(
 	db: Kysely<Database>,
 	input: { name: string; label: string; locale?: string; translationOf?: string },
-): Promise<ApiResult<MenuRow>> {
+): Promise<ApiResult<Menu>> {
 	try {
 		// Translating from a source menu only makes sense when the caller
 		// names the target locale: otherwise we'd silently clone into the
@@ -155,35 +159,24 @@ export async function handleMenuCreate(
 			};
 		}
 
-		// Resolve translation group + source (if we're creating a translation).
-		let translationGroup: string | null = null;
-		let sourceMenu: MenuRow | null = null;
+		const repo = new MenuRepository(db);
+
+		// Existence check up front so the repo's "Source not found" throw
+		// becomes a clean NOT_FOUND on the API.
 		if (input.translationOf) {
-			const src = await db
-				.selectFrom("_emdash_menus")
-				.selectAll()
-				.where("id", "=", input.translationOf)
-				.executeTakeFirst();
-			if (!src) {
+			const source = await repo.findById(input.translationOf);
+			if (!source) {
 				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) {
+		if (await repo.existsByNameAndLocale(input.name, effectiveLocale)) {
 			return {
 				success: false,
 				error: {
@@ -195,69 +188,7 @@ export async function handleMenuCreate(
 			};
 		}
 
-		const id = ulid();
-
-		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();
+		const menu = await repo.create(input);
 		return { success: true, data: menu };
 	} catch {
 		return {
@@ -270,6 +201,9 @@ export async function handleMenuCreate(
 /**
  * Get a single menu by name. Honours an optional `locale` filter; when two
  * menus share a name across locales, the locale distinguishes them.
+ *
+ * Historical behaviour: when `locale` is omitted, returns the lowest-locale
+ * match (deterministic). Mirrors the pre-repo handler.
  */
 export async function handleMenuGet(
 	db: Kysely<Database>,
@@ -277,24 +211,16 @@ export async function handleMenuGet(
 	options: { locale?: string } = {},
 ): Promise<ApiResult<MenuWithItems>> {
 	try {
-		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) {
+		const repo = new MenuRepository(db);
+		const matches = await repo.findByName(name, options);
+		if (matches.length === 0) {
 			return {
 				success: false,
 				error: { code: "NOT_FOUND", message: `Menu '${name}' not found` },
 			};
 		}
-
-		const items = await db
-			.selectFrom("_emdash_menu_items")
-			.selectAll()
-			.where("menu_id", "=", menu.id)
-			.orderBy("sort_order", "asc")
-			.execute();
-
+		const menu = matches[0];
+		const items = await repo.findItems(menu.id);
 		return { success: true, data: { ...menu, items } };
 	} catch {
 		return {
@@ -313,24 +239,15 @@ export async function handleMenuGetById(
 	id: string,
 ): Promise<ApiResult<MenuWithItems>> {
 	try {
-		const menu = await db
-			.selectFrom("_emdash_menus")
-			.selectAll()
-			.where("id", "=", id)
-			.executeTakeFirst();
+		const repo = new MenuRepository(db);
+		const menu = await repo.findWithItems(id);
 		if (!menu) {
 			return {
 				success: false,
 				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 } };
+		return { success: true, data: menu };
 	} catch {
 		return {
 			success: false,
@@ -346,46 +263,18 @@ export async function handleMenuUpdate(
 	db: Kysely<Database>,
 	name: string,
 	input: { label?: string; locale?: string },
-): Promise<ApiResult<MenuRow>> {
+): Promise<ApiResult<Menu>> {
 	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) {
+		const repo = new MenuRepository(db);
+		const resolved = await resolveMenu(repo, name, { locale: input.locale });
+		if (!resolved.success) return resolved;
+		const updated = await repo.update(resolved.menu.id, { label: input.label });
+		if (!updated) {
 			return {
 				success: false,
-				error: {
-					code: "NOT_FOUND",
-					message: `Menu '${name}' not found${input.locale ? ` in locale '${input.locale}'` : ""}`,
-				},
+				error: { code: "NOT_FOUND", message: `Menu '${name}' not found` },
 			};
 		}
-		if (matches.length > 1) {
-			return ambiguousMenuLocaleError(
-				name,
-				matches.map((m) => m.locale),
-			);
-		}
-		const menu = matches[0]!;
-
-		if (input.label) {
-			await db
-				.updateTable("_emdash_menus")
-				.set({ label: input.label })
-				.where("id", "=", menu.id)
-				.execute();
-		}
-
-		const updated = await db
-			.selectFrom("_emdash_menus")
-			.selectAll()
-			.where("id", "=", menu.id)
-			.executeTakeFirstOrThrow();
 		return { success: true, data: updated };
 	} catch {
 		return {
@@ -396,7 +285,7 @@ export async function handleMenuUpdate(
 }
 
 /**
- * Delete a menu (and items, via cascade).
+ * Delete a menu (and its items, via the repository's explicit cleanup).
  */
 export async function handleMenuDelete(
 	db: Kysely<Database>,
@@ -404,35 +293,10 @@ export async function handleMenuDelete(
 	options: { locale?: string } = {},
 ): Promise<ApiResult<{ deleted: true }>> {
 	try {
-		// 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 (matches.length === 0) {
-			return {
-				success: false,
-				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();
+		const repo = new MenuRepository(db);
+		const resolved = await resolveMenu(repo, name, options);
+		if (!resolved.success) return resolved;
+		await repo.delete(resolved.menu.id);
 		return { success: true, data: { deleted: true } };
 	} catch {
 		return {
@@ -450,37 +314,15 @@ export async function handleMenuTranslations(
 	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) {
+		const repo = new MenuRepository(db);
+		const result = await repo.listTranslations(idOrGroup);
+		if (!result) {
 			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,
-				})),
-			},
-		};
+		return { success: true, data: result };
 	} catch {
 		return {
 			success: false,
@@ -493,91 +335,25 @@ export async function handleMenuTranslations(
 // Menu item handlers
 // ---------------------------------------------------------------------------
 
-export interface CreateMenuItemInput {
-	type: string;
-	label: string;
-	referenceCollection?: string;
-	referenceId?: string;
-	customUrl?: string;
-	target?: string;
-	titleAttr?: string;
-	cssClasses?: string;
-	parentId?: string;
-	sortOrder?: number;
-}
+export type CreateMenuItemInput = CreateMenuItemRepoInput;
+export type UpdateMenuItemInput = UpdateMenuItemRepoInput;
+export type MenuSetItemsInput = SetMenuItem;
 
 /**
- * Add an item to a menu. The item inherits the menu's locale (so listing
- * items by locale stays trivial).
+ * Add an item to a menu. The item inherits the menu's locale.
  */
 export async function handleMenuItemCreate(
 	db: Kysely<Database>,
 	menuName: string,
 	input: CreateMenuItemInput,
 	options: { locale?: string } = {},
-): Promise<ApiResult<MenuItemRow>> {
+): Promise<ApiResult<MenuItem>> {
 	try {
-		// Same fail-loud rule as handleMenuUpdate / Delete / SetItems —
-		// see ambiguousMenuLocaleError for the rationale.
-		let menuQuery = db
-			.selectFrom("_emdash_menus")
-			.select(["id", "locale"])
-			.where("name", "=", menuName);
-		if (options.locale !== undefined) menuQuery = menuQuery.where("locale", "=", options.locale);
-		const matches = await menuQuery.execute();
+		const repo = new MenuRepository(db);
+		const resolved = await resolveMenu(repo, menuName, options);
+		if (!resolved.success) return resolved;
 
-		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) {
-			const maxOrder = await db
-				.selectFrom("_emdash_menu_items")
-				.select(({ fn }) => fn.max("sort_order").as("max"))
-				.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;
-		}
-
-		const id = ulid();
-		await db
-			.insertInto("_emdash_menu_items")
-			.values({
-				id,
-				menu_id: menu.id,
-				parent_id: input.parentId ?? null,
-				sort_order: sortOrder,
-				type: input.type,
-				reference_collection: input.referenceCollection ?? null,
-				reference_id: input.referenceId ?? null,
-				custom_url: input.customUrl ?? null,
-				label: input.label,
-				title_attr: input.titleAttr ?? null,
-				target: input.target ?? null,
-				css_classes: input.cssClasses ?? null,
-				locale: menu.locale,
-				translation_group: id,
-			})
-			.execute();
-
-		const item = await db
-			.selectFrom("_emdash_menu_items")
-			.selectAll()
-			.where("id", "=", id)
-			.executeTakeFirstOrThrow();
+		const item = await repo.createItem(resolved.menu.id, resolved.menu.locale, input);
 		return { success: true, data: item };
 	} catch {
 		return {
@@ -587,16 +363,6 @@ export async function handleMenuItemCreate(
 	}
 }
 
-export interface UpdateMenuItemInput {
-	label?: string;
-	customUrl?: string;
-	target?: string;
-	titleAttr?: string;
-	cssClasses?: string;
-	parentId?: string | null;
-	sortOrder?: number;
-}
-
 /**
  * Update a menu item.
  */
@@ -606,62 +372,19 @@ export async function handleMenuItemUpdate(
 	itemId: string,
 	input: UpdateMenuItemInput,
 	options: { locale?: string } = {},
-): Promise<ApiResult<MenuItemRow>> {
+): Promise<ApiResult<MenuItem>> {
 	try {
-		// See ambiguousMenuLocaleError for the rationale.
-		let menuQuery = db
-			.selectFrom("_emdash_menus")
-			.select(["id", "locale"])
-			.where("name", "=", menuName);
-		if (options.locale !== undefined) menuQuery = menuQuery.where("locale", "=", options.locale);
-		const matches = await menuQuery.execute();
-
-		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 repo = new MenuRepository(db);
+		const resolved = await resolveMenu(repo, menuName, options);
+		if (!resolved.success) return resolved;
 
-		const item = await db
-			.selectFrom("_emdash_menu_items")
-			.select("id")
-			.where("id", "=", itemId)
-			.where("menu_id", "=", menu.id)
-			.executeTakeFirst();
-
-		if (!item) {
+		const updated = await repo.updateItem(resolved.menu.id, itemId, input);
+		if (!updated) {
 			return {
 				success: false,
 				error: { code: "NOT_FOUND", message: "Menu item not found" },
 			};
 		}
-
-		const updates: Record<string, unknown> = {};
-		if (input.label !== undefined) updates.label = input.label;
-		if (input.customUrl !== undefined) updates.custom_url = input.customUrl;
-		if (input.target !== undefined) updates.target = input.target;
-		if (input.titleAttr !== undefined) updates.title_attr = input.titleAttr;
-		if (input.cssClasses !== undefined) updates.css_classes = input.cssClasses;
-		if (input.parentId !== undefined) updates.parent_id = input.parentId;
-		if (input.sortOrder !== undefined) updates.sort_order = input.sortOrder;
-
-		if (Object.keys(updates).length > 0) {
-			await db.updateTable("_emdash_menu_items").set(updates).where("id", "=", itemId).execute();
-		}
-
-		const updated = await db
-			.selectFrom("_emdash_menu_items")
-			.selectAll()
-			.where("id", "=", itemId)
-			.executeTakeFirstOrThrow();
 		return { success: true, data: updated };
 	} catch {
 		return {
@@ -681,41 +404,17 @@ export async function handleMenuItemDelete(
 	options: { locale?: string } = {},
 ): Promise<ApiResult<{ deleted: true }>> {
 	try {
-		// See ambiguousMenuLocaleError for the rationale.
-		let menuQuery = db
-			.selectFrom("_emdash_menus")
-			.select(["id", "locale"])
-			.where("name", "=", menuName);
-		if (options.locale !== undefined) menuQuery = menuQuery.where("locale", "=", options.locale);
-		const matches = await menuQuery.execute();
-
-		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")
-			.where("id", "=", itemId)
-			.where("menu_id", "=", menu.id)
-			.execute();
+		const repo = new MenuRepository(db);
+		const resolved = await resolveMenu(repo, menuName, options);
+		if (!resolved.success) return resolved;
 
-		if (result[0]?.numDeletedRows === 0n) {
+		const deleted = await repo.deleteItem(resolved.menu.id, itemId);
+		if (!deleted) {
 			return {
 				success: false,
 				error: { code: "NOT_FOUND", message: "Menu item not found" },
 			};
 		}
-
 		return { success: true, data: { deleted: true } };
 	} catch {
 		return {
@@ -732,26 +431,9 @@ export interface ReorderItem {
 }
 
 // ---------------------------------------------------------------------------
-// Atomic-replace menu items (used by the MCP `menu_set_items` tool)
+// Atomic-replace menu items (used by the MCP `menu_set_items` tool and admin)
 // ---------------------------------------------------------------------------
 
-export interface MenuSetItemsInput {
-	label: string;
-	type: "custom" | "page" | "post" | "taxonomy" | "collection";
-	customUrl?: string;
-	referenceCollection?: string;
-	referenceId?: string;
-	titleAttr?: string;
-	target?: string;
-	cssClasses?: string;
-	/**
-	 * Index of the parent item in this same array. Must be strictly less
-	 * than the current item's index so the insert order resolves parents
-	 * before children. `undefined` makes the item top-level.
-	 */
-	parentIndex?: number;
-}
-
 /**
  * Replace the entire set of items for a menu in one atomic transaction.
  *
@@ -765,11 +447,10 @@ export async function handleMenuSetItems(
 	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.
-	// Negative indices are out of range; only Zod's `.nonnegative()` at
-	// the MCP boundary catches them today, so guard explicitly here for
-	// any caller that bypasses Zod (REST routes, direct handler use).
+	// Validate parentIndex references — must be strictly earlier so the array
+	// can be inserted in order with parents resolved first. Negative indices
+	// are caught by Zod's `.nonnegative()` at the MCP boundary, but we guard
+	// explicitly so REST routes / direct handler use get the same error.
 	for (let i = 0; i < items.length; i++) {
 		const item = items[i];
 		if (item?.parentIndex !== undefined) {
@@ -786,95 +467,29 @@ export async function handleMenuSetItems(
 	}
 
 	try {
-		// 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). Same fail-loud
-				// rule as handleMenuUpdate / handleMenuDelete.
-				let menuQuery = trx
-					.selectFrom("_emdash_menus")
-					.select(["id", "locale"])
-					.where("name", "=", menuName);
-				if (options.locale !== undefined) {
-					menuQuery = menuQuery.where("locale", "=", options.locale);
-				}
-				const matches = await menuQuery.execute();
-
-				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();
-
-				const insertedIds: string[] = [];
-				for (let i = 0; i < items.length; i++) {
-					const item = items[i];
-					if (!item) continue;
-					const id = ulid();
-					const parentId =
-						item.parentIndex !== undefined ? (insertedIds[item.parentIndex] ?? null) : null;
-					await trx
-						.insertInto("_emdash_menu_items")
-						.values({
-							id,
-							menu_id: menu.id,
-							parent_id: parentId,
-							sort_order: i,
-							type: item.type,
-							reference_collection: item.referenceCollection ?? null,
-							reference_id: item.referenceId ?? null,
-							custom_url: item.customUrl ?? null,
-							label: item.label,
-							title_attr: item.titleAttr ?? null,
-							target: item.target ?? null,
-							css_classes: item.cssClasses ?? null,
-							locale: menu.locale,
-						})
-						.execute();
-					insertedIds.push(id);
-				}
-
-				await trx
-					.updateTable("_emdash_menus")
-					.set({ updated_at: new Date().toISOString() })
-					.where("id", "=", menu.id)
-					.execute();
-			});
-		} catch (error) {
-			if (error === notFoundSentinel) {
-				return {
-					success: false,
-					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;
-		}
+		const repo = new MenuRepository(db);
+		const resolved = await resolveMenu(repo, menuName, options);
+		if (!resolved.success) return resolved;
 
-		return { success: true, data: { name: menuName, itemCount: items.length } };
+		const { itemCount } = await repo.setItems(resolved.menu.id, resolved.menu.locale, items);
+		return { success: true, data: { name: menuName, itemCount } };
 	} catch (error) {
+		// `MenuGoneError` is thrown from inside the repository transaction
+		// when the menu was deleted concurrently between `resolveMenu` and the
+		// setItems write. Returning NOT_FOUND mirrors the original handler's
+		// in-transaction `notFoundSentinel` branch and keeps the response
+		// shape stable for REST/MCP callers.
+		if (error instanceof MenuGoneError) {
+			return {
+				success: false,
+				error: {
+					code: "NOT_FOUND",
+					message: `Menu '${menuName}' not found${
+						options.locale ? ` in locale '${options.locale}'` : ""
+					}`,
+				},
+			};
+		}
 		console.error("[emdash] handleMenuSetItems failed:", error);
 		return {
 			success: false,
@@ -891,52 +506,14 @@ export async function handleMenuItemReorder(
 	menuName: string,
 	items: ReorderItem[],
 	options: { locale?: string } = {},
-): Promise<ApiResult<MenuItemRow[]>> {
+): Promise<ApiResult<MenuItem[]>> {
 	try {
-		// See ambiguousMenuLocaleError for the rationale.
-		let menuQuery = db
-			.selectFrom("_emdash_menus")
-			.select(["id", "locale"])
-			.where("name", "=", menuName);
-		if (options.locale !== undefined) menuQuery = menuQuery.where("locale", "=", options.locale);
-		const matches = await menuQuery.execute();
+		const repo = new MenuRepository(db);
+		const resolved = await resolveMenu(repo, menuName, options);
+		if (!resolved.success) return resolved;
 
-		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) {
-				await trx
-					.updateTable("_emdash_menu_items")
-					.set({
-						parent_id: item.parentId,
-						sort_order: item.sortOrder,
-					})
-					.where("id", "=", item.id)
-					.where("menu_id", "=", menu.id)
-					.execute();
-			}
-
-			return trx
-				.selectFrom("_emdash_menu_items")
-				.selectAll()
-				.where("menu_id", "=", menu.id)
-				.orderBy("sort_order", "asc")
-				.execute();
-		});
-
-		return { success: true, data: updatedItems };
+		const updated = await repo.reorderItems(resolved.menu.id, items);
+		return { success: true, data: updated };
 	} catch {
 		return {
 			success: false,