emdash 0.9.0 → 0.10.0

package/src/api/schemas/menus.ts

@@ -20,6 +20,10 @@ export const createMenuBody = z
 	.object({
 		name: z.string().min(1),
 		label: z.string().min(1),
+		locale: z.string().min(1).optional(),
+		/** When set, clones the items from the source menu. The new menu joins
+		 * the source's translation_group. */
+		translationOf: z.string().min(1).optional(),
 	})
 	.meta({ id: "CreateMenuBody" });
 
@@ -87,6 +91,8 @@ export const menuSchema = z
 		label: z.string(),
 		created_at: z.string(),
 		updated_at: z.string(),
+		locale: z.string(),
+		translation_group: z.string().nullable(),
 	})
 	.meta({ id: "Menu" });
 
@@ -105,9 +111,26 @@ export const menuItemSchema = z
 		target: z.string().nullable(),
 		css_classes: z.string().nullable(),
 		created_at: z.string(),
+		locale: z.string(),
+		translation_group: z.string().nullable(),
 	})
 	.meta({ id: "MenuItem" });
 
+export const menuTranslationsSchema = z
+	.object({
+		translationGroup: z.string().nullable(),
+		translations: z.array(
+			z.object({
+				id: z.string(),
+				name: z.string(),
+				label: z.string(),
+				locale: z.string(),
+				updatedAt: z.string(),
+			}),
+		),
+	})
+	.meta({ id: "MenuTranslations" });
+
 export const menuListItemSchema = menuSchema
 	.extend({
 		itemCount: z.number().int(),

package/src/api/schemas/taxonomies.ts

@@ -15,6 +15,7 @@ export const createTaxonomyDefBody = z
 			.max(63)
 			.regex(/^[a-z][a-z0-9_]*$/, "Name must be lowercase alphanumeric with underscores"),
 		label: z.string().min(1).max(200),
+		labelSingular: z.string().min(1).max(200).optional(),
 		hierarchical: z.boolean().optional().default(false),
 		collections: z
 			.array(
@@ -23,6 +24,8 @@ export const createTaxonomyDefBody = z
 			.max(100)
 			.optional()
 			.default([]),
+		locale: z.string().min(1).optional(),
+		translationOf: z.string().min(1).optional(),
 	})
 	.meta({ id: "CreateTaxonomyDefBody" });
 
@@ -36,6 +39,8 @@ export const createTermBody = z
 		label: z.string().min(1),
 		parentId: z.string().nullish(),
 		description: z.string().optional(),
+		locale: z.string().min(1).optional(),
+		translationOf: z.string().min(1).optional(),
 	})
 	.meta({ id: "CreateTermBody" });
 
@@ -60,9 +65,25 @@ export const taxonomyDefSchema = z
 		labelSingular: z.string().optional(),
 		hierarchical: z.boolean(),
 		collections: z.array(z.string()),
+		locale: z.string(),
+		translationGroup: z.string().nullable(),
 	})
 	.meta({ id: "TaxonomyDef" });
 
+export const taxonomyDefTranslationsSchema = z
+	.object({
+		translationGroup: z.string().nullable(),
+		translations: z.array(
+			z.object({
+				id: z.string(),
+				name: z.string(),
+				label: z.string(),
+				locale: z.string(),
+			}),
+		),
+	})
+	.meta({ id: "TaxonomyDefTranslations" });
+
 export const taxonomyListResponseSchema = z
 	.object({ taxonomies: z.array(taxonomyDefSchema) })
 	.meta({ id: "TaxonomyListResponse" });
@@ -75,9 +96,25 @@ export const termSchema = z
 		label: z.string(),
 		parentId: z.string().nullable(),
 		description: z.string().optional(),
+		locale: z.string(),
+		translationGroup: z.string().nullable(),
 	})
 	.meta({ id: "Term" });
 
