payload-plugin-newsletter 0.16.5 → 0.16.7

package/CHANGELOG.md

@@ -1,3 +1,48 @@
+## [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
+- **Critical: Update Sync Now Works** - Fixed the afterChange hook that was blocking update operations
+  - Removed the `operation !== 'create'` check that prevented the afterChange hook from running on updates
+  - Moved update sync logic from beforeChange to afterChange for proper architectural pattern
+  - Updates are now synced AFTER they're saved to Payload, ensuring consistency
+  - Provider sync failures no longer block Payload updates
+
+### Improved
+- **Better Hook Architecture** - Sync operations now happen in the correct lifecycle stage
+  - beforeChange was architecturally wrong - if provider sync failed, data would be inconsistent
+  - afterChange ensures Payload data is saved first, then syncs to provider
+  - More resilient to network failures and API errors
+
+### Technical
+- Consolidated create and update logic in a single afterChange hook
+- Added comprehensive content change detection before syncing
+- Enhanced logging for update sync operations
+- Removed redundant beforeChange hook logic
+
 ## [0.16.5] - 2025-07-29
 
 ### Breaking Changes

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());
@@ -1435,58 +1452,162 @@ var createBroadcastsCollection = (pluginConfig) => {
       }
     ],
     hooks: {
-      // Sync with provider on create
+      // Sync with provider on create and update
       afterChange: [
-        async ({ doc, operation, req }) => {
-          if (!hasProviders || operation !== "create") return doc;
-          try {
-            const providerConfig = await getBroadcastConfig(req, pluginConfig);
-            if (!providerConfig || !providerConfig.token) {
-              req.payload.logger.error("Broadcast provider not configured in Newsletter Settings or environment variables");
-              return doc;
-            }
-            const { BroadcastApiProvider: BroadcastApiProvider2 } = await Promise.resolve().then(() => (init_broadcast2(), broadcast_exports));
-            const provider = new BroadcastApiProvider2(providerConfig);
-            const htmlContent = await convertToEmailSafeHtml(doc.contentSection?.content);
-            const providerBroadcast = await provider.create({
-              name: doc.subject,
-              // Use subject as name since we removed the name field
-              subject: doc.subject,
-              preheader: doc.contentSection?.preheader,
-              content: htmlContent,
-              trackOpens: doc.settings?.trackOpens,
-              trackClicks: doc.settings?.trackClicks,
-              replyTo: doc.settings?.replyTo || providerConfig.replyTo,
-              audienceIds: doc.audienceIds?.map((a) => a.audienceId)
-            });
-            await req.payload.update({
-              collection: "broadcasts",
-              id: doc.id,
-              data: {
+        async ({ doc, operation, req, previousDoc }) => {
+          if (!hasProviders) return doc;
+          if (operation === "create") {
+            try {
+              const providerConfig = await getBroadcastConfig(req, pluginConfig);
+              if (!providerConfig || !providerConfig.token) {
+                req.payload.logger.error("Broadcast provider not configured in Newsletter Settings or environment variables");
+                return doc;
+              }
+              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 createData = {
+                name: doc.subject,
+                // Use subject as name since we removed the name field
+                subject: doc.subject,
+                preheader: doc.contentSection?.preheader,
+                content: htmlContent,
+                trackOpens: doc.settings?.trackOpens,
+                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,
+                data: {
+                  providerId: providerBroadcast.id,
+                  providerData: providerBroadcast.providerData
+                },
+                req
+              });
+              return {
+                ...doc,
                 providerId: providerBroadcast.id,
                 providerData: providerBroadcast.providerData
-              },
-              req
-            });
-            return {
-              ...doc,
-              providerId: providerBroadcast.id,
-              providerData: providerBroadcast.providerData
-            };
-          } catch (error) {
-            if (error instanceof Error) {
-              req.payload.logger.error("Failed to create broadcast in provider:", {
-                message: error.message,
-                stack: error.stack,
-                name: error.name,
-                // If it's a BroadcastProviderError, it might have additional details
-                ...error.details
+              };
+            } catch (error) {
+              req.payload.logger.error("Raw error from broadcast provider:");
+              req.payload.logger.error(error);
+              if (error instanceof Error) {
+                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,
+                  // 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("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"
               });
-            } else {
-              req.payload.logger.error("Failed to create broadcast in provider:", error);
+              return doc;
             }
-            return doc;
           }
+          if (operation === "update" && doc.providerId) {
+            req.payload.logger.info("Broadcast afterChange update hook triggered", {
+              operation,
+              hasProviderId: !!doc.providerId,
+              sendStatus: doc.sendStatus,
+              publishStatus: doc._status
+            });
+            try {
+              const providerConfig = await getBroadcastConfig(req, pluginConfig);
+              if (!providerConfig || !providerConfig.token) {
+                req.payload.logger.error("Broadcast provider not configured in Newsletter Settings or environment variables");
+                return doc;
+              }
+              const { BroadcastApiProvider: BroadcastApiProvider2 } = await Promise.resolve().then(() => (init_broadcast2(), broadcast_exports));
+              const provider = new BroadcastApiProvider2(providerConfig);
+              const capabilities = provider.getCapabilities();
+              const sendStatus = doc.sendStatus || "draft" /* DRAFT */;
+              if (!capabilities.editableStatuses.includes(sendStatus)) {
+                req.payload.logger.info(`Skipping sync for broadcast in status: ${sendStatus}`);
+                return doc;
+              }
+              const contentChanged = doc.subject !== previousDoc?.subject || doc.contentSection?.preheader !== previousDoc?.contentSection?.preheader || JSON.stringify(doc.contentSection?.content) !== JSON.stringify(previousDoc?.contentSection?.content) || doc.settings?.trackOpens !== previousDoc?.settings?.trackOpens || doc.settings?.trackClicks !== previousDoc?.settings?.trackClicks || doc.settings?.replyTo !== previousDoc?.settings?.replyTo || JSON.stringify(doc.audienceIds) !== JSON.stringify(previousDoc?.audienceIds);
+              if (contentChanged) {
+                const updates = {};
+                if (doc.subject !== previousDoc?.subject) {
+                  updates.name = doc.subject;
+                  updates.subject = doc.subject;
+                }
+                if (doc.contentSection?.preheader !== previousDoc?.contentSection?.preheader) {
+                  updates.preheader = doc.contentSection?.preheader;
+                }
+                if (JSON.stringify(doc.contentSection?.content) !== JSON.stringify(previousDoc?.contentSection?.content)) {
+                  updates.content = await convertToEmailSafeHtml(doc.contentSection?.content);
+                }
+                if (doc.settings?.trackOpens !== previousDoc?.settings?.trackOpens) {
+                  updates.trackOpens = doc.settings.trackOpens;
+                }
+                if (doc.settings?.trackClicks !== previousDoc?.settings?.trackClicks) {
+                  updates.trackClicks = doc.settings.trackClicks;
+                }
+                if (doc.settings?.replyTo !== previousDoc?.settings?.replyTo) {
+                  updates.replyTo = doc.settings.replyTo || providerConfig.replyTo;
+                }
+                if (JSON.stringify(doc.audienceIds) !== JSON.stringify(previousDoc?.audienceIds)) {
+                  updates.audienceIds = doc.audienceIds?.map((a) => a.audienceId);
+                }
+                req.payload.logger.info("Syncing broadcast updates to provider", {
+                  providerId: doc.providerId,
+                  updates
+                });
+                await provider.update(doc.providerId, updates);
+                req.payload.logger.info(`Broadcast ${doc.id} synced to provider successfully`);
+              } else {
+                req.payload.logger.info("No content changes to sync to provider");
+              }
+            } catch (error) {
+              if (error instanceof Error) {
+                req.payload.logger.error("Failed to sync broadcast update to provider:", {
+                  message: error.message,
+                  stack: error.stack,
+                  name: error.name,
+                  // If it's a BroadcastProviderError, it might have additional details
+                  ...error.details
+                });
+              } else {
+                req.payload.logger.error("Failed to sync broadcast update to provider:", error);
+              }
+            }
+          }
+          return doc;
         },
         // Hook to send when published
         async ({ doc, operation, previousDoc, req }) => {
@@ -1544,79 +1665,8 @@ var createBroadcastsCollection = (pluginConfig) => {
           return doc;
         }
       ],
-      // Sync updates with provider
-      beforeChange: [
-        async ({ data, originalDoc, operation, req }) => {
-          if (!hasProviders || !originalDoc?.providerId || operation !== "update") return data;
-          req.payload.logger.info("Broadcast beforeChange update hook triggered", {
-            operation,
-            hasProviderId: !!originalDoc?.providerId,
-            originalSendStatus: originalDoc?.sendStatus,
-            originalPublishStatus: originalDoc?._status,
-            newSendStatus: data?.sendStatus,
-            newPublishStatus: data?._status
-          });
-          try {
-            const providerConfig = await getBroadcastConfig(req, pluginConfig);
-            if (!providerConfig || !providerConfig.token) {
-              req.payload.logger.error("Broadcast provider not configured in Newsletter Settings or environment variables");
-              return data;
-            }
-            const { BroadcastApiProvider: BroadcastApiProvider2 } = await Promise.resolve().then(() => (init_broadcast2(), broadcast_exports));
-            const provider = new BroadcastApiProvider2(providerConfig);
-            const capabilities = provider.getCapabilities();
-            const sendStatus = originalDoc.sendStatus || "draft" /* DRAFT */;
-            if (!capabilities.editableStatuses.includes(sendStatus)) {
-              req.payload.logger.info(`Skipping sync for broadcast in status: ${sendStatus}`);
-              return data;
-            }
-            const updates = {};
-            if (data.subject !== originalDoc.subject) {
-              updates.name = data.subject;
-              updates.subject = data.subject;
-            }
-            if (data.contentSection?.preheader !== originalDoc.contentSection?.preheader) updates.preheader = data.contentSection?.preheader;
-            if (data.contentSection?.content !== originalDoc.contentSection?.content) {
-              updates.content = await convertToEmailSafeHtml(data.contentSection?.content);
-            }
-            if (data.settings?.trackOpens !== originalDoc.settings?.trackOpens) {
-              updates.trackOpens = data.settings.trackOpens;
-            }
-            if (data.settings?.trackClicks !== originalDoc.settings?.trackClicks) {
-              updates.trackClicks = data.settings.trackClicks;
-            }
-            if (data.settings?.replyTo !== originalDoc.settings?.replyTo) {
-              updates.replyTo = data.settings.replyTo || providerConfig.replyTo;
-            }
-            if (JSON.stringify(data.audienceIds) !== JSON.stringify(originalDoc.audienceIds)) {
-              updates.audienceIds = data.audienceIds?.map((a) => a.audienceId);
-            }
-            if (Object.keys(updates).length > 0) {
-              req.payload.logger.info("Syncing broadcast updates to provider", {
-                providerId: originalDoc.providerId,
-                updates
-              });
-              await provider.update(originalDoc.providerId, updates);
-              req.payload.logger.info("Successfully synced broadcast updates to provider");
-            } else {
-              req.payload.logger.info("No broadcast updates to sync to provider");
-            }
-          } catch (error) {
-            if (error instanceof Error) {
-              req.payload.logger.error("Failed to update broadcast in provider:", {
-                message: error.message,
-                stack: error.stack,
-                name: error.name,
-                // If it's a BroadcastProviderError, it might have additional details
-                ...error.details
-              });
-            } else {
-              req.payload.logger.error("Failed to update broadcast in provider:", error);
-            }
-          }
-          return data;
-        }
-      ],
+      // beforeChange hooks can be added here if needed
+      beforeChange: [],
       // Handle deletion
       afterDelete: [
         async ({ doc, req }) => {