Hook-Referenz

Hooks ermöglichen es Plugins, das Verhalten von EmDash an bestimmten Punkten im Inhalts-, Medien-, E-Mail-, Kommentar- und Seitenlebenszyklus abzufangen und zu modifizieren.

Hook-Übersicht

Die folgende Tabelle listet jeden Hook auf, was ihn auslöst, was er modifizieren kann und ob er exklusiv ist:

Content-Hooks

content:beforeSave

Wird ausgeführt bevor Inhalt in der Datenbank gespeichert wird. Verwenden Sie dies zum Validieren, Transformieren oder Anreichern von Inhalten.

import { definePlugin } from "emdash";

export default definePlugin({
	id: "my-plugin",
	version: "1.0.0",
	hooks: {
		"content:beforeSave": async (event, ctx) => {
			const { content, collection, isNew } = event;

			// Zeitstempel hinzufügen
			if (isNew) {
				content.createdBy = "system";
			}
			content.modifiedAt = new Date().toISOString();

			// Modifizierten Inhalt zurückgeben
			return content;
		},
	},
});

Event

interface ContentHookEvent {
	content: Record<string, unknown>; // Inhaltsdaten
	collection: string; // Collection-Slug
	isNew: boolean; // True für Erstellung, false für Aktualisierung
}

Rückgabewert

• Modifiziertes Content-Objekt zurückgeben um Änderungen anzuwenden
• void zurückgeben um unverändert durchzuleiten

content:afterSave

Wird nach dem Speichern des Inhalts ausgeführt. Verwenden Sie dies für Nebeneffekte wie Benachrichtigungen, Cache-Invalidierung oder externe Synchronisierung.

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

    if (collection === "posts" && content.status === "published") {
      // Externen Dienst benachrichtigen
      await ctx.http?.fetch("https://api.example.com/notify", {
        method: "POST",
        body: JSON.stringify({ postId: content.id }),
      });
    }
  },
}

Rückgabewert

Kein Rückgabewert erwartet.

content:beforeDelete

Wird vor dem Löschen des Inhalts ausgeführt. Verwenden Sie dies zum Validieren oder Verhindern der Löschung.

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

    // Löschung geschützter Inhalte verhindern
    const item = await ctx.content?.get(collection, id);
    if (item?.data.protected) {
      return false; // Löschung abbrechen
    }

    // Löschung erlauben
    return true;
  },
}

Event

interface ContentDeleteEvent {
	id: string; // Eintrags-ID
	collection: string; // Collection-Slug
}

Rückgabewert

• false zurückgeben um Löschung abzubrechen
• true oder void zurückgeben um zu erlauben

content:afterDelete

Wird nach dem Löschen des Inhalts ausgeführt. Verwenden Sie dies für Aufräumarbeiten.

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

    // Zugehörige Daten bereinigen
    await ctx.storage.relatedItems.delete(`${collection}:${id}`);
  },
}

content:afterRestore

Wird nach der Wiederherstellung von gelöschtem Inhalt ausgeführt. Erfordert die Fähigkeit content:read.

hooks: {
  "content:afterRestore": async (event, ctx) => {
    ctx.log.info(`Restored ${event.collection}/${event.content.id}`);
  },
}

content:afterSchedule

Wird ausgeführt nachdem Inhalt für zukünftige Veröffentlichung geplant wurde. Erfordert die Fähigkeit content:read.

hooks: {
  "content:afterSchedule": async (event, ctx) => {
    ctx.log.info(`Scheduled ${event.collection}/${event.content.id}`);
  },
}

content:afterUnschedule

Wird ausgeführt nachdem die Planung von Inhalt aufgehoben wurde. Erfordert die Fähigkeit content:read.

hooks: {
  "content:afterUnschedule": async (event, ctx) => {
    ctx.log.info(`Unscheduled ${event.collection}/${event.content.id}`);
  },
}

Event

interface ContentStateChangeEvent {
	content: Record<string, unknown>;
	collection: string;
}

Rückgabewert

Kein Rückgabewert erwartet.

Media-Hooks

media:beforeUpload

Wird vor dem Hochladen einer Datei ausgeführt. Verwenden Sie dies zum Validieren, Umbenennen oder Ablehnen von Dateien.

