emdash 0.28.0 → 0.29.0

package/src/api/handlers/content.ts

@@ -5,6 +5,7 @@
 import type { Kysely } from "kysely";
 import { sql } from "kysely";
 
+import { isSqlite } from "../../database/dialect-helpers.js";
 import { BylineRepository } from "../../database/repositories/byline.js";
 import type { ContentBylineInput } from "../../database/repositories/byline.js";
 import { CommentRepository } from "../../database/repositories/comment.js";
@@ -12,6 +13,7 @@ import { ContentRepository } from "../../database/repositories/content.js";
 import { RedirectRepository } from "../../database/repositories/redirect.js";
 import { RevisionRepository } from "../../database/repositories/revision.js";
 import { SeoRepository } from "../../database/repositories/seo.js";
+import { TaxonomyRepository } from "../../database/repositories/taxonomy.js";
 import {
 	EmDashValidationError,
 	ScheduledNotDueError,
@@ -30,6 +32,8 @@ import type { Database } from "../../database/types.js";
 import { validateIdentifier } from "../../database/validate.js";
 import { getI18nConfig, isI18nEnabled } from "../../i18n/config.js";
 import { invalidateRedirectCache } from "../../redirects/cache.js";
+import { FTSManager } from "../../search/fts-manager.js";
+import { invalidateTermCache } from "../../taxonomies/index.js";
 import { isMissingTableError } from "../../utils/db-errors.js";
 import { encodeRev, validateRev } from "../rev.js";
 import type { ApiResult, ContentListResponse, ContentResponse } from "../types.js";
@@ -327,6 +331,30 @@ async function resolveSearchColumns(db: Kysely<Database>, collection: string): P
 	return columns;
 }
 
