emdash 0.28.0 → 0.29.0

package/src/media/usage/content-snapshots.ts

@@ -46,6 +46,7 @@ export type LoadContentMediaUsageSnapshotsResult =
 				| "DRAFT_REVISION_MISMATCH"
 				| "DRAFT_REVISION_INVALID";
 			source?: MediaUsageSourceInput;
+			snapshots?: ContentMediaUsageSnapshot[];
 	  };
 
 export interface ContentMediaUsageSnapshot {
@@ -116,6 +117,7 @@ export async function loadContentMediaUsageSnapshots(
 				success: false,
 				error: "DRAFT_REVISION_NOT_FOUND",
 				source: attemptedDraftSource,
+				snapshots,
 			};
 		}
 		if (!revisionResult.success) {
@@ -123,6 +125,7 @@ export async function loadContentMediaUsageSnapshots(
 				success: false,
 				error: "DRAFT_REVISION_INVALID",
 				source: attemptedDraftSource,
+				snapshots,
 			};
 		}
 		const revision = revisionResult.revision;
@@ -131,6 +134,7 @@ export async function loadContentMediaUsageSnapshots(
 				success: false,
 				error: "DRAFT_REVISION_MISMATCH",
 				source: attemptedDraftSource,
+				snapshots,
 			};
 		}
 

package/src/plugins/context.ts

@@ -13,6 +13,7 @@ import { MediaRepository } from "../database/repositories/media.js";
 import { OptionsRepository } from "../database/repositories/options.js";
 import { PluginStorageRepository } from "../database/repositories/plugin-storage.js";
 import { SeoRepository } from "../database/repositories/seo.js";
+import { TaxonomyRepository, type Taxonomy } from "../database/repositories/taxonomy.js";
 import { UserRepository } from "../database/repositories/user.js";
 import { withTransaction } from "../database/transaction.js";
 import type { Database } from "../database/types.js";
@@ -52,6 +53,10 @@ import type {
 	QueryOptions,
 	ContentListOptions,
 	MediaListOptions,
+	TaxonomyAccess,
+	TaxonomyDefInfo,
+	TaxonomyTermInfo,
+	TaxonomyReadOptions,
 } from "./types.js";
 
 // =============================================================================
@@ -194,6 +199,37 @@ async function assertSeoEnabled(
 	return hasSeo;
 }
 
+/**
+ * Parse the `collections` JSON column into a string array (`[]` on anything
+ * else). Mirrors the guards in the Cloudflare/workerd bridges so an
+ * in-process plugin degrades on malformed data instead of crashing.
+ */
+function parseCollectionsColumn(value: string | null): string[] {
+	if (!value) return [];
+	try {
+		const parsed: unknown = JSON.parse(value);
+		return Array.isArray(parsed)
+			? parsed.filter((item): item is string => typeof item === "string")
+			: [];
+	} catch {
+		return [];
+	}
+}
+
+/** Map a repository `Taxonomy` row to the plugin-facing term shape. */
+function taxonomyToTermInfo(term: Taxonomy): TaxonomyTermInfo {
+	return {
+		id: term.id,
+		taxonomy: term.name,
+		slug: term.slug,
+		label: term.label,
+		parentId: term.parentId,
+		data: term.data,
+		locale: term.locale,
+		translationGroup: term.translationGroup,
+	};
+}
+
 /**
  * Create read-only content access
  */
@@ -278,6 +314,48 @@ export function createContentAccess(db: Kysely<Database>): ContentAccess {
 	};
 }
 
