payload-plugin-newsletter 0.17.1 → 0.17.3

package/CHANGELOG.md

@@ -1,3 +1,28 @@
+## [0.17.3] - 2025-07-30
+
+### Fixed
+- **Duplicate Collection Slug in Endpoint Paths** - Fixed broadcast endpoints having duplicate collection slugs
+  - Removed collection slug from endpoint paths as Payload automatically prepends it
+  - Changed `/${collectionSlug}/preview` to `/preview`
+  - Changed `/${collectionSlug}/:id/send` to `/:id/send`
+  - Changed `/${collectionSlug}/:id/schedule` to `/:id/schedule`
+  - Changed `/${collectionSlug}/:id/test` to `/:id/test`
+  - Fixes 404 errors when accessing endpoints from `/api/broadcasts/preview` instead of `/api/broadcasts/broadcasts/preview`
+  - Client code can now properly access endpoints at their expected paths
+
+## [0.17.2] - 2025-07-29
+
+### Fixed
+- **Broadcast Endpoints Registration** - Fixed endpoints not being accessible in Payload v3
+  - Moved broadcast endpoints from global endpoints to collection endpoints
+  - Endpoints are now properly registered on the broadcasts collection
+  - Fixes 404 errors for all broadcast endpoints (/preview, /test, /send, /schedule)
+  - Aligns with Payload v3 architecture where collection endpoints should be defined on the collection
+
+### Changed
+- `createBroadcastManagementEndpoints` now returns empty array (kept for backward compatibility)
+- Broadcast endpoints are defined directly in the broadcasts collection configuration
+
 ## [0.17.1] - 2025-07-29
 
 ### Fixed

package/dist/collections.cjs

@@ -31,9 +31,19 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/types/newsletter.ts
+var NewsletterProviderError;
 var init_newsletter = __esm({
   "src/types/newsletter.ts"() {
     "use strict";
+    NewsletterProviderError = class extends Error {
+      constructor(message, code, provider, details) {
+        super(message);
+        this.code = code;
+        this.provider = provider;
+        this.details = details;
+        this.name = "NewsletterProviderError";
+      }
+    };
   }
 });
 
@@ -1241,12 +1251,427 @@ async function getBroadcastConfig(req, pluginConfig) {
   }
 }
 