hooks: {
  "media:beforeUpload": async (event, ctx) => {
    const { file } = event;

    // Dateien über 10MB ablehnen
    if (file.size > 10 * 1024 * 1024) {
      throw new Error("File too large");
    }

    // Datei umbenennen
    return {
      name: `${Date.now()}-${file.name}`,
      type: file.type,
      size: file.size,
    };
  },
}

Event

interface MediaUploadEvent {
	file: {
		name: string; // Originaler Dateiname
		type: string; // MIME-Typ
		size: number; // Größe in Bytes
	};
}

Rückgabewert

• Modifizierte Datei-Metadaten zurückgeben um Änderungen anzuwenden
• void zurückgeben um unverändert durchzuleiten
• Einen Fehler werfen um den Upload abzulehnen

media:afterUpload

Wird nach dem Hochladen einer Datei ausgeführt. Verwenden Sie dies für Verarbeitung, Thumbnails oder Metadaten-Extraktion.

hooks: {
  "media:afterUpload": async (event, ctx) => {
    const { media } = event;

    if (media.mimeType.startsWith("image/")) {
      // Bild-Metadaten speichern
      await ctx.kv.set(`media:${media.id}:analyzed`, {
        processedAt: new Date().toISOString(),
      });
    }
  },
}

Event

interface MediaAfterUploadEvent {
	media: {
		id: string;
		filename: string;
		mimeType: string;
		size: number | null;
		url: string;
		createdAt: string;
	};
}

Lifecycle-Hooks

plugin:install

Wird ausgeführt wenn ein Plugin erstmals installiert wird. Verwenden Sie dies für die initiale Einrichtung, das Erstellen von Speicher-Collections oder das Seeden von Daten.

hooks: {
  "plugin:install": async (event, ctx) => {
    // Standardeinstellungen initialisieren
    await ctx.kv.set("settings:enabled", true);
    await ctx.kv.set("settings:threshold", 100);

    ctx.log.info("Plugin installed successfully");
  },
}

plugin:activate

Wird ausgeführt wenn ein Plugin aktiviert wird (nach Installation oder Reaktivierung).

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

plugin:deactivate

Wird ausgeführt wenn ein Plugin deaktiviert wird.

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

plugin:uninstall

Wird ausgeführt wenn ein Plugin entfernt wird. Verwenden Sie dies für Aufräumarbeiten.

hooks: {
  "plugin:uninstall": async (event, ctx) => {
    const { deleteData } = event;

    if (deleteData) {
      // Alle Plugin-Daten bereinigen
      const items = await ctx.kv.list("settings:");
      for (const { key } of items) {
        await ctx.kv.delete(key);
      }
    }

    ctx.log.info("Plugin uninstalled");
  },
}

Event

interface UninstallEvent {
	deleteData: boolean; // Benutzer hat das Löschen der Daten gewählt
}

Cron-Hook

cron

Wird ausgelöst wenn eine geplante Aufgabe ausgeführt wird. Planen Sie Aufgaben mit ctx.cron.schedule().

hooks: {
  "cron": async (event, ctx) => {
    if (event.name === "daily-sync") {
      const data = await ctx.http?.fetch("https://api.example.com/data");
      ctx.log.info("Sync complete");
    }
  },
}

Event

interface CronEvent {
	name: string;
	data?: Record<string, unknown>;
	scheduledAt: string;
}

E-Mail-Hooks

E-Mail-Hooks werden in dieser Reihenfolge ausgeführt: email:beforeSend, dann email:deliver, dann email:afterSend.

email:beforeSend

Fähigkeit: hooks.email-events:register

Middleware-Hook der vor der Zustellung ausgeführt wird. Nachrichten transformieren oder Zustellung abbrechen.

hooks: {
  "email:beforeSend": async (event, ctx) => {
    // Footer zu allen E-Mails hinzufügen
    return {
      ...event.message,
      text: event.message.text + "\n\n—Sent from My Site",
    };

    // Oder false zurückgeben um Zustellung abzubrechen
  },
}

Event

interface EmailBeforeSendEvent {
	message: { to: string; subject: string; text: string; html?: string };
	source: string;
}

Rückgabewert

• Modifizierte Nachricht zurückgeben zum Transformieren
• false zurückgeben um Zustellung abzubrechen
• void zurückgeben um unverändert durchzuleiten

email:deliver

Fähigkeit: hooks.email-transport:register | Exklusiv: Ja

