emdash 0.9.0 → 0.10.0

package/src/api/handlers/dashboard.ts

@@ -140,21 +140,22 @@ async function fetchRecentItems(
 
 	const collectionsWithTitle = new Set(titleFields.map((r) => r.collection_slug));
 
-	// Build a UNION ALL query across all content tables.
-	// Each branch is wrapped in SELECT * FROM (...) so the inner
-	// ORDER BY + LIMIT is valid SQLite (bare ORDER BY inside UNION
-	// branches is a syntax error in SQLite).
-	const subQueries = collections.map((col) => {
-		validateIdentifier(col.slug);
-		const table = `ec_${col.slug}`;
-		const hasTitle = collectionsWithTitle.has(col.slug);
-
-		// Use title column if it exists, otherwise fall back to slug → id.
-		// All output uses snake_case to avoid SQLite quoting issues on D1.
-		const titleExpr = hasTitle ? sql`COALESCE(title, slug, id)` : sql`COALESCE(slug, id)`;
-
-		return sql<RecentItemRow>`
-			SELECT * FROM (
+	// Issue one query per collection in parallel, then merge in JS.
+	// A single UNION ALL across N collections trips D1's
+	// SQLITE_LIMIT_COMPOUND_SELECT cap when N is large enough (#895);
+	// per-collection queries side-step that. Each query fetches at most
+	// 10 rows, so the merge handles at most N * 10 rows before slicing.
+	const perCollection = await Promise.all(
+		collections.map(async (col) => {
+			validateIdentifier(col.slug);
+			const table = `ec_${col.slug}`;
+			const hasTitle = collectionsWithTitle.has(col.slug);
+
+			// Use title column if it exists, otherwise fall back to slug, id.
+			// All output uses snake_case to avoid SQLite quoting issues on D1.
+			const titleExpr = hasTitle ? sql`COALESCE(title, slug, id)` : sql`COALESCE(slug, id)`;
+
+			const result = await sql<RecentItemRow>`
 				SELECT
 					id,
 					${sql.lit(col.slug)} AS collection,
@@ -168,27 +169,19 @@ async function fetchRecentItems(
 				WHERE deleted_at IS NULL
 				ORDER BY updated_at DESC
 				LIMIT 10
-			)
-		`;
-	});
-
-	// Combine with UNION ALL
-	// eslint-disable-next-line typescript-eslint(no-unnecessary-type-assertion) -- noUncheckedIndexedAccess
-	let combined = subQueries[0]!;
-	for (let i = 1; i < subQueries.length; i++) {
-		// eslint-disable-next-line typescript-eslint(no-unnecessary-type-assertion) -- noUncheckedIndexedAccess
-		combined = sql<RecentItemRow>`${combined} UNION ALL ${subQueries[i]!}`;
-	}
-
-	// Final sort + limit across all branches
-	const result = await sql<RecentItemRow>`
-		SELECT * FROM (${combined})
-		ORDER BY updated_at DESC
-		LIMIT 10
-	`.execute(db);
-
-	// Map snake_case DB rows → camelCase API shape
-	return result.rows.map((row) => ({
+			`.execute(db);
+			return result.rows;
+		}),
+	);
+
+	// Merge across collections, sort by updated_at desc, take top 10.
+	const merged = perCollection
+		.flat()
+		.toSorted((a, b) => (a.updated_at < b.updated_at ? 1 : a.updated_at > b.updated_at ? -1 : 0))
+		.slice(0, 10);
+
+	// Map snake_case DB rows to camelCase API shape
+	return merged.map((row) => ({
 		id: row.id,
 		collection: row.collection,
 		collectionLabel: row.collection_label,

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,34 @@ 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;
+	}>;
+}
+
 // ---------------------------------------------------------------------------
 // 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 +70,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 +95,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 +110,117 @@ 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 {
+		// 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 +231,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,19 +268,52 @@ 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 '${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 {
+		let query = db.selectFrom("_emdash_menus").select("id").where("name", "=", name);
+		if (input.locale !== undefined) query = query.where("locale", "=", input.locale);
+		const menu = await query.executeTakeFirst();
 
 		if (!menu) {
 			return {
@@ -197,7 +335,6 @@ export async function handleMenuUpdate(
 			.selectAll()
 			.where("id", "=", menu.id)
 			.executeTakeFirstOrThrow();
-
 		return { success: true, data: updated };
 	} catch {
 		return {
@@ -208,18 +345,17 @@ 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();
+		let query = db.selectFrom("_emdash_menus").select("id").where("name", "=", name);
+		if (options.locale !== undefined) query = query.where("locale", "=", options.locale);
+		const menu = await query.executeTakeFirst();
 
 		if (!menu) {
 			return {
@@ -233,7 +369,6 @@ export async function handleMenuDelete(
 		// 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 +378,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,19 +443,22 @@ 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
+		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 menu = await menuQuery.executeTakeFirst();
 
 		if (!menu) {
 			return {
@@ -290,7 +475,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 +495,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 +505,6 @@ export async function handleMenuItemCreate(
 			.selectAll()
 			.where("id", "=", id)
 			.executeTakeFirstOrThrow();
-
 		return { success: true, data: item };
 	} catch {
 		return {
@@ -347,13 +532,12 @@ export async function handleMenuItemUpdate(
 	menuName: string,
 	itemId: string,
 	input: UpdateMenuItemInput,
+	options: { locale?: string } = {},
 ): Promise<ApiResult<MenuItemRow>> {
 	try {
-		const menu = await db
-			.selectFrom("_emdash_menus")
-			.select("id")
-			.where("name", "=", menuName)
-			.executeTakeFirst();
+		let menuQuery = db.selectFrom("_emdash_menus").select("id").where("name", "=", menuName);
+		if (options.locale !== undefined) menuQuery = menuQuery.where("locale", "=", options.locale);
+		const menu = await menuQuery.executeTakeFirst();
 
 		if (!menu) {
 			return {
@@ -394,7 +578,6 @@ export async function handleMenuItemUpdate(
 			.selectAll()
 			.where("id", "=", itemId)
 			.executeTakeFirstOrThrow();
-
 		return { success: true, data: updated };
 	} catch {
 		return {
@@ -411,13 +594,12 @@ export async function handleMenuItemDelete(
 	db: Kysely<Database>,
 	menuName: string,
 	itemId: string,
+	options: { locale?: string } = {},
 ): Promise<ApiResult<{ deleted: true }>> {
 	try {
-		const menu = await db
-			.selectFrom("_emdash_menus")
-			.select("id")
-			.where("name", "=", menuName)
-			.executeTakeFirst();
+		let menuQuery = db.selectFrom("_emdash_menus").select("id").where("name", "=", menuName);
+		if (options.locale !== undefined) menuQuery = menuQuery.where("locale", "=", options.locale);
+		const menu = await menuQuery.executeTakeFirst();
 
 		if (!menu) {
 			return {
@@ -589,13 +771,12 @@ export async function handleMenuItemReorder(
 	db: Kysely<Database>,
 	menuName: string,
 	items: ReorderItem[],
+	options: { locale?: string } = {},
 ): Promise<ApiResult<MenuItemRow[]>> {
 	try {
-		const menu = await db
-			.selectFrom("_emdash_menus")
-			.select("id")
-			.where("name", "=", menuName)
-			.executeTakeFirst();
+		let menuQuery = db.selectFrom("_emdash_menus").select("id").where("name", "=", menuName);
+		if (options.locale !== undefined) menuQuery = menuQuery.where("locale", "=", options.locale);
+		const menu = await menuQuery.executeTakeFirst();
 
 		if (!menu) {
 			return {