emdash 0.9.0 → 0.11.0

package/src/fields/types.ts

@@ -1,5 +1,7 @@
 import type { z } from "astro/zod";
 
+import type { FieldValidation } from "../schema/types.js";
+
 /**
  * SQLite column types that map from field types
  */
@@ -19,6 +21,7 @@ export interface FieldDefinition<_T = unknown> {
 	schema: z.ZodTypeAny;
 	options?: unknown;
 	ui?: FieldUIHints;
+	validation?: FieldValidation;
 }
 
 /**

package/src/i18n/resolve.ts

@@ -0,0 +1,37 @@
+/**
+ * Shared locale-resolution helpers.
+ *
+ * Matches the pattern used by `query.ts` for content: an explicit locale wins,
+ * otherwise we fall back to the request-context locale, otherwise to
+ * `defaultLocale` when i18n is enabled, otherwise to `undefined` (meaning "do
+ * not filter by locale" — legacy single-locale behaviour).
+ */
+
+import { getRequestContext } from "../request-context.js";
+import { getFallbackChain, getI18nConfig, isI18nEnabled } from "./config.js";
+
+/**
+ * Resolve the locale to use for a query given an optional explicit value.
+ * Returns `undefined` when no locale information is available; callers should
+ * treat that as "do not filter by locale".
+ */
+export function resolveLocale(explicit?: string): string | undefined {
+	if (explicit !== undefined) return explicit;
+	const ctxLocale = getRequestContext()?.locale;
+	if (ctxLocale !== undefined) return ctxLocale;
+	const cfg = getI18nConfig();
+	if (cfg && isI18nEnabled()) return cfg.defaultLocale;
+	return undefined;
+}
+
+/**
+ * Fallback chain to try when looking up a single item. When i18n is disabled
+ * or the locale is unspecified, returns a single-element array (or empty when
+ * no locale resolves) so callers can iterate uniformly.
+ */
+export function resolveLocaleChain(explicit?: string): string[] {
+	const locale = resolveLocale(explicit);
+	if (locale === undefined) return [];
+	if (!isI18nEnabled()) return [locale];
+	return getFallbackChain(locale);
+}

package/src/index.ts

