payload-plugin-newsletter 0.25.9 → 0.25.12

package/CHANGELOG.md

@@ -1,3 +1,27 @@
+## [0.25.12] - 2026-01-02
+
+### Added
+- New exported utilities for external preview generation:
+  - `generateBroadcastPreviewHtml()` - Generate preview HTML from broadcast content
+  - `populateMediaFields()` - Resolve Media IDs to full media objects with URLs
+  - `convertToEmailSafeHtml()` - Convert Lexical content to email-safe HTML
+  - `PreviewOptions` and `PreviewResult` types for TypeScript support
+- Extracted media population logic to `src/utils/mediaPopulation.ts` for cleaner code organization
+- Created `src/utils/preview.ts` with high-level preview generation utility
+
+### Changed
+- Refactored `src/endpoints/broadcasts/preview.ts` to use new utility files
+- Improved TypeScript types for media population functions
+
+## [0.25.11] - 2025-12-11
+
+### Fixed
+- Fixed LinkFeature configuration causing URLs to disappear in the Lexical editor link drawer
+  - The custom `fields` array was replacing Payload's default fields, removing the crucial `linkType` field
+  - Now uses default LinkFeature fields which include all required fields for the drawer UI to work correctly
+- Fixed TypeScript errors with Payload logger API (pino signature requires object first, then message)
+- Fixed `relationTo` type errors where `string | string[]` was passed to `findByID`
+
 ## [0.25.9] - 2025-08-19
 
 ### Fixed

package/dist/collections.cjs

@@ -754,25 +754,8 @@ var createEmailSafeFeatures = (additionalBlocks) => {
     (0, import_richtext_lexical.ItalicFeature)(),
     (0, import_richtext_lexical.UnderlineFeature)(),
     (0, import_richtext_lexical.StrikethroughFeature)(),
-    // Links with enhanced configuration
-    (0, import_richtext_lexical.LinkFeature)({
-      fields: [
-        {
-          name: "url",
-          type: "text",
-          required: true,
-          admin: {
-            description: "Enter the full URL (including https://)"
-          }
-        },
-        {
-          name: "newTab",
-          type: "checkbox",
-          label: "Open in new tab",
-          defaultValue: false
-        }
-      ]
-    }),
+    // Links - use default fields to ensure drawer UI works correctly
+    (0, import_richtext_lexical.LinkFeature)(),
     // Lists
     (0, import_richtext_lexical.OrderedListFeature)(),
     (0, import_richtext_lexical.UnorderedListFeature)(),
@@ -828,25 +811,8 @@ var createEmailLexicalEditor = (customBlocks = []) => {
       (0, import_richtext_lexical.ItalicFeature)(),
       (0, import_richtext_lexical.UnderlineFeature)(),
       (0, import_richtext_lexical.StrikethroughFeature)(),
-      // Links with enhanced configuration
-      (0, import_richtext_lexical.LinkFeature)({
-        fields: [
-          {
-            name: "url",
-            type: "text",
-            required: true,
-            admin: {
-              description: "Enter the full URL (including https://)"
-            }
-          },
-          {
-            name: "newTab",
-            type: "checkbox",
-            label: "Open in new tab",
-            defaultValue: false
-          }
-        ]
-      }),
+      // Links - use default fields to ensure drawer UI works correctly
+      (0, import_richtext_lexical.LinkFeature)(),
       // Lists
       (0, import_richtext_lexical.OrderedListFeature)(),
       (0, import_richtext_lexical.UnorderedListFeature)(),
@@ -1414,7 +1380,7 @@ async function getBroadcastConfig(req, pluginConfig) {
     }
     return pluginConfig.providers?.broadcast || null;
   } catch (error) {
-    req.payload.logger.error("Failed to get broadcast config from settings:", error);
+    req.payload.logger.error({ error: String(error) }, "Failed to get broadcast config from settings");
     return pluginConfig.providers?.broadcast || null;
   }
 }
@@ -1792,70 +1758,88 @@ var createTestBroadcastEndpoint = (config, collectionSlug) => {
   };
 };
 