+// src/endpoints/broadcasts/send.ts
+init_types();
+
+// src/utils/access.ts
+var isAdmin = (user, config) => {
+  if (!user || user.collection !== "users") {
+    return false;
+  }
+  if (config?.access?.isAdmin) {
+    return config.access.isAdmin(user);
+  }
+  if (user.roles?.includes("admin")) {
+    return true;
+  }
+  if (user.isAdmin === true) {
+    return true;
+  }
+  if (user.role === "admin") {
+    return true;
+  }
+  if (user.admin === true) {
+    return true;
+  }
+  return false;
+};
+var adminOnly = (config) => ({ req }) => {
+  const user = req.user;
+  return isAdmin(user, config);
+};
+var adminOrSelf = (config) => ({ req, id }) => {
+  const user = req.user;
+  if (!user) {
+    if (!id) {
+      return {
+        id: {
+          equals: "unauthorized-no-access"
+        }
+      };
+    }
+    return false;
+  }
+  if (isAdmin(user, config)) {
+    return true;
+  }
+  if (user.collection === "subscribers") {
+    if (!id) {
+      return {
+        id: {
+          equals: user.id
+        }
+      };
+    }
+    return id === user.id;
+  }
+  if (!id) {
+    return {
+      id: {
+        equals: "unauthorized-no-access"
+      }
+    };
+  }
+  return false;
+};
+
+// src/utils/auth.ts
+async function getAuthenticatedUser(req) {
+  try {
+    const me = await req.payload.find({
+      collection: "users",
+      where: {
+        id: {
+          equals: "me"
+          // Special value in Payload to get current user
+        }
+      },
+      limit: 1,
+      depth: 0
+    });
+    return me.docs[0] || null;
+  } catch {
+    return null;
+  }
+}
+async function requireAdmin(req, config) {
+  const user = await getAuthenticatedUser(req);
+  if (!user) {
+    return {
+      authorized: false,
+      error: "Authentication required"
+    };
+  }
+  if (!isAdmin(user, config)) {
+    return {
+      authorized: false,
+      error: "Admin access required"
+    };
+  }
+  return {
+    authorized: true,
+    user
+  };
+}
+
+// src/endpoints/broadcasts/send.ts
+var createSendBroadcastEndpoint = (config, collectionSlug) => {
+  return {
+    path: "/:id/send",
+    method: "post",
+    handler: async (req) => {
+      try {
+        const auth = await requireAdmin(req, config);
+        if (!auth.authorized) {
+          return Response.json({
+            success: false,
+            error: auth.error
+          }, { status: 401 });
+        }
+        if (!config.features?.newsletterManagement?.enabled) {
+          return Response.json({
+            success: false,
+            error: "Broadcast management is not enabled"
+          }, { status: 400 });
+        }
+        const url = new URL(req.url || "", `http://localhost`);
+        const pathParts = url.pathname.split("/");
+        const id = pathParts[pathParts.length - 2];
+        if (!id) {
+          return Response.json({
+            success: false,
+            error: "Broadcast ID is required"
+          }, { status: 400 });
+        }
+        const data = await (req.json?.() || Promise.resolve({}));
+        const broadcastDoc = await req.payload.findByID({
+          collection: collectionSlug,
+          id,
+          user: auth.user
+        });
+        if (!broadcastDoc || !broadcastDoc.providerId) {
+          return Response.json({
+            success: false,
+            error: "Broadcast not found or not synced with provider"
+          }, { status: 404 });
+        }
+        const providerConfig = await getBroadcastConfig(req, config);
+        if (!providerConfig || !providerConfig.token) {
+          return Response.json({
+            success: false,
+            error: "Broadcast provider not configured in Newsletter Settings or environment variables"
+          }, { status: 500 });
+        }
+        const { BroadcastApiProvider: BroadcastApiProvider2 } = await Promise.resolve().then(() => (init_broadcast2(), broadcast_exports));
+        const provider = new BroadcastApiProvider2(providerConfig);
+        const broadcast = await provider.send(broadcastDoc.providerId, data);
+        await req.payload.update({
+          collection: collectionSlug,
+          id,
+          data: {
+            sendStatus: "sending" /* SENDING */,
+            sentAt: (/* @__PURE__ */ new Date()).toISOString()
+          },
+          user: auth.user
+        });
+        return Response.json({
+          success: true,
+          message: "Broadcast sent successfully",
+          broadcast
+        });
+      } catch (error) {
+        console.error("Failed to send broadcast:", error);
+        if (error instanceof NewsletterProviderError) {
+          return Response.json({
+            success: false,
+            error: error.message,
+            code: error.code
+          }, { status: error.code === "NOT_SUPPORTED" ? 501 : 500 });
+        }
+        return Response.json({
+          success: false,
+          error: "Failed to send broadcast"
+        }, { status: 500 });
+      }
+    }
+  };
+};
+
+// src/endpoints/broadcasts/schedule.ts
+init_types();
+var createScheduleBroadcastEndpoint = (config, collectionSlug) => {
+  return {
+    path: "/:id/schedule",
+    method: "post",
+    handler: async (req) => {
+      try {
+        const auth = await requireAdmin(req, config);
+        if (!auth.authorized) {
+          return Response.json({
+            success: false,
+            error: auth.error
+          }, { status: 401 });
+        }
+        if (!config.features?.newsletterManagement?.enabled) {
+          return Response.json({
+            success: false,
+            error: "Broadcast management is not enabled"
+          }, { status: 400 });
+        }
+        const url = new URL(req.url || "", `http://localhost`);
+        const pathParts = url.pathname.split("/");
+        const id = pathParts[pathParts.length - 2];
+        if (!id) {
+          return Response.json({
+            success: false,
+            error: "Broadcast ID is required"
+          }, { status: 400 });
+        }
+        const data = await (req.json?.() || Promise.resolve({}));
+        const { scheduledAt } = data;
+        if (!scheduledAt) {
+          return Response.json({
+            success: false,
+            error: "scheduledAt is required"
+          }, { status: 400 });
+        }
+        const scheduledDate = new Date(scheduledAt);
+        if (isNaN(scheduledDate.getTime())) {
+          return Response.json({
+            success: false,
+            error: "Invalid scheduledAt date"
+          }, { status: 400 });
+        }
+        if (scheduledDate <= /* @__PURE__ */ new Date()) {
+          return Response.json({
+            success: false,
+            error: "scheduledAt must be in the future"
+          }, { status: 400 });
+        }
+        const broadcastDoc = await req.payload.findByID({
+          collection: collectionSlug,
+          id,
+          user: auth.user
+        });
+        if (!broadcastDoc || !broadcastDoc.providerId) {
+          return Response.json({
+            success: false,
+            error: "Broadcast not found or not synced with provider"
+          }, { status: 404 });
+        }
+        const providerConfig = config.providers?.broadcast;
+        if (!providerConfig) {
+          return Response.json({
+            success: false,
+            error: "Broadcast provider not configured"
+          }, { status: 500 });
+        }
+        const { BroadcastApiProvider: BroadcastApiProvider2 } = await Promise.resolve().then(() => (init_broadcast2(), broadcast_exports));
+        const provider = new BroadcastApiProvider2(providerConfig);
+        const broadcast = await provider.schedule(broadcastDoc.providerId, scheduledDate);
+        await req.payload.update({
+          collection: collectionSlug,
+          id,
+          data: {
+            sendStatus: "scheduled" /* SCHEDULED */,
+            scheduledAt: scheduledDate.toISOString()
+          },
+          user: auth.user
+        });
+        return Response.json({
+          success: true,
+          message: `Broadcast scheduled for ${scheduledDate.toISOString()}`,
+          broadcast
+        });
+      } catch (error) {
+        console.error("Failed to schedule broadcast:", error);
+        if (error instanceof NewsletterProviderError) {
+          return Response.json({
+            success: false,
+            error: error.message,
+            code: error.code
+          }, { status: error.code === "NOT_SUPPORTED" ? 501 : 500 });
+        }
+        return Response.json({
+          success: false,
+          error: "Failed to schedule broadcast"
+        }, { status: 500 });
+      }
+    }
+  };
+};
+
+// src/endpoints/broadcasts/test.ts
+var createTestBroadcastEndpoint = (config, collectionSlug) => {
+  return {
+    path: "/:id/test",
+    method: "post",
+    handler: async (req) => {
+      try {
+        const auth = await requireAdmin(req, config);
+        if (!auth.authorized) {
+          return Response.json({
+            success: false,
+            error: auth.error
+          }, { status: 401 });
+        }
+        const url = new URL(req.url || "", `http://localhost`);
+        const pathParts = url.pathname.split("/");
+        const id = pathParts[pathParts.length - 2];
+        if (!id) {
+          return Response.json({
+            success: false,
+            error: "Broadcast ID is required"
+          }, { status: 400 });
+        }
+        const data = await (req.json?.() || Promise.resolve({}));
+        const testEmail = data.email || auth.user.email;
+        if (!testEmail) {
+          return Response.json({
+            success: false,
+            error: "No email address available for test send"
+          }, { status: 400 });
+        }
+        const broadcast = await req.payload.findByID({
+          collection: collectionSlug,
+          id,
+          user: auth.user
+        });
+        if (!broadcast) {
+          return Response.json({
+            success: false,
+            error: "Broadcast not found"
+          }, { status: 404 });
+        }
+        const htmlContent = await convertToEmailSafeHtml(broadcast.content, {
+          wrapInTemplate: true,
+          preheader: broadcast.preheader,
+          customBlockConverter: config.customizations?.broadcasts?.customBlockConverter
+        });
+        const emailService = req.payload.newsletterEmailService;
+        if (!emailService) {
+          return Response.json({
+            success: false,
+            error: "Email service is not configured"
+          }, { status: 500 });
+        }
+        const providerConfig = config.providers.default === "resend" ? config.providers.resend : config.providers.broadcast;
+        const fromEmail = providerConfig?.fromAddress || providerConfig?.fromEmail || "noreply@example.com";
+        const fromName = providerConfig?.fromName || "Newsletter";
+        const replyTo = broadcast.settings?.replyTo || providerConfig?.replyTo;
+        await emailService.send({
+          to: testEmail,
+          from: fromEmail,
+          fromName,
+          replyTo,
+          subject: `[TEST] ${broadcast.subject}`,
+          html: htmlContent,
+          trackOpens: false,
+          trackClicks: false
+        });
+        return Response.json({
+          success: true,
+          message: `Test email sent to ${testEmail}`
+        });
+      } catch (error) {
+        console.error("Failed to send test broadcast:", error);
+        return Response.json({
+          success: false,
+          error: "Failed to send test email"
+        }, { status: 500 });
+      }
+    }
+  };
+};
+
+// src/endpoints/broadcasts/preview.ts
+var createBroadcastPreviewEndpoint = (config, collectionSlug) => {
+  return {
+    path: "/preview",
+    method: "post",
+    handler: async (req) => {
+      try {
+        const data = await (req.json?.() || Promise.resolve({}));
+        const { content, preheader, subject } = data;
+        if (!content) {
+          return Response.json({
+            success: false,
+            error: "Content is required for preview"
+          }, { status: 400 });
+        }
+        const mediaUrl = req.payload.config.serverURL ? `${req.payload.config.serverURL}/api/media` : "/api/media";
+        const htmlContent = await convertToEmailSafeHtml(content, {
+          wrapInTemplate: true,
+          preheader,
+          mediaUrl,
+          customBlockConverter: config.customizations?.broadcasts?.customBlockConverter
+        });
+        return Response.json({
+          success: true,
+          preview: {
+            subject: subject || "Preview",
+            preheader: preheader || "",
+            html: htmlContent
+          }
+        });
+      } catch (error) {
+        console.error("Failed to generate email preview:", error);
+        return Response.json({
+          success: false,
+          error: "Failed to generate email preview"
+        }, { status: 500 });
+      }
+    }
+  };
+};
+
 // src/collections/Broadcasts.ts
 var createBroadcastsCollection = (pluginConfig) => {
   const hasProviders = !!(pluginConfig.providers?.broadcast || pluginConfig.providers?.resend);
   const customizations = pluginConfig.customizations?.broadcasts;
+  const collectionSlug = "broadcasts";
   return {
-    slug: "broadcasts",
+    slug: collectionSlug,
     access: {
       read: () => true,
       // Public read access
@@ -1275,6 +1700,12 @@ var createBroadcastsCollection = (pluginConfig) => {
       description: "Individual email campaigns sent to subscribers",
       defaultColumns: ["subject", "_status", "sendStatus", "sentAt", "recipientCount"]
     },
+    endpoints: [
+      createSendBroadcastEndpoint(pluginConfig, collectionSlug),
+      createScheduleBroadcastEndpoint(pluginConfig, collectionSlug),
+      createTestBroadcastEndpoint(pluginConfig, collectionSlug),
+      createBroadcastPreviewEndpoint(pluginConfig, collectionSlug)
+    ],
     fields: [
       {
         name: "subject",
@@ -1820,67 +2251,6 @@ var createBroadcastsCollection = (pluginConfig) => {
   };
 };
 
-// src/utils/access.ts
-var isAdmin = (user, config) => {
-  if (!user || user.collection !== "users") {
-    return false;
-  }
-  if (config?.access?.isAdmin) {
-    return config.access.isAdmin(user);
-  }
-  if (user.roles?.includes("admin")) {
-    return true;
-  }
-  if (user.isAdmin === true) {
-    return true;
-  }
-  if (user.role === "admin") {
-    return true;
-  }
-  if (user.admin === true) {
-    return true;
-  }
-  return false;
-};
-var adminOnly = (config) => ({ req }) => {
-  const user = req.user;
-  return isAdmin(user, config);
-};
-var adminOrSelf = (config) => ({ req, id }) => {
-  const user = req.user;
-  if (!user) {
-    if (!id) {
-      return {
-        id: {
-          equals: "unauthorized-no-access"
-        }
-      };
-    }
-    return false;
-  }
-  if (isAdmin(user, config)) {
-    return true;
-  }
-  if (user.collection === "subscribers") {
-    if (!id) {
-      return {
-        id: {
-          equals: user.id
-        }
-      };
-    }
-    return id === user.id;
-  }
-  if (!id) {
-    return {
-      id: {
-        equals: "unauthorized-no-access"
-      }
-    };
-  }
-  return false;
-};
-
 // src/emails/render.tsx
 var import_render = require("@react-email/render");