emdash 0.32.0 → 0.34.0

package/src/seed/apply.ts

@@ -30,6 +30,7 @@ import type {
 	SeedFile,
 	SeedApplyOptions,
 	SeedApplyResult,
+	SeedCollection,
 	SeedTaxonomyTerm,
 	SeedMenuItem,
 	SeedWidget,
@@ -37,6 +38,21 @@ import type {
 	SeedBylineAvatar,
 } from "./types.js";
 
+/**
+ * Set a collection's `titleField`/`dateField`: a separate write run after the
+ * fields exist, so `updateCollection` can validate them. No-op when neither is set.
+ */
+async function applyDisplayDateFields(
+	registry: SchemaRegistry,
+	collection: SeedCollection,
+): Promise<void> {
+	if (collection.titleField === undefined && collection.dateField === undefined) return;
+	await registry.updateCollection(collection.slug, {
+		titleField: collection.titleField,
+		dateField: collection.dateField,
+	});
+}
+
 const FILE_EXTENSION_PATTERN = /\.([a-z0-9]+)(?:\?|$)/i;
 import { validateSeed } from "./validate.js";
 
@@ -177,8 +193,12 @@ export async function applySeed(
 						labelSingular: collection.labelSingular,
 						description: collection.description,
 						icon: collection.icon,
+						admin: collection.admin,
 						supports: collection.supports || [],
 						urlPattern: collection.urlPattern,
+						routable: collection.routable,
+						hidden: collection.hidden,
+						sortOrder: collection.sortOrder,
 						commentsEnabled: collection.commentsEnabled,
 					});
 					result.collections.updated++;
@@ -193,6 +213,7 @@ export async function applySeed(
 								required: field.required || false,
 								unique: field.unique || false,
 								searchable: field.searchable || false,
+								indexed: field.indexed || false,
 								defaultValue: field.defaultValue,
 								validation: field.validation,
 								widget: field.widget,
@@ -207,6 +228,7 @@ export async function applySeed(
 								required: field.required || false,
 								unique: field.unique || false,
 								searchable: field.searchable || false,
+								indexed: field.indexed || false,
 								defaultValue: field.defaultValue,
 								validation: field.validation,
 								widget: field.widget,
@@ -215,6 +237,9 @@ export async function applySeed(
 							result.fields.created++;
 						}
 					}
+
+					// Second write: display/date fields, now that fields exist.
+					await applyDisplayDateFields(registry, collection);
 					continue;
 				}
 
@@ -231,6 +256,7 @@ export async function applySeed(
 				required: field.required || false,
 				unique: field.unique || false,
 				searchable: field.searchable || false,
+				indexed: field.indexed || false,
 				defaultValue: field.defaultValue,
 				validation: field.validation,
 				widget: field.widget,
@@ -245,12 +271,19 @@ export async function applySeed(
 					labelSingular: collection.labelSingular,
 					description: collection.description,
 					icon: collection.icon,
+					admin: collection.admin,
 					supports: collection.supports || [],
 					urlPattern: collection.urlPattern,
+					routable: collection.routable,
+					hidden: collection.hidden,
+					sortOrder: collection.sortOrder,
 					commentsEnabled: collection.commentsEnabled,
 				},
 				fields,
 			);
+			// titleField/dateField reference existing fields, so set them after
+			// the schema exists.
+			await applyDisplayDateFields(registry, collection);
 			result.collections.created++;
 			result.fields.created += fields.length;
 		}