-// src/endpoints/broadcasts/preview.ts
+// src/utils/mediaPopulation.ts
 async function populateMediaFields(content, payload, config) {
   if (!content || typeof content !== "object") return content;
-  if (content.root?.children) {
-    for (const child of content.root.children) {
+  const typedContent = content;
+  if (typedContent.root?.children) {
+    for (const child of typedContent.root.children) {
       await populateBlockMediaFields(child, payload, config);
     }
   }
   return content;
 }
 async function populateBlockMediaFields(node, payload, config) {
-  if (node.type === "block" && node.fields) {
-    const blockType = node.fields.blockType || node.fields.blockName;
+  if (!node || typeof node !== "object") return;
+  const typedNode = node;
+  if (typedNode.type === "block" && typedNode.fields) {
+    const blockType = typedNode.fields.blockType || typedNode.fields.blockName;
     const customBlocks = config.customizations?.broadcasts?.customBlocks || [];
     const blockConfig = customBlocks.find((b) => b.slug === blockType);
     if (blockConfig && blockConfig.fields) {
       for (const field of blockConfig.fields) {
-        if (field.type === "upload" && field.relationTo && node.fields[field.name]) {
-          const fieldValue = node.fields[field.name];
+        if (field.type === "upload" && field.relationTo && typedNode.fields[field.name]) {
+          const fieldValue = typedNode.fields[field.name];
+          const collectionName = Array.isArray(field.relationTo) ? field.relationTo[0] : field.relationTo;
           if (typeof fieldValue === "string" && fieldValue.match(/^[a-f0-9]{24}$/i)) {
             try {
               const media = await payload.findByID({
-                collection: field.relationTo,
+                collection: collectionName,
                 id: fieldValue,
                 depth: 0
               });
               if (media) {
-                node.fields[field.name] = media;
-                payload.logger?.info(`Populated ${field.name} for block ${blockType}:`, {
-                  mediaId: fieldValue,
-                  mediaUrl: media.url,
-                  filename: media.filename
-                });
+                typedNode.fields[field.name] = media;
+                payload.logger?.info(
+                  {
+                    mediaId: fieldValue,
+                    mediaUrl: media.url,
+                    filename: media.filename
+                  },
+                  `Populated ${field.name} for block ${blockType}`
+                );
               }
             } catch (error) {
-              payload.logger?.error(`Failed to populate ${field.name} for block ${blockType}:`, error);
+              payload.logger?.error(
+                { error: String(error) },
+                `Failed to populate ${field.name} for block ${blockType}`
+              );
             }
           }
         }
         if (field.type === "array" && field.fields) {
-          const arrayValue = node.fields[field.name];
+          const arrayValue = typedNode.fields[field.name];
           if (Array.isArray(arrayValue)) {
             for (const arrayItem of arrayValue) {
               if (arrayItem && typeof arrayItem === "object") {
+                const typedArrayItem = arrayItem;
                 for (const arrayField of field.fields) {
-                  if (arrayField.type === "upload" && arrayField.relationTo && arrayItem[arrayField.name]) {
-                    const arrayFieldValue = arrayItem[arrayField.name];
+                  if (arrayField.type === "upload" && arrayField.relationTo && typedArrayItem[arrayField.name]) {
+                    const arrayFieldValue = typedArrayItem[arrayField.name];
+                    const arrayCollectionName = Array.isArray(arrayField.relationTo) ? arrayField.relationTo[0] : arrayField.relationTo;
                     if (typeof arrayFieldValue === "string" && arrayFieldValue.match(/^[a-f0-9]{24}$/i)) {
                       try {
                         const media = await payload.findByID({
-                          collection: arrayField.relationTo,
+                          collection: arrayCollectionName,
                           id: arrayFieldValue,
                           depth: 0
                         });
                         if (media) {
-                          arrayItem[arrayField.name] = media;
-                          payload.logger?.info(`Populated array ${arrayField.name} for block ${blockType}:`, {
-                            mediaId: arrayFieldValue,
-                            mediaUrl: media.url,
-                            filename: media.filename
-                          });
+                          typedArrayItem[arrayField.name] = media;
+                          payload.logger?.info(
+                            {
+                              mediaId: arrayFieldValue,
+                              mediaUrl: media.url,
+                              filename: media.filename
+                            },
+                            `Populated array ${arrayField.name} for block ${blockType}`
+                          );
                         }
                       } catch (error) {
-                        payload.logger?.error(`Failed to populate array ${arrayField.name} for block ${blockType}:`, error);
+                        payload.logger?.error(
+                          { error: String(error) },
+                          `Failed to populate array ${arrayField.name} for block ${blockType}`
+                        );
                       }
                     }
                   }
@@ -1864,23 +1848,24 @@ async function populateBlockMediaFields(node, payload, config) {
             }
           }
         }
-        if (field.type === "richText" && node.fields[field.name]) {
-          await populateRichTextUploads(node.fields[field.name], payload);
+        if (field.type === "richText" && typedNode.fields[field.name]) {
+          await populateRichTextUploads(typedNode.fields[field.name], payload);
           payload.logger?.info(`Processed rich text field ${field.name} for upload nodes`);
         }
       }
     }
   }
-  if (node.children) {
-    for (const child of node.children) {
+  if (typedNode.children) {
+    for (const child of typedNode.children) {
       await populateBlockMediaFields(child, payload, config);
     }
   }
 }
 async function populateRichTextUploads(content, payload) {
   if (!content || typeof content !== "object") return;
-  if (content.root?.children) {
-    await processNodeArray(content.root.children);
+  const typedContent = content;
+  if (typedContent.root?.children) {
+    await processNodeArray(typedContent.root.children);
   }
   if (Array.isArray(content)) {
     await processNodeArray(content);
@@ -1890,33 +1875,42 @@ async function populateRichTextUploads(content, payload) {
   }
   async function processNode(node) {
     if (!node || typeof node !== "object") return;
-    if (node.type === "upload" && node.relationTo === "media" && typeof node.value === "string" && node.value.match(/^[a-f0-9]{24}$/i)) {
+    const typedNode = node;
+    if (typedNode.type === "upload" && typedNode.relationTo === "media" && typeof typedNode.value === "string" && typedNode.value.match(/^[a-f0-9]{24}$/i)) {
       try {
         const media = await payload.findByID({
           collection: "media",
-          id: node.value,
+          id: typedNode.value,
           depth: 0
         });
         if (media) {
-          node.value = media;
-          payload.logger?.info(`Populated rich text upload node:`, {
-            mediaId: node.value,
-            mediaUrl: media.url,
-            filename: media.filename
-          });
+          typedNode.value = media;
+          payload.logger?.info(
+            {
+              mediaId: typedNode.value,
+              mediaUrl: media.url,
+              filename: media.filename
+            },
+            "Populated rich text upload node"
+          );
         }
       } catch (error) {
-        payload.logger?.error(`Failed to populate rich text upload ${node.value}:`, error);
+        payload.logger?.error(
+          { error: String(error) },
+          `Failed to populate rich text upload ${typedNode.value}`
+        );
       }
     }
-    if (node.children && Array.isArray(node.children)) {
-      await processNodeArray(node.children);
+    if (typedNode.children && Array.isArray(typedNode.children)) {
+      await processNodeArray(typedNode.children);
     }
-    if (node.root?.children && Array.isArray(node.root.children)) {
-      await processNodeArray(node.root.children);
+    if (typedNode.root?.children && Array.isArray(typedNode.root.children)) {
+      await processNodeArray(typedNode.root.children);
     }
   }
 }
+
+// src/endpoints/broadcasts/preview.ts
 var createBroadcastPreviewEndpoint = (config, _collectionSlug) => {
   return {
     path: "/preview",
@@ -2310,7 +2304,7 @@ var createBroadcastsCollection = (pluginConfig) => {
             return doc;
           }
           if (operation === "update") {
-            req.payload.logger.info("Broadcast afterChange update hook triggered", {
+            req.payload.logger.info({
               operation,
               hasProviderId: !!doc.providerId,
               hasExternalId: !!doc.externalId,
@@ -2318,7 +2312,7 @@ var createBroadcastsCollection = (pluginConfig) => {
               publishStatus: doc._status,
               hasSubject: !!doc.subject,
               hasContent: !!doc.contentSection?.content
-            });
+            }, "Broadcast afterChange update hook triggered");
             try {
               const providerConfig = await getBroadcastConfig(req, pluginConfig);
               if (!providerConfig || !providerConfig.token) {
@@ -2405,10 +2399,10 @@ var createBroadcastsCollection = (pluginConfig) => {
                   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", {
+                  req.payload.logger.info({
                     providerId: doc.providerId,
                     updates
-                  });
+                  }, "Syncing broadcast updates to provider");
                   await provider.update(doc.providerId, updates);
                   req.payload.logger.info(`Broadcast ${doc.id} synced to provider successfully`);
                 } else {
@@ -2430,18 +2424,18 @@ var createBroadcastsCollection = (pluginConfig) => {
                   ...error.statusText
                 });
               } else if (typeof error === "string") {
-                req.payload.logger.error("Error is a string:", error);
+                req.payload.logger.error({ errorValue: error }, "Error is a string");
               } else if (error && typeof error === "object") {
-                req.payload.logger.error("Error is an object:", JSON.stringify(error, null, 2));
+                req.payload.logger.error({ errorValue: JSON.stringify(error, null, 2) }, "Error is an object");
               } else {
-                req.payload.logger.error("Unknown error type:", typeof error);
+                req.payload.logger.error({ errorType: typeof error }, "Unknown error type");
               }
-              req.payload.logger.error("Failed broadcast document (update operation):", {
+              req.payload.logger.error({
                 id: doc.id,
                 subject: doc.subject,
                 hasContent: !!doc.contentSection?.content,
                 contentType: doc.contentSection?.content ? typeof doc.contentSection.content : "none"
-              });
+              }, "Failed broadcast document (update operation)");
             }
           }
           return doc;
@@ -2487,7 +2481,7 @@ var createBroadcastsCollection = (pluginConfig) => {
                   ...error.details
                 });
               } else {
-                req.payload.logger.error(`Failed to send broadcast ${doc.id}:`, error);
+                req.payload.logger.error({ error: String(error) }, `Failed to send broadcast ${doc.id}`);
               }
               await req.payload.update({
                 collection: "broadcasts",
@@ -2530,7 +2524,7 @@ var createBroadcastsCollection = (pluginConfig) => {
                 ...error.details
               });
             } else {
-              req.payload.logger.error("Failed to delete broadcast from provider:", error);
+              req.payload.logger.error({ error: String(error) }, "Failed to delete broadcast from provider");
             }
           }
           return doc;