emdash 1.2.0 → 1.3.1

package/src/schema/registry.ts

@@ -10,6 +10,7 @@ import { sql } from "kysely";
 import { ulid } from "ulidx";
 
 import { refreshDevTypes } from "../astro/dev-typegen.js";
+import { deleteSharedCollectionRecords } from "../database/collection-cleanup.js";
 import {
 	columnExists,
 	currentTimestamp,
@@ -1211,11 +1212,18 @@ export class SchemaRegistry {
 				const ftsManager = new FTSManager(trx);
 				await ftsManager.dropFtsTable(slug);
 
-				// Drop the content table
+				// Drop the content table first: ec_* rows hold foreign keys to
+				// revisions.id, so the content table must go before revisions can
+				// be removed.
 				const tableName = this.getTableName(slug);
 				await sql`DROP TABLE IF EXISTS ${sql.ref(tableName)}`.execute(trx);
 				contentTableDropped = true;
 
+				// Remove shared-table records that are keyed by collection slug.
+				// Dropping the content table or deleting the collection row does not
+				// cascade to these, so they have to be cleared explicitly.
+				await deleteSharedCollectionRecords(trx, slug);
+
 				// Delete the collection record (fields will cascade)
 				await trx.deleteFrom("_emdash_collections").where("id", "=", existing.id).execute();
 			});
@@ -1316,6 +1324,7 @@ export class SchemaRegistry {
 		);
 
 		let schemaMutated = false;
