emdash 0.31.1 → 0.33.0

package/src/database/repositories/media.ts

@@ -85,6 +85,9 @@ export interface FindManyMediaOptions {
 	q?: string;
 }
 
+const UPLOAD_ATTEMPT_CLEANUP_AGE_MS = 60 * 60 * 1000;
+const UPLOAD_ATTEMPT_CLEANUP_BATCH_SIZE = 100;
+
 /**
  * Media repository for database operations
  */
@@ -138,6 +141,129 @@ export class MediaRepository {
 		});
 	}
 
+	async createUploadAttempt(mediaId: string, storageKey: string): Promise<void> {
+		const now = new Date().toISOString();
+		await this.db
+			.insertInto("_emdash_media_upload_attempts")
+			.values({
+				media_id: mediaId,
+				storage_key: storageKey,
+				status: "active",
+				created_at: now,
+				updated_at: now,
+			})
+			.execute();
+	}
+
+	async hasUploadAttempt(storageKey: string): Promise<boolean> {
+		const row = await this.db
+			.selectFrom("_emdash_media_upload_attempts")
+			.select("storage_key")
+			.where("storage_key", "=", storageKey)
+			.executeTakeFirst();
+		return row !== undefined;
+	}
+
+	async claimUploadAttemptForCleanup(storageKey: string): Promise<boolean> {
+		const result = await this.db
+			.updateTable("_emdash_media_upload_attempts")
+			.set({ status: "cleanup", updated_at: new Date().toISOString() })
+			.where("storage_key", "=", storageKey)
+			.where((eb) =>
+				eb.not(
+					eb.exists(
+						eb
+							.selectFrom("media")
+							.select("media.id")
+							.whereRef("media.storage_key", "=", "_emdash_media_upload_attempts.storage_key"),
+					),
+				),
+			)
+			.executeTakeFirst();
+
+		return Number(result.numUpdatedRows ?? 0) > 0;
+	}
+
+	async deleteUploadAttempt(storageKey: string): Promise<void> {
+		await this.db
+			.deleteFrom("_emdash_media_upload_attempts")
+			.where("storage_key", "=", storageKey)
+			.execute();
+	}
+
+	async deleteCompletedUploadAttempts(): Promise<number> {
+		const result = await this.db
+			.deleteFrom("_emdash_media_upload_attempts")
+			.where((eb) =>
+				eb.exists(
+					eb
+						.selectFrom("media")
+						.select("media.id")
+						.whereRef("media.id", "=", "_emdash_media_upload_attempts.media_id")
+						.whereRef("media.storage_key", "=", "_emdash_media_upload_attempts.storage_key")
+						.where("media.status", "=", "ready"),
+				),
+			)
+			.executeTakeFirst();
+		return Number(result.numDeletedRows ?? 0);
+	}
+
+	async findUploadAttemptsForCleanup(
+		maxAgeMs: number = UPLOAD_ATTEMPT_CLEANUP_AGE_MS,
+		limit: number = UPLOAD_ATTEMPT_CLEANUP_BATCH_SIZE,
+	): Promise<string[]> {
+		const cutoff = new Date(Date.now() - maxAgeMs).toISOString();
+		const rows = await this.db
+			.selectFrom("_emdash_media_upload_attempts")
+			.select("storage_key")
+			.where((eb) => eb.or([eb("status", "=", "cleanup"), eb("created_at", "<", cutoff)]))
+			.where((eb) =>
+				eb.not(
+					eb.exists(
+						eb
+							.selectFrom("media")
+							.select("media.id")
+							.whereRef("media.storage_key", "=", "_emdash_media_upload_attempts.storage_key"),
+					),
+				),
+			)
+			.orderBy("created_at", "asc")
+			.limit(limit)
+			.execute();
+
+		return rows.map((row) => row.storage_key);
+	}
+
+	async publishPendingStorageKey(
+		id: string,
+		expectedStorageKey: string,
+		storageKey: string,
+		contentHash?: string,
+	): Promise<boolean> {
+		const result = await this.db
+			.updateTable("media")
+			.set({
+				storage_key: storageKey,
+				...(contentHash !== undefined ? { content_hash: contentHash } : {}),
+			})
+			.where("id", "=", id)
+			.where("status", "=", "pending")
+			.where("storage_key", "=", expectedStorageKey)
+			.where((eb) =>
+				eb.exists(
+					eb
+						.selectFrom("_emdash_media_upload_attempts")
+						.select("storage_key")
+						.where("media_id", "=", id)
+						.where("storage_key", "=", storageKey)
+						.where("status", "=", "active"),
+				),
+			)
+			.executeTakeFirst();
+
+		return Number(result.numUpdatedRows ?? 0) > 0;
+	}
+
 	/**
 	 * Confirm upload (mark as ready)
 	 */
@@ -149,13 +275,10 @@ export class MediaRepository {
 			size?: number;
 			blurhash?: string;
 			dominantColor?: string;
+			contentHash?: string | null;
 		},
