emdash 0.32.0 → 0.34.0

package/src/api/handlers/taxonomies.ts

@@ -7,17 +7,27 @@
  * so assignments span every locale of a post.
  */
 
-import type { Kysely, Selectable } from "kysely";
+import { sql, type Kysely, type Selectable } from "kysely";
 import { ulid } from "ulidx";
 
-import { TaxonomyRepository } from "../../database/repositories/taxonomy.js";
+import { TaxonomyRepository, type SiblingPosition } from "../../database/repositories/taxonomy.js";
+import { withTransaction } from "../../database/transaction.js";
 import type { Database, TaxonomyDefTable } from "../../database/types.js";
-import { resolveConfiguredLocale } from "../../i18n/config.js";
+import { getI18nConfig, resolveConfiguredLocale } from "../../i18n/config.js";
 import { invalidateTaxonomyDefsCache, invalidateTermCache } from "../../taxonomies/index.js";
 import { fetchVisibleTermCounts } from "../../taxonomies/term-counts.js";
 import type { ApiResult } from "../types.js";
 
 const NAME_PATTERN = /^[a-z][a-z0-9_]*$/;
+const MAX_GENERATED_TERM_SLUG_ATTEMPTS = 16;
+
+function isTermSlugUniqueViolation(error: unknown): boolean {
+	const message = error instanceof Error ? error.message.toLowerCase() : "";
+	return (
+		(message.includes("unique constraint failed") || message.includes("duplicate key")) &&
+		message.includes("slug")
+	);
+}
 
 // ---------------------------------------------------------------------------
 // Response types
@@ -38,6 +48,10 @@ export interface TaxonomyListResponse {
 	taxonomies: TaxonomyDef[];
 }
 
