emdash 0.4.0 → 0.6.0

package/src/search/query.ts

@@ -275,9 +275,10 @@ export async function getSuggestions(
 		const ftsTable = ftsManager.getFtsTableName(collection);
 		const contentTable = ftsManager.getContentTableName(collection);
 
-		// Use prefix search for autocomplete
-		const prefixQuery = `${escapeQuery(query)}*`;
-		if (!prefixQuery || prefixQuery === "*") {
+		// 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;
 		}
 

package/src/seed/apply.ts

@@ -792,7 +792,15 @@ async function applyContentTaxonomies(
 			.execute();
 	}
 
-	if (!entry.taxonomies) return;
+	if (!entry.taxonomies) {
+		// In update mode we may have just deleted rows above; invalidate so
+		// hydration doesn't serve stale "has terms" cached value.
+		if (isUpdate) {
+			const { invalidateTermCache } = await import("../taxonomies/index.js");
+			invalidateTermCache();
+		}
+		return;
+	}
 
 	for (const [taxonomyName, termSlugs] of Object.entries(entry.taxonomies)) {
 		const termRepo = new TaxonomyRepository(db);
@@ -804,6 +812,12 @@ async function applyContentTaxonomies(
 			}
 		}
 	}
+
+	// Seed writes directly to content_taxonomies. Clear the cache so
+	// the worker lifetime cached "has any term assignments" probe
+	// re-runs on the next read.
+	const { invalidateTermCache } = await import("../taxonomies/index.js");
+	invalidateTermCache();
 }
 
 /**

package/src/settings/index.ts

@@ -11,6 +11,7 @@ import { MediaRepository } from "../database/repositories/media.js";
 import { OptionsRepository } from "../database/repositories/options.js";
 import type { Database } from "../database/types.js";
 import { getDb } from "../loader.js";
+import { peekRequestCache, requestCached } from "../request-cache.js";
 import type { Storage } from "../storage/types.js";
 import type { SiteSettings, SiteSettingKey, MediaReference } from "./types.js";
 
@@ -75,8 +76,24 @@ async function resolveMediaReference(
 export async function getSiteSetting<K extends SiteSettingKey>(
 	key: K,
 ): Promise<SiteSettings[K] | undefined> {
-	const db = await getDb();
-	return getSiteSettingWithDb(key, db);
+	// If `getSiteSettings()` has already been called in this request,
+	// read from that (request-cached) batch rather than firing a second
+	// options-table query. Common layout: a Base template pulls the
+	// whole settings object up-front, then `EmDashHead` or a plugin
+	// asks for one key — no reason the singular call should round-trip
+	// again.
+	const primed = peekRequestCache<Partial<SiteSettings>>("siteSettings");
+	if (primed) {
+		const settings = await primed;
+		return settings[key];
+	}
+
+	// Otherwise cache per-key. Templates that pull several settings
+	// independently still share the in-flight query for each one.
+	return requestCached(`siteSetting:${key}`, async () => {
+		const db = await getDb();
+		return getSiteSettingWithDb(key, db);
+	});
 }
 
 /**
@@ -124,9 +141,11 @@ export async function getSiteSettingWithDb<K extends SiteSettingKey>(
  * console.log(settings.logo?.url); // "/_emdash/api/media/file/abc123"
  * ```
  */