@@ -456,23 +489,31 @@ export async function applySeed(
 	// 7. Content (created before menus so refs can resolve)
 	if (includeContent && seed.content) {
 		const contentRepo = new ContentRepository(db);
+		const schemaRegistry = new SchemaRegistry(db);
 
 		try {
 			// Create content entries
 			for (const [collectionSlug, entries] of Object.entries(seed.content)) {
+				const collectionRoutable =
+					(await schemaRegistry.getCollection(collectionSlug))?.routable !== false;
 				for (const entry of entries) {
+					const entrySlug =
+						typeof entry.slug === "string" && entry.slug.trim().length > 0 ? entry.slug : null;
 					// Resolve the entry's locale up front so a non-`en` single-locale
 					// export (which omits `locale`) is filed under the project default
 					// rather than `en` (#1421).
 					const entryLocale = resolveConfiguredLocale(entry.locale ?? defaultLocale);
 
-					// Check if entry exists (by slug + locale for locale-aware lookup)
-					const existing = await contentRepo.findBySlug(collectionSlug, entry.slug, entryLocale);
+					// Slugful entries use the existing locale-aware key. Slugless seed
+					// entries persist their seed ID, which keeps re-application idempotent.
+					const existing = entrySlug
+						? await contentRepo.findBySlug(collectionSlug, entrySlug, entryLocale)
+						: await contentRepo.findById(collectionSlug, entry.id);
 
 					if (existing) {
 						if (onConflict === "error") {
 							throw new Error(
-								`Conflict: content "${entry.slug}" in "${collectionSlug}" already exists`,
+								`Conflict: content "${entrySlug ?? entry.id}" in "${collectionSlug}" already exists`,
 							);
 						}
 
@@ -523,8 +564,32 @@ export async function applySeed(
 											entryId: existing.id,
 											data: resolvedData,
 										});
-										await trxContentRepo.setDraftRevision(collectionSlug, existing.id, draft.id);
-										await trxContentRepo.publish(collectionSlug, existing.id);
+										try {
+											await trxContentRepo.setDraftRevision(collectionSlug, existing.id, draft.id);
+											await trxContentRepo.publish(
+												collectionSlug,
+												existing.id,
+												undefined,
+												false,
+												undefined,
+												true,
+												collectionRoutable,
+											);
+										} catch (error) {
+											try {
+												await trxRevisionRepo.deleteIfUnreferenced(
+													collectionSlug,
+													existing.id,
+													draft.id,
+												);
+											} catch (cleanupError) {
+												console.error(
+													`[seed] Failed to clean up unstaged revision ${draft.id}:`,
+													cleanupError,
+												);
+											}
+											throw error;
+										}
 									}
 								});
 							} catch (error) {
@@ -570,8 +635,9 @@ export async function applySeed(
 							const trxBylineRepo = new BylineRepository(trx);
 
 							const item = await trxContentRepo.create({
+								...(entrySlug ? {} : { id: entry.id }),
 								type: collectionSlug,
-								slug: entry.slug,
+								slug: entrySlug,
 								status,
 								data: resolvedData,
 								locale: entryLocale,
@@ -593,7 +659,15 @@ export async function applySeed(
 							// revision so the admin UI shows "Unpublish" instead of "Save & Publish"
 							// and `live_revision_id` is populated for downstream queries.
 							if (status === "published") {
-								await trxContentRepo.publish(collectionSlug, item.id);
+								await trxContentRepo.publish(
+									collectionSlug,
+									item.id,
+									undefined,
+									false,
+									undefined,
+									true,
+									collectionRoutable,
+								);
 							}
 
 							return item;
@@ -941,7 +1015,11 @@ async function applyContentBylines(
 	bylineRepo: BylineRepository,
 	collectionSlug: string,
 	contentId: string,
-	entry: { slug: string; bylines?: Array<{ byline: string; roleLabel?: string }> },
+	entry: {
+		id: string;
+		slug?: string | null;
+		bylines?: Array<{ byline: string; roleLabel?: string }>;
+	},
 	seedBylineIdMap: Map<string, string>,
 	isUpdate = false,
 ): Promise<void> {
@@ -966,7 +1044,7 @@ async function applyContentBylines(
 
 	if (credits.length !== entry.bylines.length) {
 		console.warn(
-			`content.${collectionSlug}.${entry.slug}: one or more byline refs could not be resolved`,
+			`content.${collectionSlug}.${entry.slug ?? entry.id}: one or more byline refs could not be resolved`,
 		);
 	}
 
@@ -989,13 +1067,10 @@ async function applyContentTaxonomies(
 	entry: { taxonomies?: Record<string, string[]> },
 	isUpdate: boolean,
 ): Promise<void> {
+	const termRepo = new TaxonomyRepository(db);
 	// In update mode, clear existing taxonomy assignments first
 	if (isUpdate) {
-		await db
-			.deleteFrom("content_taxonomies")
-			.where("collection", "=", collectionSlug)
-			.where("entry_id", "=", contentId)
-			.execute();
+		await termRepo.clearEntryTerms(collectionSlug, contentId);
 	}
 
 	if (!entry.taxonomies) {
@@ -1009,8 +1084,6 @@ async function applyContentTaxonomies(
 	}
 
 	for (const [taxonomyName, termSlugs] of Object.entries(entry.taxonomies)) {
-		const termRepo = new TaxonomyRepository(db);
-
 		for (const termSlug of termSlugs) {
 			const term = await termRepo.findBySlug(taxonomyName, termSlug);
 			if (term) {

package/src/seed/types.ts

@@ -5,7 +5,7 @@
  * collections, fields, menus, settings, taxonomies, redirects, widget areas, and optional sample content.
  */
 
-import type { FieldType } from "../schema/types.js";
+import type { CollectionAdminConfig, FieldType } from "../schema/types.js";
 import type { SiteSettings } from "../settings/types.js";
 import type { Storage } from "../storage/types.js";
 
@@ -72,10 +72,27 @@ export interface SeedCollection {
 	labelSingular?: string;
 	description?: string;
 	icon?: string;
+	admin?: CollectionAdminConfig;
 	supports?: ("drafts" | "revisions" | "preview" | "scheduling" | "search" | "seo")[];
 	urlPattern?: string;
+	/** Require a slug before an entry can be published. Defaults to true. */
+	routable?: boolean;
+	/**
+	 * Omit this collection from the admin sidebar. It stays reachable through
+	 * the API, MCP, plugin hooks, and direct `/content/:collection` URLs.
+	 */
+	hidden?: boolean;
+	/**
+	 * Explicit position in the admin sidebar (ascending). Collections without
+	 * a `sortOrder` keep the alphabetical order and follow the ordered ones.
+	 */
+	sortOrder?: number;
 	/** Enable comments on this collection */
 	commentsEnabled?: boolean;
+	/** Field slug powering the admin list Title column (defaults to title display) */
+	titleField?: string;
+	/** Field slug (a datetime field) powering the admin list Date column (defaults to last-updated) */
+	dateField?: string;
 	fields: SeedField[];
 }
 
@@ -89,6 +106,7 @@ export interface SeedField {
 	required?: boolean;
 	unique?: boolean;
 	searchable?: boolean;
+	indexed?: boolean;
 	defaultValue?: unknown;
 	validation?: Record<string, unknown>;
 	widget?: string;
@@ -253,8 +271,8 @@ export interface SeedContentEntry {
 	/** Seed-local ID for $ref resolution */
 	id: string;
 
-	/** URL slug */
-	slug: string;
+	/** URL slug. May be omitted for entries in non-routable collections. */
+	slug?: string | null;
 
 	/** Publication status */
 	status?: "published" | "draft";

package/src/seed/validate.ts

@@ -5,7 +5,7 @@
  */
 
 import { getI18nConfig, resolveConfiguredLocale } from "../i18n/config.js";
-import { FIELD_TYPES } from "../schema/types.js";
+import { FIELD_TYPES, isIndexableFieldType, MAX_COLLECTION_LIST_COLUMNS } from "../schema/types.js";
 import type { SeedFile, SeedMenuItem, ValidationResult } from "./types.js";
 
 const COLLECTION_FIELD_SLUG_PATTERN = /^[a-z][a-z0-9_]*$/;
@@ -107,6 +107,43 @@ export function validateSeed(data: unknown): ValidationResult {
 				if (!collection.label) {
 					errors.push(`${prefix}: label is required`);
 				}
+				if (collection.routable !== undefined && typeof collection.routable !== "boolean") {
+					errors.push(`${prefix}.routable: must be a boolean`);
+				}
+
+				const declaredFieldSlugs = new Set(
+					Array.isArray(collection.fields)
+						? collection.fields.flatMap((field) =>
+								isRecord(field) && typeof field.slug === "string" ? [field.slug] : [],
+							)
+						: [],
+				);
+
+				if (collection.admin !== undefined) {
+					if (!isRecord(collection.admin)) {
+						errors.push(`${prefix}.admin: must be an object`);
+					} else if (collection.admin.listColumns !== undefined) {
+						if (!Array.isArray(collection.admin.listColumns)) {
+							errors.push(`${prefix}.admin.listColumns: must be an array`);
+						} else {
+							if (collection.admin.listColumns.length > MAX_COLLECTION_LIST_COLUMNS) {
+								errors.push(
+									`${prefix}.admin.listColumns: must contain at most ${MAX_COLLECTION_LIST_COLUMNS} items`,
+								);
+							}
+							for (let j = 0; j < collection.admin.listColumns.length; j++) {
+								const slug = collection.admin.listColumns[j];
+								if (typeof slug !== "string" || !COLLECTION_FIELD_SLUG_PATTERN.test(slug)) {
+									errors.push(`${prefix}.admin.listColumns[${j}]: must be a valid field slug`);
+								} else if (!declaredFieldSlugs.has(slug)) {
+									errors.push(
+										`${prefix}.admin.listColumns[${j}]: references unknown field "${slug}"`,
+									);
+								}
+							}
+						}
+					}
+				}
 
 				// Validate fields
 				if (!Array.isArray(collection.fields)) {
@@ -141,10 +178,16 @@ export function validateSeed(data: unknown): ValidationResult {
 							errors.push(`${fieldPrefix}: label is required`);
 						}
 
+						if (field.indexed !== undefined && typeof field.indexed !== "boolean") {
+							errors.push(`${fieldPrefix}.indexed: must be a boolean`);
+						}
+
 						if (!field.type) {
 							errors.push(`${fieldPrefix}: type is required`);
 						} else if (!(FIELD_TYPES as readonly string[]).includes(field.type)) {
 							errors.push(`${fieldPrefix}.type: unsupported field type "${field.type}"`);
+						} else if (field.indexed === true && !isIndexableFieldType(field.type)) {
+							errors.push(`${fieldPrefix}.indexed: type "${field.type}" cannot be indexed`);
 						}
 					}
 				}
@@ -550,6 +593,9 @@ export function validateSeed(data: unknown): ValidationResult {
 					errors.push(`content.${collectionSlug}: must be an array`);
 					continue;
 				}
+				const collectionRoutable =
+					seed.collections?.find((collection) => collection.slug === collectionSlug)?.routable !==
+					false;
 
 				const entryIds = new Set<string>();
 
@@ -569,7 +615,11 @@ export function validateSeed(data: unknown): ValidationResult {
 						entryIds.add(entry.id);
 					}
 
-					if (!entry.slug) {
+					const hasSlug = typeof entry.slug === "string" && entry.slug.trim().length > 0;
+					if (entry.slug !== undefined && entry.slug !== null && typeof entry.slug !== "string") {
+						errors.push(`${prefix}.slug: must be a string`);
+					}
+					if (collectionRoutable && !hasSlug) {
 						errors.push(`${prefix}: slug is required`);
 					}
 

package/src/taxonomies/index.ts

@@ -6,17 +6,21 @@
  * `i18n/resolve.ts`).
  *
  * Because `content_taxonomies.taxonomy_id` stores the translation_group (not a
- * specific term id), the joins here are `taxonomies.translation_group =
- * content_taxonomies.taxonomy_id` + filter by `taxonomies.locale`, which picks
- * the right per-locale term.
+ * specific term id), and `entry_id` stores the content translation_group, one
+ * assignment resolves to the requested locale on both sides.
  */
 
+import { sql, type Kysely } from "kysely";
+
+import type { Database } from "../database/types.js";
+import { validateIdentifier } from "../database/validate.js";
+import { getI18nConfig } from "../i18n/config.js";
 import { resolveLocale, resolveLocaleChain } from "../i18n/resolve.js";
 import { getDb, resetTaxonomyNamesCache } from "../loader.js";
 import {
 	cachedQuery,
 	CacheNamespace,
-	contentNamespace,
+	contentCacheNamespaces,
 	invalidateTaxonomyObjectCache,
 	isObjectCacheActive,
 } from "../object-cache/index.js";
@@ -40,6 +44,55 @@ export interface TaxonomyTermsOptions extends TaxonomyQueryOptions {
 	includeCounts?: boolean;
 }
 
+interface EntryTermRow {
+	entry_id: string;
+	id: string;
+	name: string;
+	slug: string;
+	label: string;
+	parent_id: string | null;
+	locale: string;
+	translation_group: string | null;
+}
+
+async function selectEntryTermRows(
+	db: Kysely<Database>,
+	collection: string,
+	entryIds: string[],
+	taxonomyName?: string,
+	locale?: string,
+): Promise<EntryTermRow[]> {
+	validateIdentifier(collection, "collection slug");
+	const tableName = `ec_${collection}`;
+	const preferredLocale = locale ? sql`${locale}` : sql`content.locale`;
+	const defaultLocale = getI18nConfig()?.defaultLocale ?? "en";
+	const result = await sql<EntryTermRow>`
+		SELECT content.id AS entry_id,
+			coalesce(exact_term.id, default_term.id) AS id,
+			coalesce(exact_term.name, default_term.name) AS name,
+			coalesce(exact_term.slug, default_term.slug) AS slug,
+			coalesce(exact_term.label, default_term.label) AS label,
+			coalesce(exact_term.parent_id, default_term.parent_id) AS parent_id,
+			coalesce(exact_term.locale, default_term.locale) AS locale,
+			coalesce(exact_term.translation_group, default_term.translation_group) AS translation_group
+		FROM ${sql.ref(tableName)} AS content
+		INNER JOIN content_taxonomies AS pivot
+			ON pivot.entry_id = content.translation_group
+			AND pivot.collection = ${collection}
+		LEFT JOIN taxonomies AS exact_term
+			ON exact_term.translation_group = pivot.taxonomy_id
+			AND exact_term.locale = ${preferredLocale}
+		LEFT JOIN taxonomies AS default_term
+			ON default_term.translation_group = pivot.taxonomy_id
+			AND default_term.locale = ${defaultLocale}
+		WHERE content.id IN (${sql.join(entryIds.map((id) => sql`${id}`))})
+			AND coalesce(exact_term.id, default_term.id) IS NOT NULL
+			${taxonomyName ? sql`AND coalesce(exact_term.name, default_term.name) = ${taxonomyName}` : sql``}
+		ORDER BY coalesce(exact_term.label, default_term.label) ASC
+	`.execute(db);
+	return result.rows;
+}
+
 /** Invalidate cached taxonomy term data and any content that hydrates terms. */
 export function invalidateTermCache(): void {
 	invalidateTaxonomyObjectCache();
@@ -51,10 +104,9 @@ export function invalidateTermCache(): void {
  * Taxonomy *definitions* (the "category"/"tag" taxonomies themselves, not
  * their terms) are read on every public render that hydrates entry terms —
  * `getAllTermsForEntries` → `getCollectionTaxonomyNames` → `getTaxonomyDefs` —
- * but change extremely rarely: they're created via the admin API or applied
- * from a seed, and there is no edit/delete-def path. Caching them across the
- * isolate lifetime drops the per-render `SELECT * FROM _emdash_taxonomy_defs`
- * to once-per-isolate.
+ * but change extremely rarely: they're written only by the admin API and by
+ * seed application. Caching them across the isolate lifetime drops the
+ * per-render `SELECT * FROM _emdash_taxonomy_defs` to once-per-isolate.
  *
  * Stored on globalThis behind a Symbol key (same pattern as
  * `settings/index.ts`) so the bundler duplicating this module across SSR
@@ -89,8 +141,8 @@ const defsHolder: TaxonomyDefsHolder =
 /**
  * Invalidate the isolate-wide taxonomy-definitions cache (and the related
  * loader taxonomy-names cache). Called from every taxonomy-def write path
- * (`handleTaxonomyCreate`, seed application). Other isolates refresh on their
- * next recycle — staleness bounded by isolate lifetime.
+ * (`handleTaxonomyCreate`/`Update`/`Delete`, seed application). Other isolates
+ * refresh on their next recycle — staleness bounded by isolate lifetime.
  */
 export function invalidateTaxonomyDefsCache(): void {
 	defsHolder.version++;
@@ -228,12 +280,14 @@ export async function getTaxonomyDef(
  * Object-cache namespaces for values that embed visible term counts: the
  * taxonomy epoch (term/assignment writes) plus each counted collection's
  * content epoch, so publishing, unpublishing, or trashing an entry
- * invalidates the cached count promptly. A scheduled entry becoming due
- * flips visibility without a write, so that staleness stays bounded by the
- * cache entry's TTL.
+ * invalidates the cached count promptly. Both content namespace generations
+ * participate so rolling deployments preserve invalidation in either direction.
  */
 function termCountNamespaces(collections: string[]): string[] {
-	return [...Array.from(new Set(collections), contentNamespace), CacheNamespace.TAXONOMIES];
+	return [
+		...[...new Set(collections)].flatMap((collection) => contentCacheNamespaces(collection)),
+		CacheNamespace.TAXONOMIES,
+	];
 }
 
 /**
@@ -259,7 +313,7 @@ export async function getTaxonomyTerms(
 	// The two are independent, so run them concurrently to save a round trip.
 	const [terms, counts] = await Promise.all([
 		getTermList(def, locale),
-		getVisibleTermCounts(def.name, def.collections),
+		getVisibleTermCounts(def.name, def.collections, locale),
 	]);
 	return withCounts(terms, counts);
 }
@@ -299,6 +353,7 @@ async function loadTaxonomyTerms(
 		.selectFrom("taxonomies")
 		.selectAll()
 		.where("name", "=", def.name)
+		.orderBy("sort_order", "asc")
 		.orderBy("label", "asc");
 	if (locale !== undefined) termsQuery = termsQuery.where("locale", "=", locale);
 
@@ -331,28 +386,30 @@ async function loadTaxonomyTerms(
 
 /**
  * Per-translation-group visible-usage counts for one taxonomy, in a single
- * round-trip (see `fetchVisibleTermCounts`). Counts are locale-independent
- * (the pivot stores translation_group), and the request-cached map is shared
- * by every consumer in the render — the widget (`getTaxonomyTerms`) and the
- * single-term page (`getTerm`) never issue separate count queries.
+ * round-trip (see `fetchVisibleTermCounts`). The pivot identity is the
+ * translation group, while entry rows are scoped to the resolved locale.
+ * Request and object cache keys include that locale so translated views never
+ * reuse each other's visible counts.
  */
 function getVisibleTermCounts(
 	taxonomyName: string,
 	collections: string[],
+	locale?: string,
 ): Promise<Map<string, number>> {
 	// The collection scope is part of the key: per-locale rows of the same def
 	// can drift in their declared collections, and a caller may pass a narrower
 	// scope. Identical inputs (the widget + term-page hot path) still share one
 	// entry.
 	const scope = [...new Set(collections)].toSorted().join(",");
-	return requestCached(`taxonomy-term-counts:${taxonomyName}:${scope}`, async () => {
+	const localeScope = locale ?? "*";
+	return requestCached(`taxonomy-term-counts:${taxonomyName}:${scope}:${localeScope}`, async () => {
 		// A Map is not JSON-representable — cache the entries, rebuild on read.
 		const entries = await cachedQuery({
 			namespace: termCountNamespaces(collections),
-			key: `termCounts:${taxonomyName}:${scope}`,
+			key: `termCounts:${taxonomyName}:${scope}:${localeScope}`,
 			load: async (): Promise<Array<[string, number]>> => {
 				const db = await getDb();
-				return [...(await fetchVisibleTermCounts(db, taxonomyName, collections))];
+				return [...(await fetchVisibleTermCounts(db, taxonomyName, collections, locale))];
 			},
 		});
 		return new Map(entries);
@@ -417,6 +474,7 @@ async function loadTerm(
 		// Children store the parent's translation_group in parent_id (not a row
 		// id), so a translated parent still owns its children in its own locale.
 		.where("parent_id", "=", row.translation_group ?? row.id)
+		.orderBy("sort_order", "asc")
 		.orderBy("label", "asc");
 	const termLocale = row.locale;
 	if (termLocale) childrenQuery = childrenQuery.where("locale", "=", termLocale);
@@ -426,7 +484,7 @@ async function loadTerm(
 	// databases. The counts map is request-cached per taxonomy — on a page
 	// that also renders the taxonomy widget it's a free Map lookup.
 	const [counts, childRows] = await Promise.all([
-		getVisibleTermCounts(taxonomyName, collections),
+		getVisibleTermCounts(taxonomyName, collections, chain[0] ?? row.locale),
 		childrenQuery.execute(),
 	]);
 	const count = counts.get(row.translation_group ?? row.id) ?? 0;
@@ -457,8 +515,8 @@ async function loadTerm(
 }
 
 /**
- * Terms assigned to a content entry, resolved into the active locale. Terms
- * whose translation_group lacks a row in the requested locale are omitted.
+ * Terms assigned to a content entry, resolved into the active locale and then
+ * the configured default locale.
  */
 export function getEntryTerms(
 	collection: string,
@@ -475,26 +533,11 @@ export function getEntryTerms(
 		`terms:${collection}:${entryId}:${taxonomyName ?? "*"}:${locale ?? "*"}`,
 		() =>
 			cachedQuery({
-				namespace: [contentNamespace(collection), CacheNamespace.TAXONOMIES],
+				namespace: [...contentCacheNamespaces(collection), CacheNamespace.TAXONOMIES],
 				key: `entryTerms:${collection}:${entryId}:${taxonomyName ?? "*"}:${locale ?? "*"}`,
 				load: async () => {
 					const db = await getDb();
-
-					let query = 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);
-
-					if (taxonomyName) query = query.where("taxonomies.name", "=", taxonomyName);
-					if (locale !== undefined) query = query.where("taxonomies.locale", "=", locale);
-
-					const rows = await query.execute();
+					const rows = await selectEntryTermRows(db, collection, [entryId], taxonomyName, locale);
 					return rows.map<TaxonomyTerm>((row) => ({
 						id: row.id,
 						name: row.name,
@@ -579,27 +622,7 @@ export async function getTermsForEntries(
 		for (const chunk of chunks(missedIds, SQL_BATCH_SIZE)) {
 			let rows;
 			try {
-				let query = db
-					.selectFrom("content_taxonomies")
-					.innerJoin("taxonomies", "taxonomies.translation_group", "content_taxonomies.taxonomy_id")
-					.select([
-						"content_taxonomies.entry_id",
-						"taxonomies.id",
-						"taxonomies.name",
-						"taxonomies.slug",
-						"taxonomies.label",
-						"taxonomies.parent_id",
-						"taxonomies.locale",
-						"taxonomies.translation_group",
-					])
-					.where("content_taxonomies.collection", "=", collection)
-					.where("content_taxonomies.entry_id", "in", chunk)
-					.where("taxonomies.name", "=", taxonomyName)
-					// Match the order getAllTermsForEntries (the cache primer) uses, so
-					// cache-hit and DB-miss entries in one result are ordered consistently.
-					.orderBy("taxonomies.label", "asc");
-				if (locale !== undefined) query = query.where("taxonomies.locale", "=", locale);
-				rows = await query.execute();
+				rows = await selectEntryTermRows(db, collection, chunk, taxonomyName, locale);
 			} catch (error) {
 				if (isMissingTableError(error)) return [...result.entries()];
 				throw error;
@@ -631,7 +654,7 @@ export async function getTermsForEntries(
 	const pairs =
 		idKey.length <= 256
 			? await cachedQuery({
-					namespace: [contentNamespace(collection), CacheNamespace.TAXONOMIES],
+					namespace: [...contentCacheNamespaces(collection), CacheNamespace.TAXONOMIES],
 					key: `termsForEntries:${collection}:${taxonomyName}:${locale ?? "*"}:${idKey}`,
 					load,
 				})
@@ -661,24 +684,7 @@ export async function getAllTermsForEntries(
 	for (const chunk of chunks(uniqueIds, SQL_BATCH_SIZE)) {
 		let rows;
 		try {
-			let query = db
-				.selectFrom("content_taxonomies")
-				.innerJoin("taxonomies", "taxonomies.translation_group", "content_taxonomies.taxonomy_id")
-				.select([
-					"content_taxonomies.entry_id",
-					"taxonomies.id",
-					"taxonomies.name",
-					"taxonomies.slug",
-					"taxonomies.label",
-					"taxonomies.parent_id",
-					"taxonomies.locale",
-					"taxonomies.translation_group",
-				])
-				.where("content_taxonomies.collection", "=", collection)
-				.where("content_taxonomies.entry_id", "in", chunk)
-				.orderBy("taxonomies.label", "asc");
-			if (locale !== undefined) query = query.where("taxonomies.locale", "=", locale);
-			rows = await query.execute();
+			rows = await selectEntryTermRows(db, collection, chunk, undefined, locale);
 		} catch (error) {
 			if (isMissingTableError(error)) {
 				for (const id of uniqueIds) {