payload-plugin-newsletter 0.16.6 → 0.16.8

package/CHANGELOG.md

@@ -1,3 +1,42 @@
+## [0.16.8] - 2025-01-29
+
+### Fixed
+- **Handle Empty Content When Creating Broadcasts** - Fixed error when creating broadcasts without content
+  - Added null/undefined check in convertToEmailSafeHtml function
+  - Skip provider sync when subject or content is missing on create
+  - Skip provider sync when content is empty after conversion
+  - Prevents "Cannot destructure property 'root' of 'editorState'" error
+  - Broadcasts can now be created empty and synced later when content is added
+
+### Technical
+- Updated convertToEmailSafeHtml to accept undefined/null editorState
+- Added pre-sync validation in afterChange hook for create operations
+- Empty broadcasts are saved in Payload but not synced to provider until content is added
+
+## [0.16.7] - 2025-07-29
+
+### Added
+- **Comprehensive Diagnostic Logging** - Added extensive logging to diagnose broadcast sync issues
+  - Logs the HTML content conversion process
+  - Shows exactly what data is being sent to the Broadcast API (with preview)
+  - Displays request URL, method, and body structure
+  - Shows API response status and headers
+  - Captures and logs all error types (Error objects, strings, JSON responses)
+  - Logs raw errors to identify unexpected error formats
+
+### Improved
+- **Better Error Visibility** - Enhanced error handling to capture more details
+  - Raw error logging to see the actual error structure
+  - Multiple error format handlers (Error, string, object, unknown)
+  - Response body parsing for API errors
+  - Document context logging when errors occur
+  - API request/response details in provider logs
+
+### Technical
+- Added pre-API call logging in afterChange hook
+- Added comprehensive error logging in BroadcastApiProvider
+- Logs help identify if issues are with content, API format, or authentication
+
 ## [0.16.6] - 2025-07-29
 
 ### Fixed

package/dist/collections.cjs

