emdash 0.30.0 → 0.31.1

package/src/i18n/repair-locale-casing.ts

@@ -0,0 +1,51 @@
+import type { Kysely } from "kysely";
+import { sql } from "kysely";
+
+import { listTablesLike } from "../database/dialect-helpers.js";
+import type { Database } from "../database/types.js";
+
+/** Rewrite stored locales to the exact casing used by the site configuration. */
+export async function repairLocaleCasing(
+	db: Kysely<Database>,
+	configuredLocales: readonly string[],
+): Promise<void> {
+	const tableNames = await listTablesLike(db, "ec_%");
+
+	for (const tableName of tableNames) {
+		const table = sql.ref(tableName);
+		const slug = tableName.slice("ec_".length);
+		for (const locale of configuredLocales) {
+			await sql`
+				UPDATE ${table} AS target
+				SET locale = ${locale}
+				WHERE lower(target.locale) = lower(${locale})
+					AND target.locale != ${locale}
+					AND NOT EXISTS (
+						SELECT 1
+						FROM ${table} AS existing
+						WHERE existing.slug = target.slug AND existing.locale = ${locale}
+					)
+					AND target.id = (
+						SELECT MIN(candidate.id)
+						FROM ${table} AS candidate
+						WHERE candidate.slug = target.slug
+							AND lower(candidate.locale) = lower(${locale})
+							AND candidate.locale != ${locale}
+					)
+			`.execute(db);
+
+			await sql`
+				UPDATE content_taxonomies AS pivot
+				SET locale = ${locale}
+				WHERE pivot.collection = ${slug}
+					AND lower(pivot.locale) = lower(${locale})
+					AND pivot.locale != ${locale}
+					AND EXISTS (
+						SELECT 1
+						FROM ${table} AS content
+						WHERE content.id = pivot.entry_id AND content.locale = ${locale}
+					)
+			`.execute(db);
+		}
+	}
+}

package/src/search/query.ts

@@ -10,6 +10,7 @@ import { sql } from "kysely";
 import { encodeCursor, decodeCursor, InvalidCursorError } from "../database/repositories/types.js";
 import type { Database } from "../database/types.js";
 import { validateIdentifier } from "../database/validate.js";