+/**
+ * Decide whether the content-list `q` filter can be served from the
+ * collection's FTS5 index instead of a full-scan substring LIKE (#1517).
+ *
+ * Requires SQLite (FTS5 is SQLite-only), search enabled on the collection,
+ * every non-slug display column present in the searchable-field set (or the
+ * index would miss matches the LIKE finds), and the index table actually
+ * existing.
+ */
+async function canUseFtsForListFilter(
+	db: Kysely<Database>,
+	collection: string,
+	searchColumns: string[],
+): Promise<boolean> {
+	if (!isSqlite(db)) return false;
+	const ftsManager = new FTSManager(db);
+	const config = await ftsManager.getSearchConfig(collection);
+	if (!config?.enabled) return false;
+	const searchable = new Set(await ftsManager.getSearchableFields(collection));
+	const covered = searchColumns.every((col) => col === "slug" || searchable.has(col));
+	if (!covered) return false;
+	return ftsManager.ftsTableExists(collection);
+}
+
 /**
  * Create a 301 auto-redirect from an entry's old URL to its new one after a
  * slug change, using the collection's URL pattern. Shared by
@@ -416,6 +444,7 @@ export async function handleContentList(
 		if (q) {
 			where.q = q;
 			where.searchColumns = await resolveSearchColumns(db, collection);
+			where.useFts = await canUseFtsForListFilter(db, collection, where.searchColumns);
 		}
 
 		const result = await repo.findMany(collection, {
@@ -638,6 +667,7 @@ export async function handleContentCreate(
 		locale?: string;
 		translationOf?: string;
 		seo?: ContentSeoInput;
+		taxonomies?: Record<string, string[]>;
 		createdAt?: string | null;
 		publishedAt?: string | null;
 	},
@@ -712,7 +742,6 @@ export async function handleContentCreate(
 			// when the target already has credits, but the cleaner guard
 			// is to skip the call entirely.
 			if (body.translationOf) {
-				const { TaxonomyRepository } = await import("../../database/repositories/taxonomy.js");
 				const taxRepo = new TaxonomyRepository(trx);
 				await taxRepo.copyEntryTerms(collection, body.translationOf, created.id);
 
@@ -737,6 +766,18 @@ export async function handleContentCreate(
 				created.seo = { ...SEO_DEFAULTS };
 			}
 
+			// Attach taxonomy terms in the same transaction. The MCP tool
+			// (and the REST create body) previously accepted a `taxonomies`
+			// field on `content_create` without doing anything with it, so
+			// agents publishing a categorized/tagged entry had to make N
+			// follow-up REST calls per taxonomy. This resolves each slug in
+			// the entry's locale and pipes it through the same
+			// `setTermsForEntry` path the `.../terms/{taxonomy}` REST route
+			// uses, so the two entry points can't drift.
+			if (body.taxonomies) {
+				await assignTaxonomies(trx, collection, created.id, effectiveLocale, body.taxonomies);
+			}
+
 			return created;
 		});
 
@@ -816,6 +857,7 @@ export async function handleContentUpdate(
 		locale?: string;
 		_rev?: string;
 		seo?: ContentSeoInput;
+		taxonomies?: Record<string, string[]>;
 		publishedAt?: string | null;
 	},
 ): Promise<ApiResult<ContentResponse>> {
@@ -922,6 +964,20 @@ export async function handleContentUpdate(
 
 			await hydrateBylines(trx, collection, updated);
 
+			// Replace taxonomy assignments in the same transaction. Uses the
+			// entry's own locale (post-update) to resolve slugs so an update
+			// that also changes locale still lands on the correct term
+			// variants. See handleContentCreate for rationale.
+			if (body.taxonomies) {
+				await assignTaxonomies(
+					trx,
+					collection,
+					resolvedId,
+					updated.locale ?? body.locale,
+					body.taxonomies,
+				);
+			}
+
 			return updated;
 		});
 
@@ -1769,3 +1825,57 @@ async function syncNonTranslatableFields(
 		AND id != ${updatedItemId}
 	`.execute(trx);
 }
+
+/**
+ * Resolve a `{ taxonomyName: [slug, ...] }` map to term IDs and replace the
+ * entry's assignments for each named taxonomy.
+ *
+ * Shared by handleContentCreate and handleContentUpdate so both MCP entry
+ * points behave identically. Slug resolution is scoped to `locale`; passing
+ * `undefined` lets `findBySlug` fall back to its default (lowest locale code)
+ * so callers on single-locale sites don't need to know the site's default.
+ *
+ * Throws EmDashValidationError on unknown slug or wrong shape; the calling
+ * handler translates that into a VALIDATION_ERROR response.
+ */
+async function assignTaxonomies(
+	trx: Kysely<Database>,
+	collection: string,
+	entryId: string,
+	locale: string | undefined,
+	taxonomies: Record<string, string[]>,
+): Promise<void> {
+	const taxRepo = new TaxonomyRepository(trx);
+	let anyChange = false;
+
+	for (const [taxonomyName, slugs] of Object.entries(taxonomies)) {
+		if (!Array.isArray(slugs)) {
+			throw new EmDashValidationError(`taxonomies.${taxonomyName} must be an array of term slugs`);
+		}
+
+		const termIds: string[] = [];
+		for (const slug of slugs) {
+			if (typeof slug !== "string" || slug.length === 0) {
+				throw new EmDashValidationError(
+					`taxonomies.${taxonomyName} contains a non-string or empty slug`,
+				);
+			}
+			const term = await taxRepo.findBySlug(taxonomyName, slug, locale);
+			if (!term) {
+				throw new EmDashValidationError(
+					`Unknown taxonomy term: ${taxonomyName}='${slug}'${
+						locale ? ` (locale '${locale}')` : ""
+					}`,
+				);
+			}
+			termIds.push(term.id);
+		}
+
+		await taxRepo.setTermsForEntry(collection, entryId, taxonomyName, termIds);
+		anyChange = true;
+	}
+
+	// Match the REST route's behaviour: taxonomy term assignments changed,
+	// so invalidate the taxonomy object cache used during hydration.
+	if (anyChange) invalidateTermCache();
+}