+		let fieldStorageReady = false;
 		try {
 			const created = await withTransaction(this.db, async (trx) => {
 				// Insert field record
@@ -1359,6 +1368,8 @@ export class SchemaRegistry {
 					);
 				}
 
+				fieldStorageReady = true;
+
 				if (input.indexed) {
 					await this.createFieldIndex(collectionSlug, id, input.slug, trx);
 				}
@@ -1397,6 +1408,12 @@ export class SchemaRegistry {
 			return created;
 		} catch (error) {
 			if (schemaMutated) {
+				// D1 cannot roll back the insert when ADD COLUMN fails. Once storage
+				// exists, later failures must not remove its field metadata.
+				if (!fieldStorageReady) {
+					await this.db.deleteFrom("_emdash_fields").where("id", "=", id).execute();
+				}
+
 				if (activeCoverageInvalidated) {
 					await invalidateContentMediaUsageSchemaChange(this.db, collectionSlug);
 				} else {

package/src/schema/zod-generator.ts

@@ -164,6 +164,7 @@ function getBaseSchema(type: FieldType, field: Pick<Field, "validation">): ZodTy
 				id: z.string(),
 				src: z.string().optional(),
 				alt: z.string().optional(),
+				caption: z.string().optional(),
 				width: z.number().optional(),
 				height: z.number().optional(),
 				filename: z.string().optional(),
@@ -641,7 +642,7 @@ function fieldTypeToTypeScript(field: {
 
 		case "image": {
 			const media =
-				"{ id: string; src?: string; alt?: string; width?: number; height?: number; filename?: string; mimeType?: string; blurhash?: string; dominantColor?: string; focalX?: number; focalY?: number; provider?: string; previewUrl?: string; meta?: Record<string, unknown> }";
+				"{ id: string; src?: string; alt?: string; caption?: string; width?: number; height?: number; filename?: string; mimeType?: string; blurhash?: string; dominantColor?: string; focalX?: number; focalY?: number; provider?: string; previewUrl?: string; meta?: Record<string, unknown> }";
 			return `${media.slice(0, -2)}; darkVariant?: ${media} }`;
 		}
 

package/src/search/fts-manager.ts

@@ -27,6 +27,47 @@ function resolveSearchTokenizer(tokenize?: SearchTokenizer): SearchTokenizer {
 	return tokenize;
 }
 
+export interface CollectionSearchMetadata {
+	config: SearchConfig;
+	searchableFields: string[];
+	hasTitle: boolean;
+}
+
+function parseSearchConfig(searchConfig: string, titleField: string | null): SearchConfig | null {
+	try {
+		const parsed: unknown = JSON.parse(searchConfig);
+		if (
+			typeof parsed !== "object" ||
+			parsed === null ||
+			!("enabled" in parsed) ||
+			typeof parsed.enabled !== "boolean"
+		) {
+			return null;
+		}
+		const config: SearchConfig = { enabled: parsed.enabled };
+		if (titleField) config.titleField = titleField;
+		if ("weights" in parsed && typeof parsed.weights === "object" && parsed.weights !== null) {
+			// weights is a JSON-parsed object — safe to treat as Record<string, number>
+			const weights: Record<string, number> = {};
+			for (const [k, v] of Object.entries(parsed.weights)) {
+				if (typeof v === "number") {
+					weights[k] = v;
+				}
+			}
+			config.weights = weights;
+		}
+		if ("tokenize" in parsed) {
+			if (!isSearchTokenizer(parsed.tokenize)) {
+				return null;
+			}
+			config.tokenize = parsed.tokenize;
+		}
+		return config;
+	} catch {
+		return null;
+	}
+}
+
 /**
  * FTS5 Manager
  *
@@ -394,38 +435,67 @@ export class FTSManager {
 			return null;
 		}
 
-		try {
-			const parsed: unknown = JSON.parse(result.search_config);
+		return parseSearchConfig(result.search_config, result.title_field);
+	}
+
+	/**
+	 * Load all metadata needed to search the requested collections in one round trip.
+	 * Omitted or empty slugs select all search-enabled collections.
+	 */
+	async getSearchMetadata(
+		collectionSlugs?: string[],
+	): Promise<Map<string, CollectionSearchMetadata>> {
+		if (!isSqlite(this.db)) return new Map();
+
+		let query = this.db
+			.selectFrom("_emdash_collections as c")
+			.select([
+				"c.slug",
+				"c.search_config",
+				"c.title_field",
+				// bm25 weights are positional, so use the index's physical column order.
+				sql<string>`(
+					SELECT json_group_array(name ORDER BY cid)
+					FROM pragma_table_info(${"_emdash_fts_"} || c.slug)
+					WHERE cid >= 2
+				)`.as("searchable_fields"),
+				sql<number>`EXISTS (
+					SELECT 1 FROM _emdash_fields WHERE collection_id = c.id AND slug = 'title'
+				)`.as("has_title"),
+			])
+			.where("c.search_config", "is not", null).where(sql<boolean>`EXISTS (
+				SELECT 1 FROM sqlite_master
+				WHERE type = 'table' AND name = ${"_emdash_fts_"} || c.slug
+			)`);
+
+		if (collectionSlugs?.length) {
+			query = query.where(
+				"c.slug",
+				"in",
+				sql<string>`(SELECT value FROM json_each(${JSON.stringify(collectionSlugs)}))`,
+			);
+		}
+
+		const metadata = new Map<string, CollectionSearchMetadata>();
+		for (const row of await query.execute()) {
+			const config = row.search_config
+				? parseSearchConfig(row.search_config, row.title_field)
+				: null;
+			if (!config?.enabled) continue;
+			const searchableFields: unknown = JSON.parse(row.searchable_fields);
 			if (
-				typeof parsed !== "object" ||
-				parsed === null ||
-				!("enabled" in parsed) ||
-				typeof parsed.enabled !== "boolean"
+				!Array.isArray(searchableFields) ||
+				!searchableFields.every((field: unknown) => typeof field === "string")
 			) {
-				return null;
-			}
-			const config: SearchConfig = { enabled: parsed.enabled };
-			if (result.title_field) config.titleField = result.title_field;
-			if ("weights" in parsed && typeof parsed.weights === "object" && parsed.weights !== null) {
-				// weights is a JSON-parsed object — safe to treat as Record<string, number>
-				const weights: Record<string, number> = {};
-				for (const [k, v] of Object.entries(parsed.weights)) {
-					if (typeof v === "number") {
-						weights[k] = v;
-					}
-				}
-				config.weights = weights;
+				throw new Error("Invalid FTS field metadata");
 			}
-			if ("tokenize" in parsed) {
-				if (!isSearchTokenizer(parsed.tokenize)) {
-					return null;
-				}
-				config.tokenize = parsed.tokenize;
-			}
-			return config;
-		} catch {
-			return null;
+			metadata.set(row.slug, {
+				config,
+				searchableFields,
+				hasTitle: Boolean(row.has_title),
+			});
 		}
+		return metadata;
 	}
 
 	/**

package/src/search/query.ts

@@ -11,8 +11,10 @@ import { encodeCursor, decodeCursor, InvalidCursorError } from "../database/repo
 import type { Database } from "../database/types.js";
 import { validateIdentifier } from "../database/validate.js";
 import { resolveConfiguredLocale } from "../i18n/config.js";
+import { localeMatches } from "../i18n/query.js";
 import { getDb } from "../loader.js";
 import { FTSManager } from "./fts-manager.js";
+import type { CollectionSearchMetadata } from "./fts-manager.js";
 import type {
 	SearchOptions,
 	CollectionSearchOptions,
@@ -63,7 +65,9 @@ function decodeSearchOffset(cursor: string): number {
 
 /** 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;
+// FTS5 operators are uppercase-only; a case-insensitive match would treat
+// ordinary words as syntax and skip the safe quoting path below.
+const FTS_OPERATORS_PATTERN = /\b(AND|OR|NOT|NEAR)\b/;
 const DOUBLE_QUOTE_PATTERN = /"/g;
 
 /**
@@ -128,15 +132,10 @@ export async function searchWithDb(
 	const status = options.status ?? "published";
 	const offset = options.cursor ? decodeSearchOffset(options.cursor) : 0;
 
-	// Get searchable collections
-	let collections = options.collections;
-	if (!collections || collections.length === 0) {
-		collections = await getSearchableCollections(db);
-	}
+	if (!escapeQuery(query)) return { items: [] };
 
-	if (collections.length === 0) {
-		return { items: [] };
-	}
+	const metadata = await ftsManager.getSearchMetadata(options.collections);
+	const collections = options.collections?.length ? options.collections : [...metadata.keys()];
 
 	// To rank the merged window [offset, offset + limit) correctly, each
 	// collection must contribute its own top (offset + limit) rows — in the
@@ -146,11 +145,9 @@ export async function searchWithDb(
 
 	// 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);
-		if (!config?.enabled) {
+		const collectionMetadata = metadata.get(collection);
+		if (!collectionMetadata) {
 			continue;
 		}
 
@@ -164,9 +161,7 @@ export async function searchWithDb(
 				limit: perCollectionLimit,
 				scope: options.scope,
 			},
-			config.weights,
-			titleColumns.has(collection),
-			config.titleField,
+			collectionMetadata,
 		);
 
 		allResults.push(...collectionResults);
@@ -206,15 +201,13 @@ export async function searchCollection(
 	query: string,
 	options: CollectionSearchOptions = {},
 ): Promise<SearchResponse> {
-	const ftsManager = new FTSManager(db);
-	const config = await ftsManager.getSearchConfig(collection);
-
-	if (!config?.enabled) {
-		return { items: [] };
-	}
-
 	const limit = options.limit ?? 20;
 	const offset = options.cursor ? decodeSearchOffset(options.cursor) : 0;
+	if (!escapeQuery(query)) return { items: [] };
+
+	const ftsManager = new FTSManager(db);
+	const metadata = (await ftsManager.getSearchMetadata([collection])).get(collection);
+	if (!metadata) return { items: [] };
 
 	// 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
@@ -229,9 +222,7 @@ export async function searchCollection(
 			limit: offset + limit + 1,
 			scope: options.scope,
 		},
-		config.weights,
-		undefined,
-		config.titleField,
+		metadata,
 	);
 
 	const items = fetched.slice(offset, offset + limit);
@@ -249,9 +240,7 @@ async function searchSingleCollection(
 	collection: string,
 	query: string,
 	options: CollectionSearchOptions,
-	weights?: Record<string, number>,
-	hasTitle?: boolean,
-	titleField?: string,
+	metadata: CollectionSearchMetadata,
 ): Promise<SearchResult[]> {
 	// Validate before any raw SQL interpolation
 	validateIdentifier(collection, "collection slug");
@@ -263,11 +252,6 @@ async function searchSingleCollection(
 	const status = options.status ?? "published";
 	const locale = options.locale ? resolveConfiguredLocale(options.locale) : undefined;
 
-	// Check if FTS table exists
-	if (!(await ftsManager.ftsTableExists(collection))) {
-		return [];
-	}
-
 	// Escape the query for FTS5
 	const escapedQuery = escapeQuery(query);
 	if (!escapedQuery) {
@@ -275,7 +259,8 @@ async function searchSingleCollection(
 	}
 
 	// Get searchable fields for snippet generation
-	const searchableFields = await ftsManager.getSearchableFields(collection);
+	const { searchableFields, hasTitle, config } = metadata;
+	const { weights, titleField } = config;
 
 	// Title scope restricts the FTS5 match to the collection's title column.
 	// The scoped column must be one of the indexed searchable fields; a
@@ -298,9 +283,7 @@ 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". Multi-collection callers
-	// precompute this in bulk and pass it in; single-collection callers fall
-	// back to the per-collection check.
+	// errors with "no such column: c.title".
 	// 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.
@@ -309,8 +292,7 @@ async function searchSingleCollection(
 		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`;
+		titleExpr = hasTitle ? sql`c.title` : sql`NULL`;
 	}
 
 	// Build weight string for bm25 if weights provided
@@ -352,7 +334,7 @@ async function searchSingleCollection(
 		WHERE "${sql.raw(ftsTable)}" MATCH ${matchQuery}
 		AND c.status = ${status}
 		AND c.deleted_at IS NULL
-		${locale ? sql`AND c.locale = ${locale}` : sql``}
+		${locale ? sql`AND ${localeMatches("c.locale", locale)}` : sql``}
 		ORDER BY score
 		LIMIT ${limit}
 	`.execute(db);
@@ -438,25 +420,19 @@ export async function getSuggestions(
 	const limit = options.limit ?? 5;
 	const locale = options.locale ? resolveConfiguredLocale(options.locale) : undefined;
 
-	// Get searchable collections
-	let collections = options.collections;
-	if (!collections || collections.length === 0) {
-		collections = await getSearchableCollections(db);
-	}
-
-	if (collections.length === 0) {
-		return [];
-	}
+	// escapeQuery already appends the prefix wildcard to each term.
+	const prefixQuery = escapeQuery(query);
+	if (!prefixQuery) return [];
 
-	const suggestions: Suggestion[] = [];
 	const ftsManager = new FTSManager(db);
-	const titleColumns = await ftsManager.getCollectionsWithTitleColumn(collections);
+	const metadata = await ftsManager.getSearchMetadata(options.collections);
+	const collections = options.collections?.length ? options.collections : [...metadata.keys()];
+	const suggestions: Suggestion[] = [];
 
 	for (const collection of collections) {
-		const config = await ftsManager.getSearchConfig(collection);
-		if (!config?.enabled) {
-			continue;
-		}
+		const collectionMetadata = metadata.get(collection);
+		if (!collectionMetadata) continue;
+		const { config, hasTitle } = collectionMetadata;
 
 		// Suggestions are title-based (Suggestion.title is required). A configured
 		// titleField supplies it -- a validated existing column -- so it
@@ -468,7 +444,7 @@ export async function getSuggestions(
 		if (config.titleField) {
 			validateIdentifier(config.titleField, "title field");
 			titleExpr = sql`c.${sql.ref(config.titleField)}`;
-		} else if (titleColumns.has(collection)) {
+		} else if (hasTitle) {
 			titleExpr = sql`c.title`;
 		} else {
 			continue;
@@ -480,13 +456,6 @@ export async function getSuggestions(
 		const ftsTable = ftsManager.getFtsTableName(collection);
 		const contentTable = ftsManager.getContentTableName(collection);
 
-		// Use prefix search for autocomplete. `escapeQuery` already appends `*`
-		// to each term for prefix matching, so we must not append another one.
-		const prefixQuery = escapeQuery(query);
-		if (!prefixQuery) {
-			continue;
-		}
-
 		let results;
 		try {
 			results = await sql<{
@@ -504,7 +473,7 @@ export async function getSuggestions(
 				AND c.status = 'published'
 				AND c.deleted_at IS NULL
 				AND ${titleExpr} IS NOT NULL
-				${locale ? sql`AND c.locale = ${locale}` : sql``}
+				${locale ? sql`AND ${localeMatches("c.locale", locale)}` : sql``}
 				ORDER BY bm25("${sql.raw(ftsTable)}")
 				LIMIT ${limit}
 			`.execute(db);