Der Transport-Provider. Nur ein Plugin kann E-Mails zustellen. Verantwortlich für das tatsächliche Senden der Nachricht über einen E-Mail-Dienst.

hooks: {
  "email:deliver": {
    exclusive: true,
    handler: async (event, ctx) => {
      await sendViaSES(event.message);
    },
  },
}

email:afterSend

Fähigkeit: hooks.email-events:register

Fire-and-forget-Hook nach erfolgreicher Zustellung. Fehler werden protokolliert, aber nicht weitergegeben.

hooks: {
  "email:afterSend": async (event, ctx) => {
    await ctx.kv.set(`email:log:${Date.now()}`, {
      to: event.message.to,
      subject: event.message.subject,
    });
  },
}

Kommentar-Hooks

Kommentar-Hooks werden in dieser Reihenfolge ausgeführt: comment:beforeCreate, dann comment:moderate, dann comment:afterCreate. Der Hook comment:afterModerate wird separat ausgelöst wenn ein Administrator den Status eines Kommentars ändert.

comment:beforeCreate

Fähigkeit: users:read

Middleware-Hook bevor ein Kommentar gespeichert wird. Kommentare anreichern, validieren oder ablehnen.

hooks: {
  "comment:beforeCreate": async (event, ctx) => {
    // Kommentare mit Links ablehnen
    if (event.comment.body.includes("http")) {
      return false;
    }
  },
}

Event

interface CommentBeforeCreateEvent {
	comment: {
		collection: string;
		contentId: string;
		parentId: string | null;
		authorName: string;
		authorEmail: string;
		authorUserId: string | null;
		body: string;
		ipHash: string | null;
		userAgent: string | null;
	};
	metadata: Record<string, unknown>;
}

Rückgabewert

• Modifiziertes Event zurückgeben zum Transformieren
• false zurückgeben um abzulehnen
• void zurückgeben um durchzuleiten

comment:moderate

Fähigkeit: users:read | Exklusiv: Ja

Entscheidet ob ein Kommentar genehmigt, ausstehend oder Spam ist. Nur ein Moderations-Provider ist aktiv.

hooks: {
  "comment:moderate": {
    exclusive: true,
    handler: async (event, ctx) => {
      const score = await checkSpam(event.comment);
      return {
        status: score > 0.8 ? "spam" : score > 0.5 ? "pending" : "approved",
        reason: `Spam score: ${score}`,
      };
    },
  },
}

Event

interface CommentModerateEvent {
	comment: { /* wie bei beforeCreate */ };
	metadata: Record<string, unknown>;
	collectionSettings: {
		commentsEnabled: boolean;
		commentsModeration: "all" | "first_time" | "none";
		commentsClosedAfterDays: number;
		commentsAutoApproveUsers: boolean;
	};
	priorApprovedCount: number;
}

Rückgabewert

{ status: "approved" | "pending" | "spam"; reason?: string }

comment:afterCreate

Fähigkeit: users:read

Fire-and-forget-Hook nachdem ein Kommentar gespeichert wurde. Verwenden Sie dies für Benachrichtigungen.

hooks: {
  "comment:afterCreate": async (event, ctx) => {
    if (event.comment.status === "approved") {
      await ctx.email?.send({
        to: event.contentAuthor?.email,
        subject: `New comment on "${event.content.title}"`,
        text: `${event.comment.authorName} commented: ${event.comment.body}`,
      });
    }
  },
}

comment:afterModerate

Fähigkeit: users:read

Fire-and-forget-Hook wenn ein Administrator den Status eines Kommentars manuell ändert.

Event

interface CommentAfterModerateEvent {
	comment: { id: string; /* ... */ };
	previousStatus: string;
	newStatus: string;
	moderator: { id: string; name: string | null };
}

Seiten-Hooks

Seiten-Hooks werden beim Rendern öffentlicher Seiten ausgeführt. Sie ermöglichen Plugins das Injizieren von Metadaten und Skripten.

page:metadata

Fähigkeit: Keine erforderlich

Meta-Tags, Open-Graph-Eigenschaften, JSON-LD-strukturierte Daten oder Link-Tags zum Seiten-Head beitragen.

hooks: {
  "page:metadata": async (event, ctx) => {
    return [
      { kind: "meta", name: "generator", content: "EmDash" },
      { kind: "property", property: "og:site_name", content: event.page.siteName },
      { kind: "jsonld", graph: { "@type": "WebSite", name: event.page.siteName } },
    ];
  },
}

