payload-plugin-newsletter 0.25.12 → 0.26.0

package/dist/server.d.ts

@@ -1,4 +1,5 @@
-import { Field, Block, RichTextField, Config, Endpoint, CollectionConfig, GlobalConfig } from 'payload';
+import { Field, Block, RichTextField, Payload, Config, Endpoint, CollectionConfig, GlobalConfig } from 'payload';
+import { SerializedEditorState } from 'lexical';
 
 /**
  * Core types for broadcast management functionality
@@ -632,6 +633,96 @@ interface SurveyQuestion {
     required?: boolean;
 }
 
+/**
+ * Recursively populates media fields in Lexical content.
+ * Resolves Media IDs to full media objects with URLs.
+ *
+ * @param content - Lexical editor state content
+ * @param payload - Payload instance for database queries
+ * @param config - Newsletter plugin configuration
+ * @returns Populated content with resolved media objects
+ */
+declare function populateMediaFields(content: unknown, payload: Payload, config: NewsletterPluginConfig): Promise<unknown>;
+
+/**
+ * Options for generating broadcast preview HTML
+ */
+interface PreviewOptions {
+    /** Email subject line */
+    subject: string;
+    /** Email preheader text (preview text in inbox) */
+    preheader?: string;
+    /** Whether to wrap content in email template (default: true) */
+    wrapInTemplate?: boolean;
+    /** Base URL for media files (optional, derived from payload.config.serverURL if not provided) */
+    mediaUrl?: string;
+    /** Additional document data to pass to custom wrapper */
+    documentData?: Record<string, unknown>;
+}
+/**
+ * Result from preview generation
+ */
+interface PreviewResult {
+    /** Generated HTML content */
+    html: string;
+    /** Subject line used */
+    subject: string;
+    /** Preheader text used (null if not provided) */
+    preheader: string | null;
+}
+/**
+ * Generates preview HTML from broadcast content.
+ *
+ * This utility handles the full preview generation pipeline:
+ * 1. Populates media fields (resolves Media IDs to full objects with URLs)
+ * 2. Converts Lexical content to email-safe HTML
+ * 3. Optionally wraps in email template
+ *
+ * @param content - Lexical editor state content from broadcast
+ * @param payload - Payload instance for database queries
+ * @param config - Newsletter plugin configuration
+ * @param options - Preview generation options
+ * @returns Preview result with HTML, subject, and preheader
+ *
+ * @example
+ * ```typescript
+ * import { generateBroadcastPreviewHtml } from 'payload-plugin-newsletter'
+ *
+ * const preview = await generateBroadcastPreviewHtml(
+ *   broadcast.content,
+ *   payload,
+ *   pluginConfig,
+ *   {
+ *     subject: broadcast.subject,
+ *     preheader: broadcast.preheader,
+ *     wrapInTemplate: true,
+ *   }
+ * )
+ *
+ * // preview.html contains the rendered email HTML
+ * ```
+ */
+declare function generateBroadcastPreviewHtml(content: SerializedEditorState | null | undefined, payload: Payload, config: NewsletterPluginConfig, options: PreviewOptions): Promise<PreviewResult>;
+
+/**
+ * Converts Lexical editor state to email-safe HTML
+ */
+declare function convertToEmailSafeHtml(editorState: SerializedEditorState | undefined | null, options?: {
+    wrapInTemplate?: boolean;
+    preheader?: string;
+    mediaUrl?: string;
+    customBlockConverter?: (node: any, mediaUrl?: string) => Promise<string>;
+    payload?: any;
+    populateFields?: string[] | ((blockType: string) => string[]);
+    customWrapper?: (content: string, options?: {
+        preheader?: string;
+        subject?: string;
+        documentData?: Record<string, any>;
+    }) => string | Promise<string>;
+    subject?: string;
+    documentData?: Record<string, any>;
+}): Promise<string>;
+
 declare module 'payload' {
     interface BasePayload {
         newsletterEmailService?: any;
@@ -710,4 +801,4 @@ declare class BroadcastProvider implements EmailProvider {
     removeContact(email: string): Promise<void>;
 }
 
-export { BroadcastProvider, type NewsletterPluginConfig, ResendProvider, type Subscriber, createBroadcastsCollection, createNewsletterSettingsGlobal, createPreferencesEndpoint, createSubscribeEndpoint, createSubscribersCollection, createUnsubscribeEndpoint, createVerifyMagicLinkEndpoint, newsletterPlugin };
+export { BroadcastProvider, type NewsletterPluginConfig, type PreviewOptions, type PreviewResult, ResendProvider, type Subscriber, convertToEmailSafeHtml, createBroadcastsCollection, createNewsletterSettingsGlobal, createPreferencesEndpoint, createSubscribeEndpoint, createSubscribersCollection, createUnsubscribeEndpoint, createVerifyMagicLinkEndpoint, generateBroadcastPreviewHtml, newsletterPlugin, populateMediaFields };

package/dist/server.js

@@ -2763,10 +2763,20 @@ async function updateBroadcastStatus(event, status, payload, broadcastsSlug) {
       return;
     }
     const broadcast = existing.docs[0];
+    const newWebhookEvent = {
+      eventType: event.type,
+      receivedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      eventPayload: event.data
+    };
+    const existingEvents = broadcast.webhookData?.webhookEvents || [];
+    const webhookEvents = [...existingEvents.slice(-9), newWebhookEvent];
     const updateData = {
-      status,
-      lastWebhookEvent: event.type,
-      lastWebhookEventAt: event.occurred_at
+      sendStatus: status,
+      // CRITICAL: Top-level field - 'sendStatus' not 'status'
+      "webhookData.lastWebhookEvent": event.type,
+      "webhookData.lastWebhookEventAt": event.occurred_at,
+      "webhookData.webhookEvents": webhookEvents
+      // Log event for debugging
     };
     switch (event.type) {
       case WEBHOOK_EVENT_TYPES.BROADCAST_SCHEDULED:
@@ -2774,42 +2784,42 @@ async function updateBroadcastStatus(event, status, payload, broadcastsSlug) {
         break;
       case WEBHOOK_EVENT_TYPES.BROADCAST_SENDING: {
         const sendingEvent = event;
-        updateData.sentCount = sendingEvent.data.sent_count;
-        updateData.totalCount = sendingEvent.data.total_count;
+        updateData["webhookData.sentCount"] = sendingEvent.data.sent_count;
+        updateData["webhookData.totalCount"] = sendingEvent.data.total_count;
         break;
       }
       case WEBHOOK_EVENT_TYPES.BROADCAST_SENT: {
         const sentEvent = event;
-        updateData.sentCount = sentEvent.data.sent_count;
+        updateData["webhookData.sentCount"] = sentEvent.data.sent_count;
         updateData.sentAt = sentEvent.data.completed_at;
-        updateData.sendingStartedAt = sentEvent.data.started_at;
+        updateData["webhookData.sendingStartedAt"] = sentEvent.data.started_at;
         break;
       }
       case WEBHOOK_EVENT_TYPES.BROADCAST_FAILED: {
         const failedEvent = event;
-        updateData.failureReason = failedEvent.data.error;
-        updateData.failedAt = failedEvent.data.failed_at;
+        updateData["webhookData.failureReason"] = failedEvent.data.error;
+        updateData["webhookData.failedAt"] = failedEvent.data.failed_at;
         break;
       }
       case WEBHOOK_EVENT_TYPES.BROADCAST_PARTIAL_FAILURE: {
         const partialFailureEvent = event;
-        updateData.sentCount = partialFailureEvent.data.sent_count;
-        updateData.failedCount = partialFailureEvent.data.failed_count;
-        updateData.totalCount = partialFailureEvent.data.total_count;
-        updateData.hasWarnings = true;
+        updateData["webhookData.sentCount"] = partialFailureEvent.data.sent_count;
+        updateData["webhookData.failedCount"] = partialFailureEvent.data.failed_count;
+        updateData["webhookData.totalCount"] = partialFailureEvent.data.total_count;
+        updateData["webhookData.hasWarnings"] = true;
         break;
       }
       case WEBHOOK_EVENT_TYPES.BROADCAST_ABORTED: {
         const abortedEvent = event;
-        updateData.abortedAt = abortedEvent.data.aborted_at;
-        updateData.abortReason = abortedEvent.data.reason;
+        updateData["webhookData.abortedAt"] = abortedEvent.data.aborted_at;
+        updateData["webhookData.abortReason"] = abortedEvent.data.reason;
         break;
       }
       case WEBHOOK_EVENT_TYPES.BROADCAST_PAUSED: {
         const pausedEvent = event;
-        updateData.pausedAt = pausedEvent.data.paused_at;
-        updateData.sentCount = pausedEvent.data.sent_count;
-        updateData.remainingCount = pausedEvent.data.remaining_count;
+        updateData["webhookData.pausedAt"] = pausedEvent.data.paused_at;
+        updateData["webhookData.sentCount"] = pausedEvent.data.sent_count;
+        updateData["webhookData.remainingCount"] = pausedEvent.data.remaining_count;
         break;
       }
     }
@@ -4821,6 +4831,33 @@ var createBroadcastsCollection = (pluginConfig) => {
           {
             name: "pausedAt",
             type: "date"
+          },
+          {
+            name: "webhookEvents",
+            type: "array",
+            label: "Webhook Event Log",
+            maxRows: 10,
+            admin: {
+              readOnly: true,
+              description: "Recent webhook events for debugging"
+            },
+            fields: [
+              {
+                name: "eventType",
+                type: "text",
+                admin: { readOnly: true }
+              },
+              {
+                name: "receivedAt",
+                type: "date",
+                admin: { readOnly: true }
+              },
+              {
+                name: "eventPayload",
+                type: "json",
+                admin: { readOnly: true }
+              }
+            ]
           }
         ]
       }
@@ -5289,6 +5326,28 @@ var setPluginConfig = (config) => {
 // src/utilities/session.ts
 import jwt2 from "jsonwebtoken";
 
+// src/utils/preview.ts
+async function generateBroadcastPreviewHtml(content, payload, config, options) {
+  const mediaUrl = options.mediaUrl ?? (payload.config.serverURL ? `${payload.config.serverURL}/api/media` : "/api/media");
+  const emailPreviewConfig = config.customizations?.broadcasts?.emailPreview;
+  payload.logger?.info("Populating media fields for preview generation...");
+  const populatedContent = await populateMediaFields(content, payload, config);
+  const html = await convertToEmailSafeHtml(populatedContent, {
+    wrapInTemplate: options.wrapInTemplate ?? emailPreviewConfig?.wrapInTemplate ?? true,
+    preheader: options.preheader,
+    subject: options.subject,
+    mediaUrl,
+    documentData: options.documentData,
+    customBlockConverter: config.customizations?.broadcasts?.customBlockConverter,
+    customWrapper: emailPreviewConfig?.customWrapper
+  });
+  return {
+    html,
+    subject: options.subject,
+    preheader: options.preheader ?? null
+  };
+}
+
 // src/index.ts
 var newsletterPlugin = (pluginConfig) => (incomingConfig) => {
   const config = {
@@ -5443,6 +5502,7 @@ var newsletterPlugin = (pluginConfig) => (incomingConfig) => {
 export {
   BroadcastProvider,
   ResendProvider,
+  convertToEmailSafeHtml,
   createBroadcastsCollection,
   createNewsletterSettingsGlobal,
   createPreferencesEndpoint,
@@ -5450,5 +5510,7 @@ export {
   createSubscribersCollection,
   createUnsubscribeEndpoint,
   createVerifyMagicLinkEndpoint,
-  newsletterPlugin
+  generateBroadcastPreviewHtml,
+  newsletterPlugin,
+  populateMediaFields
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "payload-plugin-newsletter",
-  "version": "0.25.12",
+  "version": "0.26.0",
   "description": "Complete newsletter management plugin for Payload CMS with subscriber management, magic link authentication, and email service integration",
   "type": "module",
   "main": "./dist/index.js",