emdash 0.28.1 → 0.30.0

package/src/database/repositories/taxonomy.ts

@@ -1,8 +1,33 @@
-import type { Kysely, Selectable } from "kysely";
+import { sql, type Kysely, type Selectable } from "kysely";
 import { ulid } from "ulidx";
 
 import { invalidateTaxonomyObjectCache } from "../../object-cache/index.js";
-import type { Database, TaxonomyTable, ContentTaxonomyTable } from "../types.js";
+import { isMissingTableError } from "../../utils/db-errors.js";
+import type { Database, TaxonomyTable } from "../types.js";
+import { validateIdentifier } from "../validate.js";
+
+/**
+ * Filter + sort columns denormalized from an entry's `ec_*` row onto its
+ * `content_taxonomies` pivot rows (migration 051). Stamped at insert time so a
+ * newly-tagged entry is immediately seekable by a taxonomy-filtered listing.
+ */
+interface PivotDenorm {
+	status: string | null;
+	scheduled_at: string | null;
+	deleted_at: string | null;
+	locale: string | null;
+	published_at: string | null;
+	created_at: string | null;
+}
+
+const EMPTY_DENORM: PivotDenorm = {
+	status: null,
+	scheduled_at: null,
+	deleted_at: null,
+	locale: null,
+	published_at: null,
+	created_at: null,
+};
 
 export interface Taxonomy {
 	id: string;
@@ -251,14 +276,10 @@ export class TaxonomyRepository {
 		const group = await this.resolveTranslationGroup(taxonomyId);
 		if (!group) return;
 
-		const row: ContentTaxonomyTable = {
-			collection,
-			entry_id: entryId,
-			taxonomy_id: group,
-		};
+		const denorm = await this.fetchEntryDenorm(collection, entryId);
 		await this.db
 			.insertInto("content_taxonomies")
-			.values(row)
+			.values({ collection, entry_id: entryId, taxonomy_id: group, ...denorm })
 			.onConflict((oc) => oc.doNothing())
 			.execute();
 		invalidateTaxonomyObjectCache();
@@ -342,6 +363,7 @@ export class TaxonomyRepository {
 
 		const toAdd = [...newGroups].filter((g) => !currentGroups.has(g));
 		if (toAdd.length > 0) {
+			const denorm = await this.fetchEntryDenorm(collection, entryId);
 			await this.db
 				.insertInto("content_taxonomies")
 				.values(
@@ -349,6 +371,7 @@ export class TaxonomyRepository {
 						collection,
 						entry_id: entryId,
 						taxonomy_id,
+						...denorm,
 					})),
 				)
 				.onConflict((oc) => oc.doNothing())
@@ -387,6 +410,9 @@ export class TaxonomyRepository {
 			.execute();
 		if (rows.length === 0) return;
 
+		// Stamp the TARGET entry's current values — the copy inherits the source's
+		// term memberships but the target's own status/dates/locale.
+		const denorm = await this.fetchEntryDenorm(collection, targetEntryId);
 		await this.db
 			.insertInto("content_taxonomies")
 			.values(
@@ -394,6 +420,7 @@ export class TaxonomyRepository {
 					collection,
 					entry_id: targetEntryId,
 					taxonomy_id: r.taxonomy_id,
+					...denorm,
 				})),
 			)
 			.onConflict((oc) => oc.doNothing())
@@ -401,9 +428,37 @@ export class TaxonomyRepository {
 		invalidateTaxonomyObjectCache();
 	}
 
+	/**
+	 * Read the denormalized filter + sort columns from an entry's `ec_*` row so
+	 * they can be stamped onto new pivot rows (migration 051). A missing table or
+	 * missing row yields all-nulls: the pivot columns are advisory, and the
+	 * listing read path re-checks the authoritative `ec_*` row regardless.
+	 */
+	private async fetchEntryDenorm(collection: string, entryId: string): Promise<PivotDenorm> {
+		validateIdentifier(collection, "collection type");
+		const tableName = `ec_${collection}`;
+		try {
+			const result = await sql<PivotDenorm>`
+				SELECT status, scheduled_at, deleted_at, locale, published_at, created_at
+				FROM ${sql.ref(tableName)}
+				WHERE id = ${entryId}
+			`.execute(this.db);
+			return result.rows[0] ?? EMPTY_DENORM;
+		} catch (error) {
+			if (isMissingTableError(error)) return EMPTY_DENORM;
+			throw error;
+		}
+	}
+
 	/**
 	 * Count content entries that use any translation of this term. Accepts
 	 * either a term id or a translation_group — we normalise to the group.
+	 *
+	 * Counts raw pivot rows regardless of the entry's status or deletion —
+	 * drafts and trashed entries are included. User-facing counts (admin term
+	 * list/get, public widget and term pages) use `fetchVisibleTermCounts`
+	 * from `taxonomies/term-counts.ts` instead, which counts only publicly
+	 * visible entries.
 	 */
 	async countEntriesWithTerm(termIdOrGroup: string): Promise<number> {
 		const group = await this.resolveTranslationGroup(termIdOrGroup);
@@ -453,6 +508,9 @@ export class TaxonomyRepository {
 	 *
 	 * Pass translation_groups (not term ids) — `content_taxonomies.taxonomy_id`
 	 * stores the translation_group so a single assignment spans every locale.
+	 *
+	 * Like `countEntriesWithTerm`, this counts raw pivot rows regardless of
+	 * status/deletion; user-facing counts go through `fetchVisibleTermCounts`.
 	 */
 	async countEntriesForTerms(translationGroups: string[]): Promise<Map<string, number>> {
 		if (translationGroups.length === 0) return new Map();

package/src/database/repositories/types.ts

@@ -158,6 +158,14 @@ export interface FindManyOptions {
 		 * repository stays generic. Each name is validated as a SQL identifier.
 		 */
 		searchColumns?: string[];
+		/**
+		 * Serve `q` from the collection's FTS5 index (`_emdash_fts_<slug>`)
+		 * instead of an unindexable substring LIKE. Set by the handler only
+		 * when the collection has search enabled and the index exists
+		 * (SQLite only). The repository combines a token-prefix MATCH with
+		 * an index-served slug prefix so slug lookups keep working.
+		 */
+		useFts?: boolean;
 		/** Inclusive date range over a whitelisted timestamp column. */
 		dateFilter?: ContentDateFilter;
 	};

package/src/database/types.ts

@@ -28,6 +28,27 @@ export interface ContentTaxonomyTable {
 	collection: string; // e.g., 'posts'
 	entry_id: string; // ID in the ec_* table
 	taxonomy_id: string; // stores taxonomies.translation_group (locale-agnostic)
+	// Denormalized filter + sort columns mirrored from the entry's ec_* row
+	// (migration 051). They let a taxonomy-filtered listing seek the matching
+	// entries directly on the pivot instead of scanning the whole collection.
+	//
+	// ADVISORY, not authoritative: D1 has no transactions, so the write-path
+	// re-stamp (ContentRepository / TaxonomyRepository) is a separate statement
+	// from the ec_* mutation and can be transiently stale. The read path narrows
+	// the candidate set with these columns but re-checks the real filter
+	// predicates on the joined ec_* row. `updated_at` is deliberately NOT
+	// denormalized — it moves on every edit, so denormalizing it would force a
+	// pivot re-stamp on the common edit path for little read value.
+	//
+	// Nullable/Generated so inserts that predate a re-stamp (or the migration
+	// backfill) leave them NULL; every insert site in the repositories stamps
+	// them explicitly.
+	status: Generated<string | null>;
+	scheduled_at: Generated<string | null>;
+	deleted_at: Generated<string | null>;
+	locale: Generated<string | null>;
+	published_at: Generated<string | null>;
+	created_at: Generated<string | null>;
 }
 
 export interface TaxonomyDefTable {
@@ -341,6 +362,8 @@ export interface PluginStateTable {
 	// `source = 'config' | 'marketplace'`; populated for `source = 'registry'`.
 	registry_publisher_did: string | null;
 	registry_slug: string | null;
+	mcp_tools_enabled: Generated<number>;
+	mcp_tools_consent: string | null;
 }
 
 export interface PluginIndexTable {

package/src/db/adapters.ts

@@ -48,6 +48,15 @@ export interface DatabaseDescriptor {
 	 * the middleware takes its default (singleton) path.
 	 */
 	supportsRequestScope?: boolean;
+	/**
+	 * When true, the adapter's runtime entrypoint MUST export a named
+	 * `createCoalescingDialect` function. The runtime uses this fresh dialect
+	 * only for its cold-start read batch.
+	 *
+	 * When false or absent, the virtual module exports `undefined` without
+	 * inspecting an optional entrypoint export.
+	 */
+	supportsCoalescing?: boolean;
 }
 
 export interface SqliteConfig {

package/src/db/postgres.ts

@@ -5,9 +5,10 @@
  * Loaded at runtime via virtual module.
  */
 
-import { PostgresDialect } from "kysely";
+import type { PostgresDialect } from "kysely";
 import { Pool } from "pg";
 
+import { FailFastPostgresDialect } from "../database/pg-migration-lock.js";
 import type { PostgresConfig } from "./adapters.js";
 
 /**
@@ -26,5 +27,7 @@ export function createDialect(config: PostgresConfig): PostgresDialect {
 		max: config.pool?.max ?? 10,
 	});
 
-	return new PostgresDialect({ pool });
+	// Fail-fast migration locking instead of Kysely's blocking advisory
+	// lock — see pg-migration-lock.ts (#1744).
+	return new FailFastPostgresDialect({ pool });
 }