emdash 0.16.0 → 0.17.0

package/src/database/repositories/content.ts

@@ -17,6 +17,9 @@ import { EmDashValidationError, encodeCursor, decodeCursor } from "./types.js";
 // Regex pattern for ULID validation
 const ULID_PATTERN = /^[0-9A-Z]{26}$/;
 
+// LIKE wildcards that must be escaped so user search input is matched literally.
+const LIKE_WILDCARD_RE = /[\\%_]/g;
+
 /**
  * System columns that exist in every ec_* table
  */
@@ -489,6 +492,8 @@ export class ContentRepository {
 			query = query.where("locale" as any, "=", options.where.locale);
 		}
 
+		query = this.applySearchFilter(query, options.where);
+
 		// Handle cursor pagination — decodeCursor throws InvalidCursorError
 		// on malformed input; let it propagate so handlers surface a
 		// structured INVALID_CURSOR rather than silently returning page 1.
@@ -519,8 +524,8 @@ export class ContentRepository {
 			.limit(limit + 1);
 
 		// Run the page fetch and the unbounded count together — the UI needs
-		// both to render a stable denominator, and issuing them in parallel
-		// on SQLite is essentially free.
+		// both to render a stable denominator (kept on every page intentionally),
+		// and issuing them in parallel on SQLite is essentially free.
 		const [rows, total] = await Promise.all([query.execute(), this.count(type, options.where)]);
 		const hasMore = rows.length > limit;
 		const items = rows.slice(0, limit);
@@ -753,12 +758,45 @@ export class ContentRepository {
 		return Number(result?.count || 0);
 	}
 
+	/**
+	 * Apply the optional case-insensitive `q` substring filter across the
+	 * handler-resolved `searchColumns` (OR'd). User input is treated literally
+	 * (LIKE wildcards escaped) and `lower()` is applied on both sides for
+	 * SQLite/Postgres case-insensitive parity.
+	 */
+	private applySearchFilter<QB extends { where: (cb: (eb: any) => unknown) => QB }>(
+		query: QB,
+		where?: { q?: string; searchColumns?: string[] },
+	): QB {
+		const term = where?.q?.trim();
+		const columns = where?.searchColumns;
+		if (!term || !columns || columns.length === 0) return query;
+
+		const escaped = term.replace(LIKE_WILDCARD_RE, (c) => `\\${c}`);
+		const pattern = `%${escaped}%`;
+
+		return query.where((eb) =>
+			eb.or(
+				columns.map((col) => {
+					validateIdentifier(col, "search column");
+					return eb(sql`lower(${sql.ref(col)})`, "like", sql`lower(${pattern}) escape '\\'`);
+				}),
+			),
+		);
+	}
+
 	/**
 	 * Count content items
 	 */
 	async count(
 		type: string,
-		where?: { status?: string; authorId?: string; locale?: string },
+		where?: {
+			status?: string;
+			authorId?: string;
+			locale?: string;
+			q?: string;
+			searchColumns?: string[];
+		},
 	): Promise<number> {
 		const tableName = getTableName(type);
 
@@ -779,6 +817,8 @@ export class ContentRepository {
 			query = query.where("locale" as any, "=", where.locale);
 		}
 
+		query = this.applySearchFilter(query, where);
+
 		const result = await query.executeTakeFirst();
 		return Number(result?.count || 0);
 	}

package/src/database/repositories/media.ts

@@ -81,6 +81,8 @@ export interface FindManyMediaOptions {
 	/** Filter by MIME type. Pass a string for a single prefix/exact, or an array to match any. Strings ending with "/" are treated as LIKE prefix matches; others are exact equality. */
 	mimeType?: string | readonly string[];
 	status?: MediaStatus | "all"; // Filter by status, defaults to "ready"
+	/** Case-insensitive substring matched against the filename (covers filename and extension). */
+	q?: string;
 }
 
 /**
@@ -250,6 +252,18 @@ export class MediaRepository {
 			query = query.where((eb) => mimeMatchExpr(eb, mimeFilters));
 		}
 
+		// Case-insensitive filename substring search (also matches extensions).
+		// LIKE wildcards in the term are escaped so they're treated literally.
+		const term = options.q?.trim();
+		if (term) {
+			const pattern = `%${escapeLike(term)}%`;
+			query = query.where(
+				sql<string>`lower(filename)`,
+				"like",
+				sql<string>`lower(${pattern}) escape '\\'`,
+			);
+		}
+
 		// Default to only showing ready items
 		if (options.status !== "all") {
 			query = query.where("status", "=", options.status ?? "ready");

package/src/database/repositories/types.ts

@@ -1,3 +1,4 @@
+import type { CustomFieldValue } from "../../schema/types.js";
 import { encodeBase64, decodeBase64 } from "../../utils/base64.js";
 
 /**
@@ -58,6 +59,25 @@ export interface BylineSummary {
 	displayName: string;
 	bio: string | null;
 	avatarMediaId: string | null;
+	/**
+	 * The avatar media's storage key, folded in by a LEFT JOIN on the
+	 * `media` table during content byline hydration. Non-null only when the
+	 * byline has an avatar AND was loaded through the content-credit hydration
+	 * path (`getContentBylines` / `getContentBylinesMany`, i.e. the
+	 * `entry.data.bylines` populated by `getEmDashCollection` / `getEmDashEntry`).
+	 * The plain byline finders (`findById`, `findBySlug`, …) leave it null.
+	 *
+	 * Lets list pages build a direct storage URL for an author avatar without a
+	 * per-byline `MediaRepository.findById`, avoiding an N+1 when many distinct
+	 * authors appear on one page.
+	 *
+	 * Optional so adding it is a non-breaking change for existing code that
+	 * constructs a `BylineSummary` literal; the repositories always populate it
+	 * (to `null` when there's no avatar or no media join).
+	 */
+	avatarStorageKey?: string | null;
+	/** Avatar media alt text, from the same media join. Null when not joined. */
+	avatarAlt?: string | null;
 	websiteUrl: string | null;
 	userId: string | null;
 	isGuest: boolean;
@@ -76,6 +96,16 @@ export interface BylineSummary {
 	 * populate it.
 	 */
 	translationGroup: string | null;
+	/**
+	 * Custom field values registered via the byline-fields schema (migration
+	 * 041, Discussion #1174). Optional in the TypeScript shape so existing
+	 * object-literal consumers (test fixtures, plugin renderers) stay
+	 * source-compatible; the runtime always returns `{}` when no fields are
+	 * registered. Translatable values reflect this row's locale; non-
+	 * translatable values are shared across every locale variant of the
+	 * byline's `translation_group`.
+	 */
+	customFields?: Record<string, CustomFieldValue>;
 }
 
 export interface ContentBylineCredit {
@@ -91,6 +121,14 @@ export interface FindManyOptions {
 		status?: string;
 		authorId?: string;
 		locale?: string;
+		/** Case-insensitive substring to match against `searchColumns`. */
+		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.
+		 */
+		searchColumns?: string[];
 	};
 	orderBy?: {
 		field: string;

package/src/database/types.ts

@@ -437,6 +437,9 @@ export interface Database {
 	_emdash_404_log: NotFoundLogTable;
 	_emdash_bylines: BylineTable;
 	_emdash_content_bylines: ContentBylineTable;
+	_emdash_byline_fields: BylineFieldTable;
+	_emdash_byline_field_values: BylineFieldValueTable;
+	_emdash_byline_field_group_values: BylineFieldGroupValueTable;
 	_emdash_rate_limits: RateLimitTable;
 }
 
@@ -529,6 +532,47 @@ export interface ContentBylineTable {
 	created_at: Generated<string>;
 }
 
+// Byline custom fields (migration 041, Discussion #1174)
+//
+// `_emdash_byline_fields` stores definitions; values land in either
+// `_emdash_byline_field_values` (translatable, keyed by byline row id) or
+// `_emdash_byline_field_group_values` (non-translatable, keyed by
+// translation_group). Per-field `translatable` flag picks the home table.
+
+export interface BylineFieldTable {
+	id: string;
+	slug: string;
+	label: string;
+	/** One of: 'string', 'text', 'url', 'boolean', 'select'. v1 subset. */
+	type: string;
+	required: Generated<number>; // 0 or 1
+	/** 0 = group-shared, 1 = per-locale. Defaults to 1 at the DB level. */
+	translatable: Generated<number>;
+	/** JSON: `{ options?: string[] }` for `select`-type fields. */
+	validation: string | null;
+	sort_order: Generated<number>;
+	created_at: Generated<string>;
+	updated_at: Generated<string>;
+}
+
+export interface BylineFieldValueTable {
+	byline_id: string;
+	field_id: string;
+	/** JSON-encoded value (`CustomFieldValue` after parse). */
+	value: string | null;
+	created_at: Generated<string>;
+	updated_at: Generated<string>;
+}
+
+export interface BylineFieldGroupValueTable {
+	translation_group: string;
+	field_id: string;
+	/** JSON-encoded value (`CustomFieldValue` after parse). */
+	value: string | null;
+	created_at: Generated<string>;
+	updated_at: Generated<string>;
+}
+
 // Rate Limits
 
 export interface RateLimitTable {

package/src/emdash-runtime.ts

@@ -2122,6 +2122,7 @@ export class EmDashRuntime {
 			orderBy?: string;
 			order?: "asc" | "desc";
 			locale?: string;
+			q?: string;
 		},
 	) {
 		return handleContentList(this.db, collection, params);
@@ -2271,6 +2272,7 @@ export class EmDashRuntime {
 				noIndex?: boolean;
 			};
 			publishedAt?: string | null;
+			locale?: string;
 			/** Skip revision creation (used by autosave) */
 			skipRevision?: boolean;
 			_rev?: string;
@@ -2279,7 +2281,7 @@ export class EmDashRuntime {
 		// Resolve slug → ID if needed (before any lookups)
 		const { ContentRepository } = await import("./database/repositories/content.js");
 		const repo = new ContentRepository(this.db);
-		const resolvedItem = await repo.findByIdOrSlug(collection, id);
+		const resolvedItem = await repo.findByIdOrSlug(collection, id, body.locale);
 		const resolvedId = resolvedItem?.id ?? id;
 
 		// Validate _rev early — before draft revision writes which modify updated_at.
@@ -2555,6 +2557,7 @@ export class EmDashRuntime {
 		cursor?: string;
 		limit?: number;
 		mimeType?: string | readonly string[];
+		q?: string;
 	}) {
 		return handleMediaList(this.db, params);
 	}

package/src/index.ts

@@ -96,6 +96,7 @@ export type {
 	PortableTextTextBlock,
 	PortableTextImageBlock,
 	PortableTextCodeBlock,
+	PortableTextHtmlBlock,
 	PortableTextUnknownBlock,
 	ProseMirrorMark,
 	ProseMirrorNode,

package/src/loader.ts

@@ -25,8 +25,28 @@ import { isMissingColumnError, isMissingTableError } from "./utils/db-errors.js"
 const FIELD_NAME_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
 
 /**
- * System columns that are not part of the content data
+ * SEO columns joined in from `_emdash_seo` on the single-entry path, mapped to
+ * aliased result keys. SEO lives in a side table, so a LEFT JOIN folds it into
+ * the entry load at zero extra query cost; the result is surfaced as a nested
+ * `data.seo` object (see extractSeo) rather than flat fields.
+ *
+ * The `_emdash_` prefix on the aliases guarantees they can never collide with
+ * a content field. Field slugs must match `/^[a-z][a-z0-9_]*$/`, so a user can
+ * legitimately define a `seo_title` field; selecting the joined column under
+ * its bare name would shadow that field in the result set and drop the user's
+ * value. The prefix (illegal as a leading slug char) sidesteps this entirely.
  */
+const SEO_COLUMN_ALIASES: Record<string, string> = {
+	seo_title: "_emdash_seo_title",
+	seo_description: "_emdash_seo_description",
+	seo_image: "_emdash_seo_image",
+	seo_canonical: "_emdash_seo_canonical",
+	seo_no_index: "_emdash_seo_no_index",
+};
+
+/** Aliased SEO result keys — excluded from generic field mapping. */
+const SEO_ALIAS_COLUMNS = Object.values(SEO_COLUMN_ALIASES);
+
 /**
  * System columns excluded from entry.data
  * Note: slug is intentionally NOT excluded - it's useful as data.slug in templates
@@ -47,8 +67,46 @@ const SYSTEM_COLUMNS = new Set([
 	"draft_revision_id",
 	"locale",
 	"translation_group",
+	// Aliased SEO columns joined from _emdash_seo on the single-entry path.
+	// Surfaced as a nested data.seo object (see extractSeo), never as flat
+	// fields. The aliases are _emdash_-prefixed so they can't shadow a user
+	// field named e.g. `seo_title`.
+	...SEO_ALIAS_COLUMNS,
 ]);
 
+/** Resolved SEO shape attached to `entry.data.seo`. Mirrors `ContentSeo`. */
+interface EntrySeo {
+	title: string | null;
+	description: string | null;
+	image: string | null;
+	canonical: string | null;
+	noIndex: boolean;
+}
+
+/**
+ * Build a `data.seo` object from the joined `_emdash_seo` columns on a row.
+ *
+ * Returns `null` when no SEO row exists (LEFT JOIN miss → `seo_no_index` is
+ * NULL, since the column is `NOT NULL DEFAULT 0` whenever a row is present).
+ * Returning null keeps the `seo` key off entries that have none, so
+ * `getSeoMeta()` falls back to its defaults exactly as before.
+ */
+function extractSeo(row: Record<string, unknown>): EntrySeo | null {
+	const noIndex = row[SEO_COLUMN_ALIASES.seo_no_index];
+	if (noIndex === null || noIndex === undefined) return null;
+	const title = row[SEO_COLUMN_ALIASES.seo_title];
+	const description = row[SEO_COLUMN_ALIASES.seo_description];
+	const image = row[SEO_COLUMN_ALIASES.seo_image];
+	const canonical = row[SEO_COLUMN_ALIASES.seo_canonical];
+	return {
+		title: typeof title === "string" ? title : null,
+		description: typeof description === "string" ? description : null,
+		image: typeof image === "string" ? image : null,
+		canonical: typeof canonical === "string" ? canonical : null,
+		noIndex: noIndex === 1,
+	};
+}
+
 /**
  * Get the table name for a collection type
  */
@@ -809,18 +867,36 @@ export function emdashLoader(): LiveLoader<EntryData, EntryFilter, CollectionFil
 
 				// Use raw SQL for dynamic table name, match by slug or id
 				// When locale is specified, prefer locale-scoped slug match,
-				// but IDs are globally unique so always check id without locale scope
+				// but IDs are globally unique so always check id without locale scope.
+				//
+				// LEFT JOIN _emdash_seo folds per-entry SEO (canonical, noindex,
+				// etc.) into this single query at zero extra round-trip cost. The
+				// joined columns are surfaced as a nested data.seo object via
+				// extractSeo() and excluded from the generic field mapping. SEO is
+				// 1:1 with content (PK on collection+content_id), so the join never
+				// multiplies rows.
+				const seoSelect = sql.join(
+					Object.entries(SEO_COLUMN_ALIASES).map(
+						([col, alias]) => sql`${sql.ref(`s.${col}`)} AS ${sql.ref(alias)}`,
+					),
+				);
 				const result = locale
 					? await sql<Record<string, unknown>>`
-							SELECT * FROM ${sql.ref(tableName)}
-							WHERE deleted_at IS NULL
-							AND ((slug = ${id} AND locale = ${locale}) OR id = ${id})
+							SELECT c.*, ${seoSelect}
+							FROM ${sql.ref(tableName)} AS c
+							LEFT JOIN ${sql.ref("_emdash_seo")} AS s
+								ON s.collection = ${type} AND s.content_id = c.id
+							WHERE c.deleted_at IS NULL
+							AND ((c.slug = ${id} AND c.locale = ${locale}) OR c.id = ${id})
 							LIMIT 1
 						`.execute(db)
 					: await sql<Record<string, unknown>>`
-							SELECT * FROM ${sql.ref(tableName)}
-							WHERE deleted_at IS NULL
-							AND (slug = ${id} OR id = ${id})
+							SELECT c.*, ${seoSelect}
+							FROM ${sql.ref(tableName)} AS c
+							LEFT JOIN ${sql.ref("_emdash_seo")} AS s
+								ON s.collection = ${type} AND s.content_id = c.id
+							WHERE c.deleted_at IS NULL
+							AND (c.slug = ${id} OR c.id = ${id})
 							LIMIT 1
 						`.execute(db);
 
@@ -872,11 +948,20 @@ export function emdashLoader(): LiveLoader<EntryData, EntryFilter, CollectionFil
 							revLocale !== "" &&
 							(revLocale !== i18nConfig.defaultLocale || i18nConfig.prefixDefaultLocale);
 						const revId = shouldPrefixRev ? `${revLocale}/${revSlug}` : revSlug;
+						// SEO is not revisioned — it comes from the content row's
+						// joined _emdash_seo columns, not the revision snapshot.
+						const revEntryData: Record<string, unknown> = {
+							...systemData,
+							slug,
+							...mapRevisionData(parsed),
+						};
+						const revSeo = extractSeo(row);
+						if (revSeo) revEntryData.seo = revSeo;
 						return {
 							id: revId,
 							slug,
 							status: rowStr(row, "status", "draft"),
-							data: { ...systemData, slug, ...mapRevisionData(parsed) },
+							data: revEntryData,
 							cacheHint: {
 								tags: [rowStr(row, "id")],
 								lastModified: row.updated_at ? new Date(rowStr(row, "updated_at")) : undefined,
@@ -885,11 +970,14 @@ export function emdashLoader(): LiveLoader<EntryData, EntryFilter, CollectionFil
 					}
 				}
 
+				const entryData = mapRowToData(row);
+				const entrySeo = extractSeo(row);
+				if (entrySeo) entryData.seo = entrySeo;
 				return {
 					id: entryId,
 					slug: rowStr(row, "slug"),
 					status: rowStr(row, "status", "draft"),
-					data: mapRowToData(row),
+					data: entryData,
 					cacheHint: {
 						tags: [rowStr(row, "id")],
 						lastModified: row.updated_at ? new Date(rowStr(row, "updated_at")) : undefined,

package/src/mcp/server.ts

@@ -632,6 +632,12 @@ export function createMcpServer(): McpServer {
 			inputSchema: z.object({
 				collection: z.string().describe("Collection slug"),
 				id: z.string().describe("Content item ID or slug"),
+				locale: z
+					.string()
+					.optional()
+					.describe(
+						"Locale to scope slug lookup (e.g. 'fr'). Only affects slug resolution; IDs are globally unique.",
+					),
 				data: z
 					.record(z.string(), z.unknown())
 					.optional()
@@ -677,7 +683,7 @@ export function createMcpServer(): McpServer {
 			const { emdash, userId, userRole } = getExtra(extra);
 
 			// Fetch item to check ownership
-			const existing = await emdash.handleContentGet(args.collection, args.id);
+			const existing = await emdash.handleContentGet(args.collection, args.id, args.locale);
 			if (!existing.success) {
 				return unwrap(existing);
 			}
@@ -713,6 +719,7 @@ export function createMcpServer(): McpServer {
 						data: args.data,
 						slug: args.slug,
 						authorId: userId,
+						locale: args.locale,
 						seo: args.seo,
 						bylines: args.bylines,
 						publishedAt: args.publishedAt,
@@ -736,6 +743,7 @@ export function createMcpServer(): McpServer {
 						data: args.data,
 						slug: args.slug,
 						authorId: userId,
+						locale: args.locale,
 						seo: args.seo,
 						bylines: args.bylines,
 						publishedAt: args.publishedAt,
@@ -751,6 +759,7 @@ export function createMcpServer(): McpServer {
 					data: args.data,
 					slug: args.slug,
 					authorId: userId,
+					locale: args.locale,
 					seo: args.seo,
 					bylines: args.bylines,
 					publishedAt: args.publishedAt,

package/src/request-cache.ts

@@ -111,3 +111,26 @@ export function setRequestCacheEntry<T>(key: string, value: T): void {
 	if (cache.has(key)) return;
 	cache.set(key, Promise.resolve(value));
 }
+
+/**
+ * Remove a key from the request-scoped cache.
+ *
+ * Used by write paths that need to invalidate a downstream read cache —
+ * `setRequestCacheEntry` deliberately doesn't overwrite, and `requestCached`
+ * returns the cached promise even after the underlying data has changed.
+ * Without an explicit clear, a `read → write → read` sequence in a single
+ * request can return stale data on the second read.
+ *
+ * Concrete case: `BylineRepository.update` invalidates
+ * `byline-field-group-values:${translation_group}` after writing a
+ * non-translatable custom-field value, so the post-update `findById`
+ * (and any later reads in the same request) see the fresh value.
+ *
+ * No-ops outside a request context.
+ */
+export function clearRequestCacheEntry(key: string): void {
+	const ctx = getRequestContext();
+	if (!ctx) return;
+	const cache = store.get(ctx);
+	cache?.delete(key);
+}