Hooks | EmDash CMS Everything

Hooks ermöglichen es Plugins, Code als Reaktion auf Ereignisse auszuführen. Alle Hooks erhalten ein Event-Objekt und den Plugin-Kontext und werden bei der Plugin-Definition deklariert — es gibt keine dynamische Registrierung zur Laufzeit.

Diese Seite behandelt Sandboxed-Plugins. Hooks funktionieren bei nativen Plugins identisch; native Plugins können zusätzlich page:fragments registrieren.

Hook-Signatur

Jeder Hook-Handler nimmt zwei Argumente entgegen:

async (event, ctx) => ReturnType;

event — Daten über das, was gerade passiert ist (Inhalt wird gespeichert, Medien hochgeladen, Lebenszyklus-Übergang usw.)
ctx — der PluginContext mit Storage, KV, Logging und fähigkeitsgesteuerten APIs

satisfies SandboxedPlugin am Default-Export leitet event vom Hook-Namen (dem vollständigen kanonischen Ereignistyp) und ctx als PluginContext ab, sodass Handler keine Parameter-Annotationen benötigen. Um einen Event-Typ namentlich in einem Helper zu referenzieren, importieren Sie ihn aus emdash/plugin.

Hook-Konfiguration

Ein Hook kann als einfacher Handler oder in einem Config-Objekt deklariert werden:

Einfach

hooks: {
	"content:afterSave": async (event, ctx) => {
		ctx.log.info("Content saved");
	},
},

Vollständige Konfiguration

hooks: {
	"content:afterSave": {
		priority: 100,
		timeout: 5000,
		dependencies: ["audit-log"],
		errorPolicy: "continue",
		handler: async (event, ctx) => {
			ctx.log.info("Content saved");
		},
	},
},

Konfigurationsoptionen

Option	Typ	Standard	Beschreibung
`priority`	`number`	`100`	Ausführungsreihenfolge. Niedrigere Zahlen werden zuerst ausgeführt.
`timeout`	`number`	`5000`	Maximale Ausführungszeit in Millisekunden.
`dependencies`	`string[]`	`[]`	Plugin-IDs, die vor diesem Hook laufen müssen.
`errorPolicy`	`"abort" \| "continue"`	`"abort"`	Ob die Pipeline bei einem Fehler gestoppt werden soll.
`exclusive`	`boolean`	`false`	Nur ein Plugin kann der aktive Anbieter sein. Verwendet für `email:deliver` und `comment:moderate`.
`handler`	`function`	—	Die Hook-Handler-Funktion. Erforderlich.

Lebenszyklus-Hooks

Werden während der Plugin-Installation, Aktivierung, Deaktivierung und Entfernung ausgeführt.

`plugin:install`

Wird einmal ausgeführt, wenn das Plugin zum ersten Mal zu einer Seite hinzugefügt wird.

"plugin:install": async (_event, ctx) => {
	ctx.log.info("Installing plugin...");
	await ctx.kv.set("settings:enabled", true);
	await ctx.storage.items.put("default", { name: "Default Item" });
},

Event: {} — Gibt zurück: Promise<void>

`plugin:activate`

Wird ausgeführt, wenn das Plugin aktiviert wird (nach der Installation oder beim erneuten Aktivieren).

"plugin:activate": async (_event, ctx) => {
	ctx.log.info("Plugin activated");
},

Event: {} — Gibt zurück: Promise<void>

`plugin:deactivate`

Wird ausgeführt, wenn das Plugin deaktiviert wird (aber nicht entfernt).

"plugin:deactivate": async (_event, ctx) => {
	ctx.log.info("Plugin deactivated");
},

Event: {} — Gibt zurück: Promise<void>

`plugin:uninstall`

Wird ausgeführt, wenn das Plugin von einer Seite entfernt wird.

"plugin:uninstall": async (event, ctx) => {
	ctx.log.info("Uninstalling plugin...");
	if (event.deleteData) {
		const result = await ctx.storage.items.query({ limit: 1000 });
		await ctx.storage.items.deleteMany(result.items.map((i) => i.id));
	}
},

Event: { deleteData: boolean } — Gibt zurück: Promise<void>

Content-Hooks

Werden bei Erstellen-, Aktualisieren- und Löschen-Operationen auf Seiteninhalte ausgeführt.

`content:beforeSave`

Wird ausgeführt, bevor Inhalt gespeichert wird. Gibt modifizierten Inhalt zurück, oder void, um ihn unverändert zu lassen. Wirft eine Exception, um abzubrechen.

"content:beforeSave": async (event, ctx) => {
	const { content, collection } = event;

	if (collection === "posts" && !content.title) {
		throw new Error("Posts require a title");
	}

	if (typeof content.slug === "string") {
		content.slug = content.slug.toLowerCase().replace(/\s+/g, "-");
	}

	return content;
},

Event: { content, collection, isNew } — Gibt zurück: modifizierten Inhalt oder void.

`content:afterSave`

Wird ausgeführt, nachdem Inhalt erfolgreich gespeichert wurde. Verwenden Sie es für Seiteneffekte wie Benachrichtigungen, Logging oder externe Synchronisierungen.

"content:afterSave": async (event, ctx) => {
	ctx.log.info(`${event.isNew ? "Created" : "Updated"} ${event.collection}/${event.content.id}`);

	if (ctx.http) {
		await ctx.http.fetch("https://api.example.com/webhook", {
			method: "POST",
			body: JSON.stringify({ event: "content:save", id: event.content.id }),
		});
	}
},

Event: { content, collection, isNew } — Gibt zurück: Promise<void>

`content:beforeDelete`

Wird ausgeführt, bevor Inhalt gelöscht wird. Gibt false zurück, um abzubrechen; true oder void erlaubt es.

"content:beforeDelete": async (event, ctx) => {
	if (event.collection === "pages" && event.id === "home") {
		ctx.log.warn("Cannot delete home page");
		return false;
	}
	return true;
},

Event: { id, collection } — Gibt zurück: boolean | void

`content:afterDelete`

Wird ausgeführt, nachdem Inhalt erfolgreich gelöscht wurde.

"content:afterDelete": async (event, ctx) => {
	await ctx.storage.cache.delete(`${event.collection}:${event.id}`);
},

Event: { id, collection } — Gibt zurück: Promise<void>

`content:afterPublish`

Wird ausgeführt, nachdem Inhalt von Entwurf auf Live befördert wurde. Erfordert die Fähigkeit content:read.