emdash 0.33.0 → 0.34.0

package/src/search/query.ts

@@ -165,6 +165,7 @@ export async function searchWithDb(
 			},
 			config.weights,
 			titleColumns.has(collection),
+			config.titleField,
 		);
 
 		allResults.push(...collectionResults);
@@ -223,6 +224,8 @@ export async function searchCollection(
 		query,
 		{ status: options.status, locale: options.locale, limit: offset + limit + 1 },
 		config.weights,
+		undefined,
+		config.titleField,
 	);
 
 	const items = fetched.slice(offset, offset + limit);
@@ -242,6 +245,7 @@ async function searchSingleCollection(
 	options: CollectionSearchOptions,
 	weights?: Record<string, number>,
 	hasTitle?: boolean,
+	titleField?: string,
 ): Promise<SearchResult[]> {
 	// Validate before any raw SQL interpolation
 	validateIdentifier(collection, "collection slug");
@@ -269,11 +273,20 @@ async function searchSingleCollection(
 
 	// `title` is an optional user-defined field, not a system column. Only
 	// select it when the collection actually has one; otherwise the query
-	// errors with "no such column: c.title" (#1178). Multi-collection callers
+	// errors with "no such column: c.title". Multi-collection callers
 	// precompute this in bulk and pass it in; single-collection callers fall
 	// back to the per-collection check.
-	const collectionHasTitle = hasTitle ?? (await ftsManager.hasTitleColumn(collection));
-	const titleExpr = collectionHasTitle ? sql`c.title` : sql`NULL`;
+	// A configured titleField drives the result title so search shows
+	// the same value as the content list. It's a validated existing field, so
+	// the column exists; otherwise fall back to the optional `title` column.
+	let titleExpr;
+	if (titleField) {
+		validateIdentifier(titleField, "title field");
+		titleExpr = sql`c.${sql.ref(titleField)}`;
+	} else {
+		const collectionHasTitle = hasTitle ?? (await ftsManager.hasTitleColumn(collection));
+		titleExpr = collectionHasTitle ? sql`c.title` : sql`NULL`;
+	}
 
 	// Build weight string for bm25 if weights provided
 	// Format: bm25(table, weight1, weight2, ...)
@@ -420,11 +433,19 @@ export async function getSuggestions(
 			continue;
 		}
 
-		// Suggestions are title-based (Suggestion.title is required and the
-		// query filters on `c.title IS NOT NULL`). Collections without a
-		// `title` field can't produce one, and selecting `c.title` would
-		// error, so skip them. See #1178.
-		if (!titleColumns.has(collection)) {
+		// Suggestions are title-based (Suggestion.title is required). A configured
+		// titleField supplies it -- a validated existing column -- so it
+		// takes precedence and keeps autocomplete consistent with search results.
+		// Otherwise fall back to the optional `title` field; collections with
+		// neither can't produce a suggestion and are skipped (selecting a missing
+		// column would error).
+		let titleExpr;
+		if (config.titleField) {
+			validateIdentifier(config.titleField, "title field");
+			titleExpr = sql`c.${sql.ref(config.titleField)}`;
+		} else if (titleColumns.has(collection)) {
+			titleExpr = sql`c.title`;
+		} else {
 			continue;
 		}
 
@@ -448,16 +469,16 @@ export async function getSuggestions(
 				slug: string | null;
 				title: string;
 			}>`
-				SELECT 
+				SELECT
 					c.id,
 					c.slug,
-					c.title
+					${titleExpr} AS title
 				FROM "${sql.raw(ftsTable)}" f
 				JOIN "${sql.raw(contentTable)}" c ON f.id = c.id
 				WHERE "${sql.raw(ftsTable)}" MATCH ${prefixQuery}
 				AND c.status = 'published'
 				AND c.deleted_at IS NULL
-				AND c.title IS NOT NULL
+				AND ${titleExpr} IS NOT NULL
 				${locale ? sql`AND c.locale = ${locale}` : sql``}
 				ORDER BY bm25("${sql.raw(ftsTable)}")
 				LIMIT ${limit}

package/src/search/types.ts

@@ -16,6 +16,8 @@ export interface SearchConfig {
 	enabled: boolean;
 	/** Field weights for ranking (higher = more important) */
 	weights?: Record<string, number>;
+	/** Field slug used as the result title, from the collection's titleField. */
+	titleField?: string;
 	/** FTS5 tokenizer configuration (defaults to English Porter stemming) */
 	tokenize?: SearchTokenizer;
 }

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,10 @@ 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,
@@ -195,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,
@@ -209,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,
@@ -217,6 +237,9 @@ export async function applySeed(
 							result.fields.created++;
 						}
 					}
+
+					// Second write: display/date fields, now that fields exist.
+					await applyDisplayDateFields(registry, collection);
 					continue;
 				}
 
@@ -233,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,
@@ -247,14 +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;
 		}
@@ -460,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`,
 							);
 						}
 
@@ -529,7 +566,15 @@ export async function applySeed(
 										});
 										try {
 											await trxContentRepo.setDraftRevision(collectionSlug, existing.id, draft.id);
-											await trxContentRepo.publish(collectionSlug, existing.id);
+											await trxContentRepo.publish(
+												collectionSlug,
+												existing.id,
+												undefined,
+												false,
+												undefined,
+												true,
+												collectionRoutable,
+											);
 										} catch (error) {
 											try {
 												await trxRevisionRepo.deleteIfUnreferenced(
@@ -590,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,
@@ -613,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;
@@ -961,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> {
@@ -986,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`,
 		);
 	}
 
@@ -1009,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) {
@@ -1029,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,8 +72,11 @@ 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.
@@ -86,6 +89,10 @@ export interface SeedCollection {
 	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[];
 }
 
@@ -99,6 +106,7 @@ export interface SeedField {
 	required?: boolean;
 	unique?: boolean;
 	searchable?: boolean;
+	indexed?: boolean;
 	defaultValue?: unknown;
 	validation?: Record<string, unknown>;
 	widget?: string;
@@ -263,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`);
 					}