emdash 0.6.0 → 0.8.0

package/src/api/handlers/content.ts

@@ -14,6 +14,7 @@ import { RevisionRepository } from "../../database/repositories/revision.js";
 import { SeoRepository } from "../../database/repositories/seo.js";
 import {
 	EmDashValidationError,
+	InvalidCursorError,
 	type ContentItem,
 	type ContentSeo,
 	type ContentSeoInput,
@@ -23,9 +24,26 @@ import type { Database } from "../../database/types.js";
 import { validateIdentifier } from "../../database/validate.js";
 import { isI18nEnabled } from "../../i18n/config.js";
 import { invalidateRedirectCache } from "../../redirects/cache.js";
+import { isMissingTableError } from "../../utils/db-errors.js";
 import { encodeRev, validateRev } from "../rev.js";
 import type { ApiResult, ContentListResponse, ContentResponse } from "../types.js";
 
+/**
+ * Narrow a caught error to one carrying a structured `apiError` discriminant.
+ * Used by transaction callbacks that want to surface a specific error code
+ * through the standard Error throwing path.
+ */
+function hasApiError(error: unknown): error is Error & { apiError: { code: string } } {
+	if (!(error instanceof Error) || !("apiError" in error)) return false;
+	const { apiError } = error;
+	return (
+		typeof apiError === "object" &&
+		apiError !== null &&
+		"code" in apiError &&
+		typeof apiError.code === "string"
+	);
+}
+
 /**
  * Extract a slug source (title or name) from content data.
  * Returns null if no suitable string field is found.
@@ -267,6 +285,28 @@ export async function handleContentList(
 			},
 		};
 	} catch (error) {
+		if (error instanceof InvalidCursorError) {
+			return {
+				success: false,
+				error: { code: "INVALID_CURSOR", message: error.message },
+			};
+		}
+		if (isMissingTableError(error)) {
+			return {
+				success: false,
+				error: {
+					code: "COLLECTION_NOT_FOUND",
+					message: `Collection '${collection}' not found`,
+				},
+			};
+		}
+		if (error instanceof EmDashValidationError) {
+			// e.g. invalid orderBy field
+			return {
+				success: false,
+				error: { code: "VALIDATION_ERROR", message: error.message },
+			};
+		}
 		console.error("Content list error:", error);
 		return {
 			success: false,
@@ -453,6 +493,46 @@ export async function handleContentCreate(
 			data: { item, _rev: encodeRev(item) },
 		};
 	} catch (error) {
+		if (isMissingTableError(error)) {
+			return {
+				success: false,
+				error: {
+					code: "COLLECTION_NOT_FOUND",
+					message: `Collection '${collection}' not found`,
+				},
+			};
+		}
+		if (error instanceof EmDashValidationError) {
+			return {
+				success: false,
+				error: { code: "VALIDATION_ERROR", message: error.message },
+			};
+		}
+		// SQLite UNIQUE constraint OR Postgres unique_violation — slug
+		// collisions and any other unique violations land here. Match
+		// specifically on "unique constraint failed" / "duplicate key" so we
+		// don't false-positive on NOT NULL or CHECK violations whose
+		// messages also contain "constraint failed".
+		const message = error instanceof Error ? error.message.toLowerCase() : "";
+		if (message.includes("unique constraint failed") || message.includes("duplicate key")) {
+			// Detect slug-specific collisions by message fingerprint
+			if (message.includes("slug")) {
+				return {
+					success: false,
+					error: {
+						code: "SLUG_CONFLICT",
+						message: `Slug '${body.slug ?? "(auto-generated)"}' already exists in collection '${collection}'`,
+					},
+				};
+			}
+			return {
+				success: false,
+				error: {
+					code: "CONFLICT",
+					message: "Unique constraint violation",
+				},
+			};
+		}
 		console.error("Content create error:", error);
 		return {
 			success: false,
@@ -483,6 +563,7 @@ export async function handleContentUpdate(
 		bylines?: ContentBylineInput[];
 		_rev?: string;
 		seo?: ContentSeoInput;
+		publishedAt?: string | null;
 	},
 ): Promise<ApiResult<ContentResponse>> {
 	try {
@@ -542,6 +623,7 @@ export async function handleContentUpdate(
 				slug: body.slug,
 				status: body.status,
 				authorId: body.authorId,
+				publishedAt: body.publishedAt,
 			});
 
 			if (body.bylines !== undefined) {
@@ -602,11 +684,44 @@ export async function handleContentUpdate(
 	} catch (error) {
 		// Handle structured errors thrown from inside the transaction
 		// (rev check failures, not-found)
-		if (error instanceof Error && "apiError" in error) {
-			const { code } = (error as Error & { apiError: { code: string } }).apiError;
+		if (hasApiError(error)) {
+			return {
+				success: false,
+				error: { code: error.apiError.code, message: error.message },
+			};
+		}
+		if (isMissingTableError(error)) {
 			return {
 				success: false,
-				error: { code, message: error.message },
+				error: {
+					code: "COLLECTION_NOT_FOUND",
+					message: `Collection '${collection}' not found`,
+				},
+			};
+		}
+		if (error instanceof EmDashValidationError) {
+			return {
+				success: false,
+				error: { code: "VALIDATION_ERROR", message: error.message },
+			};
+		}
+		const message = error instanceof Error ? error.message.toLowerCase() : "";
+		if (message.includes("unique constraint failed") || message.includes("duplicate key")) {
+			if (message.includes("slug")) {
+				return {
+					success: false,
+					error: {
+						code: "SLUG_CONFLICT",
+						message: `Slug '${body.slug ?? id}' already exists in collection '${collection}'`,
+					},
+				};
+			}
+			return {
+				success: false,
+				error: {
+					code: "CONFLICT",
+					message: "Unique constraint violation",
+				},
 			};
 		}
 		console.error("Content update error:", error);
@@ -867,6 +982,12 @@ export async function handleContentListTrashed(
 			},
 		};
 	} catch (error) {
+		if (error instanceof InvalidCursorError) {
+			return {
+				success: false,
+				error: { code: "INVALID_CURSOR", message: error.message },
+			};
+		}
 		console.error("Content list trashed error:", error);
 		return {
 			success: false,

package/src/api/handlers/index.ts

@@ -113,11 +113,13 @@ export {
 	handleMenuItemUpdate,
 	handleMenuItemDelete,
 	handleMenuItemReorder,
+	handleMenuSetItems,
 	type MenuListItem,
 	type MenuWithItems,
 	type CreateMenuItemInput,
 	type UpdateMenuItemInput,
 	type ReorderItem,
+	type MenuSetItemsInput,
 } from "./menus.js";
 
 // Section handlers

package/src/api/handlers/media.ts

@@ -5,6 +5,7 @@
 import type { Kysely } from "kysely";
 
 import { MediaRepository, type MediaItem } from "../../database/repositories/media.js";
+import { InvalidCursorError } from "../../database/repositories/types.js";
 import type { Database } from "../../database/types.js";
 import type { ApiResult } from "../types.js";
 
@@ -43,7 +44,13 @@ export async function handleMediaList(
 				nextCursor: result.nextCursor,
 			},
 		};
-	} catch {
+	} catch (error) {
+		if (error instanceof InvalidCursorError) {
+			return {
+				success: false,
+				error: { code: "INVALID_CURSOR", message: error.message },
+			};
+		}
 		return {
 			success: false,
 			error: {

package/src/api/handlers/menus.ts

@@ -42,26 +42,33 @@ export interface MenuWithItems extends MenuRow {
  */
 export async function handleMenuList(db: Kysely<Database>): Promise<ApiResult<MenuListItem[]>> {
 	try {
-		const menus = await db
-			.selectFrom("_emdash_menus")
-			.select(["id", "name", "label", "created_at", "updated_at"])
-			.orderBy("name", "asc")
+		// 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
+			.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",
+				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();
 
-		const menusWithCounts = await Promise.all(
-			menus.map(async (menu) => {
-				const { count } = await db
-					.selectFrom("_emdash_menu_items")
-					.select(({ fn }) => fn.countAll<number>().as("count"))
-					.where("menu_id", "=", menu.id)
-					.executeTakeFirstOrThrow();
-
-				return {
-					...menu,
-					itemCount: count,
-				};
-			}),
-		);
+		// 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,
+			itemCount: typeof row.itemCount === "string" ? Number(row.itemCount) : row.itemCount,
+		}));
 
 		return { success: true, data: menusWithCounts };
 	} catch {
@@ -135,7 +142,7 @@ export async function handleMenuGet(
 		if (!menu) {
 			return {
 				success: false,
-				error: { code: "NOT_FOUND", message: "Menu not found" },
+				error: { code: "NOT_FOUND", message: `Menu '${name}' not found` },
 			};
 		}
 
@@ -173,7 +180,7 @@ export async function handleMenuUpdate(
 		if (!menu) {
 			return {
 				success: false,
-				error: { code: "NOT_FOUND", message: "Menu not found" },
+				error: { code: "NOT_FOUND", message: `Menu '${name}' not found` },
 			};
 		}
 
@@ -217,10 +224,14 @@ export async function handleMenuDelete(
 		if (!menu) {
 			return {
 				success: false,
-				error: { code: "NOT_FOUND", message: "Menu not found" },
+				error: { code: "NOT_FOUND", message: `Menu '${name}' not found` },
 			};
 		}
 
+		// 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 } };
@@ -443,6 +454,134 @@ export interface ReorderItem {
 	sortOrder: number;
 }
 
+// ---------------------------------------------------------------------------
+// Atomic-replace menu items (used by the MCP `menu_set_items` tool)
+// ---------------------------------------------------------------------------
+
+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.
+ *
+ * Existing items are deleted and the new list is inserted in the order
+ * provided. `parentIndex` references resolve to actual parent IDs as the
+ * insert proceeds.
+ */
+export async function handleMenuSetItems(
+	db: Kysely<Database>,
+	menuName: string,
+	items: MenuSetItemsInput[],
+): 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).
+	for (let i = 0; i < items.length; i++) {
+		const item = items[i];
+		if (item?.parentIndex !== undefined) {
+			if (item.parentIndex < 0 || item.parentIndex >= i) {
+				return {
+					success: false,
+					error: {
+						code: "VALIDATION_ERROR",
+						message: `item[${i}].parentIndex (${item.parentIndex}) must reference an earlier item`,
+					},
+				};
+			}
+		}
+	}
+
+	try {
+		// Sentinel for "menu not found" thrown from inside the transaction
+		// so the rollback fires before we return the structured error.
+		const notFoundSentinel = Symbol("menu-not-found");
+
+		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
+					.selectFrom("_emdash_menus")
+					.select("id")
+					.where("name", "=", menuName)
+					.executeTakeFirst();
+
+				if (!menu) {
+					throw notFoundSentinel;
+				}
+
+				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,
+						})
+						.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` },
+				};
+			}
+			throw error;
+		}
+
+		return { success: true, data: { name: menuName, itemCount: items.length } };
+	} catch (error) {
+		console.error("[emdash] handleMenuSetItems failed:", error);
+		return {
+			success: false,
+			error: { code: "MENU_SET_ITEMS_ERROR", message: "Failed to set menu items" },
+		};
+	}
+}
+
 /**
  * Batch reorder menu items.
  */

package/src/api/handlers/redirects.ts

@@ -11,6 +11,7 @@ import {
 	type NotFoundEntry,
 	type NotFoundSummary,
 } from "../../database/repositories/redirect.js";
+import { InvalidCursorError } from "../../database/repositories/types.js";
 import type { FindManyResult } from "../../database/repositories/types.js";
 import type { Database } from "../../database/types.js";
 import { wouldCreateLoop, detectLoops, type RedirectEdge } from "../../redirects/loops.js";
@@ -48,7 +49,13 @@ export async function handleRedirectList(
 				...(loopRedirectIds.length > 0 ? { loopRedirectIds } : {}),
 			},
 		};
-	} catch {
+	} catch (error) {
+		if (error instanceof InvalidCursorError) {
+			return {
+				success: false,
+				error: { code: "INVALID_CURSOR", message: error.message },
+			};
+		}
 		return {
 			success: false,
 			error: { code: "REDIRECT_LIST_ERROR", message: "Failed to fetch redirects" },
@@ -318,7 +325,7 @@ export async function handleRedirectDelete(
 function loopError(loopPath: string[]): ApiResult<never> {
 	const hops = loopPath
 		.slice(0, -1)
-		.map((p, i) => `${p} \u2192 ${loopPath[i + 1]!}`)
+		.map((p, i) => `${p} \u2192 ${loopPath[i + 1]}`)
 		.join("\n");
 	return {
 		success: false,
@@ -387,7 +394,13 @@ export async function handleNotFoundList(
 		const repo = new RedirectRepository(db);
 		const result = await repo.find404s(params);
 		return { success: true, data: result };
-	} catch {
+	} catch (error) {
+		if (error instanceof InvalidCursorError) {
+			return {
+				success: false,
+				error: { code: "INVALID_CURSOR", message: error.message },
+			};
+		}
 		return {
 			success: false,
 			error: { code: "NOT_FOUND_LIST_ERROR", message: "Failed to fetch 404 log" },

package/src/api/handlers/sections.ts

@@ -5,6 +5,7 @@
 import type { Kysely } from "kysely";
 import { ulid } from "ulidx";
 
+import { InvalidCursorError } from "../../database/repositories/types.js";
 import type { FindManyResult } from "../../database/repositories/types.js";
 import type { Database } from "../../database/types.js";
 import {
@@ -36,7 +37,13 @@ export async function handleSectionList(
 		});
 
 		return { success: true, data: result };
-	} catch {
+	} catch (error) {
+		if (error instanceof InvalidCursorError) {
+			return {
+				success: false,
+				error: { code: "INVALID_CURSOR", message: error.message },
+			};
+		}
 		return {
 			success: false,
 			error: { code: "SECTION_LIST_ERROR", message: "Failed to fetch sections" },