emdash 0.9.0 → 0.11.0

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/media/upload-url.ts

@@ -15,8 +15,10 @@ import { ulid } from "ulidx";
 
 import { requirePerm } from "#api/authorize.js";
 import { apiError, apiSuccess, handleError } from "#api/error.js";
+import { GLOBAL_UPLOAD_ALLOWLIST, resolveFieldAllowlist } from "#api/handlers/media-allowlist.js";
 import { isParseError, parseBody } from "#api/parse.js";
 import { DEFAULT_MAX_UPLOAD_SIZE, mediaUploadUrlBody } from "#api/schemas.js";
+import { matchesMimeAllowlist, normalizeMime } from "#media/mime.js";
 
 export const prerender = false;
 
@@ -70,9 +72,13 @@ export const POST: APIRoute = async ({ request, locals }) => {
 		const body = await parseBody(request, mediaUploadUrlBody(maxSize));
 		if (isParseError(body)) return body;
 
-		// Validate content type
-		const allowedTypes = ["image/", "video/", "audio/", "application/pdf"];
-		if (!allowedTypes.some((type) => body.contentType.startsWith(type))) {
+		// Validate content type (field-aware widening)
+		const fieldAllowlist = body.fieldId
+			? await resolveFieldAllowlist(emdash.db, body.fieldId)
+			: null;
+		const allowlist = fieldAllowlist ?? [...GLOBAL_UPLOAD_ALLOWLIST];
+
+		if (!matchesMimeAllowlist(body.contentType, allowlist)) {
 			return apiError("INVALID_TYPE", "File type not allowed", 400);
 		}
 
@@ -100,7 +106,7 @@ export const POST: APIRoute = async ({ request, locals }) => {
 		// Create pending media record with content hash
 		const mediaItem = await repo.createPending({
 			filename: body.filename,
-			mimeType: body.contentType,
+			mimeType: normalizeMime(body.contentType),
 			size: body.size,
 			storageKey,
 			contentHash: body.contentHash,

package/src/astro/routes/api/media.ts

@@ -12,9 +12,11 @@ import { ulid } from "ulidx";
 
 import { requirePerm } from "#api/authorize.js";
 import { apiError, apiSuccess, handleError, unwrapResult } from "#api/error.js";
+import { GLOBAL_UPLOAD_ALLOWLIST, resolveFieldAllowlist } from "#api/handlers/media-allowlist.js";
 import { isParseError, parseQuery } from "#api/parse.js";
 import { DEFAULT_MAX_UPLOAD_SIZE, formatFileSize, mediaListQuery } from "#api/schemas.js";
 import { MediaRepository } from "#db/repositories/media.js";
+import { matchesMimeAllowlist, normalizeMime } from "#media/mime.js";
 import { generatePlaceholder } from "#media/placeholder.js";
 import { computeContentHash } from "#utils/hash.js";
 
@@ -106,9 +108,15 @@ export const POST: APIRoute = async ({ request, locals }) => {
 			return apiError("NO_FILE", "No file provided", 400);
 		}
 
-		// Validate file type
-		const allowedTypes = ["image/", "video/", "audio/", "application/pdf"];
-		if (!allowedTypes.some((type) => file.type.startsWith(type))) {
+		// Validate file type — widen the allowlist when a field-specific list is configured
+		const fieldIdEntry = formData.get("fieldId");
+		const fieldId =
+			typeof fieldIdEntry === "string" && fieldIdEntry.length > 0 ? fieldIdEntry : null;
+
+		const fieldAllowlist = fieldId ? await resolveFieldAllowlist(emdash.db, fieldId) : null;
+		const allowlist = fieldAllowlist ?? [...GLOBAL_UPLOAD_ALLOWLIST];
+
+		if (!matchesMimeAllowlist(file.type, allowlist)) {
 			return apiError("INVALID_TYPE", "File type not allowed", 400);
 		}
 
@@ -174,7 +182,7 @@ export const POST: APIRoute = async ({ request, locals }) => {
 		// Create media record
 		const result = await emdash.handleMediaCreate({
 			filename: file.name,
-			mimeType: file.type,
+			mimeType: normalizeMime(file.type),
 			size: file.size,
 			width,
 			height,

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");

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

@@ -0,0 +1,82 @@
+/**
+ * Menu translation endpoints
+ *
+ * GET  /_emdash/api/menus/:name/translations       — list translations for a menu (uses any locale row)
+ * POST /_emdash/api/menus/:name/translations       — create a new locale translation (body: { locale, label })
+ */
+
+import type { APIRoute } from "astro";
+import { z } from "zod";
+
+import { requirePerm } from "#api/authorize.js";
+import { handleError, requireDb, unwrapResult } from "#api/error.js";
+import { handleMenuCreate, handleMenuGet, handleMenuTranslations } from "#api/handlers/menus.js";
+import { isParseError, parseBody, parseQuery } from "#api/parse.js";
+import { localeFilterQuery } from "#api/schemas.js";
+
+export const prerender = false;
+
+const createTranslationBody = z
+	.object({
+		locale: z.string().min(1),
+		label: z.string().min(1).optional(),
+	})
+	.meta({ id: "CreateMenuTranslationBody" });
+
+export const GET: APIRoute = async ({ params, request, locals }) => {
+	const { emdash, user } = locals;
+	const name = params.name!;
+
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
+
+	const denied = requirePerm(user, "menus:read");
+	if (denied) return denied;
+
+	const localeQ = parseQuery(new URL(request.url), localeFilterQuery);
+	if (isParseError(localeQ)) return localeQ;
+
+	try {
+		// Look up any menu row matching the name so we can get its translation_group.
+		const anchor = await handleMenuGet(emdash.db, name, { locale: localeQ.locale });
+		if (!anchor.success) return unwrapResult(anchor);
+		const result = await handleMenuTranslations(emdash.db, anchor.data.id);
+		return unwrapResult(result);
+	} catch (error) {
+		return handleError(error, "Failed to fetch menu translations", "MENU_TRANSLATIONS_ERROR");
+	}
+};
+
+export const POST: APIRoute = async ({ params, request, locals }) => {
+	const { emdash, user } = locals;
+	const name = params.name!;
+
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
+
+	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, createTranslationBody);
+		if (isParseError(body)) return body;
+
+		// Resolve the source menu (either by explicit locale in query, or the
+		// first matching row). Its id becomes the `translationOf` for the new row.
+		const source = await handleMenuGet(emdash.db, name, { locale: localeQ.locale });
+		if (!source.success) return unwrapResult(source);
+
+		const result = await handleMenuCreate(emdash.db, {
+			name,
+			label: body.label ?? source.data.label,
+			locale: body.locale,
+			translationOf: source.data.id,
+		});
+		return unwrapResult(result, 201);
+	} catch (error) {
+		return handleError(error, "Failed to create menu translation", "MENU_TRANSLATION_CREATE_ERROR");
+	}
+};