payload-plugin-newsletter 0.16.8 → 0.16.9

package/CHANGELOG.md

@@ -1,3 +1,18 @@
+## [0.16.9] - 2025-01-29
+
+### Fixed
+- **Deferred Provider Sync for Empty Broadcasts** - Fixed issue where broadcasts created empty were never synced to provider
+  - Update operation now handles "deferred create" scenario when providerId is missing
+  - When a broadcast has subject and content but no providerId, it creates the broadcast in the provider
+  - Normal update sync works for broadcasts that already exist in the provider
+  - Resolves workflow: create empty → add content → save → now syncs to provider
+
+### Technical
+- Modified update operation handler to check for missing providerId
+- Added deferred create logic in update afterChange hook
+- Separated normal update logic to only run when providerId exists
+- Added comprehensive error handling for both deferred create and normal update scenarios
+
 ## [0.16.8] - 2025-01-29
 
 ### Fixed

package/dist/collections.cjs

@@ -1549,7 +1549,7 @@ var createBroadcastsCollection = (pluginConfig) => {
               return doc;
             }
           }
-          if (operation === "update" && doc.providerId) {
+          if (operation === "update") {
             req.payload.logger.info("Broadcast afterChange update hook triggered", {
               operation,
               hasProviderId: !!doc.providerId,
@@ -1564,57 +1564,135 @@ var createBroadcastsCollection = (pluginConfig) => {
               }
               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 (!doc.providerId) {
+                if (!doc.subject || !doc.contentSection?.content) {
+                  req.payload.logger.info("Still missing required fields for provider sync");
+                  return doc;
                 }
-                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;
+                try {
+                  req.payload.logger.info("Creating broadcast in provider (deferred from initial create)...");
+                  const htmlContent = await convertToEmailSafeHtml(doc.contentSection?.content);
+                  if (!htmlContent || htmlContent.trim() === "") {
+                    req.payload.logger.info("Skipping provider sync - content is empty after conversion");
+                    return doc;
+                  }
+                  const createData = {
+                    name: doc.subject,
+                    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",
+                    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
+                  });
+                  req.payload.logger.info(`Broadcast ${doc.id} created in provider successfully (deferred)`);
+                  return {
+                    ...doc,
+                    providerId: providerBroadcast.id,
+                    providerData: providerBroadcast.providerData
+                  };
+                } catch (error) {
+                  req.payload.logger.error("Raw error from broadcast provider (deferred create):");
+                  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,
+                      ...error.details,
+                      ...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 (deferred create):", {
+                    id: doc.id,
+                    subject: doc.subject,
+                    hasContent: !!doc.contentSection?.content,
+                    contentType: doc.contentSection?.content ? typeof doc.contentSection.content : "none"
+                  });
+                  return doc;
                 }
-                if (doc.settings?.replyTo !== previousDoc?.settings?.replyTo) {
-                  updates.replyTo = doc.settings.replyTo || providerConfig.replyTo;
+              }
+              if (doc.providerId) {
+                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;
                 }
-                if (JSON.stringify(doc.audienceIds) !== JSON.stringify(previousDoc?.audienceIds)) {
-                  updates.audienceIds = doc.audienceIds?.map((a) => a.audienceId);
+                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");
                 }
-                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:", {
+                req.payload.logger.error("Failed to handle broadcast update operation:", {
                   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);
+                req.payload.logger.error("Failed to handle broadcast update operation:", error);
               }
             }
           }