+/**
+ * Create read-only taxonomy access (gated on `taxonomies:read`).
+ */
+export function createTaxonomyAccess(db: Kysely<Database>): TaxonomyAccess {
+	const taxonomyRepo = new TaxonomyRepository(db);
+
+	return {
+		async getAll(options?: TaxonomyReadOptions): Promise<TaxonomyDefInfo[]> {
+			let query = db.selectFrom("_emdash_taxonomy_defs").selectAll();
+			if (options?.locale !== undefined) query = query.where("locale", "=", options.locale);
+			const rows = await query.orderBy("name", "asc").execute();
+			return rows.map((row) => ({
+				name: row.name,
+				label: row.label,
+				labelSingular: row.label_singular,
+				hierarchical: row.hierarchical === 1,
+				collections: parseCollectionsColumn(row.collections),
+				locale: row.locale,
+			}));
+		},
+
+		async getTerms(taxonomy: string, options?: TaxonomyReadOptions): Promise<TaxonomyTermInfo[]> {
+			const terms = await taxonomyRepo.findByName(taxonomy, { locale: options?.locale });
+			return terms.map(taxonomyToTermInfo);
+		},
+
+		async getEntryTerms(
+			collection: string,
+			entryId: string,
+			options?: TaxonomyReadOptions & { taxonomy?: string },
+		): Promise<TaxonomyTermInfo[]> {
+			const terms = await taxonomyRepo.getTermsForEntry(
+				collection,
+				entryId,
+				options?.taxonomy,
+				options?.locale,
+			);
+			return terms.map(taxonomyToTermInfo);
+		},
+	};
+}
+
 /**
  * Create full content access with write operations.
  *
@@ -1015,6 +1093,12 @@ export class PluginContextFactory {
 			content = createContentAccess(db);
 		}
 
+		// Capability-gated: taxonomies (read-only)
+		let taxonomies: TaxonomyAccess | undefined;
+		if (capabilities.has("taxonomies:read")) {
+			taxonomies = createTaxonomyAccess(db);
+		}
+
 		// Capability-gated: media
 		// `upload()` only needs `storage`; `getUploadUrl()` is derived from
 		// storage when no explicit provider is wired. Granting write access on
@@ -1078,6 +1162,7 @@ export class PluginContextFactory {
 			storage,
 			kv,
 			content,
+			taxonomies,
 			media,
 			http,
 			log,

package/src/plugins/define-plugin.ts

@@ -142,6 +142,7 @@ function defineNativePlugin<TStorage extends PluginStorageConfig>(
 		"network:request:unrestricted",
 		"content:read",
 		"content:write",
+		"taxonomies:read",
 		"media:read",
 		"media:write",
 		"users:read",

package/src/plugins/index.ts

@@ -118,6 +118,10 @@ export type {
 	MediaItem,
 	ContentListOptions,
 	MediaListOptions,
+	TaxonomyAccess,
+	TaxonomyDefInfo,
+	TaxonomyTermInfo,
+	TaxonomyReadOptions,
 
 	// Hook types
 	PluginHooks,

package/src/plugins/manifest-schema.ts

@@ -27,6 +27,7 @@ export const CURRENT_PLUGIN_CAPABILITIES = [
 	"network:request:unrestricted",
 	"content:read",
 	"content:write",
+	"taxonomies:read",
 	"media:read",
 	"media:write",
 	"users:read",
@@ -246,6 +247,7 @@ const declaredAccessSchema = z.object({
 	content: z
 		.object({ read: accessConstraints.optional(), write: accessConstraints.optional() })
 		.optional(),
+	taxonomies: z.object({ read: accessConstraints.optional() }).optional(),
 	media: z
 		.object({ read: accessConstraints.optional(), write: accessConstraints.optional() })
 		.optional(),

package/src/plugins/types.ts

@@ -244,6 +244,45 @@ export type ContentWriteInput = Record<string, unknown> & {
 	seo?: ContentItemSeoInput;
 };
 
+/**
+ * Taxonomy definition returned from the taxonomy API (e.g. "category", "tag").
+ */
+export interface TaxonomyDefInfo {
+	name: string;
+	label: string;
+	labelSingular: string | null;
+	hierarchical: boolean;
+	/** Collections this taxonomy is attached to (e.g. `["posts"]`). */
+	collections: string[];
+	locale: string;
+}
+
+/**
+ * Taxonomy term returned from the taxonomy API. Flat shape — for hierarchical
+ * taxonomies the tree is reconstructed via `parentId` (which stores the
+ * parent's locale-agnostic `translationGroup`).
+ */
+export interface TaxonomyTermInfo {
+	id: string;
+	/** Taxonomy name this term belongs to (e.g. "category"). */
+	taxonomy: string;
+	slug: string;
+	label: string;
+	parentId: string | null;
+	/** Term metadata as edited in the admin (`description` etc.). */
+	data: Record<string, unknown> | null;
+	locale: string;
+	translationGroup: string | null;
+}
+
+/**
+ * Options accepted by taxonomy read operations. Omitting `locale` returns
+ * rows for every locale.
+ */
+export interface TaxonomyReadOptions {
+	locale?: string;
+}
+
 /**
  * Content access interface - capability-gated
  */
@@ -258,6 +297,23 @@ export interface ContentAccess {
 	delete?(collection: string, id: string): Promise<boolean>;
 }
 
