emdash 0.32.0 → 0.34.0

package/src/database/repositories/taxonomy.ts

@@ -2,32 +2,63 @@ import { sql, type Kysely, type Selectable } from "kysely";
 import { ulid } from "ulidx";
 
 import { invalidateTaxonomyObjectCache } from "../../object-cache/index.js";
-import { isMissingTableError } from "../../utils/db-errors.js";
+import { slugify } from "../../utils/slugify.js";
+import { withTransaction } from "../transaction.js";
 import type { Database, TaxonomyTable } from "../types.js";
 import { validateIdentifier } from "../validate.js";
 
+/** A member of one sibling group and the position it currently holds. */
+export interface SiblingPosition {
+	group: string;
+	position: number;
+}
+
 /**
- * Filter + sort columns denormalized from an entry's `ec_*` row onto its
- * `content_taxonomies` pivot rows (migration 051). Stamped at insert time so a
- * newly-tagged entry is immediately seekable by a taxonomy-filtered listing.
+ * Translation groups per reorder `UPDATE`. Each costs three bound parameters —
+ * a CASE `WHEN`/`THEN` pair plus one slot in the `IN` list — which keeps a
+ * statement inside D1's 100-parameter ceiling.
  */
-interface PivotDenorm {
-	status: string | null;
-	scheduled_at: string | null;
-	deleted_at: string | null;
-	locale: string | null;
-	published_at: string | null;
-	created_at: string | null;
+const GROUPS_PER_UPDATE = 32;
+const NUMERIC_SUFFIX_PATTERN = /^\d+$/;
+
+/** Deal the listed groups back out over the slots they hold, in the order given. */
+function permuteWithinSlots(
+	listed: readonly string[],
+	occupied: readonly number[],
+): Map<string, number> {
+	const slots = occupied.toSorted((a, b) => a - b);
+	const target = new Map<string, number>();
+	listed.forEach((group, index) => {
+		const position = slots[index];
+		if (position !== undefined) target.set(group, position);
+	});
+	return target;
 }
 
-const EMPTY_DENORM: PivotDenorm = {
-	status: null,
-	scheduled_at: null,
-	deleted_at: null,
-	locale: null,
-	published_at: null,
-	created_at: null,
-};
+/**
+ * Renumber a whole sibling group 0..n-1, with the listed groups in the order
+ * given and every other member left in the place it already held.
+ *
+ * Works off each member's index in the sequence rather than its stored value,
+ * which is what lets it resolve positions that tie. The sort is stable, so
+ * tied members keep the order `siblings` arrives in — deterministic, but a
+ * listing that mixes locales breaks a tie on whichever locale's label sorts
+ * first, not on the order any one caller rendered.
+ */
+function renumberSiblings(
+	listed: readonly string[],
+	siblings: readonly SiblingPosition[],
+): Map<string, number> {
+	const sequence = siblings.toSorted((a, b) => a.position - b.position);
+	const wanted = new Set(listed);
+	const target = new Map<string, number>();
+	let next = 0;
+	sequence.forEach(({ group }, index) => {
+		const replacement = wanted.has(group) ? listed[next++] : undefined;
+		target.set(replacement ?? group, index);
+	});
+	return target;
+}
 
 export interface Taxonomy {
 	id: string;
@@ -38,6 +69,11 @@ export interface Taxonomy {
 	data: Record<string, unknown> | null;
 	locale: string;
 	translationGroup: string | null;
+	/**
+	 * Position among siblings. Shared by every row of a `translation_group` —
+	 * a term sits in the same place in every locale it is translated into.
+	 */
+	sortOrder: number;
 }
 
 export interface CreateTaxonomyInput {
@@ -65,16 +101,51 @@ export interface FindOptions {
 	locale?: string;
 }
 
+export interface TaxonomyManualPageCursor {
+	sortOrder: number;
+	label: string;
+	id: string;
+}
+
+export interface TaxonomyPageOptions extends FindOptions {
+	cursor?: TaxonomyManualPageCursor;
+	limit?: number;
+}
+
+export interface TaxonomyPage {
+	items: Taxonomy[];
+	hasMore: boolean;
+}
+
+export interface TaxonomyAssignmentTranslation {
+	id: string;
+	slug: string;
+	locale: string;
+}
+
+export interface TaxonomyAssignmentResolution {
+	translationGroup: string;
+	term: Taxonomy | null;
+	availableLocales: string[];
+	translations: TaxonomyAssignmentTranslation[];
+}
+
 /**
  * Taxonomy repository for categories, tags, and other classification.
  *
  * Terms are per-locale. Translations of the same term share a `translation_group`
- * ULID. `content_taxonomies.taxonomy_id` stores the translation_group so a single
- * association spans every locale of a post.
+ * ULID. `content_taxonomies` stores translation_groups on both sides so a single
+ * association spans every locale of a post and term.
  *
- * The repository does not resolve locale fallbacks on its own — callers supply
- * the locale they want. Runtime helpers and handlers use `getFallbackChain()`
- * from `i18n/config` when they need fallback behaviour.
+ * Strict lookup methods use only the locale callers supply. The explicitly
+ * resolved methods accept both the preferred and default locales so their
+ * fallback policy stays visible at the call site.
+ *
+ * `sort_order` is per translation_group, not per row: every row sharing a
+ * translation_group carries the same value, so a term holds one position across
+ * all its locales. Sibling groups are keyed on the raw `parent_id` column, which
+ * is locale-agnostic for the same reason (it stores the parent's
+ * translation_group). Writes must preserve both invariants.
  */
 export class TaxonomyRepository {
 	constructor(private db: Kysely<Database>) {}
@@ -98,10 +169,17 @@ export class TaxonomyRepository {
 		const parentId = parentInput ? await this.resolveParentRef(parentInput) : null;
 
 		let translationGroup = id;
+		let sortOrder: number | null = null;
 		if (input.translationOf) {
 			const source = await this.findById(input.translationOf);
 			if (source?.translationGroup) translationGroup = source.translationGroup;
+			// A translation is the same term in another locale, so it takes the
+			// group's position — but only while it stays in the group that position
+			// belongs to. Landing under a different parent makes it a new member of
+			// that sibling group, and the source's position means nothing there.
+			if (source && source.parentId === parentId) sortOrder = source.sortOrder;
 		}
+		sortOrder ??= await this.nextSortOrder(input.name, parentId);
 
 		await this.db
 			.insertInto("taxonomies")
@@ -112,6 +190,7 @@ export class TaxonomyRepository {
 				label: input.label,
 				parent_id: parentId,
 				data: input.data ? JSON.stringify(input.data) : null,
+				sort_order: sortOrder,
 				// When omitted, the DB DEFAULT 'en' is used — keeps behaviour
 				// consistent with ContentRepository and lets higher layers
 				// supply an explicit locale from request context.
@@ -152,18 +231,43 @@ export class TaxonomyRepository {
 		return row ? this.rowToTaxonomy(row) : null;
 	}
 
+	/** Generate a locale-scoped term slug, adding a numeric suffix when needed. */
+	async generateUniqueSlug(name: string, text: string, locale?: string): Promise<string> {
+		const baseSlug = slugify(text);
+		let query = this.db
+			.selectFrom("taxonomies")
+			.select("slug")
+			.where("name", "=", name)
+			.where((eb) => eb.or([eb("slug", "=", baseSlug), eb("slug", "like", `${baseSlug}-%`)]));
+		if (locale !== undefined) query = query.where("locale", "=", locale);
+		const candidates = await query.execute();
+		if (!candidates.some((candidate) => candidate.slug === baseSlug)) return baseSlug;
+
+		let maxSuffix = 0;
+		const prefix = `${baseSlug}-`;
+		for (const candidate of candidates) {
+			if (!candidate.slug.startsWith(prefix)) continue;
+			const suffix = candidate.slug.slice(prefix.length);
+			if (!NUMERIC_SUFFIX_PATTERN.test(suffix)) continue;
+			maxSuffix = Math.max(maxSuffix, Number.parseInt(suffix, 10));
+		}
+		return `${baseSlug}-${maxSuffix + 1}`;
+	}
+
 	/**
 	 * Get all terms for a taxonomy (e.g., all categories).
 	 *
-	 * `id asc` is a stable tiebreaker for terms that share a label. Without it
-	 * the SQL ordering is implementation-defined when labels match, which
-	 * breaks keyset pagination over `(label, id)`.
+	 * `sort_order` carries the manual order set from the admin; it is 0 for
+	 * terms nobody has reordered, so an untouched taxonomy still comes back
+	 * alphabetically. `id asc` is a stable tiebreaker for terms that share both
+	 * values. Without it the SQL ordering is implementation-defined when they match.
 	 */
 	async findByName(name: string, options: FindOptions = {}): Promise<Taxonomy[]> {
 		let query = this.db
 			.selectFrom("taxonomies")
 			.selectAll()
 			.where("name", "=", name)
+			.orderBy("sort_order", "asc")
 			.orderBy("label", "asc")
 			.orderBy("id", "asc");
 
@@ -181,6 +285,71 @@ export class TaxonomyRepository {
 		return rows.map((row) => this.rowToTaxonomy(row));
 	}
 
+	async findByNameResolved(
+		name: string,
+		locale: string,
+		defaultLocale: string,
+	): Promise<Taxonomy[]> {
+		const locales = [...new Set([locale, defaultLocale])];
+		const rows = await this.db
+			.selectFrom("taxonomies")
+			.selectAll()
+			.where("name", "=", name)
+			.where("locale", "in", locales)
+			.orderBy("sort_order", "asc")
+			.orderBy("label", "asc")
+			.orderBy("id", "asc")
+			.execute();
+
+		const selected = new Map<string, Taxonomy>();
+		for (const row of rows) {
+			const term = this.rowToTaxonomy(row);
+			const group = term.translationGroup ?? term.id;
+			const current = selected.get(group);
+			if (!current || term.locale === locale) selected.set(group, term);
+		}
+		return [...selected.values()].toSorted(
+			(a, b) =>
+				a.sortOrder - b.sortOrder || a.label.localeCompare(b.label) || a.id.localeCompare(b.id),
+		);
+	}
+
+	async findPageByName(name: string, options: TaxonomyPageOptions = {}): Promise<TaxonomyPage> {
+		const limit = Math.max(1, Math.min(options.limit ?? 50, 100));
+		let query = this.db.selectFrom("taxonomies").selectAll().where("name", "=", name);
+
+		if (options.locale !== undefined) query = query.where("locale", "=", options.locale);
+
+		if (options.parentId !== undefined) {
+			query =
+				options.parentId === null
+					? query.where("parent_id", "is", null)
+					: query.where("parent_id", "=", options.parentId);
+		}
+
+		if (options.cursor) {
+			const cursor = options.cursor;
+			query = query.where((eb) =>
+				eb.or([
+					eb("sort_order", ">", cursor.sortOrder),
+					eb.and([eb("sort_order", "=", cursor.sortOrder), eb("label", ">", cursor.label)]),
+					eb.and([
+						eb("sort_order", "=", cursor.sortOrder),
+						eb("label", "=", cursor.label),
+						eb("id", ">", cursor.id),
+					]),
+				]),
+			);
+		}
+		query = query.orderBy("sort_order", "asc").orderBy("label", "asc").orderBy("id", "asc");
+
+		const rows = await query.limit(limit + 1).execute();
+		return {
+			items: rows.slice(0, limit).map((row) => this.rowToTaxonomy(row)),
+			hasMore: rows.length > limit,
+		};
+	}
+
 	/**
 	 * Children of a term. Accepts a term id OR a translation_group and resolves
 	 * to the group, since `parent_id` stores the parent's translation_group.
@@ -196,6 +365,7 @@ export class TaxonomyRepository {
 			.selectFrom("taxonomies")
 			.selectAll()
 			.where("parent_id", "=", group)
+			.orderBy("sort_order", "asc")
 			.orderBy("label", "asc")
 			.orderBy("id", "asc");
 		if (locale !== undefined) query = query.where("locale", "=", locale);
@@ -222,28 +392,146 @@ export class TaxonomyRepository {
 		const existing = await this.findById(id);
 		if (!existing) return null;
 
+		// Per-row display fields. `parent_id` and `sort_order` are not here: both
+		// belong to the translation_group and are written across it below.
 		const updates: Record<string, unknown> = {};
 		if (input.slug !== undefined) updates.slug = input.slug;
 		if (input.label !== undefined) updates.label = input.label;
+		if (input.data !== undefined) updates.data = JSON.stringify(input.data);
+
+		const group: { parent_id?: string | null; sort_order?: number } = {};
 		if (input.parentId !== undefined) {
 			// Defense in depth: empty-string parentId means null (no parent).
 			// Otherwise persist the parent's translation_group (locale-agnostic),
 			// matching create() — see the note there.
-			updates.parent_id =
+			const parentId =
 				input.parentId === "" || input.parentId === null
 					? null
 					: await this.resolveParentRef(input.parentId);
+
+			if (parentId !== existing.parentId) {
+				group.parent_id = parentId;
+				// A position only means anything within one sibling group, so a term
+				// that changes parent is appended to the group it lands in.
+				group.sort_order = await this.nextSortOrder(existing.name, parentId);
+			}
 		}
-		if (input.data !== undefined) updates.data = JSON.stringify(input.data);
 
-		if (Object.keys(updates).length > 0) {
-			await this.db.updateTable("taxonomies").set(updates).where("id", "=", id).execute();
+		const hasRowUpdates = Object.keys(updates).length > 0;
+		const hasGroupUpdates = Object.keys(group).length > 0;
+		if (hasRowUpdates || hasGroupUpdates) {
+			await withTransaction(this.db, async (trx) => {
+				if (hasRowUpdates) {
+					await trx.updateTable("taxonomies").set(updates).where("id", "=", id).execute();
+				}
+				if (hasGroupUpdates) {
+					await trx
+						.updateTable("taxonomies")
+						.set(group)
+						.where("translation_group", "=", existing.translationGroup ?? existing.id)
+						.execute();
+				}
+			});
 			invalidateTaxonomyObjectCache();
 		}
 
 		return this.findById(id);
 	}
 
+	/**
+	 * Move `groups` (translation_groups, in the desired order) into the positions
+	 * those same groups already occupy, leaving every other member of the sibling
+	 * group where it is.
+	 *
+	 * `groups` may be a subset: a locale renders only the terms translated into
+	 * it, so an admin in `fr` often cannot name every member. A group left out
+	 * keeps its place, which is also what makes a stale list harmless.
+	 *
+	 * `siblings` is every member of the group with the position it holds, in a
+	 * listing's order — tied positions are resolved by that order, so pass it as
+	 * read. Groups already at their target are skipped, so one swap rewrites two
+	 * groups rather than the whole list.
+	 */
+	async reorder(groups: string[], siblings: readonly SiblingPosition[]): Promise<void> {
+		const current = new Map(siblings.map(({ group, position }) => [group, position]));
+
+		const listed: string[] = [];
+		const occupied: number[] = [];
+		for (const group of groups) {
+			const position = current.get(group);
+			if (position === undefined) continue;
+			listed.push(group);
+			occupied.push(position);
+		}
+		if (listed.length === 0) return;
+
+		// Tied positions have no distinct order to permute into, so the requested
+		// one would be dropped without a word. Renumbering is the only way to
+		// honour it, and it repairs the tie on the way through.
+		const target =
+			new Set(occupied).size === occupied.length
+				? permuteWithinSlots(listed, occupied)
+				: renumberSiblings(listed, siblings);
+
+		const changed = [...target].filter(([group, position]) => current.get(group) !== position);
+		if (changed.length === 0) return;
+
+		await this.applyPositions(changed);
+
+		invalidateTaxonomyObjectCache();
+	}
+
+	/**
+	 * Write one position per translation_group, GROUPS_PER_UPDATE at a time so
+	 * each statement stays inside D1's parameter ceiling.
+	 *
+	 * D1 has no transactions — `withTransaction` runs its callback bare there —
+	 * so a chunk is the unit that can't tear. A reorder spanning several chunks
+	 * can, and leaves ties, which the next reorder renumbers away.
+	 */
+	private async applyPositions(positions: readonly (readonly [string, number])[]): Promise<void> {
+		for (let index = 0; index < positions.length; index += GROUPS_PER_UPDATE) {
+			const chunk = positions.slice(index, index + GROUPS_PER_UPDATE);
+			// The CAST types the bound position. Postgres resolves a CASE whose THEN
+			// arms are all untyped parameters to text, then refuses to assign text to
+			// an integer column.
+			const arms = sql.join(
+				chunk.map(([group, position]) => sql`WHEN ${group} THEN CAST(${position} AS INTEGER)`),
+				sql` `,
+			);
+			const keys = sql.join(chunk.map(([group]) => sql`${group}`));
+			await sql`
+				UPDATE taxonomies
+				SET sort_order = CASE translation_group ${arms} END
+				WHERE translation_group IN (${keys})
+			`.execute(this.db);
+		}
+	}
+
+	/**
+	 * Position for a term joining a sibling group: one past the last member, or
+	 * 0 when the group is empty.
+	 *
+	 * Bounds are taken across every locale because a position belongs to the
+	 * translation_group, not to a row — a term translated into only one locale
+	 * still occupies its slot for all of them.
+	 */
+	private async nextSortOrder(name: string, parentId: string | null): Promise<number> {
+		let query = this.db
+			.selectFrom("taxonomies")
+			.select((eb) => eb.fn.max("sort_order").as("max"))
+			.where("name", "=", name);
+		query =
+			parentId === null
+				? query.where("parent_id", "is", null)
+				: query.where("parent_id", "=", parentId);
+
+		const bounds = await query.executeTakeFirst();
+		// Null only when the group is empty.
+		if (!bounds || bounds.max === null) return 0;
+		return bounds.max + 1;
+	}
+
 	async delete(id: string): Promise<boolean> {
 		const term = await this.findById(id);
 		if (!term) return false;
@@ -270,30 +558,56 @@ export class TaxonomyRepository {
 		return (result.numDeletedRows ?? 0n) > 0n;
 	}
 
-	// --- Content-Taxonomy Junction (taxonomy_id stores the translation_group) ---
+	// --- Content-Taxonomy Junction (both ids store translation_groups) ---
 
 	async attachToEntry(collection: string, entryId: string, taxonomyId: string): Promise<void> {
-		const group = await this.resolveTranslationGroup(taxonomyId);
-		if (!group) return;
+		const taxonomyGroup = await this.resolveTranslationGroup(taxonomyId);
+		if (!taxonomyGroup) return;
+		await this.attachGroupsToEntry(collection, entryId, [taxonomyGroup]);
+	}
 
-		const denorm = await this.fetchEntryDenorm(collection, entryId);
-		await this.db
+	/**
+	 * Attach already-resolved term translation groups in one insert and return
+	 * the number of assignments that did not already exist.
+	 */
+	async attachGroupsToEntry(
+		collection: string,
+		entryId: string,
+		taxonomyGroups: string[],
+	): Promise<number> {
+		const uniqueGroups = [...new Set(taxonomyGroups)];
+		if (uniqueGroups.length === 0) return 0;
+		const entryGroup = await this.resolveEntryTranslationGroup(collection, entryId);
+		if (!entryGroup) return 0;
+
+		const result = await this.db
 			.insertInto("content_taxonomies")
-			.values({ collection, entry_id: entryId, taxonomy_id: group, ...denorm })
+			.values(
+				uniqueGroups.map((taxonomy_id) => ({
+					collection,
+					entry_id: entryGroup,
+					taxonomy_id,
+				})),
+			)
 			.onConflict((oc) => oc.doNothing())
-			.execute();
-		invalidateTaxonomyObjectCache();
+			.executeTakeFirst();
+		const inserted = Number(result.numInsertedOrUpdatedRows ?? 0n);
+		if (inserted > 0) invalidateTaxonomyObjectCache();
+		return inserted;
 	}
 
 	async detachFromEntry(collection: string, entryId: string, taxonomyId: string): Promise<void> {
-		const group = await this.resolveTranslationGroup(taxonomyId);
-		if (!group) return;
+		const [entryGroup, taxonomyGroup] = await Promise.all([
+			this.resolveEntryTranslationGroup(collection, entryId),
+			this.resolveTranslationGroup(taxonomyId),
+		]);
+		if (!entryGroup || !taxonomyGroup) return;
 
 		await this.db
 			.deleteFrom("content_taxonomies")
 			.where("collection", "=", collection)
-			.where("entry_id", "=", entryId)
-			.where("taxonomy_id", "=", group)
+			.where("entry_id", "=", entryGroup)
+			.where("taxonomy_id", "=", taxonomyGroup)
 			.execute();
 		invalidateTaxonomyObjectCache();
 	}
@@ -309,12 +623,15 @@ export class TaxonomyRepository {
 		taxonomyName?: string,
 		locale?: string,
 	): Promise<Taxonomy[]> {
+		const entryGroup = await this.resolveEntryTranslationGroup(collection, entryId);
+		if (!entryGroup) return [];
+
 		let query = this.db
 			.selectFrom("content_taxonomies")
 			.innerJoin("taxonomies", "taxonomies.translation_group", "content_taxonomies.taxonomy_id")
 			.selectAll("taxonomies")
 			.where("content_taxonomies.collection", "=", collection)
-			.where("content_taxonomies.entry_id", "=", entryId);
+			.where("content_taxonomies.entry_id", "=", entryGroup);
 
 		if (taxonomyName) query = query.where("taxonomies.name", "=", taxonomyName);
 		if (locale !== undefined) query = query.where("taxonomies.locale", "=", locale);
@@ -323,6 +640,53 @@ export class TaxonomyRepository {
 		return rows.map((row) => this.rowToTaxonomy(row));
 	}
 
+	async getTermAssignmentsForEntry(
+		collection: string,
+		entryId: string,
+		taxonomyName: string,
+		locale: string,
+		defaultLocale: string,
+	): Promise<TaxonomyAssignmentResolution[]> {
+		const entryGroup = await this.resolveEntryTranslationGroup(collection, entryId);
+		if (!entryGroup) return [];
+
+		const rows = await this.db
+			.selectFrom("content_taxonomies")
+			.innerJoin("taxonomies", "taxonomies.translation_group", "content_taxonomies.taxonomy_id")
+			.selectAll("taxonomies")
+			.select("content_taxonomies.taxonomy_id as assignment_group")
+			.where("content_taxonomies.collection", "=", collection)
+			.where("content_taxonomies.entry_id", "=", entryGroup)
+			.where("taxonomies.name", "=", taxonomyName)
+			.orderBy("content_taxonomies.taxonomy_id", "asc")
+			.orderBy("taxonomies.locale", "asc")
+			.execute();
+
+		const byGroup = new Map<string, Taxonomy[]>();
+		for (const row of rows) {
+			const variants = byGroup.get(row.assignment_group) ?? [];
+			variants.push(this.rowToTaxonomy(row));
+			byGroup.set(row.assignment_group, variants);
+		}
+
+		return Array.from(byGroup, ([translationGroup, variants]) => {
+			const term =
+				variants.find((variant) => variant.locale === locale) ??
+				variants.find((variant) => variant.locale === defaultLocale) ??
+				null;
+			return {
+				translationGroup,
+				term,
+				availableLocales: variants.map((variant) => variant.locale),
+				translations: variants.map((variant) => ({
+					id: variant.id,
+					slug: variant.slug,
+					locale: variant.locale,
+				})),
+			};
+		});
+	}
+
 	/**
 	 * Replace all assignments of a given taxonomy for one content entry.
 	 * Term ids OR translation_groups are accepted and normalised to groups.
@@ -333,6 +697,9 @@ export class TaxonomyRepository {
 		taxonomyName: string,
 		termIds: string[],
 	): Promise<void> {
+		const entryGroup = await this.resolveEntryTranslationGroup(collection, entryId);
+		if (!entryGroup) return;
+
 		const groups: string[] = [];
 		for (const id of termIds) {
 			const group = await this.resolveTranslationGroup(id);
@@ -346,7 +713,7 @@ export class TaxonomyRepository {
 			.select(["content_taxonomies.taxonomy_id as group"])
 			.distinct()
 			.where("content_taxonomies.collection", "=", collection)
-			.where("content_taxonomies.entry_id", "=", entryId)
+			.where("content_taxonomies.entry_id", "=", entryGroup)
 			.where("taxonomies.name", "=", taxonomyName)
 			.execute();
 		const currentGroups = new Set(current.map((r) => r.group));
@@ -356,22 +723,20 @@ export class TaxonomyRepository {
 			await this.db
 				.deleteFrom("content_taxonomies")
 				.where("collection", "=", collection)
-				.where("entry_id", "=", entryId)
+				.where("entry_id", "=", entryGroup)
 				.where("taxonomy_id", "in", toRemove)
 				.execute();
 		}
 
 		const toAdd = [...newGroups].filter((g) => !currentGroups.has(g));
 		if (toAdd.length > 0) {
-			const denorm = await this.fetchEntryDenorm(collection, entryId);
 			await this.db
 				.insertInto("content_taxonomies")
 				.values(
 					toAdd.map((taxonomy_id) => ({
 						collection,
-						entry_id: entryId,
+						entry_id: entryGroup,
 						taxonomy_id,
-						...denorm,
 					})),
 				)
 				.onConflict((oc) => oc.doNothing())
@@ -382,72 +747,32 @@ export class TaxonomyRepository {
 	}
 
 	async clearEntryTerms(collection: string, entryId: string): Promise<number> {
+		const entryGroup = await this.resolveEntryTranslationGroup(collection, entryId);
+		if (!entryGroup) return 0;
+
 		const result = await this.db
 			.deleteFrom("content_taxonomies")
 			.where("collection", "=", collection)
-			.where("entry_id", "=", entryId)
+			.where("entry_id", "=", entryGroup)
 			.executeTakeFirst();
 		const removed = Number(result.numDeletedRows ?? 0);
 		if (removed > 0) invalidateTaxonomyObjectCache();
 		return removed;
 	}
 
-	/**
-	 * Copy every term assignment from one content entry to another. Used when
-	 * creating a translation of a post so the new translation inherits the
-	 * source's term assignments. Safe to call when the source has no terms.
-	 */
-	async copyEntryTerms(
+	private async resolveEntryTranslationGroup(
 		collection: string,
-		sourceEntryId: string,
-		targetEntryId: string,
-	): Promise<void> {
-		const rows = await this.db
-			.selectFrom("content_taxonomies")
-			.select(["taxonomy_id"])
-			.where("collection", "=", collection)
-			.where("entry_id", "=", sourceEntryId)
-			.execute();
-		if (rows.length === 0) return;
-
-		// Stamp the TARGET entry's current values — the copy inherits the source's
-		// term memberships but the target's own status/dates/locale.
-		const denorm = await this.fetchEntryDenorm(collection, targetEntryId);
-		await this.db
-			.insertInto("content_taxonomies")
-			.values(
-				rows.map((r) => ({
-					collection,
-					entry_id: targetEntryId,
-					taxonomy_id: r.taxonomy_id,
-					...denorm,
-				})),
-			)
-			.onConflict((oc) => oc.doNothing())
-			.execute();
-		invalidateTaxonomyObjectCache();
-	}
-
-	/**
-	 * Read the denormalized filter + sort columns from an entry's `ec_*` row so
-	 * they can be stamped onto new pivot rows (migration 051). A missing table or
-	 * missing row yields all-nulls: the pivot columns are advisory, and the
-	 * listing read path re-checks the authoritative `ec_*` row regardless.
-	 */
-	private async fetchEntryDenorm(collection: string, entryId: string): Promise<PivotDenorm> {
+		entryIdOrGroup: string,
+	): Promise<string | null> {
 		validateIdentifier(collection, "collection type");
 		const tableName = `ec_${collection}`;
-		try {
-			const result = await sql<PivotDenorm>`
-				SELECT status, scheduled_at, deleted_at, locale, published_at, created_at
-				FROM ${sql.ref(tableName)}
-				WHERE id = ${entryId}
-			`.execute(this.db);
-			return result.rows[0] ?? EMPTY_DENORM;
-		} catch (error) {
-			if (isMissingTableError(error)) return EMPTY_DENORM;
-			throw error;
-		}
+		const result = await sql<{ translation_group: string }>`
+			SELECT translation_group
+			FROM ${sql.ref(tableName)}
+			WHERE id = ${entryIdOrGroup} OR translation_group = ${entryIdOrGroup}
+			LIMIT 1
+		`.execute(this.db);
+		return result.rows[0]?.translation_group ?? null;
 	}
 
 	/**
@@ -543,6 +868,7 @@ export class TaxonomyRepository {
 			data: row.data ? JSON.parse(row.data) : null,
 			locale: row.locale,
 			translationGroup: row.translation_group,
+			sortOrder: row.sort_order,
 		};
 	}
 }