emdash 0.37.0 → 0.38.0

package/src/schema/collection-slugs-cache.ts

@@ -0,0 +1,157 @@
+/**
+ * Per-isolate cache of registered collection slugs (`_emdash_collections`).
+ *
+ * Term counting scopes its per-collection UNION to a taxonomy's declared
+ * collections, but a declared collection is not necessarily a created one:
+ * the migration-seeded defaults declare `posts` whether or not that
+ * collection ever exists. Querying optimistically and catching the
+ * missing-table error keeps results correct, yet the failed statement itself
+ * is logged by the database — on D1 it surfaces as a `no such table` error
+ * span per taxonomy per uncached render. Filtering declared collections
+ * against the registry up front means the failing statement is never sent.
+ *
+ * Stored on globalThis behind a Symbol key (same pattern as the taxonomy-defs
+ * cache in `taxonomies/index.ts`) so bundler chunk duplication cannot produce
+ * two independent caches. The promise is cached, so concurrent cold readers
+ * share one in-flight query; a rejection evicts the entry.
+ *
+ * Freshness:
+ * - Primed for free at isolate boot: runtime init's auto-seed gate already
+ *   reads `_emdash_collections` and hands the slugs to
+ *   `primeRegisteredCollections`, so cold isolates pay no extra query.
+ * - Every schema-mutation path resets it: `invalidateUrlPatternCache()`
+ *   (admin API, MCP, WordPress import, seed application) and
+ *   `SchemaRegistry.createCollection`/`deleteCollection` for direct callers.
+ * - Creations on *other* isolates surface through bounded revalidation: the
+ *   set is re-fetched only when the filter would actually drop a declared
+ *   collection and the cached copy is older than the revalidation window.
+ *   Sites whose declared collections all exist — the steady state — never
+ *   revalidate; a site with a genuinely absent collection pays one slug read
+ *   per window instead of one failing statement per render, and a collection
+ *   created elsewhere starts counting within the window.
+ *
+ * Isolated databases bypass the cache (playground / DO preview requests set
+ * `requestContext.dbIsIsolated`): they point at a divergent schema, so the
+ * slug set is fetched per request instead, deduped by the request cache.
+ */
+
+import type { Kysely } from "kysely";
+
+import type { Database } from "../database/types.js";
+import { requestCached } from "../request-cache.js";
+import { getRequestContext } from "../request-context.js";
+
+interface SlugsHolder {
+	promise: Promise<Set<string>> | null;
+	/** When the cached promise was created; gates bounded revalidation. */
+	fetchedAt: number;
+}
+
+const HOLDER_KEY = Symbol.for("emdash:collection-slugs");
+const g = globalThis as Record<symbol, unknown>;
+const holder: SlugsHolder =
+	// eslint-disable-next-line typescript/no-unsafe-type-assertion -- globalThis singleton pattern (see request-cache.ts)
+	(g[HOLDER_KEY] as SlugsHolder | undefined) ??
+	(() => {
+		const h: SlugsHolder = { promise: null, fetchedAt: 0 };
+		g[HOLDER_KEY] = h;
+		return h;
+	})();
+
+const REVALIDATE_WINDOW_MS = 60_000;
+let revalidateWindowMs = REVALIDATE_WINDOW_MS;
+
+async function fetchSlugs(db: Kysely<Database>): Promise<Set<string>> {
+	const rows = await db.selectFrom("_emdash_collections").select("slug").execute();
+	return new Set(rows.map((row) => row.slug));
+}
+
+function loadSlugs(db: Kysely<Database>): Promise<Set<string>> {
+	if (holder.promise) return holder.promise;
+	const promise = fetchSlugs(db).catch((error: unknown) => {
+		if (holder.promise === promise) holder.promise = null;
+		throw error;
+	});
+	holder.promise = promise;
+	holder.fetchedAt = Date.now();
+	return promise;
+}
+
+/**
+ * Keep only the collections that have a `_emdash_collections` row, i.e. whose
+ * `ec_*` table the registry has created. When the filter would drop a
+ * collection and the cached set is older than the revalidation window, the
+ * set is re-fetched once so a collection created by another isolate becomes
+ * visible without waiting for an isolate recycle.
+ */
+export async function filterToRegisteredCollections(
+	db: Kysely<Database>,
+	collections: readonly string[],
+): Promise<string[]> {
+	if (collections.length === 0) return [];
+	if (getRequestContext()?.dbIsIsolated === true) {
+		const slugs = await requestCached("collection-slugs", () => fetchSlugs(db));
+		return collections.filter((slug) => slugs.has(slug));
+	}
+	let slugs = await loadSlugs(db);
+	let present = collections.filter((slug) => slugs.has(slug));
+	if (present.length < collections.length && Date.now() - holder.fetchedAt > revalidateWindowMs) {
+		holder.promise = null;
+		slugs = await loadSlugs(db);
+		present = collections.filter((slug) => slugs.has(slug));
+	}
+	return present;
+}
+
+/**
+ * Seed the cache with slugs an init-time read already fetched, so the first
+ * render on a cold isolate pays no extra query. Called by the runtime's
+ * auto-seed gate.
+ */
+export function primeRegisteredCollections(slugs: readonly string[]): void {
+	holder.promise = Promise.resolve(new Set(slugs));
+	holder.fetchedAt = Date.now();
+}
+
+/**
+ * Drop the cached slug set so the next reader re-fetches. Called from every
+ * schema-mutation path (`invalidateUrlPatternCache`, `SchemaRegistry`
+ * create/delete). Other isolates converge through bounded revalidation.
+ */
+export function resetRegisteredCollectionsCache(): void {
+	holder.promise = null;
+	holder.fetchedAt = 0;
+}
+
+/**
+ * Note that a query hit a missing `ec_*` table despite the slug filter: the
+ * cached set is stale (the collection was deleted on another isolate) or the
+ * registry has drifted from the physical schema. Drops the cached set at most
+ * once per revalidation window, so the delete case converges like the create
+ * case while genuine drift costs one slug re-fetch per window instead of one
+ * per render.
+ */
+export function noteStaleRegisteredCollections(): void {
+	if (Date.now() - holder.fetchedAt > revalidateWindowMs) {
+		resetRegisteredCollectionsCache();
+	}
+}
+
+/**
+ * Test/internal helper: reset the cache and restore the production
+ * revalidation window.
+ */
+export function resetRegisteredCollectionsCacheForTests(): void {
+	resetRegisteredCollectionsCache();
+	revalidateWindowMs = REVALIDATE_WINDOW_MS;
+}
+
+/**
+ * Test-only: shorten the revalidation window so the cross-isolate refresh
+ * path can be exercised without waiting out the production window.
+ *
+ * @internal
+ */
+export function setRegisteredCollectionsRevalidateWindowForTests(ms: number): void {
+	revalidateWindowMs = ms;
+}

