emdash 0.24.1 → 0.26.0

package/src/plugins/hooks.ts

@@ -17,7 +17,7 @@ import type {
 	PluginContext,
 	ContentHookEvent,
 	ContentDeleteEvent,
-	ContentPublishStateChangeEvent,
+	ContentStateChangeEvent,
 	MediaUploadEvent,
 	MediaAfterUploadEvent,
 	LifecycleEvent,
@@ -32,7 +32,10 @@ import type {
 	ContentBeforeDeleteHandler,
 	ContentAfterDeleteHandler,
 	ContentAfterPublishHandler,
+	ContentAfterRestoreHandler,
+	ContentAfterScheduleHandler,
 	ContentAfterUnpublishHandler,
+	ContentAfterUnscheduleHandler,
 	MediaBeforeUploadHandler,
 	MediaAfterUploadHandler,
 	LifecycleHandler,
@@ -66,6 +69,9 @@ type HookNameV2 =
 	| "content:afterDelete"
 	| "content:afterPublish"
 	| "content:afterUnpublish"
+	| "content:afterRestore"
+	| "content:afterSchedule"
+	| "content:afterUnschedule"
 	| "media:beforeUpload"
 	| "media:afterUpload"
 	| "cron"
@@ -82,6 +88,13 @@ type HookNameV2 =
 /**
  * Map from hook name to handler type — used for type-safe hook retrieval
  */
+type ContentStateChangeHookName =
+	| "content:afterPublish"
+	| "content:afterUnpublish"
+	| "content:afterRestore"
+	| "content:afterSchedule"
+	| "content:afterUnschedule";
+
 interface HookHandlerMap {
 	"plugin:install": LifecycleHandler;
 	"plugin:activate": LifecycleHandler;
@@ -93,6 +106,9 @@ interface HookHandlerMap {
 	"content:afterDelete": ContentAfterDeleteHandler;
 	"content:afterPublish": ContentAfterPublishHandler;
 	"content:afterUnpublish": ContentAfterUnpublishHandler;
+	"content:afterRestore": ContentAfterRestoreHandler;
+	"content:afterSchedule": ContentAfterScheduleHandler;
+	"content:afterUnschedule": ContentAfterUnscheduleHandler;
 	"media:beforeUpload": MediaBeforeUploadHandler;
 	"media:afterUpload": MediaAfterUploadHandler;
 	cron: CronHandler;
@@ -220,6 +236,9 @@ export class HookPipeline {
 			this.registerPluginHook(plugin, "content:afterDelete");
 			this.registerPluginHook(plugin, "content:afterPublish");
 			this.registerPluginHook(plugin, "content:afterUnpublish");
+			this.registerPluginHook(plugin, "content:afterRestore");
+			this.registerPluginHook(plugin, "content:afterSchedule");
+			this.registerPluginHook(plugin, "content:afterUnschedule");
 			this.registerPluginHook(plugin, "media:beforeUpload");
 			this.registerPluginHook(plugin, "media:afterUpload");
 			this.registerPluginHook(plugin, "cron");
@@ -264,6 +283,9 @@ export class HookPipeline {
 		["content:afterDelete", "content:read"],
 		["content:afterPublish", "content:read"],
 		["content:afterUnpublish", "content:read"],
+		["content:afterRestore", "content:read"],
+		["content:afterSchedule", "content:read"],
+		["content:afterUnschedule", "content:read"],
 		// Media
 		["media:beforeUpload", "media:write"],
 		["media:afterUpload", "media:read"],
@@ -648,18 +670,19 @@ export class HookPipeline {
 	}
 
 	/**
-	 * Run content:afterPublish hooks (fire-and-forget).
+	 * Run content state-change hooks that all share the same event shape.
 	 */
-	async runContentAfterPublish(
+	private async runContentStateChangeHook(
+		name: ContentStateChangeHookName,
 		content: Record<string, unknown>,
 		collection: string,
 	): Promise<HookResult<void>[]> {
-		const hooks = this.getTypedHooks("content:afterPublish");
+		const hooks = this.getTypedHooks(name);
 		const results: HookResult<void>[] = [];
 
 		for (const hook of hooks) {
 			const { handler } = hook;
-			const event: ContentPublishStateChangeEvent = { content, collection };
+			const event: ContentStateChangeEvent = { content, collection };
 			const ctx = this.getContext(hook.pluginId);
 			const start = Date.now();
 
@@ -687,6 +710,16 @@ export class HookPipeline {
 		return results;
 	}
 
+	/**
+	 * Run content:afterPublish hooks (fire-and-forget).
+	 */
+	async runContentAfterPublish(
+		content: Record<string, unknown>,
+		collection: string,
+	): Promise<HookResult<void>[]> {
+		return this.runContentStateChangeHook("content:afterPublish", content, collection);
+	}
+
 	/**
 	 * Run content:afterUnpublish hooks (fire-and-forget).
 	 */
@@ -694,37 +727,37 @@ export class HookPipeline {
 		content: Record<string, unknown>,
 		collection: string,
 	): Promise<HookResult<void>[]> {
-		const hooks = this.getTypedHooks("content:afterUnpublish");
-		const results: HookResult<void>[] = [];
-
-		for (const hook of hooks) {
-			const { handler } = hook;
-			const event: ContentPublishStateChangeEvent = { content, collection };
-			const ctx = this.getContext(hook.pluginId);
-			const start = Date.now();
+		return this.runContentStateChangeHook("content:afterUnpublish", content, collection);
+	}
 
-			try {
-				await this.executeWithTimeout(() => handler(event, ctx), hook.timeout);
-				results.push({
-					success: true,
-					pluginId: hook.pluginId,
-					duration: Date.now() - start,
-				});
-			} catch (error) {
-				results.push({
-					success: false,
-					error: error instanceof Error ? error : new Error(String(error)),
-					pluginId: hook.pluginId,
-					duration: Date.now() - start,
-				});
+	/**
+	 * Run content:afterRestore hooks (fire-and-forget).
+	 */
+	async runContentAfterRestore(
+		content: Record<string, unknown>,
+		collection: string,
+	): Promise<HookResult<void>[]> {
+		return this.runContentStateChangeHook("content:afterRestore", content, collection);
+	}
 
-				if (hook.errorPolicy === "abort") {
-					throw error;
-				}
-			}
-		}
+	/**
+	 * Run content:afterSchedule hooks (fire-and-forget).
+	 */
+	async runContentAfterSchedule(
+		content: Record<string, unknown>,
+		collection: string,
+	): Promise<HookResult<void>[]> {
+		return this.runContentStateChangeHook("content:afterSchedule", content, collection);
+	}
 
-		return results;
+	/**
+	 * Run content:afterUnschedule hooks (fire-and-forget).
+	 */
+	async runContentAfterUnschedule(
+		content: Record<string, unknown>,
+		collection: string,
+	): Promise<HookResult<void>[]> {
+		return this.runContentStateChangeHook("content:afterUnschedule", content, collection);
 	}
 
 	// =========================================================================

package/src/plugins/index.ts

@@ -128,6 +128,9 @@ export type {
 	ContentHookEvent,
 	ContentDeleteEvent,
 	ContentPublishStateChangeEvent,
+	ContentRestoreStateChangeEvent,
+	ContentScheduleStateChangeEvent,
+	ContentStateChangeEvent,
 	MediaUploadEvent,
 	MediaAfterUploadEvent,
 	LifecycleEvent,
@@ -148,6 +151,9 @@ export type {
 	ContentAfterSaveHandler,
 	ContentBeforeDeleteHandler,
 	ContentAfterDeleteHandler,
+	ContentAfterRestoreHandler,
+	ContentAfterScheduleHandler,
+	ContentAfterUnscheduleHandler,
 	MediaBeforeUploadHandler,
 	MediaAfterUploadHandler,
 	LifecycleHandler,

package/src/plugins/manager.ts

@@ -370,6 +370,39 @@ export class PluginManager {
 		return this.hookPipeline!.runContentAfterUnpublish(content, collection);
 	}
 
+	/**
+	 * Run content:afterRestore hooks across all active plugins
+	 */
+	async runContentAfterRestore(
+		content: Record<string, unknown>,
+		collection: string,
+	): Promise<HookResult<void>[]> {
+		this.ensureInitialized();
+		return this.hookPipeline!.runContentAfterRestore(content, collection);
+	}
+
+	/**
+	 * Run content:afterSchedule hooks across all active plugins
+	 */
+	async runContentAfterSchedule(
+		content: Record<string, unknown>,
+		collection: string,
+	): Promise<HookResult<void>[]> {
+		this.ensureInitialized();
+		return this.hookPipeline!.runContentAfterSchedule(content, collection);
+	}
+
+	/**
+	 * Run content:afterUnschedule hooks across all active plugins
+	 */
+	async runContentAfterUnschedule(
+		content: Record<string, unknown>,
+		collection: string,
+	): Promise<HookResult<void>[]> {
+		this.ensureInitialized();
+		return this.hookPipeline!.runContentAfterUnschedule(content, collection);
+	}
+
 	/**
 	 * Run media:beforeUpload hooks across all active plugins
 	 */

package/src/plugins/manifest-schema.ts

@@ -97,6 +97,9 @@ export const HOOK_NAMES = [
 	"content:afterDelete",
 	"content:afterPublish",
 	"content:afterUnpublish",
+	"content:afterRestore",
+	"content:afterSchedule",
+	"content:afterUnschedule",
 	"media:beforeUpload",
 	"media:afterUpload",
 	"cron",

package/src/plugins/types.ts

@@ -725,13 +725,29 @@ export interface ContentDeleteEvent {
 }
 
 /**
- * Content publish state change hook event (fired after publish or unpublish)
+ * Content state-change hook event (fired after publish, unpublish, restore,
+ * schedule, or unschedule).
  */
-export interface ContentPublishStateChangeEvent {
+export interface ContentStateChangeEvent {
 	content: Record<string, unknown>;
 	collection: string;
 }
 
+/**
+ * Content publish/unpublish hook event.
+ */
+export type ContentPublishStateChangeEvent = ContentStateChangeEvent;
+
+/**
+ * Content restore hook event.
+ */
+export type ContentRestoreStateChangeEvent = ContentStateChangeEvent;
+
+/**
+ * Content schedule/unschedule hook event.
+ */
+export type ContentScheduleStateChangeEvent = ContentStateChangeEvent;
+
 /**
  * Media hook event
  */
@@ -791,6 +807,21 @@ export type ContentAfterUnpublishHandler = (
 	ctx: PluginContext,
 ) => Promise<void>;
 
+export type ContentAfterRestoreHandler = (
+	event: ContentRestoreStateChangeEvent,
+	ctx: PluginContext,
+) => Promise<void>;
+
+export type ContentAfterScheduleHandler = (
+	event: ContentScheduleStateChangeEvent,
+	ctx: PluginContext,
+) => Promise<void>;
+
+export type ContentAfterUnscheduleHandler = (
+	event: ContentScheduleStateChangeEvent,
+	ctx: PluginContext,
+) => Promise<void>;
+
 export type MediaBeforeUploadHandler = (
 	event: MediaUploadEvent,
 	ctx: PluginContext,
@@ -976,6 +1007,11 @@ export interface PluginHooks {
 	"content:afterUnpublish"?:
 		| HookConfig<ContentAfterUnpublishHandler>
 		| ContentAfterUnpublishHandler;
+	"content:afterRestore"?: HookConfig<ContentAfterRestoreHandler> | ContentAfterRestoreHandler;
+	"content:afterSchedule"?: HookConfig<ContentAfterScheduleHandler> | ContentAfterScheduleHandler;
+	"content:afterUnschedule"?:
+		| HookConfig<ContentAfterUnscheduleHandler>
+		| ContentAfterUnscheduleHandler;
 
 	// Media hooks
 	"media:beforeUpload"?: HookConfig<MediaBeforeUploadHandler> | MediaBeforeUploadHandler;
@@ -1295,6 +1331,9 @@ export interface ResolvedPluginHooks {
 	"content:afterDelete"?: ResolvedHook<ContentAfterDeleteHandler>;
 	"content:afterPublish"?: ResolvedHook<ContentAfterPublishHandler>;
 	"content:afterUnpublish"?: ResolvedHook<ContentAfterUnpublishHandler>;
+	"content:afterRestore"?: ResolvedHook<ContentAfterRestoreHandler>;
+	"content:afterSchedule"?: ResolvedHook<ContentAfterScheduleHandler>;
+	"content:afterUnschedule"?: ResolvedHook<ContentAfterUnscheduleHandler>;
 	"media:beforeUpload"?: ResolvedHook<MediaBeforeUploadHandler>;
 	"media:afterUpload"?: ResolvedHook<MediaAfterUploadHandler>;
 	cron?: ResolvedHook<CronHandler>;

package/src/schema/registry.ts

@@ -530,10 +530,35 @@ export class SchemaRegistry {
 		// an explicit `null` clears the column.
 		const nextValidation = input.validation === undefined ? field.validation : input.validation;
 
+		// A field-type change is only safe when the underlying column type stays
+		// the same. There is no in-place column migration (only addColumn/
+		// dropColumn), so a change that would alter the SQLite column affinity
+		// (e.g. `text` TEXT -> `portableText` JSON) is rejected rather than
+		// silently rewriting only the metadata — which would leave `column_type`
+		// pointing at a column type the real `ec_*` column doesn't have (#1397).
+		let nextType = field.type;
+		let nextColumnType = field.columnType;
+		if (input.type !== undefined && input.type !== field.type) {
+			const newColumnType = FIELD_TYPE_TO_COLUMN[input.type];
+			if (newColumnType !== field.columnType) {
+				throw new SchemaError(
+					`Cannot change field "${fieldSlug}" in collection "${collectionSlug}" from type ` +
+						`"${field.type}" to "${input.type}": the underlying column type would change from ` +
+						`${field.columnType} to ${newColumnType}, which requires a manual content migration. ` +
+						`Drop and re-create the field, or migrate the column data, before changing its type.`,
+					"FIELD_TYPE_COLUMN_CHANGE",
+				);
+			}
+			nextType = input.type;
+			nextColumnType = newColumnType;
+		}
+
 		return withTransaction(this.db, async (trx) => {
 			await trx
 				.updateTable("_emdash_fields")
 				.set({
+					type: nextType,
+					column_type: nextColumnType,
 					label: input.label ?? field.label,
 					required:
 						input.required !== undefined ? (input.required ? 1 : 0) : field.required ? 1 : 0,

package/src/schema/types.ts

@@ -264,6 +264,16 @@ export interface CreateFieldInput {
  */
 export interface UpdateFieldInput {
 	label?: string;
+	/**
+	 * Change the field's type. Only type changes that keep the same underlying
+	 * column type (per `FIELD_TYPE_TO_COLUMN`) are allowed — e.g. `string` to
+	 * `slug` (both TEXT). A change that would alter the column affinity (e.g.
+	 * `text` TEXT to `portableText` JSON) is rejected, because there is no
+	 * in-place column migration and silently rewriting the metadata would
+	 * desync `column_type` from the real `ec_*` column. Omit to keep the
+	 * current type.
+	 */
+	type?: FieldType;
 	required?: boolean;
 	unique?: boolean;
 	defaultValue?: unknown;

package/src/schema/zod-generator.ts

@@ -86,7 +86,15 @@ function getBaseSchema(type: FieldType, field: Field): ZodTypeAny {
 			return z.preprocess((v) => (v === 0 || v === 1 ? Boolean(v) : v), z.boolean());
 
 		case "datetime":
-			return z.string().datetime().or(z.string().date());
+			// Accept every value that legitimately round-trips through the admin
+			// and seeds: ISO with `Z`, ISO with a timezone offset, a naive
+			// datetime (`YYYY-MM-DDTHH:mm[:ss]` -- what `<input type="datetime-local">`
+			// and many seeds produce), and a date-only value. The admin re-sends
+			// every loaded field on autosave, so a stored naive datetime must
+			// validate or the entry becomes unsavable through its own editor
+			// (#1368; same class as #867). `z.iso.*` retains semantic validation,
+			// so impossible dates are still rejected.
+			return z.iso.datetime({ offset: true, local: true }).or(z.iso.date());
 
 		case "select": {
 			const options = field.validation?.options;

package/src/seed/apply.ts

@@ -159,6 +159,7 @@ export async function applySeed(
 						if (existingField) {
 							await registry.updateField(collection.slug, field.slug, {
 								label: field.label,
+								type: field.type,
 								required: field.required || false,
 								unique: field.unique || false,
 								searchable: field.searchable || false,
@@ -345,6 +346,12 @@ export async function applySeed(
 				}
 			}
 		}
+
+		// Seeded/updated defs change which taxonomies exist — clear the
+		// isolate-wide defs + names caches so later reads in this isolate
+		// (e.g. an auto-seed triggered mid-request) reflect them immediately.
+		const { invalidateTaxonomyDefsCache } = await import("../taxonomies/index.js");
+		invalidateTaxonomyDefsCache();
 	}
 
 	// 6. Bylines

package/src/taxonomies/index.ts

@@ -12,14 +12,16 @@
  */
 
 import { resolveLocale, resolveLocaleChain } from "../i18n/resolve.js";
-import { getDb } from "../loader.js";
+import { getDb, resetTaxonomyNamesCache } from "../loader.js";
 import {
 	cachedQuery,
 	CacheNamespace,
 	contentNamespace,
 	invalidateTaxonomyObjectCache,
+	isObjectCacheActive,
 } from "../object-cache/index.js";
 import { peekRequestCache, requestCached, setRequestCacheEntry } from "../request-cache.js";
+import { getRequestContext } from "../request-context.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";
@@ -28,35 +30,136 @@ export interface TaxonomyQueryOptions {
 	locale?: string;
 }
 
+/** Invalidate cached taxonomy term data and any content that hydrates terms. */
+export function invalidateTermCache(): void {
+	invalidateTaxonomyObjectCache();
+}
+
 /**
- * Invalidate cached taxonomy data in the distributed object cache (and any
- * content that hydrates taxonomy terms). The legacy in-isolate term cache was
- * removed, so this used to be a no-op; it now drives object-cache invalidation.
+ * Worker-isolate cache for taxonomy definitions, keyed by resolved locale.
+ *
+ * Taxonomy *definitions* (the "category"/"tag" taxonomies themselves, not
+ * their terms) are read on every public render that hydrates entry terms —
+ * `getAllTermsForEntries` → `getCollectionTaxonomyNames` → `getTaxonomyDefs` —
+ * but change extremely rarely: they're created via the admin API or applied
+ * from a seed, and there is no edit/delete-def path. Caching them across the
+ * isolate lifetime drops the per-render `SELECT * FROM _emdash_taxonomy_defs`
+ * to once-per-isolate.
+ *
+ * Stored on globalThis behind a Symbol key (same pattern as
+ * `settings/index.ts`) so the bundler duplicating this module across SSR
+ * chunks can't produce two independent caches.
+ *
+ * When the distributed object cache is configured, it is authoritative and this
+ * fallback is bypassed so cross-isolate epoch invalidation cannot be undercut
+ * by stale per-isolate data on an object-cache miss.
+ *
+ * **Isolated databases bypass the cache.** Playground / DO preview requests
+ * set `requestContext.dbIsIsolated`; they point at a divergent schema, so we
+ * skip both reading and writing the global holder and fall back to the
+ * per-request cache (same precedent as `getTaxonomyNames` / byline field defs).
  */
-export function invalidateTermCache(): void {
+interface TaxonomyDefsHolder {
+	version: number;
+	/** locale key ("*" for "all locales") → { version it was fetched at, promise }. */
+	cache: Map<string, { version: number; promise: Promise<TaxonomyDef[]> }>;
+}
+
+const TAXONOMY_DEFS_CACHE_KEY = Symbol.for("emdash:taxonomy-defs");
+const taxonomyDefsStore = globalThis as Record<symbol, unknown>;
+const defsHolder: TaxonomyDefsHolder =
+	// eslint-disable-next-line typescript/no-unsafe-type-assertion -- globalThis singleton pattern (see settings/index.ts)
+	(taxonomyDefsStore[TAXONOMY_DEFS_CACHE_KEY] as TaxonomyDefsHolder | undefined) ??
+	(() => {
+		const h: TaxonomyDefsHolder = { version: 0, cache: new Map() };
+		taxonomyDefsStore[TAXONOMY_DEFS_CACHE_KEY] = h;
+		return h;
+	})();
+
+/**
+ * Invalidate the isolate-wide taxonomy-definitions cache (and the related
+ * loader taxonomy-names cache). Called from every taxonomy-def write path
+ * (`handleTaxonomyCreate`, seed application). Other isolates refresh on their
+ * next recycle — staleness bounded by isolate lifetime.
+ */
+export function invalidateTaxonomyDefsCache(): void {
+	defsHolder.version++;
+	defsHolder.cache.clear();
+	resetTaxonomyNamesCache();
 	invalidateTaxonomyObjectCache();
 }
 
+/**
+ * Test/internal helper: clear the per-isolate taxonomy-defs cache. Useful for
+ * unit tests that insert defs directly and need to force a refetch without
+ * going through a write path. Production code should rely on
+ * `invalidateTaxonomyDefsCache()`.
+ */
+export function resetTaxonomyDefsCacheForTests(): void {
+	defsHolder.version++;
+	defsHolder.cache.clear();
+}
+
+/**
+ * Fetch taxonomy definitions straight from the database (no caching).
+ */
+async function fetchTaxonomyDefs(locale: string | undefined): Promise<TaxonomyDef[]> {
+	const db = await getDb();
+	let query = db.selectFrom("_emdash_taxonomy_defs").selectAll();
+	if (locale !== undefined) query = query.where("locale", "=", locale);
+	const rows = await query.execute();
+	return rows.map(rowToTaxonomyDef);
+}
+
+/**
+ * Resolve taxonomy defs through the isolate fallback cache, bypassing it for
+ * isolated databases. The returned promise is cached (not the resolved value)
+ * so concurrent cold-isolate readers share one in-flight query; a rejection
+ * evicts the entry so the next caller retries.
+ */
+function loadTaxonomyDefs(localeKey: string, locale: string | undefined): Promise<TaxonomyDef[]> {
+	if (getRequestContext()?.dbIsIsolated === true) {
+		return fetchTaxonomyDefs(locale);
+	}
+	const existing = defsHolder.cache.get(localeKey);
+	if (existing && existing.version === defsHolder.version) {
+		return existing.promise;
+	}
+	const version = defsHolder.version;
+	const promise = fetchTaxonomyDefs(locale).catch((error: unknown) => {
+		const current = defsHolder.cache.get(localeKey);
+		if (current && current.promise === promise) {
+			defsHolder.cache.delete(localeKey);
+		}
+		throw error;
+	});
+	defsHolder.cache.set(localeKey, { version, promise });
+	return promise;
+}
+
 /**
  * Get every taxonomy definition. Definitions are per-locale (one row per
  * locale inside the same translation_group) — by default we resolve to the
  * active locale.
+ *
+ * Two-tier cache: per-request via `requestCached` (so a single render that
+ * hydrates terms for several collections pays at most one call), then
+ * per-isolate via the global holder (so warm renders issue zero queries).
+ * The `requestCached` key is unchanged so `getTaxonomyDef`'s peek still hits.
  */
 export async function getTaxonomyDefs(options: TaxonomyQueryOptions = {}): Promise<TaxonomyDef[]> {
 	const locale = resolveLocale(options.locale);
-	return requestCached(`taxonomy-defs:${locale ?? "*"}`, () =>
-		cachedQuery({
-			namespace: CacheNamespace.TAXONOMIES,
-			key: `defs:${locale ?? "*"}`,
-			load: async () => {
-				const db = await getDb();
-				let query = db.selectFrom("_emdash_taxonomy_defs").selectAll();
-				if (locale !== undefined) query = query.where("locale", "=", locale);
-				const rows = await query.execute();
-				return rows.map(rowToTaxonomyDef);
-			},
-		}),
-	);
+	const localeKey = locale ?? "*";
+	return requestCached(`taxonomy-defs:${localeKey}`, async () => {
+		if (await isObjectCacheActive()) {
+			return cachedQuery({
+				namespace: CacheNamespace.TAXONOMIES,
+				key: `defs:${localeKey}`,
+				load: () => fetchTaxonomyDefs(locale),
+			});
+		}
+		return loadTaxonomyDefs(localeKey, locale);
+	});
 }
 
 /**