emdash 0.32.0 → 0.34.0

package/dist/{taxonomies-Dbdki3Un.mjs → taxonomies-Dk3MAklL.mjs}

@@ -1,55 +1,123 @@
-import { o as __exportAll } from "./runner-BsI18UgP.mjs";
-import { i as resolveConfiguredLocale } from "./config-DyF3OKg_.mjs";
-import { t as TaxonomyRepository } from "./taxonomy-DvwWAPvA.mjs";
-import { f as fetchVisibleTermCounts, l as invalidateTaxonomyDefsCache, u as invalidateTermCache } from "./taxonomies-B61CRSha.mjs";
+import { o as __exportAll } from "./runner-BiDvq5dv.mjs";
+import { a as resolveConfiguredLocale, r as getI18nConfig } from "./config-C3EBstHi.mjs";
+import { t as withTransaction } from "./transaction-NQj4VJ7Z.mjs";
+import { t as TaxonomyRepository } from "./taxonomy-CPeM8d2o.mjs";
+import { f as fetchVisibleTermCounts, l as invalidateTaxonomyDefsCache, u as invalidateTermCache } from "./taxonomies-B0o9ExNV.mjs";
+import { sql } from "kysely";
 import { ulid } from "ulidx";
 
 //#region src/api/handlers/taxonomies.ts
+/**
+* Taxonomy and term CRUD handlers.
+*
+* i18n: terms and defs are per-locale. `(name, slug, locale)` is unique for
+* terms; `(name, locale)` for defs. Translations of the same term/def share a
+* `translation_group`. The content_taxonomies pivot stores translation_groups
+* so assignments span every locale of a post.
+*/
 var taxonomies_exports = /* @__PURE__ */ __exportAll({
 	handleTaxonomyCreate: () => handleTaxonomyCreate,
+	handleTaxonomyDefTranslations: () => handleTaxonomyDefTranslations,
+	handleTaxonomyDelete: () => handleTaxonomyDelete,
+	handleTaxonomyGet: () => handleTaxonomyGet,
 	handleTaxonomyList: () => handleTaxonomyList,
+	handleTaxonomyUpdate: () => handleTaxonomyUpdate,
 	handleTermCreate: () => handleTermCreate,
 	handleTermDelete: () => handleTermDelete,
 	handleTermGet: () => handleTermGet,
 	handleTermList: () => handleTermList,
+	handleTermReorder: () => handleTermReorder,
 	handleTermTranslations: () => handleTermTranslations,
 	handleTermUpdate: () => handleTermUpdate
 });
 const NAME_PATTERN = /^[a-z][a-z0-9_]*$/;
+const MAX_GENERATED_TERM_SLUG_ATTEMPTS = 16;
+function isTermSlugUniqueViolation(error) {
+	const message = error instanceof Error ? error.message.toLowerCase() : "";
+	return (message.includes("unique constraint failed") || message.includes("duplicate key")) && message.includes("slug");
+}
 /**
 * Build tree structure from flat terms
 */