-export async function getSiteSettings(): Promise<Partial<SiteSettings>> {
-	const db = await getDb();
-	return getSiteSettingsWithDb(db);
+export function getSiteSettings(): Promise<Partial<SiteSettings>> {
+	return requestCached("siteSettings", async () => {
+		const db = await getDb();
+		return getSiteSettingsWithDb(db);
+	});
 }
 
 /**

package/src/taxonomies/index.ts

@@ -5,103 +5,125 @@
  */
 
 import { getDb } from "../loader.js";
+import { requestCached, setRequestCacheEntry } from "../request-cache.js";
+import { chunks, SQL_BATCH_SIZE } from "../utils/chunks.js";
+import { isMissingTableError } from "../utils/db-errors.js";
 import type { TaxonomyDef, TaxonomyTerm, TaxonomyTermRow } from "./types.js";
 
+/**
+ * No-op — kept for API compatibility.
+ *
+ * Used to invalidate a worker-lifetime "has any term assignments?" probe.
+ * That probe added a query on every cold isolate to save one query on
+ * sites with zero term assignments (i.e. the wrong tradeoff), so we
+ * dropped it. The batch term join below returns an empty map for empty
+ * sites at the same cost as the probe, without the pre-check.
+ */
+export function invalidateTermCache(): void {
+	// Intentionally empty.
+}
+
 /**
  * Get all taxonomy definitions
  */
 export async function getTaxonomyDefs(): Promise<TaxonomyDef[]> {
-	const db = await getDb();
+	return requestCached("taxonomy-defs:all", async () => {
+		const db = await getDb();
 
-	const rows = await db.selectFrom("_emdash_taxonomy_defs").selectAll().execute();
+		const rows = await db.selectFrom("_emdash_taxonomy_defs").selectAll().execute();
 
-	return rows.map((row) => ({
-		id: row.id,
-		name: row.name,
-		label: row.label,
-		labelSingular: row.label_singular ?? undefined,
-		hierarchical: row.hierarchical === 1,
-		collections: row.collections ? JSON.parse(row.collections) : [],
-	}));
+		return rows.map((row) => ({
+			id: row.id,
+			name: row.name,
+			label: row.label,
+			labelSingular: row.label_singular ?? undefined,
+			hierarchical: row.hierarchical === 1,
+			collections: row.collections ? JSON.parse(row.collections) : [],
+		}));
+	});
 }
 
 /**
  * Get a single taxonomy definition by name
  */
 export async function getTaxonomyDef(name: string): Promise<TaxonomyDef | null> {
-	const db = await getDb();
+	return requestCached(`taxonomy-def:${name}`, async () => {
+		const db = await getDb();
 
-	const row = await db
-		.selectFrom("_emdash_taxonomy_defs")
-		.selectAll()
-		.where("name", "=", name)
-		.executeTakeFirst();
+		const row = await db
+			.selectFrom("_emdash_taxonomy_defs")
+			.selectAll()
+			.where("name", "=", name)
+			.executeTakeFirst();
 
-	if (!row) return null;
+		if (!row) return null;
 
-	return {
-		id: row.id,
-		name: row.name,
-		label: row.label,
-		labelSingular: row.label_singular ?? undefined,
-		hierarchical: row.hierarchical === 1,
-		collections: row.collections ? JSON.parse(row.collections) : [],
-	};
+		return {
+			id: row.id,
+			name: row.name,
+			label: row.label,
+			labelSingular: row.label_singular ?? undefined,
+			hierarchical: row.hierarchical === 1,
+			collections: row.collections ? JSON.parse(row.collections) : [],
+		};
+	});
 }
 
 /**
  * Get all terms for a taxonomy (as tree for hierarchical, flat for tags)
  */
 export async function getTaxonomyTerms(taxonomyName: string): Promise<TaxonomyTerm[]> {
-	const db = await getDb();
-
-	// Get taxonomy definition to check if hierarchical
-	const def = await getTaxonomyDef(taxonomyName);
-	if (!def) return [];
-
-	// Get all terms for this taxonomy
-	const rows = await db
-		.selectFrom("taxonomies")
-		.selectAll()
-		.where("name", "=", taxonomyName)
-		.orderBy("label", "asc")
-		.execute();
-
-	// Count entries for each term
-	const countsResult = await db
-		.selectFrom("content_taxonomies")
-		.select(["taxonomy_id"])
-		.select((eb) => eb.fn.count<number>("entry_id").as("count"))
-		.groupBy("taxonomy_id")
-		.execute();
-
-	const counts = new Map<string, number>();
-	for (const row of countsResult) {
-		counts.set(row.taxonomy_id, row.count);
-	}
+	return requestCached(`taxonomy-terms:${taxonomyName}`, async () => {
+		const db = await getDb();
+
+		// Get taxonomy definition to check if hierarchical
+		const def = await getTaxonomyDef(taxonomyName);
+		if (!def) return [];
+
+		// Get all terms for this taxonomy
+		const rows = await db
+			.selectFrom("taxonomies")
+			.selectAll()
+			.where("name", "=", taxonomyName)
+			.orderBy("label", "asc")
+			.execute();
+
+		// Count entries for each term
+		const countsResult = await db
+			.selectFrom("content_taxonomies")
+			.select(["taxonomy_id"])
+			.select((eb) => eb.fn.count<number>("entry_id").as("count"))
+			.groupBy("taxonomy_id")
+			.execute();
+
+		const counts = new Map<string, number>();
+		for (const row of countsResult) {
+			counts.set(row.taxonomy_id, row.count);
+		}
 
-	const flatTerms: TaxonomyTermRow[] = rows.map((row) => ({
-		id: row.id,
-		name: row.name,
-		slug: row.slug,
-		label: row.label,
-		parent_id: row.parent_id,
-		data: row.data,
-	}));
+		const flatTerms: TaxonomyTermRow[] = rows.map((row) => ({
+			id: row.id,
+			name: row.name,
+			slug: row.slug,
+			label: row.label,
+			parent_id: row.parent_id,
+			data: row.data,
+		}));
 
-	// If hierarchical, build tree. Otherwise return flat
-	if (def.hierarchical) {
-		return buildTree(flatTerms, counts);
-	}
+		// If hierarchical, build tree. Otherwise return flat
+		if (def.hierarchical) {
+			return buildTree(flatTerms, counts);
+		}
 
-	return flatTerms.map((term) => ({
-		id: term.id,
-		name: term.name,
-		slug: term.slug,
-		label: term.label,
-		children: [],
-		count: counts.get(term.id) ?? 0,
-	}));
+		return flatTerms.map((term) => ({
+			id: term.id,
+			name: term.name,
+			slug: term.slug,
+			label: term.label,
+			children: [],
+			count: counts.get(term.id) ?? 0,
+		}));
+	});
 }
 
 /**
@@ -160,34 +182,36 @@ export async function getTerm(taxonomyName: string, slug: string): Promise<Taxon
 /**
  * Get terms assigned to an entry
  */
-export async function getEntryTerms(
+export function getEntryTerms(
 	collection: string,
 	entryId: string,
 	taxonomyName?: string,
 ): Promise<TaxonomyTerm[]> {
-	const db = await getDb();
-
-	let query = db
-		.selectFrom("content_taxonomies")
-		.innerJoin("taxonomies", "taxonomies.id", "content_taxonomies.taxonomy_id")
-		.selectAll("taxonomies")
-		.where("content_taxonomies.collection", "=", collection)
-		.where("content_taxonomies.entry_id", "=", entryId);
-
-	if (taxonomyName) {
-		query = query.where("taxonomies.name", "=", taxonomyName);
-	}
+	return requestCached(`terms:${collection}:${entryId}:${taxonomyName ?? "*"}`, async () => {
+		const db = await getDb();
+
+		let query = db
+			.selectFrom("content_taxonomies")
+			.innerJoin("taxonomies", "taxonomies.id", "content_taxonomies.taxonomy_id")
+			.selectAll("taxonomies")
+			.where("content_taxonomies.collection", "=", collection)
+			.where("content_taxonomies.entry_id", "=", entryId);
+
+		if (taxonomyName) {
+			query = query.where("taxonomies.name", "=", taxonomyName);
+		}
 
-	const rows = await query.execute();
+		const rows = await query.execute();
 
-	return rows.map((row) => ({
-		id: row.id,
-		name: row.name,
-		slug: row.slug,
-		label: row.label,
-		parentId: row.parent_id ?? undefined,
-		children: [],
-	}));
+		return rows.map((row) => ({
+			id: row.id,
+			name: row.name,
+			slug: row.slug,
+			label: row.label,
+			parentId: row.parent_id ?? undefined,
+			children: [],
+		}));
+	});
 }
 
 /**
@@ -208,53 +232,229 @@ export async function getTermsForEntries(
 ): Promise<Map<string, TaxonomyTerm[]>> {
 	const result = new Map<string, TaxonomyTerm[]>();
 
-	// Initialize all entry IDs with empty arrays
-	for (const id of entryIds) {
+	// Initialize all entry IDs with empty arrays so callers can always
+	// expect the key to be present.
+	const uniqueIds = [...new Set(entryIds)];
+	for (const id of uniqueIds) {
 		result.set(id, []);
 	}
 
-	if (entryIds.length === 0) {
+	if (uniqueIds.length === 0) {
 		return result;
 	}
 
 	const db = await getDb();
 
-	const rows = await db
-		.selectFrom("content_taxonomies")
-		.innerJoin("taxonomies", "taxonomies.id", "content_taxonomies.taxonomy_id")
-		.select([
-			"content_taxonomies.entry_id",
-			"taxonomies.id",
-			"taxonomies.name",
-			"taxonomies.slug",
-			"taxonomies.label",
-			"taxonomies.parent_id",
-		])
-		.where("content_taxonomies.collection", "=", collection)
-		.where("content_taxonomies.entry_id", "in", entryIds)
-		.where("taxonomies.name", "=", taxonomyName)
-		.execute();
+	// Chunk the IN clause so we stay below D1's ~100 bound-parameter limit
+	// (and equivalent limits on other dialects). Matches getContentBylinesMany.
+	//
+	// Sites with no term assignments get back empty rows for one query —
+	// the previous "has any term assignments" probe spent a round-trip on
+	// every request to save that single query on empty sites, which is
+	// backwards. Pre-migration databases (content_taxonomies missing) fall
+	// through to the `isMissingTableError` catch and return empties.
+	for (const chunk of chunks(uniqueIds, SQL_BATCH_SIZE)) {
+		let rows;
+		try {
+			rows = await db
+				.selectFrom("content_taxonomies")
+				.innerJoin("taxonomies", "taxonomies.id", "content_taxonomies.taxonomy_id")
+				.select([
+					"content_taxonomies.entry_id",
+					"taxonomies.id",
+					"taxonomies.name",
+					"taxonomies.slug",
+					"taxonomies.label",
+					"taxonomies.parent_id",
+				])
+				.where("content_taxonomies.collection", "=", collection)
+				.where("content_taxonomies.entry_id", "in", chunk)
+				.where("taxonomies.name", "=", taxonomyName)
+				.execute();
+		} catch (error) {
+			if (isMissingTableError(error)) return result;
+			throw error;
+		}
 
-	for (const row of rows) {
-		const entryId = row.entry_id;
-		const term: TaxonomyTerm = {
-			id: row.id,
-			name: row.name,
-			slug: row.slug,
-			label: row.label,
-			parentId: row.parent_id ?? undefined,
-			children: [],
-		};
+		for (const row of rows) {
+			const entryId = row.entry_id;
+			const term: TaxonomyTerm = {
+				id: row.id,
+				name: row.name,
+				slug: row.slug,
+				label: row.label,
+				parentId: row.parent_id ?? undefined,
+				children: [],
+			};
+
+			const terms = result.get(entryId);
+			if (terms) {
+				terms.push(term);
+			}
+		}
+	}
+
+	return result;
+}
+
+/**
+ * Batch-fetch terms for multiple entries across ALL taxonomies in a single query.
+ *
+ * Returns a Map keyed by entry ID, where each value is a Record keyed by
+ * taxonomy name with the matching terms as an array. Used by
+ * getEmDashCollection to eagerly hydrate `entry.data.terms` and avoid
+ * the N+1 pattern that callers hit when they loop and call getEntryTerms.
+ *
+ * Pre-migration databases (content_taxonomies missing) return an empty
+ * Map — the join falls through to the `isMissingTableError` branch.
+ */
+export async function getAllTermsForEntries(
+	collection: string,
+	entryIds: string[],
+): Promise<Map<string, Record<string, TaxonomyTerm[]>>> {
+	const result = new Map<string, Record<string, TaxonomyTerm[]>>();
+
+	// Initialize unique entry IDs with empty objects so callers can always
+	// expect the key to be present. Deduping also reduces wasted bound
+	// parameters when a caller accidentally passes duplicates.
+	const uniqueIds = [...new Set(entryIds)];
+	for (const id of uniqueIds) {
+		result.set(id, {});
+	}
+
+	if (uniqueIds.length === 0) {
+		return result;
+	}
+
+	const db = await getDb();
 
-		const terms = result.get(entryId);
-		if (terms) {
-			terms.push(term);
+	// Look up which taxonomies apply to this collection. Used below to
+	// seed empty arrays for taxonomies the entry has no terms in — so
+	// callers (including the pre-populated getEntryTerms cache) get a
+	// deterministic `[]` back rather than a cache miss that triggers a DB
+	// round-trip just to confirm "no terms".
+	const applicableTaxonomyNames = await getCollectionTaxonomyNames(collection);
+
+	// Chunk the IN clause to stay below D1's ~100 bound-parameter limit
+	// (and equivalent limits on other dialects). Matches getContentBylinesMany.
+	//
+	// Previously we did a separate "has any assignments" probe to skip the
+	// join on empty sites. That traded one query per request for a query
+	// saved only on empty sites — backwards. Now the join runs directly
+	// (returning zero rows cheaply) and pre-migration databases are caught
+	// by the `isMissingTableError` branch below.
+	for (const chunk of chunks(uniqueIds, SQL_BATCH_SIZE)) {
+		let rows;
+		try {
+			rows = await db
+				.selectFrom("content_taxonomies")
+				.innerJoin("taxonomies", "taxonomies.id", "content_taxonomies.taxonomy_id")
+				.select([
+					"content_taxonomies.entry_id",
+					"taxonomies.id",
+					"taxonomies.name",
+					"taxonomies.slug",
+					"taxonomies.label",
+					"taxonomies.parent_id",
+				])
+				.where("content_taxonomies.collection", "=", collection)
+				.where("content_taxonomies.entry_id", "in", chunk)
+				.orderBy("taxonomies.label", "asc")
+				.execute();
+		} catch (error) {
+			if (isMissingTableError(error)) {
+				for (const id of uniqueIds) {
+					primeEntryTermsCache(collection, id, {}, applicableTaxonomyNames);
+				}
+				return result;
+			}
+			throw error;
 		}
+
+		for (const row of rows) {
+			const entryId = row.entry_id;
+			const term: TaxonomyTerm = {
+				id: row.id,
+				name: row.name,
+				slug: row.slug,
+				label: row.label,
+				parentId: row.parent_id ?? undefined,
+				children: [],
+			};
+
+			const byTaxonomy = result.get(entryId);
+			if (!byTaxonomy) continue;
+			const existing = byTaxonomy[row.name];
+			if (existing) {
+				existing.push(term);
+			} else {
+				byTaxonomy[row.name] = [term];
+			}
+		}
+	}
+
+	// Prime the request-scoped cache so legacy callers of getEntryTerms
+	// (which still work per-entry) hit the in-memory cache instead of
+	// re-querying. This is what gives us the N+1 win in existing templates
+	// without requiring them to be rewritten.
+	for (const [entryId, byTaxonomy] of result) {
+		primeEntryTermsCache(collection, entryId, byTaxonomy, applicableTaxonomyNames);
 	}
 
 	return result;
 }
 
+/**
+ * Return the list of taxonomy names applicable to a collection, request-
+ * cached so a page render only pays for it once.
+ *
+ * Returns an empty list when taxonomies haven't been defined yet.
+ */
+async function getCollectionTaxonomyNames(collection: string): Promise<string[]> {
+	try {
+		const defs = await getTaxonomyDefs();
+		return defs.filter((d) => d.collections.includes(collection)).map((d) => d.name);
+	} catch (error) {
+		if (isMissingTableError(error)) return [];
+		throw error;
+	}
+}
+
+/**
+ * Pre-populate the request-cache for every getEntryTerms call-shape that
+ * could hit this entry:
+ *
+ *   getEntryTerms(collection, entryId)                 -> key `terms:C:E:*`
+ *   getEntryTerms(collection, entryId, "tag")          -> key `terms:C:E:tag`
+ *   getEntryTerms(collection, entryId, "category")     -> key `terms:C:E:category`
+ *   ...one per taxonomy that applies to this collection
+ *
+ * Taxonomies with no rows on this entry are seeded with `[]` so legacy
+ * callers short-circuit to the cached empty array instead of re-querying.
+ */
+function primeEntryTermsCache(
+	collection: string,
+	entryId: string,
+	byTaxonomy: Record<string, TaxonomyTerm[]>,
+	applicableTaxonomyNames: string[],
+): void {
+	// Seed every applicable taxonomy with at least [] so
+	// getEntryTerms(collection, id, "tag") doesn't miss the cache when an
+	// entry has no tags.
+	for (const name of applicableTaxonomyNames) {
+		setRequestCacheEntry(`terms:${collection}:${entryId}:${name}`, byTaxonomy[name] ?? []);
+	}
+	// Also seed individual names that show up in data but aren't listed
+	// as applicable (e.g. taxonomy reassigned to a different collection
+	// since the terms were written).
+	for (const [name, terms] of Object.entries(byTaxonomy)) {
+		setRequestCacheEntry(`terms:${collection}:${entryId}:${name}`, terms);
+	}
+	// Flattened `*` view — all terms across all taxonomies in one array.
+	const allTerms = Object.values(byTaxonomy).flat();
+	setRequestCacheEntry(`terms:${collection}:${entryId}:*`, allTerms);
+}
+
 /**
  * Get entries by term (wraps getEmDashCollection)
  */

package/src/utils/db-errors.ts

@@ -0,0 +1,46 @@
+/**
+ * Shared detection helpers for database-layer error messages.
+ *
+ * Different SQL dialects phrase "table or relation does not exist" differently:
+ *
+ * - SQLite / D1:    "no such table: foo"
+ * - PostgreSQL:     'relation "foo" does not exist'
+ *                   'table "foo" does not exist'
+ * - MySQL (future): "Table 'db.foo' doesn't exist"
+ *
+ * Runtime code paths that short-circuit on missing tables (pre-migration
+ * probes, optional feature tables, etc.) should use these helpers rather
+ * than hand-rolling string matches per call-site.
+ */
+
+/**
+ * Extract a lowercase error message from any unknown value, safely.
+ */
+function messageOf(error: unknown): string {
+	if (error instanceof Error) return error.message.toLowerCase();
+	if (typeof error === "string") return error.toLowerCase();
+	return "";
+}
+
+/**
+ * Returns true when `error` is a "table does not exist" error across the
+ * dialects EmDash supports (D1/SQLite and PostgreSQL). Used by runtime
+ * probes to treat pre-migration databases as empty without logging a scary
+ * warning, while still propagating unrelated errors (permissions, connection
+ * loss, syntax issues) to callers.
+ */
+export function isMissingTableError(error: unknown): boolean {
+	const message = messageOf(error);
+	if (!message) return false;
+
+	// SQLite / D1
+	if (message.includes("no such table")) return true;
+
+	// PostgreSQL (and some MySQL variants): "relation ... does not exist" /
+	// "table ... does not exist" / "doesn't exist".
+	if (message.includes("does not exist") || message.includes("doesn't exist")) {
+		return message.includes("relation") || message.includes("table");
+	}
+
+	return false;
+}