+/**
+ * Taxonomy access interface — capability-gated on `taxonomies:read`.
+ * Read-only: there is no plugin-facing taxonomy write API.
+ */
+export interface TaxonomyAccess {
+	/** List taxonomy definitions. */
+	getAll(options?: TaxonomyReadOptions): Promise<TaxonomyDefInfo[]>;
+	/** All terms of a taxonomy, ordered by label. */
+	getTerms(taxonomy: string, options?: TaxonomyReadOptions): Promise<TaxonomyTermInfo[]>;
+	/** Terms assigned to a content entry, optionally scoped to one taxonomy. */
+	getEntryTerms(
+		collection: string,
+		entryId: string,
+		options?: TaxonomyReadOptions & { taxonomy?: string },
+	): Promise<TaxonomyTermInfo[]>;
+}
+
 /**
  * Full content access with write operations
  */
@@ -413,6 +469,9 @@ export interface PluginContext<TStorage extends PluginStorageConfig = PluginStor
 	/** Content access - only if read:content or write:content capability */
 	content?: ContentAccess | ContentAccessWithWrite;
 
+	/** Taxonomy access (read-only) - only if taxonomies:read capability */
+	taxonomies?: TaxonomyAccess;
+
 	/** Media access - only if read:media or write:media capability */
 	media?: MediaAccess | MediaAccessWithWrite;
 

package/src/schema/byline-registry.ts

@@ -627,7 +627,7 @@ export class BylineSchemaRegistry {
 		// payload silently. Today's `BylineFieldValidation` is `{ options? }`
 		// only, so this branch is a pass-through; left explicit for clarity.
 		const { options: _drop, ...rest } = validation;
-		return Object.keys(rest).length === 0 ? null : (rest as BylineFieldValidation);
+		return Object.keys(rest).length === 0 ? null : rest;
 	}
 }
 

package/src/search/fts-manager.ts

@@ -355,6 +355,40 @@ export class FTSManager {
 		return fields.map((f) => f.slug);
 	}
 
+	/**
+	 * Whether a collection has a user-defined `title` field.
+	 *
+	 * `title` is not a system column on `ec_*` tables -- it exists only when a
+	 * collection defines a field with slug `title`. Search and suggestion SQL
+	 * that selects `c.title` must check this first; otherwise collections
+	 * without a title field raise "no such column: c.title" (#1178).
+	 */
+	async hasTitleColumn(collectionSlug: string): Promise<boolean> {
+		const withTitle = await this.getCollectionsWithTitleColumn([collectionSlug]);
+		return withTitle.has(collectionSlug);
+	}
+
+	/**
+	 * Bulk variant of `hasTitleColumn()`: which of the given collections have
+	 * a user-defined `title` field. One query instead of one `hasTitleColumn`
+	 * round-trip pair per collection -- callers that check this once per
+	 * collection in a loop (multi-collection search, suggestions) should use
+	 * this instead (AGENTS.md: "one query beats two").
+	 */
+	async getCollectionsWithTitleColumn(collectionSlugs: string[]): Promise<Set<string>> {
+		if (collectionSlugs.length === 0) return new Set();
+
+		const rows = await this.db
+			.selectFrom("_emdash_fields as f")
+			.innerJoin("_emdash_collections as c", "c.id", "f.collection_id")
+			.select(["c.slug as collection_slug"])
+			.where("f.slug", "=", "title")
+			.execute();
+
+		const withTitle = new Set(rows.map((r) => r.collection_slug));
+		return new Set(collectionSlugs.filter((slug) => withTitle.has(slug)));
+	}
+
 	/**
 	 * Enable search for a collection.
 	 *

package/src/search/match.ts

@@ -0,0 +1,50 @@
+/**
+ * FTS5 match-expression builder for structured (non-user-syntax) queries.
+ *
+ * Unlike `escapeQuery` in `query.ts` (which powers the public search API and
+ * deliberately passes through FTS5 operators like AND/OR/NOT), this builder
+ * treats the input as plain words: every term is double-quoted with interior
+ * quotes escaped, so the result can never produce an FTS5 syntax error. Used
+ * by the admin content-list filter, where the input is a filter box, not a
+ * search-syntax field.
+ */
+
+const WHITESPACE_RE = /\s+/;
+const DOUBLE_QUOTE_RE = /"/g;
+const GLOB_SPECIAL_RE = /[[\]*?]/g;
+
+/**
+ * Build a prefix-matching FTS5 MATCH expression from free-form input.
+ *
+ * `hello wor` becomes `"hello"* "wor"*` — implicit AND with per-term prefix
+ * matching. Returns `""` when the input contains no usable terms; callers
+ * must fall back to their non-FTS path in that case.
+ */
+export function buildFtsPrefixMatch(input: string): string {
+	const terms = input
+		.trim()
+		.split(WHITESPACE_RE)
+		.map((term) => term.replace(DOUBLE_QUOTE_RE, '""'))
+		.filter((term) => term.length > 0);
+
+	if (terms.length === 0) return "";
+	return terms.map((term) => `"${term}"*`).join(" ");
+}
+
+/**
+ * Build a GLOB prefix pattern from free-form input, treating GLOB
+ * metacharacters (`* ? [ ]`) literally by wrapping each in a character
+ * class (GLOB has no ESCAPE clause).
+ *
+ * GLOB (unlike default LIKE) is case-sensitive, so with a lowercased
+ * pattern it matches slugs (lowercase by construction) while staying
+ * servable by the ordinary BINARY-collated slug index — SQLite's GLOB
+ * optimization turns a `prefix*` pattern into an index range scan.
+ */
+export function buildSlugGlobPrefix(input: string): string {
+	const escaped = input
+		.trim()
+		.toLowerCase()
+		.replace(GLOB_SPECIAL_RE, (c) => `[${c}]`);
+	return `${escaped}*`;
+}