+import { resolveConfiguredLocale } from "../i18n/config.js";
 import { getDb } from "../loader.js";
 import { FTSManager } from "./fts-manager.js";
 import type {
@@ -250,7 +251,7 @@ async function searchSingleCollection(
 	const contentTable = ftsManager.getContentTableName(collection);
 	const limit = options.limit ?? 20;
 	const status = options.status ?? "published";
-	const locale = options.locale;
+	const locale = options.locale ? resolveConfiguredLocale(options.locale) : undefined;
 
 	// Check if FTS table exists
 	if (!(await ftsManager.ftsTableExists(collection))) {
@@ -397,7 +398,7 @@ export async function getSuggestions(
 	options: SuggestOptions = {},
 ): Promise<Suggestion[]> {
 	const limit = options.limit ?? 5;
-	const locale = options.locale;
+	const locale = options.locale ? resolveConfiguredLocale(options.locale) : undefined;
 
 	// Get searchable collections
 	let collections = options.collections;

package/src/seed/apply.ts

@@ -19,7 +19,7 @@ import { TaxonomyRepository } from "../database/repositories/taxonomy.js";
 import { withTransaction } from "../database/transaction.js";
 import type { Database } from "../database/types.js";
 import type { MediaValue } from "../fields/types.js";
-import { getI18nConfig } from "../i18n/config.js";
+import { getI18nConfig, resolveConfiguredLocale } from "../i18n/config.js";
 import { ssrfSafeFetch, validateExternalUrl } from "../import/ssrf.js";
 import { markContentMediaUsageCollectionStaleSafely } from "../media/usage/content-refresh.js";
 import { SchemaRegistry } from "../schema/registry.js";
@@ -263,7 +263,7 @@ export async function applySeed(
 		const termSeedIdMap = new Map<string, string>();
 
 		for (const taxonomy of seed.taxonomies) {
-			const defLocale = taxonomy.locale ?? defaultLocale;
+			const defLocale = resolveConfiguredLocale(taxonomy.locale ?? defaultLocale);
 
 			// (name, locale) is the UNIQUE key after migration 036.
 			const existingDef = await db
@@ -340,7 +340,7 @@ export async function applySeed(
 					);
 				} else {
 					for (const term of taxonomy.terms) {
-						const termLocale = term.locale ?? defLocale;
+						const termLocale = resolveConfiguredLocale(term.locale ?? defLocale);
 						const existing = await termRepo.findBySlug(taxonomy.name, term.slug, termLocale);
 						if (existing) {
 							if (onConflict === "error") {
@@ -464,7 +464,7 @@ export async function applySeed(
 					// Resolve the entry's locale up front so a non-`en` single-locale
 					// export (which omits `locale`) is filed under the project default
 					// rather than `en` (#1421).
-					const entryLocale = entry.locale ?? defaultLocale;
+					const entryLocale = resolveConfiguredLocale(entry.locale ?? defaultLocale);
 
 					// Check if entry exists (by slug + locale for locale-aware lookup)
 					const existing = await contentRepo.findBySlug(collectionSlug, entry.slug, entryLocale);
@@ -621,7 +621,7 @@ export async function applySeed(
 		const itemSeedIdMap = new Map<string, { id: string; translationGroup: string }>();
 
 		for (const menu of seed.menus) {
-			const locale = menu.locale ?? defaultLocale;
+			const locale = resolveConfiguredLocale(menu.locale ?? defaultLocale);
 			let lookup = db
 				.selectFrom("_emdash_menus")
 				.selectAll()
@@ -867,6 +867,8 @@ async function applyHierarchicalTerms(
 ): Promise<void> {
 	// "locale::slug" -> id, so the same slug can resolve per locale.
 	const slugToId = new Map<string, string>();
+	const resolveTermLocale = (term: SeedTaxonomyTerm) =>
+		resolveConfiguredLocale(term.locale ?? defLocale);
 
 	// Multiple passes — handles deep nesting and translationOf forward refs.
 	let remaining = [...terms];
@@ -876,7 +878,7 @@ async function applyHierarchicalTerms(
 		const processedThisPass: string[] = [];
 
 		for (const term of remaining) {
-			const termLocale = term.locale ?? defLocale;
+			const termLocale = resolveTermLocale(term);
 			const parentReady = !term.parent || slugToId.has(`${termLocale}::${term.parent}`);
 			const translationReady = !term.translationOf || termSeedIdMap.has(term.translationOf);
 
@@ -921,7 +923,7 @@ async function applyHierarchicalTerms(
 		}
 
 		remaining = remaining.filter(
-			(t) => !processedThisPass.includes(t.slug + "::" + (t.locale ?? defLocale)),
+			(term) => !processedThisPass.includes(term.slug + "::" + resolveTermLocale(term)),
 		);
 		maxPasses--;
 	}

package/src/seed/validate.ts

@@ -4,6 +4,7 @@
  * Validates a seed file structure before applying it.
  */
 
+import { getI18nConfig, resolveConfiguredLocale } from "../i18n/config.js";
 import { FIELD_TYPES } from "../schema/types.js";
 import type { SeedFile, SeedMenuItem, ValidationResult } from "./types.js";
 
@@ -49,6 +50,9 @@ export function validateSeed(data: unknown): ValidationResult {
 	}
 
 	const seed = data as Partial<SeedFile>;
+	const defaultLocale =
+		getI18nConfig()?.defaultLocale ??
+		(typeof seed.defaultLocale === "string" ? seed.defaultLocale : "en");
 
 	// Required fields
 	if (!seed.version) {
@@ -163,7 +167,8 @@ export function validateSeed(data: unknown): ValidationResult {
 					errors.push(`${prefix}: name is required`);
 				} else {
 					// Uniqueness is per (name, locale).
-					const key = `${taxonomy.name}::${taxonomy.locale ?? ""}`;
+					const locale = resolveConfiguredLocale(taxonomy.locale ?? defaultLocale);
+					const key = `${taxonomy.name}::${locale}`;
 					if (taxonomyNames.has(key)) {
 						errors.push(
 							taxonomy.locale
@@ -206,7 +211,10 @@ export function validateSeed(data: unknown): ValidationResult {
 							} else {
 								// 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 ?? ""}`;
+								const locale = resolveConfiguredLocale(
+									term.locale ?? taxonomy.locale ?? defaultLocale,
+								);
+								const key = `${term.slug}::${locale}`;
 								if (termSlugs.has(key)) {
 									errors.push(
 										`${termPrefix}.slug: duplicate term slug "${term.slug}" in taxonomy "${taxonomy.name}"`,
@@ -233,7 +241,9 @@ export function validateSeed(data: unknown): ValidationResult {
 						if (taxonomy.hierarchical && taxonomy.terms) {
 							for (let j = 0; j < taxonomy.terms.length; j++) {
 								const term = taxonomy.terms[j];
-								const termLocale = term.locale ?? taxonomy.locale ?? "";
+								const termLocale = resolveConfiguredLocale(
+									term.locale ?? taxonomy.locale ?? defaultLocale,
+								);
 								if (term.parent && !termSlugs.has(`${term.parent}::${termLocale}`)) {
 									errors.push(
 										`${prefix}.terms[${j}].parent: parent term "${term.parent}" not found in taxonomy`,
@@ -268,7 +278,8 @@ export function validateSeed(data: unknown): ValidationResult {
 				} else {
 					// Uniqueness is per (name, locale) — siblings of a translation
 					// group share name but differ in locale.
-					const key = `${menu.name}::${menu.locale ?? ""}`;
+					const locale = resolveConfiguredLocale(menu.locale ?? defaultLocale);
+					const key = `${menu.name}::${locale}`;
 					if (menuNames.has(key)) {
 						errors.push(
 							menu.locale

package/src/taxonomies/index.ts

@@ -31,6 +31,15 @@ export interface TaxonomyQueryOptions {
 	locale?: string;
 }
 
+export interface TaxonomyTermsOptions extends TaxonomyQueryOptions {
+	/**
+	 * Populate each term's `count`. Counts aggregate the whole
+	 * `content_taxonomies` pivot against every declared collection, so callers
+	 * that don't render a count should opt out. Defaults to `true`.
+	 */
+	includeCounts?: boolean;
+}
+
 /** Invalidate cached taxonomy term data and any content that hydrates terms. */
 export function invalidateTermCache(): void {
 	invalidateTaxonomyObjectCache();
@@ -230,21 +239,54 @@ function termCountNamespaces(collections: string[]): string[] {
 /**
  * All terms of a taxonomy in a specific locale (flat for non-hierarchical,
  * tree for hierarchical).
+ *
+ * The term list and the visible-entry counts are loaded and cached separately:
+ * the list depends only on the taxonomy epoch, while the counts additionally
+ * depend on every counted collection's content epoch and cost an aggregate over
+ * the whole assignment pivot. Callers that don't render counts pass
+ * `includeCounts: false` and skip that aggregate entirely, while still sharing
+ * the term list with callers that do.
  */
 export async function getTaxonomyTerms(
 	taxonomyName: string,
-	options: TaxonomyQueryOptions = {},
+	options: TaxonomyTermsOptions = {},
 ): Promise<TaxonomyTerm[]> {
 	const locale = resolveLocale(options.locale);
-	return requestCached(`taxonomy-terms:${taxonomyName}:${locale ?? "*"}`, async () => {
-		const def = await getTaxonomyDef(taxonomyName, options);
-		if (!def) return [];
-		return cachedQuery({
-			namespace: termCountNamespaces(def.collections),
-			key: `terms:${taxonomyName}:${locale ?? "*"}`,
+	const def = await getTaxonomyDef(taxonomyName, options);
+	if (!def) return [];
+	if (options.includeCounts === false) return getTermList(def, locale);
+
+	// The two are independent, so run them concurrently to save a round trip.
+	const [terms, counts] = await Promise.all([
+		getTermList(def, locale),
+		getVisibleTermCounts(def.name, def.collections),
+	]);
+	return withCounts(terms, counts);
+}
+
+/** Terms without counts, under the cache keys the layout prefetch warms. */
+function getTermList(def: TaxonomyDef, locale: string | undefined): Promise<TaxonomyTerm[]> {
+	const localeKey = locale ?? "*";
+	return requestCached(`taxonomy-terms:${def.name}:${localeKey}`, () =>
+		cachedQuery({
+			namespace: CacheNamespace.TAXONOMIES,
+			key: `termList:${def.name}:${localeKey}`,
 			load: () => loadTaxonomyTerms(def, locale),
-		});
-	});
+		}),
+	);
+}
+
+/**
+ * Copy a term list with counts attached. Counts are keyed by translation_group
+ * (what the pivot stores) and are locale-independent. Rebuilds every node so
+ * the shared, cached count-free list is never mutated.
+ */
+function withCounts(terms: TaxonomyTerm[], counts: Map<string, number>): TaxonomyTerm[] {
+	return terms.map((term) => ({
+		...term,
+		count: counts.get(term.translationGroup ?? term.id) ?? 0,
+		children: withCounts(term.children, counts),
+	}));
 }
 
 async function loadTaxonomyTerms(
@@ -260,14 +302,7 @@ async function loadTaxonomyTerms(
 		.orderBy("label", "asc");
 	if (locale !== undefined) termsQuery = termsQuery.where("locale", "=", locale);
 
-	// Counts are keyed by translation_group (what the pivot stores) and are
-	// locale-independent. Only publicly visible entries are counted (#581);
-	// the map is request-cached so a term detail rendered on the same page
-	// reuses it. Independent of the terms query, so run both concurrently.
-	const [rows, counts] = await Promise.all([
-		termsQuery.execute(),
-		getVisibleTermCounts(def.name, def.collections),
-	]);
+	const rows = await termsQuery.execute();
 
 	const flatTerms: TaxonomyTermRow[] = rows.map((row) => ({
 		id: row.id,
@@ -280,7 +315,7 @@ async function loadTaxonomyTerms(
 		translation_group: row.translation_group,
 	}));
 
-	if (def.hierarchical) return buildTree(flatTerms, counts);
+	if (def.hierarchical) return buildTree(flatTerms);
 
 	return flatTerms.map((term) => ({
 		id: term.id,
@@ -289,7 +324,6 @@ async function loadTaxonomyTerms(
 		label: term.label,
 		description: term.data ? JSON.parse(term.data).description : undefined,
 		children: [],
-		count: counts.get(term.translation_group ?? term.id) ?? 0,
 		locale: term.locale,
 		translationGroup: term.translation_group,
 	}));
@@ -312,8 +346,16 @@ function getVisibleTermCounts(
 	// entry.
 	const scope = [...new Set(collections)].toSorted().join(",");
 	return requestCached(`taxonomy-term-counts:${taxonomyName}:${scope}`, async () => {
-		const db = await getDb();
-		return fetchVisibleTermCounts(db, taxonomyName, collections);
+		// A Map is not JSON-representable — cache the entries, rebuild on read.
+		const entries = await cachedQuery({
+			namespace: termCountNamespaces(collections),
+			key: `termCounts:${taxonomyName}:${scope}`,
+			load: async (): Promise<Array<[string, number]>> => {
+				const db = await getDb();
+				return [...(await fetchVisibleTermCounts(db, taxonomyName, collections))];
+			},
+		});
+		return new Map(entries);
 	});
 }
 
@@ -796,7 +838,7 @@ function rowToTaxonomyDef(row: {
 /**
  * Build tree structure from flat terms
  */
-function buildTree(flatTerms: TaxonomyTermRow[], counts: Map<string, number>): TaxonomyTerm[] {
+function buildTree(flatTerms: TaxonomyTermRow[]): TaxonomyTerm[] {
 	// parent_id holds the parent's translation_group, so link children by it.
 	// Key by (locale, group): a child's parent lives in the same locale, and an
 	// unfiltered set mixes locales whose translated siblings share a group —
@@ -814,7 +856,6 @@ function buildTree(flatTerms: TaxonomyTermRow[], counts: Map<string, number>): T
 			parentId: term.parent_id ?? undefined,
 			description: term.data ? JSON.parse(term.data).description : undefined,
 			children: [],
-			count: counts.get(term.translation_group ?? term.id) ?? 0,
 			locale: term.locale,
 			translationGroup: term.translation_group,
 		};