package/src/schema/registry.ts

@@ -32,6 +32,7 @@ import {
 } from "../media/usage/content-refresh.js";
 import { FTSManager } from "../search/fts-manager.js";
 import { chunks, SQL_BATCH_SIZE } from "../utils/chunks.js";
+import { resetRegisteredCollectionsCache } from "./collection-slugs-cache.js";
 import {
 	type Collection,
 	type CollectionAdminConfig,
@@ -196,7 +197,9 @@ export async function buildSeedCollectionCaptureFingerprint(
 				hasSeo,
 				hidden: input.hidden ?? false,
 				sortOrder: input.sortOrder ?? null,
+				...(input.group ? { group: input.group } : {}),
 				commentsEnabled: input.commentsEnabled ?? false,
+				...(input.editLocking === false ? { editLocking: false } : {}),
 				urlPattern: input.urlPattern ?? null,
 				routable: input.routable ?? true,
 			},
@@ -469,7 +472,9 @@ export class SchemaRegistry {
 				routable: input.routable === false ? 0 : 1,
 				hidden: input.hidden ? 1 : 0,
 				sort_order: input.sortOrder ?? null,
+				nav_group: input.group?.trim() || null,
 				comments_enabled: input.commentsEnabled ? 1 : 0,
+				edit_locking: input.editLocking === false ? 0 : 1,
 				url_pattern: input.urlPattern ?? null,
 			};
 
@@ -504,6 +509,7 @@ export class SchemaRegistry {
 			throw new SchemaError("Failed to create collection", "CREATE_FAILED");
 		}
 
+		resetRegisteredCollectionsCache();
 		this.notifyTypegen();
 		return collection;
 	}
@@ -613,7 +619,9 @@ export class SchemaRegistry {
 					routable: input.routable === false ? 0 : 1,
 					hidden: input.hidden ? 1 : 0,
 					sort_order: input.sortOrder ?? null,
+					nav_group: input.group?.trim() || null,
 					comments_enabled: input.commentsEnabled ? 1 : 0,
+					edit_locking: input.editLocking === false ? 0 : 1,
 					url_pattern: input.urlPattern ?? null,
 				};
 				const rows = fieldRows.map((row) => ({
@@ -679,6 +687,8 @@ export class SchemaRegistry {
 				);
 			}
 			throw error;
+		} finally {
+			if (schemaMutated) resetRegisteredCollectionsCache();
 		}
 		this.notifyTypegen();
 	}
@@ -765,6 +775,7 @@ export class SchemaRegistry {
 			}
 			if (input.hidden !== undefined) updates.hidden = input.hidden ? 1 : 0;
 			if (input.sortOrder !== undefined) updates.sort_order = input.sortOrder;
+			if (input.group !== undefined) updates.nav_group = input.group?.trim() || null;
 			if (input.titleField !== undefined) updates.title_field = input.titleField || null;
 			if (input.dateField !== undefined) updates.date_field = input.dateField || null;
 			if (input.commentsEnabled !== undefined) {
@@ -779,6 +790,7 @@ export class SchemaRegistry {
 			if (input.commentsAutoApproveUsers !== undefined) {
 				updates.comments_auto_approve_users = input.commentsAutoApproveUsers ? 1 : 0;
 			}
+			if (input.editLocking !== undefined) updates.edit_locking = input.editLocking ? 1 : 0;
 
 			updates.updated_at = new Date().toISOString();
 			await trx
@@ -863,6 +875,11 @@ export class SchemaRegistry {
 				await deleteContentMediaUsageCollection(this.db, slug);
 			}
 			throw error;
+		} finally {
+			// Even a failed delete may have dropped the ec_* table (D1 has no
+			// real transactions) — over-invalidation is harmless, a stale set
+			// is not.
+			if (contentTableDropped) resetRegisteredCollectionsCache();
 		}
 		this.notifyTypegen();
 	}
