emdash 0.24.1 → 0.25.1

package/src/plugins/hooks.ts

@@ -32,6 +32,7 @@ import type {
 	ContentBeforeDeleteHandler,
 	ContentAfterDeleteHandler,
 	ContentAfterPublishHandler,
+	ContentAfterRestoreHandler,
 	ContentAfterUnpublishHandler,
 	MediaBeforeUploadHandler,
 	MediaAfterUploadHandler,
@@ -66,6 +67,7 @@ type HookNameV2 =
 	| "content:afterDelete"
 	| "content:afterPublish"
 	| "content:afterUnpublish"
+	| "content:afterRestore"
 	| "media:beforeUpload"
 	| "media:afterUpload"
 	| "cron"
@@ -93,6 +95,7 @@ interface HookHandlerMap {
 	"content:afterDelete": ContentAfterDeleteHandler;
 	"content:afterPublish": ContentAfterPublishHandler;
 	"content:afterUnpublish": ContentAfterUnpublishHandler;
+	"content:afterRestore": ContentAfterRestoreHandler;
 	"media:beforeUpload": MediaBeforeUploadHandler;
 	"media:afterUpload": MediaAfterUploadHandler;
 	cron: CronHandler;
@@ -220,6 +223,7 @@ 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, "media:beforeUpload");
 			this.registerPluginHook(plugin, "media:afterUpload");
 			this.registerPluginHook(plugin, "cron");
@@ -264,6 +268,7 @@ export class HookPipeline {
 		["content:afterDelete", "content:read"],
 		["content:afterPublish", "content:read"],
 		["content:afterUnpublish", "content:read"],
+		["content:afterRestore", "content:read"],
 		// Media
 		["media:beforeUpload", "media:write"],
 		["media:afterUpload", "media:read"],
@@ -727,6 +732,46 @@ export class HookPipeline {
 		return results;
 	}
 
+	/**
+	 * Run content:afterRestore hooks (fire-and-forget).
+	 */
+	async runContentAfterRestore(
+		content: Record<string, unknown>,
+		collection: string,
+	): Promise<HookResult<void>[]> {
+		const hooks = this.getTypedHooks("content:afterRestore");
+		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();
+
+			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,
+				});
+
+				if (hook.errorPolicy === "abort") {
+					throw error;
+				}
+			}
+		}
+
+		return results;
+	}
+
 	// =========================================================================
 	// Media Hooks
 	// =========================================================================

package/src/plugins/index.ts

@@ -148,6 +148,7 @@ export type {
 	ContentAfterSaveHandler,
 	ContentBeforeDeleteHandler,
 	ContentAfterDeleteHandler,
+	ContentAfterRestoreHandler,
 	MediaBeforeUploadHandler,
 	MediaAfterUploadHandler,
 	LifecycleHandler,

package/src/plugins/manager.ts

@@ -370,6 +370,17 @@ 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 media:beforeUpload hooks across all active plugins
 	 */

package/src/plugins/manifest-schema.ts

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

package/src/plugins/types.ts

@@ -791,6 +791,11 @@ export type ContentAfterUnpublishHandler = (
 	ctx: PluginContext,
 ) => Promise<void>;
 
+export type ContentAfterRestoreHandler = (
+	event: ContentPublishStateChangeEvent,
+	ctx: PluginContext,
+) => Promise<void>;
+
 export type MediaBeforeUploadHandler = (
 	event: MediaUploadEvent,
 	ctx: PluginContext,
@@ -976,6 +981,7 @@ export interface PluginHooks {
 	"content:afterUnpublish"?:
 		| HookConfig<ContentAfterUnpublishHandler>
 		| ContentAfterUnpublishHandler;
+	"content:afterRestore"?: HookConfig<ContentAfterRestoreHandler> | ContentAfterRestoreHandler;
 
 	// Media hooks
 	"media:beforeUpload"?: HookConfig<MediaBeforeUploadHandler> | MediaBeforeUploadHandler;
@@ -1295,6 +1301,7 @@ export interface ResolvedPluginHooks {
 	"content:afterDelete"?: ResolvedHook<ContentAfterDeleteHandler>;
 	"content:afterPublish"?: ResolvedHook<ContentAfterPublishHandler>;
 	"content:afterUnpublish"?: ResolvedHook<ContentAfterUnpublishHandler>;
+	"content:afterRestore"?: ResolvedHook<ContentAfterRestoreHandler>;
 	"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/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,