package/src/search/query.ts

@@ -7,6 +7,7 @@
 import type { Kysely } from "kysely";
 import { sql } from "kysely";
 
+import { encodeCursor, decodeCursor, InvalidCursorError } from "../database/repositories/types.js";
 import type { Database } from "../database/types.js";
 import { validateIdentifier } from "../database/validate.js";
 import { getDb } from "../loader.js";
@@ -21,6 +22,44 @@ import type {
 	SearchStats,
 } from "./types.js";
 
+/**
+ * Marker stored in the `id` slot of a search pagination cursor.
+ *
+ * Search results are merged from per-collection FTS queries and re-sorted by
+ * score, so there is no single stable keyset column to encode (the way
+ * `getEmDashCollection` encodes `(orderValue, id)`). We page over the merged,
+ * score-sorted set by offset instead, carried as the cursor's `orderValue`.
+ * Reusing `encodeCursor`/`decodeCursor` keeps the opaque base64-JSON shape and
+ * the `InvalidCursorError` handling consistent with the rest of the API.
+ */
+const SEARCH_CURSOR_MARKER = "search";
+
+/** Encode the next-page offset into an opaque search cursor. */
+function encodeSearchCursor(offset: number): string {
+	return encodeCursor(String(offset), SEARCH_CURSOR_MARKER);
+}
+
+/**
+ * Decode a search cursor back to its offset. Throws `InvalidCursorError` for a
+ * malformed cursor or one that doesn't carry a non-negative integer offset, so
+ * a client pagination bug surfaces immediately rather than silently restarting
+ * from the first page.
+ */
+/** Upper bound on a decoded search offset, to cap the per-collection row fetch a forged cursor can trigger. */
+const MAX_SEARCH_OFFSET = 10_000;
+
+function decodeSearchOffset(cursor: string): number {
+	const { orderValue, id } = decodeCursor(cursor);
+	if (id !== SEARCH_CURSOR_MARKER) {
+		throw new InvalidCursorError(cursor);
+	}
+	const offset = Number(orderValue);
+	if (!Number.isInteger(offset) || offset < 0 || offset > MAX_SEARCH_OFFSET) {
+		throw new InvalidCursorError(cursor);
+	}
+	return offset;
+}
+
 /** Pattern to split on whitespace for query term extraction */
 const WHITESPACE_SPLIT_PATTERN = /\s+/;
 const FTS_OPERATORS_PATTERN = /\b(AND|OR|NOT|NEAR)\b/i;