+export interface TaxonomyResponse {
+	taxonomy: TaxonomyDef;
+}
+
 export interface TermData {
 	id: string;
 	name: string;
@@ -59,6 +73,10 @@ export interface TermListResponse {
 	terms: TermWithCount[];
 }
 
+export interface TermReorderResponse {
+	reordered: true;
+}
+
 export interface TermResponse {
 	term: TermData;
 }
@@ -97,7 +115,7 @@ export interface TaxonomyDefTranslationsResponse {
 /**
  * Build tree structure from flat terms
  */
-function buildTree(flatTerms: TermWithCount[]): TermWithCount[] {
+function buildTree(flatTerms: TermWithCount[], resolveByGroup = false): TermWithCount[] {
 	// `parentId` holds the parent's translation_group, so resolve links by group.
 	// Key by (locale, group): a child's parent lives in the same locale, and an
 	// unfiltered list mixes locales whose translated siblings share a group —
@@ -105,11 +123,14 @@ function buildTree(flatTerms: TermWithCount[]): TermWithCount[] {
 	const byLocaleGroup = new Map<string, TermWithCount>();
 	const roots: TermWithCount[] = [];
 	for (const term of flatTerms) {
-		byLocaleGroup.set(`${term.locale}::${term.translationGroup ?? term.id}`, term);
+		const key = resolveByGroup
+			? (term.translationGroup ?? term.id)
+			: `${term.locale}::${term.translationGroup ?? term.id}`;
+		byLocaleGroup.set(key, term);
 	}
 	for (const term of flatTerms) {
 		const parent = term.parentId
-			? byLocaleGroup.get(`${term.locale}::${term.parentId}`)
+			? byLocaleGroup.get(resolveByGroup ? term.parentId : `${term.locale}::${term.parentId}`)
 			: undefined;
 		if (parent) {
 			parent.children.push(term);
@@ -120,28 +141,105 @@ function buildTree(flatTerms: TermWithCount[]): TermWithCount[] {
 	return roots;
 }
 
-/**
- * Look up a taxonomy definition by name (optionally scoped to a locale).
- * Returns the lowest-locale match when no locale is provided.
- */
+type TaxonomyDefLookup =
+	| { success: true; def: Selectable<TaxonomyDefTable> }
+	| { success: false; error: { code: string; message: string } };
+
+function taxonomyDefNotFound(name: string, locale?: string): TaxonomyDefLookup {
+	return {
+		success: false,
+		error: {
+			code: "NOT_FOUND",
+			message: `Taxonomy '${name}' not found${locale !== undefined ? ` in locale '${locale}'` : ""}`,
+		},
+	};
+}
+
+/** Look up the exact definition addressed by a mutation. */
 async function requireTaxonomyDef(
 	db: Kysely<Database>,
 	name: string,
 	locale?: string,
-): Promise<
-	| { success: true; def: Selectable<TaxonomyDefTable> }
-	| { success: false; error: { code: string; message: string } }
-> {
+): Promise<TaxonomyDefLookup> {
 	let query = db.selectFrom("_emdash_taxonomy_defs").selectAll().where("name", "=", name);
 	if (locale !== undefined) query = query.where("locale", "=", locale);
-	const def = await query.orderBy("locale", "asc").executeTakeFirst();
-	if (!def) {
-		return {
-			success: false,
-			error: { code: "NOT_FOUND", message: `Taxonomy '${name}' not found` },
-		};
-	}
-	return { success: true, def };
+	const def = await query.orderBy("locale", "asc").orderBy("id", "asc").executeTakeFirst();
+	return def ? { success: true, def } : taxonomyDefNotFound(name, locale);
+}
+
+/**
+ * Prefer the requested locale, then the configured default. Incomplete
+ * translation groups fall back deterministically so their terms remain usable.
+ */
+async function requireTaxonomyDefWithFallback(
+	db: Kysely<Database>,
+	name: string,
+	locale?: string,
+): Promise<TaxonomyDefLookup> {
+	const defs = await db
+		.selectFrom("_emdash_taxonomy_defs")
+		.selectAll()
+		.where("name", "=", name)
+		.orderBy("locale", "asc")
+		.orderBy("id", "asc")
+		.execute();
+	const defaultLocale = getI18nConfig()?.defaultLocale;
+	const def =
+		(locale ? defs.find((candidate) => candidate.locale === locale) : undefined) ??
+		(defaultLocale ? defs.find((candidate) => candidate.locale === defaultLocale) : undefined) ??
+		defs[0];
+	return def ? { success: true, def } : taxonomyDefNotFound(name, locale);
+}
+
+/** The subset of `slugs` that still has a row in `_emdash_collections`. */
+async function findExistingCollections(
+	db: Kysely<Database>,
+	slugs: readonly string[],
+): Promise<Set<string>> {
+	if (slugs.length === 0) return new Set();
+	const rows = await db
+		.selectFrom("_emdash_collections")
+		.select("slug")
+		.where("slug", "in", [...slugs])
+		.execute();
+	return new Set(rows.map((r) => r.slug));
+}
+
+/**
+ * Reject a `collections` list naming collections that don't exist. Shared by
+ * create and update so both fail the same way instead of storing a reference
+ * that reads back filtered out.
+ */
+async function validateCollections(
+	db: Kysely<Database>,
+	collections: readonly string[],
+): Promise<{ code: "VALIDATION_ERROR"; message: string } | null> {
+	const existing = await findExistingCollections(db, collections);
+	const invalid = collections.filter((slug) => !existing.has(slug));
+	if (invalid.length === 0) return null;
+	return {
+		code: "VALIDATION_ERROR",
+		message: `Unknown collection(s): ${invalid.join(", ")}`,
+	};
+}
+
+/**
+ * Shape one definition row for a response, dropping collection references whose
+ * collection is gone. Storage is untouched — re-creating the collection
+ * re-links automatically, same as `handleTaxonomyList`.
+ */
+async function toTaxonomyResponse(
+	db: Kysely<Database>,
+	row: Selectable<TaxonomyDefTable>,
+): Promise<TaxonomyResponse> {
+	const def = rowToDef(row);
+	const realCollections = await findExistingCollections(db, def.collections);
+	return {
+		taxonomy: {
+			...def,
+			collections: def.collections.filter((slug) => realCollections.has(slug)),
+		},
+	};
 }
 
 /** Declared collections of a taxonomy def row (deduped, parsed from JSON). */
@@ -203,6 +301,31 @@ export async function handleTaxonomyList(
 	}
 }
 
+/**
+ * Get a single taxonomy definition by name.
+ *
+ * Definitions are per-locale, so `locale` picks which one; without it the
+ * lowest-locale match wins (same rule as `handleMenuGet`).
+ */
+export async function handleTaxonomyGet(
+	db: Kysely<Database>,
+	name: string,
+	options: { locale?: string } = {},
+): Promise<ApiResult<TaxonomyResponse>> {
+	try {
+		const locale = options.locale ? resolveConfiguredLocale(options.locale) : undefined;
+		const lookup = await requireTaxonomyDefWithFallback(db, name, locale);
+		if (!lookup.success) return lookup;
+
+		return { success: true, data: await toTaxonomyResponse(db, lookup.def) };
+	} catch {
+		return {
+			success: false,
+			error: { code: "TAXONOMY_GET_ERROR", message: "Failed to get taxonomy" },
+		};
+	}
+}
+
 /**
  * Create a new taxonomy definition
  */
@@ -217,9 +340,9 @@ export async function handleTaxonomyCreate(
 		locale?: string;
 		translationOf?: string;
 	},
-): Promise<ApiResult<{ taxonomy: TaxonomyDef }>> {
+): Promise<ApiResult<TaxonomyResponse>> {
 	try {
-		const locale = input.locale ? resolveConfiguredLocale(input.locale) : undefined;
+		const locale = resolveConfiguredLocale(input.locale ?? getI18nConfig()?.defaultLocale ?? "en");
 		if (!NAME_PATTERN.test(input.name)) {
 			return {
 				success: false,
@@ -232,23 +355,9 @@ export async function handleTaxonomyCreate(
 		}
 
 		const collections = [...new Set(input.collections ?? [])];
-		if (collections.length > 0) {
-			const existingCollections = await db
-				.selectFrom("_emdash_collections")
-				.select("slug")
-				.where("slug", "in", collections)
-				.execute();
-			const existingSlugs = new Set(existingCollections.map((c) => c.slug));
-			const invalid = collections.filter((c) => !existingSlugs.has(c));
-			if (invalid.length > 0) {
-				return {
-					success: false,
-					error: {
-						code: "VALIDATION_ERROR",
-						message: `Unknown collection(s): ${invalid.join(", ")}`,
-					},
-				};
-			}
+		const collectionError = await validateCollections(db, collections);
+		if (collectionError) {
+			return { success: false, error: collectionError };
 		}
 
 		let translationGroup: string | null = null;
@@ -269,22 +378,20 @@ export async function handleTaxonomyCreate(
 
 		// Duplicate guard scoped to locale (so the same name can exist in ES
 		// and EN).
-		if (locale !== undefined) {
-			const existing = await db
-				.selectFrom("_emdash_taxonomy_defs")
-				.select("id")
-				.where("name", "=", input.name)
-				.where("locale", "=", locale)
-				.executeTakeFirst();
-			if (existing) {
-				return {
-					success: false,
-					error: {
-						code: "CONFLICT",
-						message: `Taxonomy '${input.name}' already exists in locale '${locale}'`,
-					},
-				};
-			}
+		const existing = await db
+			.selectFrom("_emdash_taxonomy_defs")
+			.select("id")
+			.where("name", "=", input.name)
+			.where("locale", "=", locale)
+			.executeTakeFirst();
+		if (existing) {
+			return {
+				success: false,
+				error: {
+					code: "CONFLICT",
+					message: `Taxonomy '${input.name}' already exists in locale '${locale}'`,
+				},
+			};
 		}
 
 		const id = ulid();
@@ -297,7 +404,7 @@ export async function handleTaxonomyCreate(
 				label_singular: input.labelSingular ?? null,
 				hierarchical: input.hierarchical ? 1 : 0,
 				collections: JSON.stringify(collections),
-				...(locale !== undefined ? { locale } : {}),
+				locale,
 				translation_group: translationGroup ?? id,
 			})
 			.execute();
@@ -326,6 +433,119 @@ export async function handleTaxonomyCreate(
 	}
 }
 
+/**
+ * Update a taxonomy definition.
+ *
+ * Writes the one row `(name, locale)` resolves to — every field here belongs to
+ * a single locale's definition, so translating a taxonomy and then editing the
+ * translation leaves the other locales alone. `name` and `locale` are immutable
+ * (renaming would strand the terms, which are keyed on `name`).
+ */
+export async function handleTaxonomyUpdate(
+	db: Kysely<Database>,
+	name: string,
+	input: {
+		label?: string;
+		labelSingular?: string | null;
+		hierarchical?: boolean;
+		collections?: string[];
+		locale?: string;
+	},
+): Promise<ApiResult<TaxonomyResponse>> {
+	try {
+		const locale = input.locale ? resolveConfiguredLocale(input.locale) : undefined;
+		const lookup = await requireTaxonomyDef(db, name, locale);
+		if (!lookup.success) return lookup;
+
+		const collections = input.collections ? [...new Set(input.collections)] : undefined;
+		if (collections !== undefined) {
+			const collectionError = await validateCollections(db, collections);
+			if (collectionError) {
+				return { success: false, error: collectionError };
+			}
+		}
+
+		const updates: {
+			label?: string;
+			label_singular?: string | null;
+			hierarchical?: number;
+			collections?: string;
+		} = {};
+		if (input.label !== undefined) updates.label = input.label;
+		if (input.labelSingular !== undefined) updates.label_singular = input.labelSingular;
+		if (input.hierarchical !== undefined) updates.hierarchical = input.hierarchical ? 1 : 0;
+		if (collections !== undefined) updates.collections = JSON.stringify(collections);
+
+		if (Object.keys(updates).length > 0) {
+			await db
+				.updateTable("_emdash_taxonomy_defs")
+				.set(updates)
+				.where("id", "=", lookup.def.id)
+				.execute();
+			invalidateTaxonomyDefsCache();
+		}
+
+		const row = await db
+			.selectFrom("_emdash_taxonomy_defs")
+			.selectAll()
+			.where("id", "=", lookup.def.id)
+			.executeTakeFirstOrThrow();
+
+		return { success: true, data: await toTaxonomyResponse(db, row) };
+	} catch {
+		return {
+			success: false,
+			error: { code: "TAXONOMY_UPDATE_ERROR", message: "Failed to update taxonomy" },
+		};
+	}
+}
+
+/**
+ * Delete a taxonomy: every locale's definition, every term under that name in
+ * every locale, and the term assignments those terms hold.
+ *
+ * There is no locale scope and no non-empty guard. Terms are keyed on `name`
+ * rather than on a definition row, so leaving one locale's definition behind
+ * would leave the taxonomy half-deleted — a definition with no terms, or terms
+ * no definition describes.
+ */
+export async function handleTaxonomyDelete(
+	db: Kysely<Database>,
+	name: string,
+): Promise<ApiResult<{ deleted: true }>> {
+	try {
+		const lookup = await requireTaxonomyDef(db, name);
+		if (!lookup.success) return lookup;
+
+		await withTransaction(db, async (trx) => {
+			// `content_taxonomies.taxonomy_id` holds a term's translation_group, so
+			// the assignments have to go before the terms they are matched against.
+			await trx
+				.deleteFrom("content_taxonomies")
+				.where("taxonomy_id", "in", (eb) =>
+					eb
+						.selectFrom("taxonomies")
+						.select(sql<string>`coalesce(translation_group, id)`.as("group"))
+						.where("name", "=", name),
+				)
+				.execute();
+			await trx.deleteFrom("taxonomies").where("name", "=", name).execute();
+			await trx.deleteFrom("_emdash_taxonomy_defs").where("name", "=", name).execute();
+		});
+
+		// Covers the term caches too — see `invalidateTaxonomyDefsCache`.
+		invalidateTaxonomyDefsCache();
+
+		return { success: true, data: { deleted: true } };
+	} catch (error) {
+		console.error("[taxonomies] delete failed:", error);
+		return {
+			success: false,
+			error: { code: "TAXONOMY_DELETE_ERROR", message: "Failed to delete taxonomy" },
+		};
+	}
+}
+
 /**
  * List every locale translation of a taxonomy def (by id or translation_group).
  */
@@ -385,17 +605,33 @@ export async function handleTaxonomyDefTranslations(
 export async function handleTermList(
 	db: Kysely<Database>,
 	taxonomyName: string,
-	options: { locale?: string; includeCounts?: boolean } = {},
+	options: { locale?: string; includeCounts?: boolean; resolveFallback?: boolean } = {},
 ): Promise<ApiResult<TermListResponse>> {
 	try {
+		if (options.resolveFallback && !options.locale) {
+			return {
+				success: false,
+				error: {
+					code: "VALIDATION_ERROR",
+					message: "A locale is required when resolving taxonomy fallbacks",
+				},
+			};
+		}
 		// Definitions are per-locale but terms aren't bound to the def's locale —
-		// just ensure the taxonomy exists somewhere.
-		const lookup = await requireTaxonomyDef(db, taxonomyName);
+		// use the active definition for its collection scope.
+		const locale = options.locale ? resolveConfiguredLocale(options.locale) : undefined;
+		const lookup = await requireTaxonomyDefWithFallback(db, taxonomyName, locale);
 		if (!lookup.success) return lookup;
 
 		const repo = new TaxonomyRepository(db);
-		const locale = options.locale ? resolveConfiguredLocale(options.locale) : undefined;
-		const terms = await repo.findByName(taxonomyName, { locale });
+		const terms =
+			options.resolveFallback && locale
+				? await repo.findByNameResolved(
+						taxonomyName,
+						locale,
+						getI18nConfig()?.defaultLocale ?? "en",
+					)
+				: await repo.findByName(taxonomyName, { locale });
 
 		// Counts match what visitors see on the public site: published (or
 		// scheduled-and-due) entries that aren't soft-deleted, scoped to the
@@ -404,7 +640,7 @@ export async function handleTermList(
 		// look up by group and map back to each term's id.
 		const includeCounts = options.includeCounts ?? true;
 		const countsByGroup = includeCounts
-			? await fetchVisibleTermCounts(db, taxonomyName, defCollections(lookup.def))
+			? await fetchVisibleTermCounts(db, taxonomyName, defCollections(lookup.def), locale)
 			: undefined;
 
 		const termData: TermWithCount[] = terms.map((term) => ({
@@ -421,7 +657,9 @@ export async function handleTermList(
 		}));
 
 		const isHierarchical = lookup.def.hierarchical === 1;
-		const result = isHierarchical ? buildTree(termData) : termData;
+		const result = isHierarchical
+			? buildTree(termData, options.resolveFallback && !!locale)
+			: termData;
 		return { success: true, data: { terms: result } };
 	} catch (error) {
 		console.error("[taxonomies] term list failed:", error);
@@ -432,6 +670,102 @@ export async function handleTermList(
 	}
 }
 
+/**
+ * Set the manual order of one sibling group.
+ *
+ * `ids` names the terms to move, in the desired order; each is a row id or a
+ * translation_group and resolves to the latter, because a position belongs to a
+ * term rather than to one of its locales. Reordering never reparents — moving a
+ * term under a different parent is a term update.
+ *
+ * The group is `(taxonomy, parentId)` and has no locale: `parentId` is the
+ * parent's translation_group (a row id is accepted and resolved), and `null`
+ * selects the top level — which for a flat taxonomy is every term.
+ *
+ * `ids` may be a *subset* of the group, and the listed terms are permuted
+ * within the positions they already occupy. A locale only renders the terms
+ * translated into it, so a caller often cannot name every member; a member left
+ * out keeps its place, which is also what makes a stale list harmless.
+ */
+export async function handleTermReorder(
+	db: Kysely<Database>,
+	taxonomyName: string,
+	input: { parentId?: string | null; ids: string[] },
+): Promise<ApiResult<TermReorderResponse>> {
+	try {
+		const lookup = await requireTaxonomyDef(db, taxonomyName);
+		if (!lookup.success) return lookup;
+
+		const repo = new TaxonomyRepository(db);
+
+		let parentId = input.parentId ?? null;
+		if (parentId !== null) {
+			// Children store the parent's translation_group, so a caller passing a
+			// row id still addresses the right group. A parent whose anchor row is
+			// gone keeps the value as given (see TaxonomyRepository.resolveParentRef).
+			const parent = await repo.findById(parentId);
+			if (parent) parentId = parent.translationGroup ?? parent.id;
+		}
+
+		// Every locale's rows: membership is locale-agnostic, and a term the
+		// caller can't see still holds its slot.
+		// The order carries into how ties are resolved, so it must be stable
+		// across calls; with locales interleaved a tie falls to whichever
+		// locale's label sorts first, not to the order the caller rendered.
+		const members = await repo.findByName(taxonomyName, { parentId });
+		const siblings: SiblingPosition[] = [];
+		const seen = new Set<string>();
+		const resolve = new Map<string, string>();
+		for (const term of members) {
+			const group = term.translationGroup ?? term.id;
+			if (!seen.has(group)) {
+				seen.add(group);
+				siblings.push({ group, position: term.sortOrder });
+			}
+			// Both spellings resolve to the group: a row id, and the group itself for
+			// a caller that already holds one — including when its anchor row is gone
+			// and no member's id matches it.
+			resolve.set(group, group);
+			resolve.set(term.id, group);
+		}
+
+		const groups: string[] = [];
+		for (const id of input.ids) {
+			const group = resolve.get(id);
+			if (!group) {
+				return {
+					success: false,
+					error: {
+						code: "REORDER_MISMATCH",
+						message: `Term "${id}" is not in the sibling group being reordered`,
+					},
+				};
+			}
+			if (groups.includes(group)) {
+				return {
+					success: false,
+					error: {
+						code: "REORDER_MISMATCH",
+						message: `Term "${id}" is listed more than once`,
+					},
+				};
+			}
+			groups.push(group);
+		}
+
+		await repo.reorder(groups, siblings);
+		invalidateTermCache();
+
+		return { success: true, data: { reordered: true } };
+	} catch (error) {
+		console.error("[taxonomies] term reorder failed:", error);
+		return {
+			success: false,
+			error: { code: "TERM_REORDER_ERROR", message: "Failed to reorder terms" },
+		};
+	}
+}
+
 /**
  * Validate a parent term reference for create/update.
  *
@@ -531,7 +865,7 @@ export async function handleTermCreate(
 	db: Kysely<Database>,
 	taxonomyName: string,
 	input: {
-		slug: string;
+		slug?: string;
 		label: string;
 		parentId?: string | null;
 		description?: string;
@@ -539,8 +873,9 @@ export async function handleTermCreate(
 		translationOf?: string;
 	},
 ): Promise<ApiResult<TermResponse>> {
+	let attemptedSlug = input.slug;
 	try {
-		const locale = input.locale ? resolveConfiguredLocale(input.locale) : undefined;
+		const locale = resolveConfiguredLocale(input.locale ?? getI18nConfig()?.defaultLocale ?? "en");
 		// Taxonomy definitions are per-locale, but terms can exist in any locale
 		// regardless of whether the def has been translated there. Look up the
 		// def across all locales — we only care that it *exists*.
@@ -554,15 +889,14 @@ export async function handleTermCreate(
 			input.parentId === "" || input.parentId === undefined ? undefined : input.parentId;
 
 		// Conflict check is scoped to locale (per-locale slugs are unique).
-		const existing = await repo.findBySlug(taxonomyName, input.slug, locale);
+		const existing =
+			input.slug === undefined ? null : await repo.findBySlug(taxonomyName, input.slug, locale);
 		if (existing) {
 			return {
 				success: false,
 				error: {
 					code: "CONFLICT",
-					message: locale
-						? `Term '${input.slug}' already exists in '${taxonomyName}' (${locale})`
-						: `Term with slug '${input.slug}' already exists in taxonomy '${taxonomyName}'`,
+					message: `Term '${input.slug}' already exists in '${taxonomyName}' (${locale})`,
 				},
 			};
 		}
@@ -594,15 +928,33 @@ export async function handleTermCreate(
 			return { success: false, error: parentError };
 		}
 
-		const term = await repo.create({
-			name: taxonomyName,
-			slug: input.slug,
-			label: input.label,
-			parentId: parentId ?? undefined,
-			data: input.description ? { description: input.description } : undefined,
-			locale,
-			translationOf: input.translationOf,
-		});
+		const create = (slug: string) =>
+			repo.create({
+				name: taxonomyName,
+				slug,
+				label: input.label,
+				parentId: parentId ?? undefined,
+				data: input.description ? { description: input.description } : undefined,
+				locale,
+				translationOf: input.translationOf,
+			});
+		let term: Awaited<ReturnType<typeof create>> | undefined;
+		let lastSlugConflict: unknown;
+		if (input.slug !== undefined) {
+			term = await create(input.slug);
+		} else {
+			for (let attempt = 0; attempt < MAX_GENERATED_TERM_SLUG_ATTEMPTS; attempt++) {
+				attemptedSlug = await repo.generateUniqueSlug(taxonomyName, input.label, locale);
+				try {
+					term = await create(attemptedSlug);
+					break;
+				} catch (error) {
+					if (!isTermSlugUniqueViolation(error)) throw error;
+					lastSlugConflict = error;
+				}
+			}
+		}
+		if (!term) throw lastSlugConflict ?? new Error("Failed to create taxonomy term");
 
 		invalidateTermCache();
 
@@ -622,7 +974,16 @@ export async function handleTermCreate(
 				},
 			},
 		};
-	} catch {
+	} catch (error) {
+		if (isTermSlugUniqueViolation(error)) {
+			return {
+				success: false,
+				error: {
+					code: "CONFLICT",
+					message: `Term with slug '${attemptedSlug ?? "(generated)"}' already exists in taxonomy '${taxonomyName}'`,
+				},
+			};
+		}
 		return {
 			success: false,
 			error: { code: "TERM_CREATE_ERROR", message: "Failed to create term" },
@@ -656,12 +1017,14 @@ export async function handleTermGet(
 
 		// Count matches public visibility (published or scheduled-and-due, not
 		// soft-deleted) scoped to the def's declared collections. The def lookup
-		// is lenient: a term whose def is missing still resolves, with count 0.
-		const lookup = await requireTaxonomyDef(db, taxonomyName);
+		// falls back for incomplete translations; a term with no def at all still
+		// resolves with count 0.
+		const lookup = await requireTaxonomyDefWithFallback(db, taxonomyName, locale);
 		const counts = await fetchVisibleTermCounts(
 			db,
 			taxonomyName,
 			lookup.success ? defCollections(lookup.def) : [],
+			locale ?? term.locale,
 		);
 		const count = counts.get(term.translationGroup ?? term.id) ?? 0;
 		// Children share this term's translation_group as their parent_id; scope