@@ -1828,6 +1845,7 @@ export class SchemaRegistry {
 			routable: row.routable !== 0,
 			hidden: row.hidden === 1,
 			sortOrder: row.sort_order ?? undefined,
+			group: row.nav_group ?? undefined,
 			commentsEnabled: row.comments_enabled === 1,
 			commentsModeration:
 				moderation === "all" || moderation === "first_time" || moderation === "none"
@@ -1835,6 +1853,7 @@ export class SchemaRegistry {
 					: "first_time",
 			commentsClosedAfterDays: row.comments_closed_after_days ?? 90,
 			commentsAutoApproveUsers: row.comments_auto_approve_users === 1,
+			editLocking: row.edit_locking !== 0,
 			createdAt: row.created_at,
 			updatedAt: row.updated_at,
 		};

package/src/schema/types.ts

@@ -175,6 +175,9 @@ export interface FieldWidgetOptions {
 
 export const MAX_COLLECTION_LIST_COLUMNS = 4;
 
+/** Longest admin sidebar folder label a collection may declare. */
+export const MAX_COLLECTION_GROUP_LENGTH = 100;
+
 /** Collection-level admin presentation options. */
 export interface CollectionAdminConfig {
 	/** Custom field slugs to show in the content list. */
@@ -205,10 +208,10 @@ export interface Collection {
 	/** Whether published entries require a public slug. Defaults to true. */
 	routable?: boolean;
 	/**
-	 * Omit this collection's auto-generated entry from the admin sidebar.
-	 * The collection stays fully functional everywhere else (API, MCP, hooks,
-	 * direct `/content/:collection` URLs) — this only hides the nav link, so a
-	 * plugin that owns the collection can point editors at its own admin UI.
+	 * Omit this collection's auto-generated sidebar entry and dashboard quick
+	 * action. The collection stays fully functional everywhere else (API, MCP,
+	 * hooks, direct `/content/:collection` URLs), so a plugin that owns the
+	 * collection can point editors at its own admin UI.
 	 */
 	hidden: boolean;
 	/**
@@ -217,6 +220,12 @@ export interface Collection {
 	 * order and follow. `undefined` means "no explicit position".
 	 */
 	sortOrder?: number;
+	/**
+	 * Admin sidebar folder. Collections sharing a group render under one
+	 * collapsible entry labelled with the group; `undefined` keeps the
+	 * collection inline.
+	 */
+	group?: string;
 	/** Whether comments are enabled for this collection */
 	commentsEnabled: boolean;
 	/** Moderation strategy: "all" | "first_time" | "none" */
@@ -225,6 +234,8 @@ export interface Collection {
 	commentsClosedAfterDays: number;
 	/** Auto-approve comments from authenticated CMS users */
 	commentsAutoApproveUsers: boolean;
+	/** Whether opening an entry takes an edit lock. Defaults to true. */
+	editLocking: boolean;
 	createdAt: string;
 	updatedAt: string;
 }
@@ -269,11 +280,15 @@ export interface CreateCollectionInput {
 	urlPattern?: string;
 	routable?: boolean;
 	hasSeo?: boolean;
-	/** Omit the auto-generated admin sidebar entry (defaults to false) */
+	/** Omit the auto-generated sidebar entry and dashboard quick action (defaults to false) */
 	hidden?: boolean;
 	/** Explicit admin sidebar position (omit for the alphabetical fallback) */
 	sortOrder?: number | null;
+	/** Admin sidebar folder shared with other collections of the same group */
+	group?: string | null;
 	commentsEnabled?: boolean;
+	/** Take an edit lock when an entry is opened (defaults to true) */
+	editLocking?: boolean;
 }
 
 /**
@@ -289,14 +304,18 @@ export interface UpdateCollectionInput {
 	urlPattern?: string | null;
 	routable?: boolean;
 	hasSeo?: boolean;
-	/** Omit the auto-generated admin sidebar entry */
+	/** Omit the auto-generated sidebar entry and dashboard quick action */
 	hidden?: boolean;
 	/** Explicit admin sidebar position; `null` clears it back to alphabetical */
 	sortOrder?: number | null;
+	/** Admin sidebar folder; `null` moves the collection back inline */
+	group?: string | null;
 	commentsEnabled?: boolean;
 	commentsModeration?: "all" | "first_time" | "none";
 	commentsClosedAfterDays?: number;
 	commentsAutoApproveUsers?: boolean;
+	/** Take an edit lock when an entry is opened */
+	editLocking?: boolean;
 	/** Field slug for the Title column; `null`/`""` clears back to the default. */
 	titleField?: string | null;
 	/** Datetime field slug for the Date column; `null`/`""` clears back to the default. */