@@ -86,6 +125,7 @@ export async function searchWithDb(
 	const ftsManager = new FTSManager(db);
 	const limit = options.limit ?? 20;
 	const status = options.status ?? "published";
+	const offset = options.cursor ? decodeSearchOffset(options.cursor) : 0;
 
 	// Get searchable collections
 	let collections = options.collections;
@@ -97,8 +137,15 @@ export async function searchWithDb(
 		return { items: [] };
 	}
 
+	// To rank the merged window [offset, offset + limit) correctly, each
+	// collection must contribute its own top (offset + limit) rows — in the
+	// worst case the entire window comes from one collection. The extra +1
+	// row detects whether a further page exists.
+	const perCollectionLimit = offset + limit + 1;
+
 	// Search each collection and merge results
 	const allResults: SearchResult[] = [];
+	const titleColumns = await ftsManager.getCollectionsWithTitleColumn(collections);
 
 	for (const collection of collections) {
 		const config = await ftsManager.getSearchConfig(collection);
@@ -113,9 +160,10 @@ export async function searchWithDb(
 			{
 				status,
 				locale: options.locale,
-				limit: limit * 2, // Get extra for merging
+				limit: perCollectionLimit,
 			},
 			config.weights,
+			titleColumns.has(collection),
 		);
 
 		allResults.push(...collectionResults);
@@ -124,10 +172,13 @@ export async function searchWithDb(
 	// Sort by score descending
 	allResults.sort((a, b) => b.score - a.score);
 
-	// Apply limit
-	const items = allResults.slice(0, limit);
+	// Page the merged set by offset. A nextCursor is issued only when at least
+	// one result exists past this page.
+	const items = allResults.slice(offset, offset + limit);
+	const hasMore = allResults.length > offset + limit;
+	const nextCursor = hasMore ? encodeSearchCursor(offset + limit) : undefined;
 
-	return { items };
+	return { items, nextCursor };
 }
 
 /**
@@ -159,9 +210,25 @@ export async function searchCollection(
 		return { items: [] };
 	}
 
-	const items = await searchSingleCollection(db, collection, query, options, config.weights);
+	const limit = options.limit ?? 20;
+	const offset = options.cursor ? decodeSearchOffset(options.cursor) : 0;
+
+	// Over-fetch the [offset, offset + limit) window plus one row to detect a
+	// further page, then slice. Keeps the FTS SQL (LIMIT-only) unchanged and
+	// the cursor contract identical to the cross-collection path.
+	const fetched = await searchSingleCollection(
+		db,
+		collection,
+		query,
+		{ status: options.status, locale: options.locale, limit: offset + limit + 1 },
+		config.weights,
+	);
+
+	const items = fetched.slice(offset, offset + limit);
+	const hasMore = fetched.length > offset + limit;
+	const nextCursor = hasMore ? encodeSearchCursor(offset + limit) : undefined;
 
-	return { items };
+	return { items, nextCursor };
 }
 
 /**
@@ -173,6 +240,7 @@ async function searchSingleCollection(
 	query: string,
 	options: CollectionSearchOptions,
 	weights?: Record<string, number>,
+	hasTitle?: boolean,
 ): Promise<SearchResult[]> {
 	// Validate before any raw SQL interpolation
 	validateIdentifier(collection, "collection slug");
@@ -198,6 +266,14 @@ async function searchSingleCollection(
 	// Get searchable fields for snippet generation
 	const searchableFields = await ftsManager.getSearchableFields(collection);
 
+	// `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
+	// 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`;
+
 	// Build weight string for bm25 if weights provided
 	// Format: bm25(table, weight1, weight2, ...)
 	// First two weights are for 'id' and 'locale' columns (UNINDEXED, so 0)
@@ -225,11 +301,11 @@ async function searchSingleCollection(
 			snippet: string | null;
 			score: number;
 		}>`
-		SELECT 
+		SELECT
 			c.id,
 			c.slug,
 			c.locale,
-			c.title,
+			${titleExpr} as title,
 			snippet("${sql.raw(ftsTable)}", 2, '<mark>', '</mark>', '...', 32) as snippet,
 			${sql.raw(bm25Expr)} as score
 		FROM "${sql.raw(ftsTable)}" f
@@ -334,14 +410,23 @@ export async function getSuggestions(
 	}
 
 	const suggestions: Suggestion[] = [];
+	const ftsManager = new FTSManager(db);
+	const titleColumns = await ftsManager.getCollectionsWithTitleColumn(collections);
 
 	for (const collection of collections) {
-		const ftsManager = new FTSManager(db);
 		const config = await ftsManager.getSearchConfig(collection);
 		if (!config?.enabled) {
 			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)) {
+			continue;
+		}
+
 		// Validate before raw SQL interpolation
 		validateIdentifier(collection, "collection slug");