-function buildTree(flatTerms) {
+function buildTree(flatTerms, resolveByGroup = false) {
 	const byLocaleGroup = /* @__PURE__ */ new Map();
 	const roots = [];
-	for (const term of flatTerms) byLocaleGroup.set(`${term.locale}::${term.translationGroup ?? term.id}`, term);
 	for (const term of flatTerms) {
-		const parent = term.parentId ? byLocaleGroup.get(`${term.locale}::${term.parentId}`) : void 0;
+		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(resolveByGroup ? term.parentId : `${term.locale}::${term.parentId}`) : void 0;
 		if (parent) parent.children.push(term);
 		else roots.push(term);
 	}
 	return roots;
 }
-/**
-* Look up a taxonomy definition by name (optionally scoped to a locale).
-* Returns the lowest-locale match when no locale is provided.
-*/
-async function requireTaxonomyDef(db, name, locale) {
-	let query = db.selectFrom("_emdash_taxonomy_defs").selectAll().where("name", "=", name);
-	if (locale !== void 0) query = query.where("locale", "=", locale);
-	const def = await query.orderBy("locale", "asc").executeTakeFirst();
-	if (!def) return {
+function taxonomyDefNotFound(name, locale) {
+	return {
 		success: false,
 		error: {
 			code: "NOT_FOUND",
-			message: `Taxonomy '${name}' not found`
+			message: `Taxonomy '${name}' not found${locale !== void 0 ? ` in locale '${locale}'` : ""}`
 		}
 	};
-	return {
+}
+/** Look up the exact definition addressed by a mutation. */
+async function requireTaxonomyDef(db, name, locale) {
+	let query = db.selectFrom("_emdash_taxonomy_defs").selectAll().where("name", "=", name);
+	if (locale !== void 0) query = query.where("locale", "=", locale);
+	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, name, locale) {
+	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) : void 0) ?? (defaultLocale ? defs.find((candidate) => candidate.locale === defaultLocale) : void 0) ?? 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, slugs) {
+	if (slugs.length === 0) return /* @__PURE__ */ 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, collections) {
+	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, row) {
+	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). */
 function defCollections(def) {
 	const parsed = def.collections ? JSON.parse(def.collections) : [];
@@ -98,11 +166,35 @@ async function handleTaxonomyList(db, options = {}) {
 	}
 }
 /**
+* 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`).
+*/
+async function handleTaxonomyGet(db, name, options = {}) {
+	try {
+		const lookup = await requireTaxonomyDefWithFallback(db, name, options.locale ? resolveConfiguredLocale(options.locale) : void 0);
+		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
 */
 async function handleTaxonomyCreate(db, input) {
 	try {
-		const locale = input.locale ? resolveConfiguredLocale(input.locale) : void 0;
+		const locale = resolveConfiguredLocale(input.locale ?? getI18nConfig()?.defaultLocale ?? "en");
 		if (!NAME_PATTERN.test(input.name)) return {
 			success: false,
 			error: {
@@ -111,18 +203,11 @@ async function handleTaxonomyCreate(db, input) {
 			}
 		};
 		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 = null;
 		if (input.translationOf) {
 			const source = await db.selectFrom("_emdash_taxonomy_defs").selectAll().where("id", "=", input.translationOf).executeTakeFirst();
@@ -135,15 +220,13 @@ async function handleTaxonomyCreate(db, input) {
 			};
 			translationGroup = source.translation_group ?? source.id;
 		}
-		if (locale !== void 0) {
-			if (await db.selectFrom("_emdash_taxonomy_defs").select("id").where("name", "=", input.name).where("locale", "=", locale).executeTakeFirst()) return {
-				success: false,
-				error: {
-					code: "CONFLICT",
-					message: `Taxonomy '${input.name}' already exists in locale '${locale}'`
-				}
-			};
-		}
+		if (await db.selectFrom("_emdash_taxonomy_defs").select("id").where("name", "=", input.name).where("locale", "=", locale).executeTakeFirst()) return {
+			success: false,
+			error: {
+				code: "CONFLICT",
+				message: `Taxonomy '${input.name}' already exists in locale '${locale}'`
+			}
+		};
 		const id = ulid();
 		await db.insertInto("_emdash_taxonomy_defs").values({
 			id,
@@ -152,7 +235,7 @@ async function handleTaxonomyCreate(db, input) {
 			label_singular: input.labelSingular ?? null,
 			hierarchical: input.hierarchical ? 1 : 0,
 			collections: JSON.stringify(collections),
-			...locale !== void 0 ? { locale } : {},
+			locale,
 			translation_group: translationGroup ?? id
 		}).execute();
 		invalidateTaxonomyDefsCache();
@@ -178,16 +261,136 @@ async function handleTaxonomyCreate(db, input) {
 	}
 }
 /**
+* 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`).
+*/
+async function handleTaxonomyUpdate(db, name, input) {
+	try {
+		const lookup = await requireTaxonomyDef(db, name, input.locale ? resolveConfiguredLocale(input.locale) : void 0);
+		if (!lookup.success) return lookup;
+		const collections = input.collections ? [...new Set(input.collections)] : void 0;
+		if (collections !== void 0) {
+			const collectionError = await validateCollections(db, collections);
+			if (collectionError) return {
+				success: false,
+				error: collectionError
+			};
+		}
+		const updates = {};
+		if (input.label !== void 0) updates.label = input.label;
+		if (input.labelSingular !== void 0) updates.label_singular = input.labelSingular;
+		if (input.hierarchical !== void 0) updates.hierarchical = input.hierarchical ? 1 : 0;
+		if (collections !== void 0) 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();
+		}
+		return {
+			success: true,
+			data: await toTaxonomyResponse(db, await db.selectFrom("_emdash_taxonomy_defs").selectAll().where("id", "=", lookup.def.id).executeTakeFirstOrThrow())
+		};
+	} 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.
+*/
+async function handleTaxonomyDelete(db, name) {
+	try {
+		const lookup = await requireTaxonomyDef(db, name);
+		if (!lookup.success) return lookup;
+		await withTransaction(db, async (trx) => {
+			await trx.deleteFrom("content_taxonomies").where("taxonomy_id", "in", (eb) => eb.selectFrom("taxonomies").select(sql`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();
+		});
+		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).
+*/
+async function handleTaxonomyDefTranslations(db, idOrGroup) {
+	try {
+		const anchor = await db.selectFrom("_emdash_taxonomy_defs").selectAll().where((eb) => eb.or([eb("id", "=", idOrGroup), eb("translation_group", "=", idOrGroup)])).executeTakeFirst();
+		if (!anchor) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: "Taxonomy not found"
+			}
+		};
+		const group = anchor.translation_group ?? anchor.id;
+		return {
+			success: true,
+			data: {
+				translationGroup: group,
+				translations: (await db.selectFrom("_emdash_taxonomy_defs").selectAll().where("translation_group", "=", group).orderBy("locale", "asc").execute()).map((r) => ({
+					id: r.id,
+					name: r.name,
+					label: r.label,
+					locale: r.locale
+				}))
+			}
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "TAXONOMY_TRANSLATIONS_ERROR",
+				message: "Failed to list taxonomy translations"
+			}
+		};
+	}
+}
+/**
 * List all terms for a taxonomy (returns tree for hierarchical taxonomies)
 */
 async function handleTermList(db, taxonomyName, options = {}) {
 	try {
-		const lookup = await requireTaxonomyDef(db, taxonomyName);
+		if (options.resolveFallback && !options.locale) return {
+			success: false,
+			error: {
+				code: "VALIDATION_ERROR",
+				message: "A locale is required when resolving taxonomy fallbacks"
+			}
+		};
+		const locale = options.locale ? resolveConfiguredLocale(options.locale) : void 0;
+		const lookup = await requireTaxonomyDefWithFallback(db, taxonomyName, locale);
 		if (!lookup.success) return lookup;
 		const repo = new TaxonomyRepository(db);
-		const locale = options.locale ? resolveConfiguredLocale(options.locale) : void 0;
-		const terms = await repo.findByName(taxonomyName, { locale });
-		const countsByGroup = options.includeCounts ?? true ? await fetchVisibleTermCounts(db, taxonomyName, defCollections(lookup.def)) : void 0;
+		const terms = options.resolveFallback && locale ? await repo.findByNameResolved(taxonomyName, locale, getI18nConfig()?.defaultLocale ?? "en") : await repo.findByName(taxonomyName, { locale });
+		const countsByGroup = options.includeCounts ?? true ? await fetchVisibleTermCounts(db, taxonomyName, defCollections(lookup.def), locale) : void 0;
 		const termData = terms.map((term) => ({
 			id: term.id,
 			name: term.name,
@@ -202,7 +405,7 @@ async function handleTermList(db, taxonomyName, options = {}) {
 		}));
 		return {
 			success: true,
-			data: { terms: lookup.def.hierarchical === 1 ? buildTree(termData) : termData }
+			data: { terms: lookup.def.hierarchical === 1 ? buildTree(termData, options.resolveFallback && !!locale) : termData }
 		};
 	} catch (error) {
 		console.error("[taxonomies] term list failed:", error);
@@ -216,6 +419,85 @@ async function handleTermList(db, taxonomyName, options = {}) {
 	}
 }
 /**
+* 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.
+*/
+async function handleTermReorder(db, taxonomyName, input) {
+	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) {
+			const parent = await repo.findById(parentId);
+			if (parent) parentId = parent.translationGroup ?? parent.id;
+		}
+		const members = await repo.findByName(taxonomyName, { parentId });
+		const siblings = [];
+		const seen = /* @__PURE__ */ new Set();
+		const resolve = /* @__PURE__ */ new Map();
+		for (const term of members) {
+			const group = term.translationGroup ?? term.id;
+			if (!seen.has(group)) {
+				seen.add(group);
+				siblings.push({
+					group,
+					position: term.sortOrder
+				});
+			}
+			resolve.set(group, group);
+			resolve.set(term.id, group);
+		}
+		const groups = [];
+		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.
 *
 * Returns `null` on success or a structured error message that callers
@@ -274,17 +556,18 @@ async function validateParentTerm(repo, taxonomyName, termId, parentId, selfGrou
 * Create a new term in a taxonomy
 */
 async function handleTermCreate(db, taxonomyName, input) {
+	let attemptedSlug = input.slug;
 	try {
-		const locale = input.locale ? resolveConfiguredLocale(input.locale) : void 0;
+		const locale = resolveConfiguredLocale(input.locale ?? getI18nConfig()?.defaultLocale ?? "en");
 		const lookup = await requireTaxonomyDef(db, taxonomyName);
 		if (!lookup.success) return lookup;
 		const repo = new TaxonomyRepository(db);
 		const parentId = input.parentId === "" || input.parentId === void 0 ? void 0 : input.parentId;
-		if (await repo.findBySlug(taxonomyName, input.slug, locale)) return {
+		if (input.slug === void 0 ? null : await repo.findBySlug(taxonomyName, input.slug, locale)) 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})`
 			}
 		};
 		let selfGroup = null;
@@ -297,15 +580,29 @@ async function handleTermCreate(db, taxonomyName, input) {
 			success: false,
 			error: parentError
 		};
-		const term = await repo.create({
+		const create = (slug) => repo.create({
 			name: taxonomyName,
-			slug: input.slug,
+			slug,
 			label: input.label,
 			parentId: parentId ?? void 0,
 			data: input.description ? { description: input.description } : void 0,
 			locale,
 			translationOf: input.translationOf
 		});
+		let term;
+		let lastSlugConflict;
+		if (input.slug !== void 0) 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 ?? /* @__PURE__ */ new Error("Failed to create taxonomy term");
 		invalidateTermCache();
 		return {
 			success: true,
@@ -320,7 +617,14 @@ async function handleTermCreate(db, taxonomyName, input) {
 				translationGroup: term.translationGroup
 			} }
 		};
-	} 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: {
@@ -345,8 +649,8 @@ async function handleTermGet(db, taxonomyName, termSlug, options = {}) {
 				message: `Term '${termSlug}' not found in taxonomy '${taxonomyName}'`
 			}
 		};
-		const lookup = await requireTaxonomyDef(db, taxonomyName);
-		const count = (await fetchVisibleTermCounts(db, taxonomyName, lookup.success ? defCollections(lookup.def) : [])).get(term.translationGroup ?? term.id) ?? 0;
+		const lookup = await requireTaxonomyDefWithFallback(db, taxonomyName, locale);
+		const count = (await fetchVisibleTermCounts(db, taxonomyName, lookup.success ? defCollections(lookup.def) : [], locale ?? term.locale)).get(term.translationGroup ?? term.id) ?? 0;
 		const children = await repo.findChildren(term.id, term.locale);
 		return {
 			success: true,
@@ -526,5 +830,5 @@ async function handleTermDelete(db, taxonomyName, termSlug, options = {}) {
 }
 
 //#endregion
-export { handleTermGet as a, handleTermUpdate as c, handleTermDelete as i, taxonomies_exports as l, handleTaxonomyList as n, handleTermList as o, handleTermCreate as r, handleTermTranslations as s, handleTaxonomyCreate as t };
-//# sourceMappingURL=taxonomies-Dbdki3Un.mjs.map
+export { handleTaxonomyList as a, handleTermDelete as c, handleTermReorder as d, handleTermTranslations as f, handleTaxonomyGet as i, handleTermGet as l, taxonomies_exports as m, handleTaxonomyDefTranslations as n, handleTaxonomyUpdate as o, handleTermUpdate as p, handleTaxonomyDelete as r, handleTermCreate as s, handleTaxonomyCreate as t, handleTermList as u };
+//# sourceMappingURL=taxonomies-Dk3MAklL.mjs.map