+		expectedStorageKey?: string,
 	): Promise<MediaItem | null> {
-		const existing = await this.findById(id);
-		if (!existing) {
-			return null;
-		}
-
 		const updates: Partial<MediaRow> = {
 			status: "ready",
 		};
@@ -164,24 +287,33 @@ export class MediaRepository {
 		if (metadata?.size !== undefined) updates.size = metadata.size;
 		if (metadata?.blurhash !== undefined) updates.blurhash = metadata.blurhash;
 		if (metadata?.dominantColor !== undefined) updates.dominant_color = metadata.dominantColor;
+		if (metadata?.contentHash !== undefined) updates.content_hash = metadata.contentHash;
 
-		await this.db.updateTable("media").set(updates).where("id", "=", id).execute();
+		let query = this.db
+			.updateTable("media")
+			.set(updates)
+			.where("id", "=", id)
+			.where("status", "=", "pending");
+		if (expectedStorageKey !== undefined) {
+			query = query.where("storage_key", "=", expectedStorageKey);
+		}
 
-		return this.findById(id);
+		const row = await query.returningAll().executeTakeFirst();
+
+		return row ? this.rowToItem(row) : null;
 	}
 
 	/**
 	 * Mark upload as failed
 	 */
-	async markFailed(id: string): Promise<MediaItem | null> {
-		const existing = await this.findById(id);
-		if (!existing) {
-			return null;
+	async markFailed(id: string, expectedStorageKey?: string): Promise<MediaItem | null> {
+		let query = this.db.updateTable("media").set({ status: "failed" }).where("id", "=", id);
+		if (expectedStorageKey !== undefined) {
+			query = query.where("status", "=", "pending").where("storage_key", "=", expectedStorageKey);
 		}
 
-		await this.db.updateTable("media").set({ status: "failed" }).where("id", "=", id).execute();
-
-		return this.findById(id);
+		const row = await query.returningAll().executeTakeFirst();
+		return row ? this.rowToItem(row) : null;
 	}
 
 	/**
@@ -319,10 +451,18 @@ export class MediaRepository {
 	/**
 	 * Delete media item
 	 */
-	async delete(id: string): Promise<boolean> {
-		const result = await this.db.deleteFrom("media").where("id", "=", id).executeTakeFirst();
+	async deleteWithStorageKey(id: string): Promise<string | null> {
+		const deleted = await this.db
+			.deleteFrom("media")
+			.where("id", "=", id)
+			.returning("storage_key")
+			.executeTakeFirst();
+		if (deleted) return deleted.storage_key;
+		return null;
+	}
 
-		return (result.numDeletedRows ?? 0) > 0;
+	async delete(id: string): Promise<boolean> {
+		return (await this.deleteWithStorageKey(id)) !== null;
 	}
 
 	/**
@@ -350,21 +490,11 @@ export class MediaRepository {
 	async cleanupPendingUploads(maxAgeMs: number = 60 * 60 * 1000): Promise<string[]> {
 		const cutoff = new Date(Date.now() - maxAgeMs).toISOString();
 
-		// Select the storage keys first -- SQLite doesn't support RETURNING
-		// on DELETE in all drivers, and Kysely's RETURNING isn't universal.
 		const rows = await this.db
-			.selectFrom("media")
-			.select("storage_key")
-			.where("status", "=", "pending")
-			.where("created_at", "<", cutoff)
-			.execute();
-
-		if (rows.length === 0) return [];
-
-		await this.db
 			.deleteFrom("media")
 			.where("status", "=", "pending")
 			.where("created_at", "<", cutoff)
+			.returning("storage_key")
 			.execute();
 
 		return rows.map((r) => r.storage_key);

package/src/database/repositories/revision.ts

@@ -1,7 +1,8 @@
-import type { Kysely } from "kysely";
+import { sql, type Kysely } from "kysely";
 import { monotonicFactory } from "ulidx";
 
 import type { Database, RevisionTable } from "../types.js";
+import { validateIdentifier } from "../validate.js";
 
 const monotonic = monotonicFactory();
 
@@ -50,6 +51,26 @@ export class RevisionRepository {
 		if (!revision) {
 			throw new Error("Failed to create revision");
 		}
+
+		try {
+			await this.db
+				.insertInto("_emdash_revision_prune_queue")
+				.values({
+					collection: input.collection,
+					entry_id: input.entryId,
+					revision_id: id,
+				})
+				.onConflict((conflict) =>
+					conflict.columns(["collection", "entry_id"]).doUpdateSet({ revision_id: id }),
+				)
+				.execute();
+		} catch (error) {
+			console.error(
+				`[revisions] Failed to queue revision pruning for ${input.collection}/${input.entryId}:`,
+				error,
+			);
+		}
+
 		return revision;
 	}
 
@@ -132,6 +153,19 @@ export class RevisionRepository {
 			.where("entry_id", "=", entryId)
 			.executeTakeFirst();
 
+		try {
+			await this.db
+				.deleteFrom("_emdash_revision_prune_queue")
+				.where("collection", "=", collection)
+				.where("entry_id", "=", entryId)
+				.execute();
+		} catch (error) {
+			console.error(
+				`[revisions] Failed to clear queued revision pruning for ${collection}/${entryId}:`,
+				error,
+			);
+		}
+
 		return Number(result.numDeletedRows ?? 0);
 	}
 
@@ -139,6 +173,8 @@ export class RevisionRepository {
 	 * Delete old revisions, keeping the most recent N
 	 */
 	async pruneOldRevisions(collection: string, entryId: string, keepCount: number): Promise<number> {
+		validateIdentifier(collection, "collection");
+		const tableName = `ec_${collection}`;
 		// Get IDs of revisions to keep
 		const keep = await this.db
 			.selectFrom("revisions")
@@ -154,27 +190,56 @@ export class RevisionRepository {
 
 		if (keepIds.length === 0) return 0;
 
-		// Delete everything else for this entry
-		const result = await this.db
-			.deleteFrom("revisions")
-			.where("collection", "=", collection)
-			.where("entry_id", "=", entryId)
-			.where("id", "not in", keepIds)
-			.executeTakeFirst();
+		const result = await sql`
+			DELETE FROM revisions
+			WHERE collection = ${collection}
+			AND entry_id = ${entryId}
+			AND id NOT IN (${sql.join(keepIds.map((id) => sql`${id}`))})
+			AND NOT EXISTS (
+				SELECT 1 FROM ${sql.ref(tableName)} AS content
+				WHERE content.live_revision_id = revisions.id
+				OR content.draft_revision_id = revisions.id
+			)
+		`.execute(this.db);
 
-		return Number(result.numDeletedRows ?? 0);
+		return Number(result.numAffectedRows ?? 0);
 	}
 
-	/**
-	 * Update revision data in place
-	 * Used for autosave to avoid creating many small revisions.
-	 */
-	async updateData(id: string, data: Record<string, unknown>): Promise<void> {
+	async pruneQueuedEntry(
+		collection: string,
+		entryId: string,
+		queuedRevisionId: string,
+		keepCount: number,
+	): Promise<number> {
+		const pruned = await this.pruneOldRevisions(collection, entryId, keepCount);
 		await this.db
-			.updateTable("revisions")
-			.set({ data: JSON.stringify(data) })
-			.where("id", "=", id)
+			.deleteFrom("_emdash_revision_prune_queue")
+			.where("collection", "=", collection)
+			.where("entry_id", "=", entryId)
+			.where("revision_id", "=", queuedRevisionId)
 			.execute();
+		return pruned;
+	}
+
+	async deleteIfUnreferenced(
+		collection: string,
+		entryId: string,
+		revisionId: string,
+	): Promise<boolean> {
+		validateIdentifier(collection, "collection");
+		const tableName = `ec_${collection}`;
+		const result = await sql`
+			DELETE FROM revisions
+			WHERE id = ${revisionId}
+			AND collection = ${collection}
+			AND entry_id = ${entryId}
+			AND NOT EXISTS (
+				SELECT 1 FROM ${sql.ref(tableName)} AS content
+				WHERE content.live_revision_id = revisions.id
+				OR content.draft_revision_id = revisions.id
+			)
+		`.execute(this.db);
+		return (result.numAffectedRows ?? 0n) > 0n;
 	}
 
 	/**

package/src/database/repositories/taxonomy.ts

@@ -3,6 +3,7 @@ import { ulid } from "ulidx";
 
 import { invalidateTaxonomyObjectCache } from "../../object-cache/index.js";
 import { isMissingTableError } from "../../utils/db-errors.js";
+import { withTransaction } from "../transaction.js";
 import type { Database, TaxonomyTable } from "../types.js";
 import { validateIdentifier } from "../validate.js";
 
@@ -29,6 +30,58 @@ const EMPTY_DENORM: PivotDenorm = {
 	created_at: null,
 };
 
+/** A member of one sibling group and the position it currently holds. */
+export interface SiblingPosition {
+	group: string;
+	position: number;
+}
+
+/**
+ * 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.
+ */
+const GROUPS_PER_UPDATE = 32;
+
+/** 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;
+}
+
+/**
+ * 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;
 	name: string;
@@ -38,6 +91,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 {
@@ -75,6 +133,12 @@ export interface FindOptions {
  * 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.
+ *
+ * `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 +162,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 +183,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.
@@ -155,15 +227,18 @@ export class TaxonomyRepository {
 	/**
 	 * 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
+	 * — without it the SQL ordering is implementation-defined when they match,
+	 * which breaks keyset pagination over `(label, id)`.
 	 */
 	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");
 
@@ -196,6 +271,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 +298,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;
@@ -543,6 +737,7 @@ export class TaxonomyRepository {
 			data: row.data ? JSON.parse(row.data) : null,
 			locale: row.locale,
 			translationGroup: row.translation_group,
+			sortOrder: row.sort_order,
 		};
 	}
 }

package/src/database/repositories/types.ts

@@ -290,3 +290,10 @@ export class ScheduledNotDueError extends Error {
 		this.name = "ScheduledNotDueError";
 	}
 }
+
+export class ContentMutationConflictError extends Error {
+	constructor(message = "Content changed while the operation was in progress") {
+		super(message);
+		this.name = "ContentMutationConflictError";
+	}
+}