@@ -252,29 +252,46 @@ var init_broadcast2 = __esm({
       async create(data) {
         try {
           this.validateRequiredFields(data, ["name", "subject", "content"]);
+          const requestBody = {
+            broadcast: {
+              name: data.name,
+              subject: data.subject,
+              preheader: data.preheader,
+              body: data.content,
+              html_body: true,
+              track_opens: data.trackOpens ?? true,
+              track_clicks: data.trackClicks ?? true,
+              reply_to: data.replyTo,
+              segment_ids: data.audienceIds
+            }
+          };
+          console.log("[BroadcastApiProvider] Creating broadcast:", {
+            url: `${this.apiUrl}/api/v1/broadcasts`,
+            method: "POST",
+            hasToken: !!this.token,
+            tokenLength: this.token?.length,
+            body: JSON.stringify(requestBody, null, 2)
+          });
           const response = await fetch(`${this.apiUrl}/api/v1/broadcasts`, {
             method: "POST",
             headers: {
               "Authorization": `Bearer ${this.token}`,
               "Content-Type": "application/json"
             },
-            body: JSON.stringify({
-              broadcast: {
-                name: data.name,
-                subject: data.subject,
-                preheader: data.preheader,
-                body: data.content,
-                html_body: true,
-                track_opens: data.trackOpens ?? true,
-                track_clicks: data.trackClicks ?? true,
-                reply_to: data.replyTo,
-                segment_ids: data.audienceIds
-              }
-            })
+            body: JSON.stringify(requestBody)
           });
+          console.log("[BroadcastApiProvider] Response status:", response.status);
+          console.log("[BroadcastApiProvider] Response headers:", Object.fromEntries(response.headers.entries()));
           if (!response.ok) {
-            const error = await response.text();
-            throw new Error(`Broadcast API error: ${response.status} - ${error}`);
+            const errorText = await response.text();
+            console.error("[BroadcastApiProvider] Error response body:", errorText);
+            let errorDetails;
+            try {
+              errorDetails = JSON.parse(errorText);
+              console.error("[BroadcastApiProvider] Parsed error:", errorDetails);
+            } catch {
+            }
+            throw new Error(`Broadcast API error: ${response.status} - ${errorText}`);
           }
           const result = await response.json();
           return this.get(result.id.toString());
@@ -943,6 +960,9 @@ var EMAIL_SAFE_CONFIG = {
   FORBID_ATTR: ["class", "id", "onclick", "onload", "onerror"]
 };
 async function convertToEmailSafeHtml(editorState, options) {
+  if (!editorState) {
+    return "";
+  }
   const rawHtml = await lexicalToEmailHtml(editorState, options?.mediaUrl);
   const sanitizedHtml = import_isomorphic_dompurify.default.sanitize(rawHtml, EMAIL_SAFE_CONFIG);
   if (options?.wrapInTemplate) {
@@ -1440,6 +1460,10 @@ var createBroadcastsCollection = (pluginConfig) => {
         async ({ doc, operation, req, previousDoc }) => {
           if (!hasProviders) return doc;
           if (operation === "create") {
+            if (!doc.subject || !doc.contentSection?.content) {
+              req.payload.logger.info("Skipping provider sync - broadcast has no subject or content yet");
+              return doc;
+            }
             try {
               const providerConfig = await getBroadcastConfig(req, pluginConfig);
               if (!providerConfig || !providerConfig.token) {
@@ -1448,8 +1472,13 @@ var createBroadcastsCollection = (pluginConfig) => {
               }
               const { BroadcastApiProvider: BroadcastApiProvider2 } = await Promise.resolve().then(() => (init_broadcast2(), broadcast_exports));
               const provider = new BroadcastApiProvider2(providerConfig);
+              req.payload.logger.info("Converting content to HTML...");
               const htmlContent = await convertToEmailSafeHtml(doc.contentSection?.content);
-              const providerBroadcast = await provider.create({
+              if (!htmlContent || htmlContent.trim() === "") {
+                req.payload.logger.info("Skipping provider sync - content is empty after conversion");
+                return doc;
+              }
+              const createData = {
                 name: doc.subject,
                 // Use subject as name since we removed the name field
                 subject: doc.subject,
@@ -1459,7 +1488,21 @@ var createBroadcastsCollection = (pluginConfig) => {
                 trackClicks: doc.settings?.trackClicks,
                 replyTo: doc.settings?.replyTo || providerConfig.replyTo,
                 audienceIds: doc.audienceIds?.map((a) => a.audienceId)
+              };
+              req.payload.logger.info("Creating broadcast with data:", {
+                name: createData.name,
+                subject: createData.subject,
+                preheader: createData.preheader || "NONE",
+                contentLength: htmlContent ? htmlContent.length : 0,
+                contentPreview: htmlContent ? htmlContent.substring(0, 100) + "..." : "EMPTY",
+                trackOpens: createData.trackOpens,
+                trackClicks: createData.trackClicks,
+                replyTo: createData.replyTo,
+                audienceIds: createData.audienceIds || [],
+                apiUrl: providerConfig.apiUrl,
+                hasToken: !!providerConfig.token
               });
+              const providerBroadcast = await provider.create(createData);
               await req.payload.update({
                 collection: "broadcasts",
                 id: doc.id,
@@ -1475,17 +1518,34 @@ var createBroadcastsCollection = (pluginConfig) => {
                 providerData: providerBroadcast.providerData
               };
             } catch (error) {
+              req.payload.logger.error("Raw error from broadcast provider:");
+              req.payload.logger.error(error);
               if (error instanceof Error) {
-                req.payload.logger.error("Failed to create broadcast in provider:", {
+                req.payload.logger.error("Error is instance of Error:", {
                   message: error.message,
                   stack: error.stack,
                   name: error.name,
                   // If it's a BroadcastProviderError, it might have additional details
-                  ...error.details
+                  ...error.details,
+                  // Check if it's a fetch response error
+                  ...error.response,
+                  ...error.data,
+                  ...error.status,
+                  ...error.statusText
                 });
+              } else if (typeof error === "string") {
+                req.payload.logger.error("Error is a string:", error);
+              } else if (error && typeof error === "object") {
+                req.payload.logger.error("Error is an object:", JSON.stringify(error, null, 2));
               } else {
-                req.payload.logger.error("Failed to create broadcast in provider:", error);
+                req.payload.logger.error("Unknown error type:", typeof error);
               }
+              req.payload.logger.error("Failed broadcast document:", {
+                id: doc.id,
+                subject: doc.subject,
+                hasContent: !!doc.contentSection?.content,
+                contentType: doc.contentSection?.content ? typeof doc.contentSection.content : "none"
+              });
               return doc;
             }
           }