emdash 0.33.0 → 0.35.0

package/src/database/repositories/revision.ts

@@ -172,28 +172,39 @@ export class RevisionRepository {
 	/**
 	 * Delete old revisions, keeping the most recent N
 	 */
-	async pruneOldRevisions(collection: string, entryId: string, keepCount: number): Promise<number> {
+	async pruneOldRevisions(
+		collection: string,
+		entryId: string,
+		keepCount: number,
+		throughRevisionId?: string,
+	): Promise<number> {
 		validateIdentifier(collection, "collection");
 		const tableName = `ec_${collection}`;
-		// Get IDs of revisions to keep
-		const keep = await this.db
+		let keepQuery = this.db
 			.selectFrom("revisions")
 			.select("id")
 			.where("collection", "=", collection)
 			.where("entry_id", "=", entryId)
 			.orderBy("created_at", "desc")
 			.orderBy("id", "desc") // ULID tiebreaker
-			.limit(keepCount)
-			.execute();
+			.limit(keepCount);
+
+		if (throughRevisionId) {
+			keepQuery = keepQuery.where("id", "<=", throughRevisionId);
+		}
+
+		const keep = await keepQuery.execute();
 
 		const keepIds = keep.map((r) => r.id);
 
 		if (keepIds.length === 0) return 0;
+		const revisionBoundary = throughRevisionId ? sql`AND id <= ${throughRevisionId}` : sql``;
 
 		const result = await sql`
 			DELETE FROM revisions
 			WHERE collection = ${collection}
 			AND entry_id = ${entryId}
+			${revisionBoundary}
 			AND id NOT IN (${sql.join(keepIds.map((id) => sql`${id}`))})
 			AND NOT EXISTS (
 				SELECT 1 FROM ${sql.ref(tableName)} AS content
@@ -211,7 +222,7 @@ export class RevisionRepository {
 		queuedRevisionId: string,
 		keepCount: number,
 	): Promise<number> {
-		const pruned = await this.pruneOldRevisions(collection, entryId, keepCount);
+		const pruned = await this.pruneOldRevisions(collection, entryId, keepCount, queuedRevisionId);
 		await this.db
 			.deleteFrom("_emdash_revision_prune_queue")
 			.where("collection", "=", collection)

package/src/database/repositories/taxonomy.ts

@@ -2,34 +2,11 @@ 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";
 
-/**
- * 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.
- */
-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 EMPTY_DENORM: PivotDenorm = {
-	status: null,
-	scheduled_at: null,
-	deleted_at: null,
-	locale: null,
-	published_at: null,
-	created_at: null,
-};
-
 /** A member of one sibling group and the position it currently holds. */
 export interface SiblingPosition {
 	group: string;
@@ -42,6 +19,7 @@ export interface SiblingPosition {
  * statement inside D1's 100-parameter ceiling.
  */
 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(
@@ -123,16 +101,45 @@ 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
@@ -224,14 +231,36 @@ 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).
 	 *
 	 * `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)`.
+	 * values. Without it the SQL ordering is implementation-defined when they match.
 	 */
 	async findByName(name: string, options: FindOptions = {}): Promise<Taxonomy[]> {
 		let query = this.db
@@ -256,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.
@@ -464,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();
 	}
@@ -503,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);
@@ -517,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.
@@ -527,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);
@@ -540,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));
@@ -550,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())
@@ -576,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;
 	}
 
 	/**

package/src/database/repositories/types.ts

@@ -1,3 +1,4 @@
+import type { ContentFieldFilters } from "../../content-list-query.js";
 import type { CustomFieldValue } from "../../schema/types.js";
 import { encodeBase64, decodeBase64 } from "../../utils/base64.js";
 
@@ -12,6 +13,8 @@ import { encodeBase64, decodeBase64 } from "../../utils/base64.js";
 const MAX_CURSOR_LENGTH = 4096;
 
 export interface CreateContentInput {
+	/** Explicit content ID for stable seed imports. Omit to generate a ULID. */
+	id?: string;
 	type: string;
 	slug?: string | null;
 	data: Record<string, unknown>;
@@ -145,6 +148,34 @@ export interface ContentDateFilter {
 	to?: string;
 }
 
+/**
+ * Byline filter for a content list.
+ *
+ * `mode: "any"` matches entries credited to at least one of `bylineIds`;
+ * `mode: "none"` matches entries with no credit at all.
+ *
+ * `bylineIds` are `translation_group` values — what
+ * `_emdash_content_bylines.byline_id` stores since migration 040 — so a filter
+ * matches a byline across every locale variant.
+ *
+ * By default only explicit credits count. `includeInferred` widens the filter
+ * to the byline the list actually renders, which for an entry with no credits
+ * is the one linked to its `author_id` (see `hydrateBylinesMany`).
+ */
+export interface ContentBylineFilter {
+	mode: "any" | "none";
+	/** Ignored when `mode` is `"none"`. An empty list matches nothing. */
+	bylineIds?: string[];
+	includeInferred?: boolean;
+	/**
+	 * Locale a credit has to resolve at — the locale the list is scoped to.
+	 * Applies to explicit credits as well as inferred ones, since a byline
+	 * group credited to an entry renders only where it has a row at that
+	 * locale. Defaults to each entry's own locale when the list spans locales.
+	 */
+	locale?: string;
+}
+
 export interface FindManyOptions {
 	where?: {
 		status?: string;
@@ -154,8 +185,9 @@ export interface FindManyOptions {
 		q?: string;
 		/**
 		 * Columns the `q` substring filter is applied to (OR'd together).
-		 * Resolved by the handler from the collection's display fields so the
-		 * repository stays generic. Each name is validated as a SQL identifier.
+		 * Resolved by the handler from the collection's display fields, slug,
+		 * and any field marked searchable. Each name is validated as a SQL
+		 * identifier.
 		 */
 		searchColumns?: string[];
 		/**
@@ -168,11 +200,21 @@ export interface FindManyOptions {
 		useFts?: boolean;
 		/** Inclusive date range over a whitelisted timestamp column. */
 		dateFilter?: ContentDateFilter;
+		/** Restrict to entries by their byline credits. */
+		bylineFilter?: ContentBylineFilter;
+		/** AND-combined filters over custom fields explicitly marked as indexed. */
+		fieldFilters?: ContentFieldFilters;
 	};
 	orderBy?: {
 		field: string;
 		direction: "asc" | "desc";
 	};
+	/**
+	 * Extra field slugs allowed as `orderBy` beyond the system columns — the
+	 * collection's configured titleField/dateField. Resolved by the
+	 * handler server-side so `orderBy` stays a closed set per request.
+	 */
+	sortableExtras?: string[];
 	limit?: number;
 	cursor?: string; // Base64-encoded JSON: {orderValue: string, id: string}
 }
@@ -278,6 +320,13 @@ export class EmDashValidationError extends Error {
 	}
 }
 
+export class ContentCollectionNotFoundError extends Error {
+	constructor(collection: string) {
+		super(`Collection '${collection}' not found`);
+		this.name = "ContentCollectionNotFoundError";
+	}
+}
+
 /**
  * Thrown by `publish()` when called with `requireDue` for a row that is no
  * longer due (its `scheduled_at` was cleared or pushed into the future between