Beitragstypen

type PageMetadataContribution =
	| { kind: "meta"; name: string; content: string; key?: string }
	| { kind: "property"; property: string; content: string; key?: string }
	| {
			kind: "link";
			rel: "canonical" | "alternate" | "author" | "license" | "nlweb" | "site.standard.document";
			href: string;
			hreflang?: string;
			key?: string;
	  }
	| {
			kind: "jsonld";
			id?: string;
			graph: Record<string, unknown> | Array<Record<string, unknown>>;
	  };

Das key-Feld dedupliziert Beiträge — nur der letzte Beitrag mit einem gegebenen Key wird verwendet.

page:fragments

Fähigkeit: hooks.page-fragments:register

Skripte oder HTML in Seiten injizieren. Nur für native Plugins verfügbar.

hooks: {
  "page:fragments": async (event, ctx) => {
    return [
      {
        kind: "external-script",
        placement: "body:end",
        src: "https://analytics.example.com/script.js",
        async: true,
      },
      {
        kind: "inline-script",
        placement: "head",
        code: `window.siteId = "abc123";`,
      },
    ];
  },
}

Beitragstypen

type PageFragmentContribution =
	| {
			kind: "external-script";
			placement: "head" | "body:start" | "body:end";
			src: string;
			async?: boolean;
			defer?: boolean;
			attributes?: Record<string, string>;
			key?: string;
		}
	| {
			kind: "inline-script";
			placement: "head" | "body:start" | "body:end";
			code: string;
			attributes?: Record<string, string>;
			key?: string;
		}
	| {
			kind: "html";
			placement: "head" | "body:start" | "body:end";
			html: string;
			key?: string;
		};

Hook-Konfiguration

Hooks akzeptieren entweder eine Handler-Funktion oder ein Konfigurationsobjekt:

hooks: {
  // Einfacher Handler
  "content:afterSave": async (event, ctx) => { ... },

  // Mit Konfiguration
  "content:beforeSave": {
    priority: 50,        // Niedrigere Werte laufen zuerst (Standard: 100)
    timeout: 10000,      // Max. Ausführungszeit in ms (Standard: 5000)
    dependencies: [],    // Nach diesen Plugins ausführen
    errorPolicy: "abort", // "continue" oder "abort" (Standard)
    handler: async (event, ctx) => { ... },
  },
}

Konfigurationsoptionen

Plugin-Kontext

Alle Hooks erhalten ein Kontextobjekt mit Zugriff auf Plugin-APIs:

interface PluginContext {
	plugin: { id: string; version: string };
	storage: PluginStorage;
	kv: KVAccess;
	content?: ContentAccess;
	media?: MediaAccess;
	http?: HttpAccess;
	log: LogAccess;
	site: { name: string; url: string; locale: string };
	url(path: string): string;
	users?: UserAccess;
	cron?: CronAccess;
	email?: EmailAccess;
}

Siehe Plugin-Übersicht — Plugin-Kontext für Capability-Anforderungen und Methoden-Details.

Fehlerbehandlung

Fehler in Hooks werden protokolliert und basierend auf errorPolicy behandelt:

• "abort" (Standard) — Ausführung stoppen, Transaktion rückgängig machen falls zutreffend
• "continue" — Fehler protokollieren und zum nächsten Hook fortfahren

hooks: {
  "content:beforeSave": {
    errorPolicy: "continue", // Speicherung nicht blockieren wenn dies fehlschlägt
    handler: async (event, ctx) => {
      try {
        await ctx.http?.fetch("https://api.example.com/validate");
      } catch (error) {
        ctx.log.warn("Validation service unavailable", error);
      }
    },
  },
}

Ausführungsreihenfolge

Hooks werden in dieser Reihenfolge ausgeführt:

1. Sortiert nach priority (aufsteigend)
2. Plugins mit dependencies laufen nach ihren Abhängigkeiten
3. Bei gleicher Priorität ist die Reihenfolge deterministisch aber nicht spezifiziert

// Dies läuft zuerst (Priorität 10)
{ priority: 10, handler: ... }

// Dies läuft als zweites (Priorität 50)
{ priority: 50, handler: ... }

// Dies läuft zuletzt (Standardpriorität 100)
{ handler: ... }