package/src/api/handlers/dashboard.ts

@@ -21,6 +21,7 @@ export interface CollectionStats {
 	total: number;
 	published: number;
 	draft: number;
+	scheduled: number;
 }
 
 export interface RecentItem {
@@ -69,6 +70,7 @@ export async function handleDashboardStats(
 					total: stats.total,
 					published: stats.published,
 					draft: stats.draft,
+					scheduled: stats.scheduled,
 				};
 			}),
 		);

package/src/api/handlers/index.ts

@@ -61,6 +61,12 @@ export {
 	type MediaResponse,
 } from "./media.js";
 
+export {
+	handleMediaUsageRepair,
+	toMediaUsageRepairResponse,
+	type MediaUsageRepairResponse,
+} from "./media-usage.js";
+
 // Schema handlers
 export {
 	handleSchemaCollectionList,

package/src/api/handlers/media-usage.ts

@@ -0,0 +1,80 @@
+import type { Kysely } from "kysely";
+
+import type { Database } from "../../database/types.js";
+import {
+	repairContentMediaUsageAll,
+	repairContentMediaUsageCollection,
+	type ContentMediaUsageRepairAllResult,
+	type ContentMediaUsageRepairCollectionResult,
+} from "../../media/usage/content-repair.js";
+import { ErrorCode } from "../errors.js";
+import type { MediaUsageRepairRequest, MediaUsageRepairResponse } from "../schemas/media-usage.js";
+import type { ApiResult } from "../types.js";
+
+export type { MediaUsageRepairRequest, MediaUsageRepairResponse } from "../schemas/media-usage.js";
+
+type ContentMediaUsageRepairResult =
+	| ContentMediaUsageRepairCollectionResult
+	| ContentMediaUsageRepairAllResult;
+
+export async function handleMediaUsageRepair(
+	db: Kysely<Database>,
+	input: MediaUsageRepairRequest,
+): Promise<ApiResult<MediaUsageRepairResponse>> {
+	try {
+		let result: ContentMediaUsageRepairResult;
+		if (input.scope === "collection") {
+			result = await repairContentMediaUsageCollection(db, { collectionSlug: input.collection });
+		} else if (input.scope === "all") {
+			result = await repairContentMediaUsageAll(db);
+		} else {
+			return {
+				success: false,
+				error: {
+					code: ErrorCode.VALIDATION_ERROR,
+					message: "Invalid media usage repair request",
+				},
+			};
+		}
+
+		return { success: true, data: toMediaUsageRepairResponse(result) };
+	} catch (error) {
+		console.error("[media-usage] repair failed:", error);
+		return {
+			success: false,
+			error: {
+				code: ErrorCode.MEDIA_USAGE_REPAIR_ERROR,
+				message: "Failed to repair media usage",
+			},
+		};
+	}
+}
+
+export function toMediaUsageRepairResponse(
+	result: ContentMediaUsageRepairResult,
+): MediaUsageRepairResponse {
+	const collections = "collections" in result ? result.collections : [result];
+
+	return {
+		status: result.status,
+		indexedSourceCount: result.indexedSourceCount,
+		failedSourceCount: result.failedSourceCount,
+		skippedSourceCount: result.skippedSourceCount,
+		deletedSourceCount: result.deletedSourceCount,
+		collections: collections.map(toMediaUsageRepairCollectionSummary),
+	};
+}
+
+function toMediaUsageRepairCollectionSummary(result: ContentMediaUsageRepairCollectionResult) {
+	return {
+		collection: result.scope.scopeKey,
+		status: result.status,
+		indexedSourceCount: result.indexedSourceCount,
+		failedSourceCount: result.failedSourceCount,
+		skippedSourceCount: result.skippedSourceCount,
+		deletedSourceCount: result.deletedSourceCount,
+		lastErrorCode: result.lastErrorCode,
+		startedAt: result.startedAt,
+		completedAt: result.completedAt,
+	};
+}