emdash 0.8.0 → 0.10.0

package/src/seed/validate.ts

@@ -147,11 +147,16 @@ export function validateSeed(data: unknown): ValidationResult {
 				if (!taxonomy.name) {
 					errors.push(`${prefix}: name is required`);
 				} else {
-					// Check for duplicate taxonomy names
-					if (taxonomyNames.has(taxonomy.name)) {
-						errors.push(`${prefix}.name: duplicate taxonomy name "${taxonomy.name}"`);
+					// Uniqueness is per (name, locale).
+					const key = `${taxonomy.name}::${taxonomy.locale ?? ""}`;
+					if (taxonomyNames.has(key)) {
+						errors.push(
+							taxonomy.locale
+								? `${prefix}.name: duplicate taxonomy "${taxonomy.name}" in locale "${taxonomy.locale}"`
+								: `${prefix}.name: duplicate taxonomy name "${taxonomy.name}"`,
+						);
 					}
-					taxonomyNames.add(taxonomy.name);
+					taxonomyNames.add(key);
 				}
 
 				if (!taxonomy.label) {
@@ -184,13 +189,15 @@ export function validateSeed(data: unknown): ValidationResult {
 							if (!term.slug) {
 								errors.push(`${termPrefix}: slug is required`);
 							} else {
-								// Check for duplicate term slugs
-								if (termSlugs.has(term.slug)) {
+								// Uniqueness is per (slug, locale) so the same slug can repeat
+								// across locale variants of the def.
+								const key = `${term.slug}::${term.locale ?? taxonomy.locale ?? ""}`;
+								if (termSlugs.has(key)) {
 									errors.push(
 										`${termPrefix}.slug: duplicate term slug "${term.slug}" in taxonomy "${taxonomy.name}"`,
 									);
 								}
-								termSlugs.add(term.slug);
+								termSlugs.add(key);
 							}
 
 							if (!term.label) {
@@ -207,11 +214,12 @@ export function validateSeed(data: unknown): ValidationResult {
 							}
 						}
 
-						// Second pass: validate parent references
+						// Second pass: validate parent references (within the same locale).
 						if (taxonomy.hierarchical && taxonomy.terms) {
 							for (let j = 0; j < taxonomy.terms.length; j++) {
 								const term = taxonomy.terms[j];
-								if (term.parent && !termSlugs.has(term.parent)) {
+								const termLocale = term.locale ?? taxonomy.locale ?? "";
+								if (term.parent && !termSlugs.has(`${term.parent}::${termLocale}`)) {
 									errors.push(
 										`${prefix}.terms[${j}].parent: parent term "${term.parent}" not found in taxonomy`,
 									);
@@ -243,11 +251,17 @@ export function validateSeed(data: unknown): ValidationResult {
 				if (!menu.name) {
 					errors.push(`${prefix}: name is required`);
 				} else {
-					// Check for duplicate menu names
-					if (menuNames.has(menu.name)) {
-						errors.push(`${prefix}.name: duplicate menu name "${menu.name}"`);
+					// Uniqueness is per (name, locale) — siblings of a translation
+					// group share name but differ in locale.
+					const key = `${menu.name}::${menu.locale ?? ""}`;
+					if (menuNames.has(key)) {
+						errors.push(
+							menu.locale
+								? `${prefix}.name: duplicate menu "${menu.name}" in locale "${menu.locale}"`
+								: `${prefix}.name: duplicate menu name "${menu.name}"`,
+						);
 					}
-					menuNames.add(menu.name);
+					menuNames.add(key);
 				}
 
 				if (!menu.label) {

package/src/settings/index.ts

@@ -18,6 +18,53 @@ import type { SiteSettings, SiteSettingKey, MediaReference } from "./types.js";
 /** Prefix for site settings in the options table */
 const SETTINGS_PREFIX = "site:";
 
+/**
+ * Worker-isolate cache for the resolved `site:*` settings.
+ *
+ * Site settings (title, logo, SEO defaults) change rarely but are read on
+ * every public request. Caching across the isolate's lifetime drops the
+ * `options WHERE name LIKE 'site:%'` prefix scan from once-per-request to
+ * once-per-isolate. Cross-isolate staleness is bounded by isolate lifetime
+ * (workerd typically recycles within minutes); acceptable for chrome.
+ *
+ * Stored on globalThis with a Symbol.for key so Vite SSR chunk duplication
+ * doesn't produce two independent caches (same pattern as request-context.ts).
+ *
+ * Invalidation: every `site:*` write bumps `version`. Reads compare the
+ * cached promise's version against the current version and refetch on
+ * mismatch. Caching the promise (not the resolved value) lets concurrent
+ * cold-isolate readers share the in-flight query.
+ */
+interface SiteSettingsHolder {
+	version: number;
+	cached: Promise<Partial<SiteSettings>> | null;
+	cachedVersion: number;
+}
+
+const SITE_SETTINGS_CACHE_KEY = Symbol.for("emdash:site-settings");
+const g = globalThis as Record<symbol, unknown>;
+const holder: SiteSettingsHolder =
+	// eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- globalThis singleton pattern (see request-context.ts)
+	(g[SITE_SETTINGS_CACHE_KEY] as SiteSettingsHolder | undefined) ??
+	(() => {
+		const h: SiteSettingsHolder = { version: 0, cached: null, cachedVersion: -1 };
+		g[SITE_SETTINGS_CACHE_KEY] = h;
+		return h;
+	})();
+
+/**
+ * Bump the isolate-wide site-settings cache version, forcing the next
+ * `getSiteSettings()` to re-query the database.
+ *
+ * Called from every `site:*` write path. Other isolates still serve their
+ * own cached copy until they expire — staleness bounded by isolate lifetime.
+ */
+export function invalidateSiteSettingsCache(): void {
+	holder.version++;
+	holder.cached = null;
+	holder.cachedVersion = -1;
+}
+
 /**
  * Type guard for MediaReference values
  */
@@ -26,13 +73,18 @@ function isMediaReference(value: unknown): value is MediaReference {
 }
 
 /**
- * Resolve a media reference to include the full URL
+ * Resolve a media reference to include the full URL plus content metadata.
+ *
+ * Pulls `mimeType` and intrinsic dimensions from the media row so callers
+ * can emit correct head tags (e.g. `<link rel="icon" type="image/svg+xml">`,
+ * which Chromium requires when the URL has no `.svg` extension) without
+ * a second round-trip to the media table.
  */
 async function resolveMediaReference(
 	mediaRef: MediaReference | undefined,
 	db: Kysely<Database>,
 	_storage: Storage | null,
-): Promise<(MediaReference & { url?: string }) | undefined> {
+): Promise<MediaReference | undefined> {
 	if (!mediaRef?.mediaId) {
 		return mediaRef;
 	}
@@ -46,6 +98,9 @@ async function resolveMediaReference(
 			return {
 				...mediaRef,
 				url: `/_emdash/api/media/file/${media.storageKey}`,
+				contentType: media.mimeType,
+				...(media.width !== null ? { width: media.width } : {}),
+				...(media.height !== null ? { height: media.height } : {}),
 			};
 		}
 	} catch {
@@ -142,9 +197,24 @@ export async function getSiteSettingWithDb<K extends SiteSettingKey>(
  * ```
  */
 export function getSiteSettings(): Promise<Partial<SiteSettings>> {
-	return requestCached("siteSettings", async () => {
-		const db = await getDb();
-		return getSiteSettingsWithDb(db);
+	return requestCached("siteSettings", () => {
+		const versionAtCall = holder.version;
+		if (holder.cached && holder.cachedVersion === versionAtCall) {
+			return holder.cached;
+		}
+		const fetchPromise = (async () => {
+			const db = await getDb();
+			return getSiteSettingsWithDb(db);
+		})().catch((error) => {
+			if (holder.cached === fetchPromise) {
+				holder.cached = null;
+				holder.cachedVersion = -1;
+			}
+			throw error;
+		});
+		holder.cached = fetchPromise;
+		holder.cachedVersion = versionAtCall;
+		return fetchPromise;
 	});
 }
 
@@ -218,7 +288,11 @@ export async function setSiteSettings(
 		}
 	}
 
-	await options.setMany(updates);
+	try {
+		await options.setMany(updates);
+	} finally {
+		invalidateSiteSettingsCache();
+	}
 }
 
 /**

package/src/settings/types.ts

@@ -4,10 +4,32 @@
  * Global configuration for the site (title, logo, social links, etc.)
  */
 
-/** Media reference for logo/favicon */
+/**
+ * Media reference for logo/favicon.
+ *
+ * Stored shape is just `{ mediaId, alt? }`. The remaining fields are
+ * populated by `resolveMediaReference` on read so templates can emit
+ * correct head tags without a second round-trip to the media table.
+ *
+ * The Zod schemas at the REST/MCP boundary (`mediaReference`) define
+ * only `mediaId` and `alt` and rely on default strip-mode parsing to
+ * discard the resolved fields if a client posts them back. If you
+ * ever switch those schemas to `passthrough`, you must also strip the
+ * resolved fields explicitly in `setSiteSettings`, or stored options
+ * will accumulate stale `url` / `contentType` / `width` / `height`
+ * snapshots.
+ */
 export interface MediaReference {
 	mediaId: string;
 	alt?: string;
+	/** Resolved URL. Populated by `resolveMediaReference`; absent on raw stored values. */
+	url?: string;
+	/** Stored MIME type (e.g. `image/svg+xml`). Populated alongside `url`. */
+	contentType?: string;
+	/** Pixel width if known. Populated alongside `url`. */
+	width?: number;
+	/** Pixel height if known. Populated alongside `url`. */
+	height?: number;
 }
 
 /** Site-level SEO settings */