@@ -27,7 +27,7 @@ export type {
 export type { MediaItem, CreateMediaInput } from "./database/repositories/media.js";
 
 // Fields
-export { portableText, image, reference } from "./fields/index.js";
+export { portableText, image, file, reference } from "./fields/index.js";
 export { normalizeMediaValue } from "./media/normalize.js";
 export { generatePlaceholder } from "./media/placeholder.js";
 export type { PlaceholderData } from "./media/placeholder.js";

package/src/loader.ts

@@ -125,12 +125,59 @@ const DATE_COLUMNS = new Set(["created_at", "updated_at", "published_at", "sched
  */
 export const CURSOR_RAW_VALUES: unique symbol = Symbol("emdash:cursorRawValues");
 
+const LOCAL_MEDIA_FILE_PREFIX = "/_emdash/api/media/file/";
+const URL_SCHEME_PATTERN = /^[a-zA-Z][a-zA-Z\d+\-.]*:/;
+
 /** Safely extract a string value from a record, returning fallback if not a string */
 function rowStr(row: Record<string, unknown>, key: string, fallback = ""): string {
 	const val = row[key];
 	return typeof val === "string" ? val : fallback;
 }
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isBareMediaKey(src: string): boolean {
+	return !src.startsWith("/") && !URL_SCHEME_PATTERN.test(src);
+}
+
+function normalizeLocalMediaValue(value: unknown): unknown {
+	if (Array.isArray(value)) {
+		return value.map(normalizeLocalMediaValue);
+	}
+
+	if (!isRecord(value)) {
+		return value;
+	}
+
+	const normalized: Record<string, unknown> = {};
+	for (const [key, child] of Object.entries(value)) {
+		normalized[key] = normalizeLocalMediaValue(child);
+	}
+
+	if (
+		normalized.provider === "local" &&
+		typeof normalized.src === "string" &&
+		normalized.src.length > 0
+	) {
+		const src = normalized.src;
+		if (src.startsWith(LOCAL_MEDIA_FILE_PREFIX)) {
+			const id = src.slice(LOCAL_MEDIA_FILE_PREFIX.length);
+			if (!normalized.id && id) {
+				normalized.id = id;
+			}
+		} else if (isBareMediaKey(src)) {
+			if (!normalized.id) {
+				normalized.id = src;
+			}
+			normalized.src = `${LOCAL_MEDIA_FILE_PREFIX}${src}`;
+		}
+	}
+
+	return normalized;
+}
+
 /**
  * Map a database row to entry data
  * Extracts content fields (non-system columns) and parses JSON where needed.
@@ -164,7 +211,7 @@ function mapRowToData(row: Record<string, unknown>): Record<string, unknown> {
 			try {
 				// Only parse if it looks like JSON (starts with { or [)
 				if (value.startsWith("{") || value.startsWith("[")) {
-					data[key] = JSON.parse(value);
+					data[key] = normalizeLocalMediaValue(JSON.parse(value));
 				} else {
 					data[key] = value;
 				}
@@ -194,7 +241,7 @@ function mapRevisionData(data: Record<string, unknown>): Record<string, unknown>
 	const result: Record<string, unknown> = {};
 	for (const [key, value] of Object.entries(data)) {
 		if (key.startsWith("_")) continue; // revision metadata
-		result[key] = value;
+		result[key] = normalizeLocalMediaValue(value);
 	}
 	return result;
 }

package/src/mcp/server.ts

@@ -1667,16 +1667,19 @@ export function createMcpServer(): McpServer {
 			description:
 				"List all taxonomy definitions (e.g. categories, tags). Taxonomies are " +
 				"classification systems applied to content. Each has a name, label, and " +
-				"can be hierarchical (categories) or flat (tags).",
-			inputSchema: z.object({}),
+				"can be hierarchical (categories) or flat (tags). Optionally filter by " +
+				"locale.",
+			inputSchema: z.object({
+				locale: z.string().optional().describe("Filter by locale (omit for all)"),
+			}),
 			annotations: { readOnlyHint: true },
 		},
-		async (_args, extra) => {
+		async (args, extra) => {
 			requireScope(extra, "content:read");
 			const ec = getEmDash(extra);
 			try {
 				const { handleTaxonomyList } = await import("../api/handlers/taxonomies.js");
-				return unwrap(await handleTaxonomyList(ec.db));
+				return unwrap(await handleTaxonomyList(ec.db, { locale: args.locale }));
 			} catch (error) {
 				return respondHandlerError(error, "TAXONOMY_LIST_ERROR");
 			}
@@ -1695,6 +1698,7 @@ export function createMcpServer(): McpServer {
 				taxonomy: z.string().describe("Taxonomy name (e.g. 'categories', 'tags')"),
 				limit: z.number().int().min(1).max(100).optional().describe("Max items (default 50)"),
 				cursor: z.string().min(1).max(2048).optional().describe("Pagination cursor"),
+				locale: z.string().optional().describe("Filter by locale (omit for all)"),
 			}),
 			annotations: { readOnlyHint: true },
 		},
@@ -1702,9 +1706,8 @@ export function createMcpServer(): McpServer {
 			requireScope(extra, "content:read");
 			const ec = getEmDash(extra);
 			try {
-				// Verify taxonomy exists via handler layer
 				const { handleTaxonomyList } = await import("../api/handlers/taxonomies.js");
-				const listResult = await handleTaxonomyList(ec.db);
+				const listResult = await handleTaxonomyList(ec.db, { locale: args.locale });
 				if (!listResult.success) return unwrap(listResult);
 
 				const taxonomies = (listResult.data as { taxonomies: Array<{ name: string; id?: string }> })
@@ -1712,13 +1715,12 @@ export function createMcpServer(): McpServer {
 				const taxonomy = taxonomies.find((t: { name: string }) => t.name === args.taxonomy);
 				if (!taxonomy) return respondError("NOT_FOUND", `Taxonomy '${args.taxonomy}' not found`);
 
-				// Paginated term query via repository (avoids N+1 of handleTermList)
 				const { TaxonomyRepository } = await import("../database/repositories/taxonomy.js");
 				const { decodeCursor, encodeCursor, InvalidCursorError } =
 					await import("../database/repositories/types.js");
 				const repo = new TaxonomyRepository(ec.db);
 				const limit = Math.min(args.limit ?? 50, 100);
-				const terms = await repo.findByName(args.taxonomy);
+				const terms = await repo.findByName(args.taxonomy, { locale: args.locale });
 
 				// Manual keyset pagination over the sorted-by-label results.
 				// Using a base64-encoded `(label, id)` cursor matches the
@@ -1760,6 +1762,8 @@ export function createMcpServer(): McpServer {
 						label: t.label,
 						parentId: t.parentId,
 						description: typeof t.data?.description === "string" ? t.data.description : undefined,
+						locale: t.locale,
+						translationGroup: t.translationGroup,
 					})),
 					nextCursor,
 				});
@@ -1785,6 +1789,11 @@ export function createMcpServer(): McpServer {
 				label: z.string().describe("Display name"),
 				parentId: z.string().optional().describe("Parent term ID for hierarchical taxonomies"),
 				description: z.string().optional().describe("Description of the term"),
+				locale: z.string().optional().describe("Locale for the new term (e.g. 'es')"),
+				translationOf: z
+					.string()
+					.optional()
+					.describe("Term id to join as a translation (same translation_group)"),
 			}),
 		},
 		async (args, extra) => {
@@ -1799,6 +1808,8 @@ export function createMcpServer(): McpServer {
 						label: args.label,
 						parentId: args.parentId,
 						description: args.description,
+						locale: args.locale,
+						translationOf: args.translationOf,
 					}),
 				);
 			} catch (error) {
@@ -1875,6 +1886,29 @@ export function createMcpServer(): McpServer {
 		},
 	);
 
+	server.registerTool(
+		"taxonomy_term_translations",
+		{
+			title: "List Term Translations",
+			description:
+				"Return every locale variant of a taxonomy term, identified via its shared translation_group.",
+			inputSchema: z.object({
+				id: z.string().describe("Term id (or translation_group)"),
+			}),
+			annotations: { readOnlyHint: true },
+		},
+		async (args, extra) => {
+			requireScope(extra, "content:read");
+			const ec = getEmDash(extra);
+			try {
+				const { handleTermTranslations } = await import("../api/handlers/taxonomies.js");
+				return unwrap(await handleTermTranslations(ec.db, args.id));
+			} catch (error) {
+				return respondHandlerError(error, "TERM_TRANSLATIONS_ERROR");
+			}
+		},
+	);
+
 	// =====================================================================
 	// Menu tools
 	// =====================================================================
@@ -1884,18 +1918,20 @@ export function createMcpServer(): McpServer {
 		{
 			title: "List Menus",
 			description:
-				"List all navigation menus defined in the CMS. Menus are named " +
-				"navigation structures (e.g. 'main', 'footer') containing ordered " +
-				"items with labels, URLs, and optional nesting.",
-			inputSchema: z.object({}),
+				"List navigation menus. Menus are per-locale: filter by `locale` to " +
+				"get just one locale's worth, or omit to list every row (one per " +
+				"locale per menu name).",
+			inputSchema: z.object({
+				locale: z.string().optional().describe("Filter by locale (omit for all)"),
+			}),
 			annotations: { readOnlyHint: true },
 		},
-		async (_args, extra) => {
+		async (args, extra) => {
 			requireScope(extra, "content:read");
 			const ec = getEmDash(extra);
 			try {
 				const { handleMenuList } = await import("../api/handlers/menus.js");
-				return unwrap(await handleMenuList(ec.db));
+				return unwrap(await handleMenuList(ec.db, { locale: args.locale }));
 			} catch (error) {
 				return respondHandlerError(error, "MENU_LIST_ERROR");
 			}
@@ -1907,11 +1943,11 @@ export function createMcpServer(): McpServer {
 		{
 			title: "Get Menu with Items",
 			description:
-				"Get a menu by name including all its items in order. Items have a " +
-				"label, URL, type (custom/content/collection), and optional parent " +
-				"for nesting.",
+				"Get a menu by name, including its items. When multiple locales exist, " +
+				"pass `locale` to pick the right one.",
 			inputSchema: z.object({
 				name: z.string().describe("Menu name (e.g. 'main', 'footer')"),
+				locale: z.string().optional().describe("Locale to resolve the menu for"),
 			}),
 			annotations: { readOnlyHint: true },
 		},
@@ -1920,13 +1956,36 @@ export function createMcpServer(): McpServer {
 			const ec = getEmDash(extra);
 			try {
 				const { handleMenuGet } = await import("../api/handlers/menus.js");
-				return unwrap(await handleMenuGet(ec.db, args.name));
+				return unwrap(await handleMenuGet(ec.db, args.name, { locale: args.locale }));
 			} catch (error) {
 				return respondHandlerError(error, "MENU_GET_ERROR");
 			}
 		},
 	);
 
+	server.registerTool(
+		"menu_translations",
+		{
+			title: "List Menu Translations",
+			description:
+				"Return every locale variant of a menu, identified via the shared translation_group.",
+			inputSchema: z.object({
+				id: z.string().describe("Menu id (or translation_group)"),
+			}),
+			annotations: { readOnlyHint: true },
+		},
+		async (args, extra) => {
+			requireScope(extra, "content:read");
+			const ec = getEmDash(extra);
+			try {
+				const { handleMenuTranslations } = await import("../api/handlers/menus.js");
+				return unwrap(await handleMenuTranslations(ec.db, args.id));
+			} catch (error) {
+				return respondHandlerError(error, "MENU_TRANSLATIONS_ERROR");
+			}
+		},
+	);
+
 	server.registerTool(
 		"menu_create",
 		{
@@ -1934,13 +1993,23 @@ export function createMcpServer(): McpServer {
 			description:
 				"Create a new navigation menu. The `name` is the stable identifier used " +
 				"by site templates (e.g. 'main', 'footer'); `label` is the human-readable " +
-				"name shown in the admin. Add items afterwards with menu_set_items.",
+				"name shown in the admin. Menus are per-locale, so pass `locale` when " +
+				"the same menu name exists in multiple translations. Add items afterwards " +
+				"with menu_set_items. If `translationOf` is set, `locale` must also be set.",
+			// `locale`-when-`translationOf` is enforced inside handleMenuCreate
+			// so REST/SDK callers get the same guard. The description above
+			// documents the rule; the handler returns VALIDATION_ERROR.
 			inputSchema: z.object({
 				name: z
 					.string()
 					.regex(COLLECTION_SLUG_PATTERN)
 					.describe("Stable identifier (lowercase letters, numbers, underscores)"),
 				label: z.string().describe("Display name for the admin"),
+				locale: z.string().optional().describe("Locale for this menu (e.g. 'fr-fr')"),
+				translationOf: z
+					.string()
+					.optional()
+					.describe("Existing menu id to create this locale variant from"),
 			}),
 		},
 		async (args, extra) => {
@@ -1949,7 +2018,14 @@ export function createMcpServer(): McpServer {
 			const ec = getEmDash(extra);
 			try {
 				const { handleMenuCreate } = await import("../api/handlers/menus.js");
-				return unwrap(await handleMenuCreate(ec.db, { name: args.name, label: args.label }));
+				return unwrap(
+					await handleMenuCreate(ec.db, {
+						name: args.name,
+						label: args.label,
+						locale: args.locale,
+						translationOf: args.translationOf,
+					}),
+				);
 			} catch (error) {
 				return respondHandlerError(error, "MENU_CREATE_ERROR");
 			}
@@ -1960,10 +2036,13 @@ export function createMcpServer(): McpServer {
 		"menu_update",
 		{
 			title: "Update Menu",
-			description: "Update a menu's label. The `name` (stable identifier) cannot be changed.",
+			description:
+				"Update a menu's label. The `name` (stable identifier) cannot be changed. " +
+				"On multi-locale installs, pass `locale` so the correct translation is updated.",
 			inputSchema: z.object({
 				name: z.string().describe("Menu name to update"),
 				label: z.string().describe("New display label"),
+				locale: z.string().optional().describe("Locale of the menu to update"),
 			}),
 		},
 		async (args, extra) => {
@@ -1972,7 +2051,9 @@ export function createMcpServer(): McpServer {
 			const ec = getEmDash(extra);
 			try {
 				const { handleMenuUpdate } = await import("../api/handlers/menus.js");
-				return unwrap(await handleMenuUpdate(ec.db, args.name, { label: args.label }));
+				return unwrap(
+					await handleMenuUpdate(ec.db, args.name, { label: args.label, locale: args.locale }),
+				);
 			} catch (error) {
 				return respondHandlerError(error, "MENU_UPDATE_ERROR");
 			}
@@ -1983,9 +2064,12 @@ export function createMcpServer(): McpServer {
 		"menu_delete",
 		{
 			title: "Delete Menu",
-			description: "Delete a menu. Items are also removed. Cannot be undone.",
+			description:
+				"Delete a menu. Items are also removed. Cannot be undone. On multi-locale " +
+				"installs, pass `locale` so only the intended translation is removed.",
 			inputSchema: z.object({
 				name: z.string().describe("Menu name to delete"),
+				locale: z.string().optional().describe("Locale of the menu to delete"),
 			}),
 			annotations: { destructiveHint: true },
 		},
@@ -1995,7 +2079,7 @@ export function createMcpServer(): McpServer {
 			const ec = getEmDash(extra);
 			try {
 				const { handleMenuDelete } = await import("../api/handlers/menus.js");
-				return unwrap(await handleMenuDelete(ec.db, args.name));
+				return unwrap(await handleMenuDelete(ec.db, args.name, { locale: args.locale }));
 			} catch (error) {
 				return respondHandlerError(error, "MENU_DELETE_ERROR");
 			}
@@ -2010,9 +2094,11 @@ export function createMcpServer(): McpServer {
 				"Replace the entire item list of a menu in one call. This is atomic: the " +
 				"existing items are deleted and the new list is inserted in the order " +
 				"provided. Use this rather than per-item add/remove tools so the resulting " +
-				"order and parent links are unambiguous.",
+				"order and parent links are unambiguous. On multi-locale installs, pass " +
+				"`locale` so only the intended translation is rewritten.",
 			inputSchema: z.object({
 				name: z.string().describe("Menu name to update"),
+				locale: z.string().optional().describe("Locale of the menu to rewrite"),
 				items: z
 					.array(
 						z.object({
@@ -2056,7 +2142,9 @@ export function createMcpServer(): McpServer {
 			const ec = getEmDash(extra);
 			try {
 				const { handleMenuSetItems } = await import("../api/handlers/menus.js");
-				return unwrap(await handleMenuSetItems(ec.db, args.name, args.items));
+				return unwrap(
+					await handleMenuSetItems(ec.db, args.name, args.items, { locale: args.locale }),
+				);
 			} catch (error) {
 				return respondHandlerError(error, "MENU_SET_ITEMS_ERROR");
 			}

package/src/media/mime.ts

@@ -0,0 +1,75 @@
+export function normalizeMime(mime: string): string {
+	return mime.split(";")[0]!.trim().toLowerCase();
+}
+
+export function matchesMimeAllowlist(mime: string, allowList: readonly string[]): boolean {
+	const normalized = normalizeMime(mime);
+	for (const entry of allowList) {
+		if (!entry || !entry.includes("/")) continue;
+		const normalizedEntry = normalizeMime(entry);
+		if (normalizedEntry.endsWith("/")) {
+			if (normalized.startsWith(normalizedEntry)) return true;
+		} else if (normalized === normalizedEntry) {
+			return true;
+		}
+	}
+	return false;
+}
+
+export const EXTENSION_TO_MIME: Readonly<Record<string, string>> = {
+	".pdf": "application/pdf",
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".gif": "image/gif",
+	".webp": "image/webp",
+	".svg": "image/svg+xml",
+	".mp3": "audio/mpeg",
+	".wav": "audio/wav",
+	".mp4": "video/mp4",
+	".webm": "video/webm",
+	".zip": "application/zip",
+	".tar": "application/x-tar",
+	".gz": "application/gzip",
+	".csv": "text/csv",
+	".doc": "application/msword",
+	".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+	".xls": "application/vnd.ms-excel",
+	".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+	".txt": "text/plain",
+	".rtf": "application/rtf",
+	".vtt": "text/vtt",
+	".srt": "application/x-subrip",
+	".woff": "font/woff",
+	".woff2": "font/woff2",
+};
+
+const VALID_MIME_RE = /^[a-z0-9][a-z0-9!#$&^_+\-.]*\/[a-z0-9!#$&^_+\-.]*$/i;
+
+export function expandExtensionShorthand(entry: string): string | null {
+	const trimmed = entry.trim();
+	if (!trimmed) return null;
+	if (trimmed.includes("/")) return VALID_MIME_RE.test(trimmed) ? trimmed : null;
+	if (trimmed.startsWith(".")) {
+		return EXTENSION_TO_MIME[trimmed.toLowerCase()] ?? null;
+	}
+	return null;
+}
+
+/**
+ * Extract the `allowedMimeTypes` list from a `_emdash_fields.validation` row
+ * (raw JSON string). Returns null when the value is missing, malformed, or the
+ * list is empty — callers treat that as "no field-specific constraint".
+ */
+export function parseAllowedMimeTypes(rawValidation: string | null | undefined): string[] | null {
+	if (!rawValidation) return null;
+	try {
+		const parsed: unknown = JSON.parse(rawValidation);
+		if (typeof parsed !== "object" || parsed === null) return null;
+		const list = (parsed as { allowedMimeTypes?: unknown }).allowedMimeTypes;
+		if (!Array.isArray(list) || list.length === 0) return null;
+		return list.filter((entry): entry is string => typeof entry === "string");
+	} catch {
+		return null;
+	}
+}