+export const termTranslationsSchema = z
+	.object({
+		translationGroup: z.string().nullable(),
+		translations: z.array(
+			z.object({
+				id: z.string(),
+				slug: z.string(),
+				label: z.string(),
+				locale: z.string(),
+			}),
+		),
+	})
+	.meta({ id: "TermTranslations" });
+
 export const termWithCountSchema: z.ZodType = z
 	.object({
 		id: z.string(),
@@ -88,6 +125,8 @@ export const termWithCountSchema: z.ZodType = z
 		description: z.string().optional(),
 		count: z.number().int(),
 		children: z.array(z.lazy(() => termWithCountSchema)),
+		locale: z.string(),
+		translationGroup: z.string().nullable(),
 	})
 	.meta({ id: "TermWithCount" });
 

package/src/astro/integration/routes.ts

@@ -313,6 +313,11 @@ export function injectCoreRoutes(injectRoute: InjectRoute): void {
 		entrypoint: resolveRoute("api/taxonomies/[name]/terms/[slug].ts"),
 	});
 
+	injectRoute({
+		pattern: "/_emdash/api/taxonomies/[name]/terms/[slug]/translations",
+		entrypoint: resolveRoute("api/taxonomies/[name]/terms/[slug]/translations.ts"),
+	});
+
 	injectRoute({
 		pattern: "/_emdash/api/content/[collection]/[id]/terms/[taxonomy]",
 		entrypoint: resolveRoute("api/content/[collection]/[id]/terms/[taxonomy].ts"),
@@ -555,6 +560,11 @@ export function injectCoreRoutes(injectRoute: InjectRoute): void {
 		entrypoint: resolveRoute("api/menus/[name]/reorder.ts"),
 	});
 
+	injectRoute({
+		pattern: "/_emdash/api/menus/[name]/translations",
+		entrypoint: resolveRoute("api/menus/[name]/translations.ts"),
+	});
+
 	// Widget area routes
 	injectRoute({
 		pattern: "/_emdash/api/widget-areas",

package/src/astro/routes/api/content/[collection]/[id]/permanent.ts

@@ -16,7 +16,7 @@ export const DELETE: APIRoute = async ({ params, locals, cache }) => {
 	const collection = params.collection!;
 	const id = params.id!;
 
-	const denied = requirePerm(user, "import:execute");
+	const denied = requirePerm(user, "content:delete_permanent");
 	if (denied) return denied;
 
 	if (!emdash?.handleContentPermanentDelete) {

package/src/astro/routes/api/import/wordpress/rewrite-url-helpers.ts

@@ -0,0 +1,196 @@
+const REGEX_SPECIAL_CHARS = /[.*+?^${}()|[\]\\]/g;
+const WORDPRESS_IMAGE_SIZE_SUFFIX = /-\d+x\d+(?=\.[^./?#]+$)/;
+const BASE_URL_EXTENSION = /^(.+)(\.[^./?#]+)$/;
+
+/**
+ * Strip query parameters from a URL for base matching
+ */
+export function getBaseUrl(url: string): string {
+	try {
+		const parsed = new URL(url);
+		return `${parsed.origin}${parsed.pathname}`;
+	} catch {
+		// If URL parsing fails, try simple string split
+		return url.split("?")[0] || url;
+	}
+}
+
+/**
+ * Build a map of base URLs to new URLs for flexible matching
+ */
+export function buildBaseUrlMap(urlMap: Record<string, string>): Map<string, string> {
+	const baseMap = new Map<string, string>();
+	for (const [oldUrl, newUrl] of Object.entries(urlMap)) {
+		const baseUrl = getBaseUrl(oldUrl);
+		baseMap.set(baseUrl, newUrl);
+	}
+	return baseMap;
+}
+
+/**
+ * Find matching new URL for a given URL, checking exact, base, and WordPress image-size matches
+ */
+export function findMatchingUrl(
+	url: string,
+	exactMap: Record<string, string>,
+	baseMap: Map<string, string>,
+): string | null {
+	if (exactMap[url]) {
+		return exactMap[url];
+	}
+
+	const baseUrl = getBaseUrl(url);
+	const baseMatch = baseMap.get(baseUrl);
+	if (baseMatch) {
+		return baseMatch;
+	}
+
+	const wordPressImageMatch = baseMap.get(stripWordPressImageSizeSuffix(baseUrl));
+	if (wordPressImageMatch) {
+		return wordPressImageMatch;
+	}
+
+	return null;
+}
+
+/**
+ * Portable Text block type (simplified for URL rewriting)
+ */
+export interface PortableTextBlock {
+	_type: string;
+	_key?: string;
+	asset?: {
+		_type?: string;
+		_ref?: string;
+		url?: string;
+	};
+	link?: string;
+	// For nested content like galleries
+	images?: PortableTextBlock[];
+	columns?: Array<{ content?: PortableTextBlock[] }>;
+	[key: string]: unknown;
+}
+
+/**
+ * Rewrite URLs in a Portable Text array, returning whether any changes were made
+ */
+export function rewritePortableTextUrls(
+	blocks: PortableTextBlock[],
+	exactMap: Record<string, string>,
+	baseMap: Map<string, string>,
+): { changed: boolean; urlsRewritten: number } {
+	let changed = false;
+	let urlsRewritten = 0;
+
+	for (const block of blocks) {
+		// Handle image blocks
+		if (block._type === "image" && block.asset?.url) {
+			const newUrl = findMatchingUrl(block.asset.url, exactMap, baseMap);
+			if (newUrl) {
+				block.asset.url = newUrl;
+				block.asset._ref = newUrl; // Also update the reference
+				changed = true;
+				urlsRewritten++;
+			}
+		}
+
+		// Handle image link URLs (for linked images)
+		if (block._type === "image" && block.link) {
+			const newUrl = findMatchingUrl(block.link, exactMap, baseMap);
+			if (newUrl) {
+				block.link = newUrl;
+				changed = true;
+				urlsRewritten++;
+			}
+		}
+
+		// Handle gallery blocks with nested images
+		if (block._type === "gallery" && Array.isArray(block.images)) {
+			const result = rewritePortableTextUrls(block.images, exactMap, baseMap);
+			if (result.changed) {
+				changed = true;
+				urlsRewritten += result.urlsRewritten;
+			}
+		}
+
+		// Handle columns blocks with nested content
+		if (block._type === "columns" && Array.isArray(block.columns)) {
+			for (const column of block.columns) {
+				if (Array.isArray(column.content)) {
+					const result = rewritePortableTextUrls(column.content, exactMap, baseMap);
+					if (result.changed) {
+						changed = true;
+						urlsRewritten += result.urlsRewritten;
+					}
+				}
+			}
+		}
+	}
+
+	return { changed, urlsRewritten };
+}
+
+/**
+ * Rewrite URLs in a string field using simple string replacement
+ */
+export function rewriteStringUrls(
+	value: string,
+	exactMap: Record<string, string>,
+	baseMap: Map<string, string>,
+): { newValue: string; changed: boolean; urlsRewritten: number } {
+	let newValue = value;
+	let changed = false;
+	let urlsRewritten = 0;
+
+	// Try exact matches first
+	for (const [oldUrl, newUrl] of Object.entries(exactMap)) {
+		if (newValue.includes(oldUrl)) {
+			newValue = newValue.split(oldUrl).join(newUrl);
+			changed = true;
+			urlsRewritten++;
+		}
+	}
+
+	// For base URL matching in strings, we need to be more careful
+	// Only match if we find a URL that starts with the base
+	for (const [baseUrl, newUrl] of baseMap.entries()) {
+		// Look for the base URL followed by optional query string or end
+		const regex = buildBaseUrlMatchRegex(baseUrl);
+		const matches = newValue.match(regex);
+		if (matches) {
+			for (const match of matches) {
+				// Don't replace if we already have an exact match in the map
+				if (!exactMap[match]) {
+					newValue = newValue.split(match).join(newUrl);
+					changed = true;
+					urlsRewritten++;
+				}
+			}
+		}
+	}
+
+	return { newValue, changed, urlsRewritten };
+}
+
+/**
+ * Escape special regex characters in a string
+ */
+function escapeRegExp(string: string): string {
+	return string.replace(REGEX_SPECIAL_CHARS, "\\$&");
+}
+
+function stripWordPressImageSizeSuffix(url: string): string {
+	return url.replace(WORDPRESS_IMAGE_SIZE_SUFFIX, "");
+}
+
+function buildBaseUrlMatchRegex(baseUrl: string): RegExp {
+	const extensionMatch = BASE_URL_EXTENSION.exec(baseUrl);
+	const basePattern = extensionMatch
+		? `${escapeRegExp(extensionMatch[1])}(?:-\\d+x\\d+)?${escapeRegExp(extensionMatch[2])}`
+		: escapeRegExp(baseUrl);
+
+	return new RegExp(
+		`${basePattern}(\\?[^"'\\s]*)?(?=$|["'\\s<>)\\],;:!?]|\\.(?=$|["'\\s<>)\\]]))`,
+		"g",
+	);
+}

package/src/astro/routes/api/import/wordpress/rewrite-urls.ts

@@ -22,9 +22,13 @@ import { normalizeMediaValue } from "#media/normalize.js";
 import type { MediaProvider } from "#media/types.js";
 import type { EmDashHandlers } from "#types";
 
-export const prerender = false;
-
-const REGEX_SPECIAL_CHARS = /[.*+?^${}()|[\]\\]/g;
+import {
+	buildBaseUrlMap,
+	findMatchingUrl,
+	rewritePortableTextUrls,
+	rewriteStringUrls,
+} from "./rewrite-url-helpers.js";
+import type { PortableTextBlock } from "./rewrite-url-helpers.js";
 
 export interface RewriteUrlsResult {
 	/** Total items updated */
@@ -37,6 +41,8 @@ export interface RewriteUrlsResult {
 	errors: Array<{ collection: string; id: string; error: string }>;
 }
 
+export const prerender = false;
+
 export const POST: APIRoute = async ({ request, locals }) => {
 	const { emdash, user } = locals;
 
@@ -70,180 +76,6 @@ export const POST: APIRoute = async ({ request, locals }) => {
 	}
 };
 
-/**
- * Strip query parameters from a URL for base matching
- */
-function getBaseUrl(url: string): string {
-	try {
-		const parsed = new URL(url);
-		return `${parsed.origin}${parsed.pathname}`;
-	} catch {
-		// If URL parsing fails, try simple string split
-		return url.split("?")[0] || url;
-	}
-}
-
-/**
- * Build a map of base URLs to new URLs for flexible matching
- */
-function buildBaseUrlMap(urlMap: Record<string, string>): Map<string, string> {
-	const baseMap = new Map<string, string>();
-	for (const [oldUrl, newUrl] of Object.entries(urlMap)) {
-		const baseUrl = getBaseUrl(oldUrl);
-		baseMap.set(baseUrl, newUrl);
-	}
-	return baseMap;
-}
-
-/**
- * Find matching new URL for a given URL, checking both exact and base matches
- */
-function findMatchingUrl(
-	url: string,
-	exactMap: Record<string, string>,
-	baseMap: Map<string, string>,
-): string | null {
-	// Try exact match first
-	if (exactMap[url]) {
-		return exactMap[url];
-	}
-
-	// Try base URL match (ignoring query params)
-	const baseUrl = getBaseUrl(url);
-	const baseMatch = baseMap.get(baseUrl);
-	if (baseMatch) {
-		return baseMatch;
-	}
-
-	return null;
-}
-
-/**
- * Portable Text block type (simplified for URL rewriting)
- */
-interface PortableTextBlock {
-	_type: string;
-	_key?: string;
-	asset?: {
-		_type?: string;
-		_ref?: string;
-		url?: string;
-	};
-	link?: string;
-	// For nested content like galleries
-	images?: PortableTextBlock[];
-	columns?: Array<{ content?: PortableTextBlock[] }>;
-	[key: string]: unknown;
-}
-
-/**
- * Rewrite URLs in a Portable Text array, returning whether any changes were made
- */
-function rewritePortableTextUrls(
-	blocks: PortableTextBlock[],
-	exactMap: Record<string, string>,
-	baseMap: Map<string, string>,
-): { changed: boolean; urlsRewritten: number } {
-	let changed = false;
-	let urlsRewritten = 0;
-
-	for (const block of blocks) {
-		// Handle image blocks
-		if (block._type === "image" && block.asset?.url) {
-			const newUrl = findMatchingUrl(block.asset.url, exactMap, baseMap);
-			if (newUrl) {
-				block.asset.url = newUrl;
-				block.asset._ref = newUrl; // Also update the reference
-				changed = true;
-				urlsRewritten++;
-			}
-		}
-
-		// Handle image link URLs (for linked images)
-		if (block._type === "image" && block.link) {
-			const newUrl = findMatchingUrl(block.link, exactMap, baseMap);
-			if (newUrl) {
-				block.link = newUrl;
-				changed = true;
-				urlsRewritten++;
-			}
-		}
-
-		// Handle gallery blocks with nested images
-		if (block._type === "gallery" && Array.isArray(block.images)) {
-			const result = rewritePortableTextUrls(block.images, exactMap, baseMap);
-			if (result.changed) {
-				changed = true;
-				urlsRewritten += result.urlsRewritten;
-			}
-		}
-
-		// Handle columns blocks with nested content
-		if (block._type === "columns" && Array.isArray(block.columns)) {
-			for (const column of block.columns) {
-				if (Array.isArray(column.content)) {
-					const result = rewritePortableTextUrls(column.content, exactMap, baseMap);
-					if (result.changed) {
-						changed = true;
-						urlsRewritten += result.urlsRewritten;
-					}
-				}
-			}
-		}
-	}
-
-	return { changed, urlsRewritten };
-}
-
-/**
- * Rewrite URLs in a string field using simple string replacement
- */
-function rewriteStringUrls(
-	value: string,
-	exactMap: Record<string, string>,
-	baseMap: Map<string, string>,
-): { newValue: string; changed: boolean; urlsRewritten: number } {
-	let newValue = value;
-	let changed = false;
-	let urlsRewritten = 0;
-
-	// Try exact matches first
-	for (const [oldUrl, newUrl] of Object.entries(exactMap)) {
-		if (newValue.includes(oldUrl)) {
-			newValue = newValue.split(oldUrl).join(newUrl);
-			changed = true;
-			urlsRewritten++;
-		}
-	}
-
-	// For base URL matching in strings, we need to be more careful
-	// Only match if we find a URL that starts with the base
-	for (const [baseUrl, newUrl] of baseMap.entries()) {
-		// Look for the base URL followed by optional query string or end
-		const regex = new RegExp(escapeRegExp(baseUrl) + "(\\?[^\"'\\s]*)?", "g");
-		const matches = newValue.match(regex);
-		if (matches) {
-			for (const match of matches) {
-				// Don't replace if we already have an exact match in the map
-				if (!exactMap[match]) {
-					newValue = newValue.split(match).join(newUrl);
-					changed = true;
-					urlsRewritten++;
-				}
-			}
-		}
-	}
-
-	return { newValue, changed, urlsRewritten };
-}
-
-/**
- * Escape special regex characters in a string
- */
-function escapeRegExp(string: string): string {
-	return string.replace(REGEX_SPECIAL_CHARS, "\\$&");
-}
-
 async function rewriteUrls(
 	db: NonNullable<EmDashHandlers["db"]>,
 	urlMap: Record<string, string>,

package/src/astro/routes/api/menus/[name]/items.ts

@@ -1,9 +1,9 @@
 /**
  * Menu items CRUD endpoints
  *
- * POST   /_emdash/api/menus/:name/items - Add item
- * PUT    /_emdash/api/menus/:name/items/:id - Update item
- * DELETE /_emdash/api/menus/:name/items/:id - Delete item
+ * POST   /_emdash/api/menus/:name/items[?locale=xx]
+ * PUT    /_emdash/api/menus/:name/items?id=...[&locale=xx]
+ * DELETE /_emdash/api/menus/:name/items?id=...[&locale=xx]
  */
 
 import type { APIRoute } from "astro";
@@ -18,6 +18,7 @@ import {
 import { isParseError, parseBody, parseQuery } from "#api/parse.js";
 import {
 	createMenuItemBody,
+	localeFilterQuery,
 	menuItemDeleteQuery,
 	menuItemUpdateQuery,
 	updateMenuItemBody,
@@ -32,11 +33,14 @@ export const POST: APIRoute = async ({ params, request, locals }) => {
 	const denied = requirePerm(user, "menus:manage");
 	if (denied) return denied;
 
+	const localeQ = parseQuery(new URL(request.url), localeFilterQuery);
+	if (isParseError(localeQ)) return localeQ;
+
 	try {
 		const body = await parseBody(request, createMenuItemBody);
 		if (isParseError(body)) return body;
 
-		const result = await handleMenuItemCreate(emdash.db, name, body);
+		const result = await handleMenuItemCreate(emdash.db, name, body, { locale: localeQ.locale });
 		return unwrapResult(result, 201);
 	} catch (error) {
 		return handleError(error, "Failed to create menu item", "MENU_ITEM_CREATE_ERROR");
@@ -53,13 +57,17 @@ export const PUT: APIRoute = async ({ params, request, locals }) => {
 	const url = new URL(request.url);
 	const query = parseQuery(url, menuItemUpdateQuery);
 	if (isParseError(query)) return query;
+	const localeQ = parseQuery(url, localeFilterQuery);
+	if (isParseError(localeQ)) return localeQ;
 	const itemId = query.id;
 
 	try {
 		const body = await parseBody(request, updateMenuItemBody);
 		if (isParseError(body)) return body;
 
-		const result = await handleMenuItemUpdate(emdash.db, name, itemId, body);
+		const result = await handleMenuItemUpdate(emdash.db, name, itemId, body, {
+			locale: localeQ.locale,
+		});
 		return unwrapResult(result);
 	} catch (error) {
 		return handleError(error, "Failed to update menu item", "MENU_ITEM_UPDATE_ERROR");
@@ -76,10 +84,12 @@ export const DELETE: APIRoute = async ({ params, request, locals }) => {
 	const url = new URL(request.url);
 	const query = parseQuery(url, menuItemDeleteQuery);
 	if (isParseError(query)) return query;
+	const localeQ = parseQuery(url, localeFilterQuery);
+	if (isParseError(localeQ)) return localeQ;
 	const itemId = query.id;
 
 	try {
-		const result = await handleMenuItemDelete(emdash.db, name, itemId);
+		const result = await handleMenuItemDelete(emdash.db, name, itemId, { locale: localeQ.locale });
 		return unwrapResult(result);
 	} catch (error) {
 		return handleError(error, "Failed to delete menu item", "MENU_ITEM_DELETE_ERROR");

package/src/astro/routes/api/menus/[name]/reorder.ts

@@ -9,8 +9,8 @@ import type { APIRoute } from "astro";
 import { requirePerm } from "#api/authorize.js";
 import { handleError, unwrapResult } from "#api/error.js";
 import { handleMenuItemReorder } from "#api/handlers/menus.js";
-import { isParseError, parseBody } from "#api/parse.js";
-import { reorderMenuItemsBody } from "#api/schemas.js";
+import { isParseError, parseBody, parseQuery } from "#api/parse.js";
+import { localeFilterQuery, reorderMenuItemsBody } from "#api/schemas.js";
 
 export const prerender = false;
 
@@ -21,11 +21,16 @@ export const POST: APIRoute = async ({ params, request, locals }) => {
 	const denied = requirePerm(user, "menus:manage");
 	if (denied) return denied;
 
+	const localeQ = parseQuery(new URL(request.url), localeFilterQuery);
+	if (isParseError(localeQ)) return localeQ;
+
 	try {
 		const body = await parseBody(request, reorderMenuItemsBody);
 		if (isParseError(body)) return body;
 
-		const result = await handleMenuItemReorder(emdash.db, name, body.items);
+		const result = await handleMenuItemReorder(emdash.db, name, body.items, {
+			locale: localeQ.locale,
+		});
 		return unwrapResult(result);
 	} catch (error) {
 		return handleError(error, "Failed to reorder menu items", "MENU_REORDER_ERROR");