payload-plugin-newsletter 0.9.2 → 0.10.0

package/dist/index.cjs

@@ -65,13 +65,6 @@ var init_broadcast = __esm({
   }
 });
 
-// src/types/channel.ts
-var init_channel = __esm({
-  "src/types/channel.ts"() {
-    "use strict";
-  }
-});
-
 // src/types/providers.ts
 var BaseBroadcastProvider;
 var init_providers = __esm({
@@ -176,7 +169,6 @@ var init_types = __esm({
   "src/types/index.ts"() {
     "use strict";
     init_broadcast();
-    init_channel();
     init_providers();
     init_newsletter();
   }
@@ -197,8 +189,7 @@ var init_broadcast2 = __esm({
         super(config);
         this.name = "broadcast";
         this.apiUrl = config.apiUrl.replace(/\/$/, "");
-        this.isDevelopment = process.env.NODE_ENV !== "production";
-        this.token = this.isDevelopment ? config.tokens.development || config.tokens.production || "" : config.tokens.production || config.tokens.development || "";
+        this.token = config.token;
         if (!this.token) {
           throw new BroadcastProviderError(
             "Broadcast API token is required",
@@ -207,158 +198,6 @@ var init_broadcast2 = __esm({
           );
         }
       }
-      // Channel Management Methods
-      async listChannels(options) {
-        try {
-          const params = new URLSearchParams();
-          if (options?.limit) params.append("limit", options.limit.toString());
-          if (options?.offset) params.append("offset", options.offset.toString());
-          const response = await fetch(`${this.apiUrl}/api/v1/channels?${params}`, {
-            method: "GET",
-            headers: {
-              "Authorization": `Bearer ${this.token}`,
-              "Content-Type": "application/json"
-            }
-          });
-          if (!response.ok) {
-            const error = await response.text();
-            throw new Error(`Broadcast API error: ${response.status} - ${error}`);
-          }
-          const data = await response.json();
-          const channels = data.data.map((channel) => this.transformChannelFromApi(channel));
-          return {
-            channels,
-            total: data.total || channels.length,
-            limit: options?.limit || 20,
-            offset: options?.offset || 0
-          };
-        } catch (error) {
-          throw new BroadcastProviderError(
-            `Failed to list channels: ${error instanceof Error ? error.message : "Unknown error"}`,
-            "PROVIDER_ERROR" /* PROVIDER_ERROR */,
-            this.name,
-            error
-          );
-        }
-      }
-      async getChannel(id) {
-        try {
-          const response = await fetch(`${this.apiUrl}/api/v1/channels/${id}`, {
-            method: "GET",
-            headers: {
-              "Authorization": `Bearer ${this.token}`,
-              "Content-Type": "application/json"
-            }
-          });
-          if (!response.ok) {
-            if (response.status === 404) {
-              throw new BroadcastProviderError(
-                `Channel not found: ${id}`,
-                "CHANNEL_NOT_FOUND" /* CHANNEL_NOT_FOUND */,
-                this.name
-              );
-            }
-            const error = await response.text();
-            throw new Error(`Broadcast API error: ${response.status} - ${error}`);
-          }
-          const channel = await response.json();
-          return this.transformChannelFromApi(channel);
-        } catch (error) {
-          if (error instanceof BroadcastProviderError) throw error;
-          throw new BroadcastProviderError(
-            `Failed to get channel: ${error instanceof Error ? error.message : "Unknown error"}`,
-            "PROVIDER_ERROR" /* PROVIDER_ERROR */,
-            this.name,
-            error
-          );
-        }
-      }
-      async createChannel(data) {
-        try {
-          const response = await fetch(`${this.apiUrl}/api/v1/channels`, {
-            method: "POST",
-            headers: {
-              "Authorization": `Bearer ${this.token}`,
-              "Content-Type": "application/json"
-            },
-            body: JSON.stringify({
-              channel: {
-                name: data.name,
-                description: data.description,
-                from: data.fromName,
-                address: data.fromEmail,
-                reply_to: data.replyTo
-              }
-            })
-          });
-          if (!response.ok) {
-            const error = await response.text();
-            throw new Error(`Broadcast API error: ${response.status} - ${error}`);
-          }
-          const channel = await response.json();
-          return this.transformChannelFromApi(channel);
-        } catch (error) {
-          throw new BroadcastProviderError(
-            `Failed to create channel: ${error instanceof Error ? error.message : "Unknown error"}`,
-            "PROVIDER_ERROR" /* PROVIDER_ERROR */,
-            this.name,
-            error
-          );
-        }
-      }
-      async updateChannel(id, data) {
-        try {
-          const updateData = { channel: {} };
-          if (data.name !== void 0) updateData.channel.name = data.name;
-          if (data.description !== void 0) updateData.channel.description = data.description;
-          if (data.fromName !== void 0) updateData.channel.from = data.fromName;
-          if (data.fromEmail !== void 0) updateData.channel.address = data.fromEmail;
-          if (data.replyTo !== void 0) updateData.channel.reply_to = data.replyTo;
-          const response = await fetch(`${this.apiUrl}/api/v1/channels/${id}`, {
-            method: "PATCH",
-            headers: {
-              "Authorization": `Bearer ${this.token}`,
-              "Content-Type": "application/json"
-            },
-            body: JSON.stringify(updateData)
-          });
-          if (!response.ok) {
-            const error = await response.text();
-            throw new Error(`Broadcast API error: ${response.status} - ${error}`);
-          }
-          const channel = await response.json();
-          return this.transformChannelFromApi(channel);
-        } catch (error) {
-          throw new BroadcastProviderError(
-            `Failed to update channel: ${error instanceof Error ? error.message : "Unknown error"}`,
-            "PROVIDER_ERROR" /* PROVIDER_ERROR */,
-            this.name,
-            error
-          );
-        }
-      }
-      async deleteChannel(id) {
-        try {
-          const response = await fetch(`${this.apiUrl}/api/v1/channels/${id}`, {
-            method: "DELETE",
-            headers: {
-              "Authorization": `Bearer ${this.token}`,
-              "Content-Type": "application/json"
-            }
-          });
-          if (!response.ok) {
-            const error = await response.text();
-            throw new Error(`Broadcast API error: ${response.status} - ${error}`);
-          }
-        } catch (error) {
-          throw new BroadcastProviderError(
-            `Failed to delete channel: ${error instanceof Error ? error.message : "Unknown error"}`,
-            "PROVIDER_ERROR" /* PROVIDER_ERROR */,
-            this.name,
-            error
-          );
-        }
-      }
       // Broadcast Management Methods
       async list(options) {
         try {
@@ -422,7 +261,7 @@ var init_broadcast2 = __esm({
       }
       async create(data) {
         try {
-          this.validateRequiredFields(data, ["channelId", "name", "subject", "content"]);
+          this.validateRequiredFields(data, ["name", "subject", "content"]);
           const response = await fetch(`${this.apiUrl}/api/v1/broadcasts`, {
             method: "POST",
             headers: {
@@ -431,8 +270,6 @@ var init_broadcast2 = __esm({
             },
             body: JSON.stringify({
               broadcast: {
-                channel_id: parseInt(data.channelId),
-                // Broadcast API uses numeric IDs
                 name: data.name,
                 subject: data.subject,
                 preheader: data.preheader,
@@ -649,8 +486,8 @@ var init_broadcast2 = __esm({
           supportsABTesting: false,
           supportsTemplates: false,
           supportsPersonalization: true,
-          supportsMultipleChannels: true,
-          supportsChannelSegmentation: true,
+          supportsMultipleChannels: false,
+          supportsChannelSegmentation: false,
           editableStatuses: ["draft" /* DRAFT */, "scheduled" /* SCHEDULED */],
           supportedContentTypes: ["html", "text"]
         };
@@ -666,406 +503,37 @@ var init_broadcast2 = __esm({
       transformBroadcastFromApi(broadcast) {
         return {
           id: broadcast.id.toString(),
-          channelId: "1",
-          // TODO: Get from API response when available
           name: broadcast.name,
           subject: broadcast.subject,
           preheader: broadcast.preheader,
           content: broadcast.body,
-          status: this.mapBroadcastStatus(broadcast.status),
-          trackOpens: broadcast.track_opens,
-          trackClicks: broadcast.track_clicks,
-          replyTo: broadcast.reply_to,
-          recipientCount: broadcast.total_recipients,
-          sentAt: broadcast.sent_at ? new Date(broadcast.sent_at) : void 0,
-          scheduledAt: broadcast.scheduled_send_at ? new Date(broadcast.scheduled_send_at) : void 0,
-          createdAt: new Date(broadcast.created_at),
-          updatedAt: new Date(broadcast.updated_at),
-          providerData: { broadcast },
-          providerId: broadcast.id.toString(),
-          providerType: "broadcast"
-        };
-      }
-      transformChannelFromApi(channel) {
-        return {
-          id: channel.id.toString(),
-          name: channel.name,
-          description: channel.description,
-          fromName: channel.from,
-          fromEmail: channel.address,
-          replyTo: channel.reply_to,
-          providerId: channel.id.toString(),
-          providerType: "broadcast",
-          subscriberCount: channel.total_active_subscribers,
-          active: true,
-          // Broadcast API doesn't have an active field
-          createdAt: new Date(channel.created_at),
-          updatedAt: new Date(channel.updated_at)
-        };
-      }
-      mapBroadcastStatus(status) {
-        const statusMap = {
-          "draft": "draft" /* DRAFT */,
-          "scheduled": "scheduled" /* SCHEDULED */,
-          "queueing": "sending" /* SENDING */,
-          "sending": "sending" /* SENDING */,
-          "sent": "sent" /* SENT */,
-          "failed": "failed" /* FAILED */,
-          "partial_failure": "failed" /* FAILED */,
-          "paused": "paused" /* PAUSED */,
-          "aborted": "canceled" /* CANCELED */
-        };
-        return statusMap[status] || "draft" /* DRAFT */;
-      }
-    };
-  }
-});
-
-// src/providers/resend/broadcast.ts
-var broadcast_exports2 = {};
-__export(broadcast_exports2, {
-  ResendBroadcastProvider: () => ResendBroadcastProvider
-});
-var import_resend3, ResendBroadcastProvider;
-var init_broadcast3 = __esm({
-  "src/providers/resend/broadcast.ts"() {
-    "use strict";
-    import_resend3 = require("resend");
-    init_types();
-    ResendBroadcastProvider = class extends BaseBroadcastProvider {
-      constructor(config) {
-        super(config);
-        this.name = "resend";
-        this.client = new import_resend3.Resend(config.apiKey);
-        this.audienceIds = config.audienceIds || {};
-        this.isDevelopment = process.env.NODE_ENV !== "production";
-        if (!config.apiKey) {
-          throw new BroadcastProviderError(
-            "Resend API key is required",
-            "CONFIGURATION_ERROR" /* CONFIGURATION_ERROR */,
-            this.name
-          );
-        }
-      }
-      // Channel Management Methods (map to Resend Audiences)
-      async listChannels(options) {
-        try {
-          const response = await this.client.audiences.list();
-          const channels = response.data?.data?.map((audience) => ({
-            id: audience.id,
-            name: audience.name,
-            description: void 0,
-            // Resend doesn't have description
-            fromName: this.config.fromName || "",
-            fromEmail: this.config.fromEmail || "",
-            replyTo: this.config.replyTo,
-            providerId: audience.id,
-            providerType: "resend",
-            subscriberCount: void 0,
-            // Not available in list API
-            active: true,
-            createdAt: new Date(audience.created_at),
-            updatedAt: new Date(audience.created_at)
-            // No updated_at in Resend
-          })) || [];
-          return {
-            channels,
-            total: channels.length,
-            limit: options?.limit || 100,
-            offset: options?.offset || 0
-          };
-        } catch (error) {
-          throw new BroadcastProviderError(
-            `Failed to list channels (audiences): ${error instanceof Error ? error.message : "Unknown error"}`,
-            "PROVIDER_ERROR" /* PROVIDER_ERROR */,
-            this.name,
-            error
-          );
-        }
-      }
-      async getChannel(id) {
-        try {
-          const response = await this.client.audiences.get(id);
-          if (!response.data) {
-            throw new BroadcastProviderError(
-              `Channel (audience) not found: ${id}`,
-              "CHANNEL_NOT_FOUND" /* CHANNEL_NOT_FOUND */,
-              this.name
-            );
-          }
-          return {
-            id: response.data.id,
-            name: response.data.name,
-            description: void 0,
-            fromName: this.config.fromName || "",
-            fromEmail: this.config.fromEmail || "",
-            replyTo: this.config.replyTo,
-            providerId: response.data.id,
-            providerType: "resend",
-            subscriberCount: void 0,
-            // Not available
-            active: true,
-            createdAt: new Date(response.data.created_at),
-            updatedAt: new Date(response.data.created_at)
-          };
-        } catch (error) {
-          if (error instanceof BroadcastProviderError) throw error;
-          throw new BroadcastProviderError(
-            `Failed to get channel (audience): ${error instanceof Error ? error.message : "Unknown error"}`,
-            "PROVIDER_ERROR" /* PROVIDER_ERROR */,
-            this.name,
-            error
-          );
-        }
-      }
-      async createChannel(data) {
-        try {
-          const response = await this.client.audiences.create({
-            name: data.name
-          });
-          if (!response.data) {
-            throw new Error("Failed to create audience");
-          }
-          return {
-            id: response.data.id,
-            name: response.data.name,
-            description: data.description,
-            fromName: data.fromName,
-            fromEmail: data.fromEmail,
-            replyTo: data.replyTo,
-            providerId: response.data.id,
-            providerType: "resend",
-            subscriberCount: 0,
-            active: true,
-            createdAt: /* @__PURE__ */ new Date(),
-            updatedAt: /* @__PURE__ */ new Date()
-          };
-        } catch (error) {
-          throw new BroadcastProviderError(
-            `Failed to create channel (audience): ${error instanceof Error ? error.message : "Unknown error"}`,
-            "PROVIDER_ERROR" /* PROVIDER_ERROR */,
-            this.name,
-            error
-          );
-        }
-      }
-      async updateChannel(_id, _data) {
-        throw new BroadcastProviderError(
-          "Updating channels (audiences) is not supported by Resend API",
-          "NOT_SUPPORTED" /* NOT_SUPPORTED */,
-          this.name
-        );
-      }
-      async deleteChannel(id) {
-        try {
-          await this.client.audiences.remove(id);
-        } catch (error) {
-          throw new BroadcastProviderError(
-            `Failed to delete channel (audience): ${error instanceof Error ? error.message : "Unknown error"}`,
-            "PROVIDER_ERROR" /* PROVIDER_ERROR */,
-            this.name,
-            error
-          );
-        }
-      }
-      // Broadcast Management Methods
-      async list(_options) {
-        throw new BroadcastProviderError(
-          "Listing broadcasts is not currently supported by Resend API. This feature may be available in the dashboard only.",
-          "NOT_SUPPORTED" /* NOT_SUPPORTED */,
-          this.name
-        );
-      }
-      async get(_id) {
-        throw new BroadcastProviderError(
-          "Getting individual broadcasts is not currently supported by Resend API. This feature may be available in the dashboard only.",
-          "NOT_SUPPORTED" /* NOT_SUPPORTED */,
-          this.name
-        );
-      }
-      async create(data) {
-        try {
-          this.validateRequiredFields(data, ["channelId", "name", "subject", "content"]);
-          const locale = "en";
-          const audienceConfig = this.audienceIds?.[locale];
-          const audienceId = this.isDevelopment ? audienceConfig?.development || audienceConfig?.production : audienceConfig?.production || audienceConfig?.development;
-          if (!audienceId && data.audienceIds?.length) {
-          }
-          const resendClient = this.client;
-          if (resendClient.broadcasts?.create) {
-            const broadcast = await resendClient.broadcasts.create({
-              name: data.name,
-              subject: data.subject,
-              from: `${this.config.fromName || "Newsletter"} <${this.config.fromEmail || "noreply@example.com"}>`,
-              reply_to: data.replyTo,
-              audience_id: audienceId || data.audienceIds?.[0],
-              content: {
-                html: data.content
-                // TODO: Handle plain text version
-              }
-            });
-            return this.transformResendToBroadcast(broadcast);
-          }
-          throw new BroadcastProviderError(
-            "Creating broadcasts via API is not currently supported. Please check if Resend has released their Broadcasts API.",
-            "NOT_SUPPORTED" /* NOT_SUPPORTED */,
-            this.name
-          );
-        } catch (error) {
-          if (error instanceof BroadcastProviderError) throw error;
-          throw new BroadcastProviderError(
-            `Failed to create broadcast: ${error instanceof Error ? error.message : "Unknown error"}`,
-            "PROVIDER_ERROR" /* PROVIDER_ERROR */,
-            this.name,
-            error
-          );
-        }
-      }
-      async update(_id, _data) {
-        throw new BroadcastProviderError(
-          "Updating broadcasts is not currently supported by Resend API. Note: Resend broadcasts can only be edited where they were created.",
-          "NOT_SUPPORTED" /* NOT_SUPPORTED */,
-          this.name
-        );
-      }
-      async delete(_id) {
-        throw new BroadcastProviderError(
-          "Deleting broadcasts is not currently supported by Resend API.",
-          "NOT_SUPPORTED" /* NOT_SUPPORTED */,
-          this.name
-        );
-      }
-      async send(id, options) {
-        try {
-          const resendClient = this.client;
-          if (resendClient.broadcasts?.send) {
-            await resendClient.broadcasts.send(id, {
-              audience_id: options?.audienceIds?.[0]
-              // TODO: Handle test mode if supported
-            });
-            return {
-              id,
-              channelId: options?.audienceIds?.[0] || "1",
-              name: "Unknown",
-              subject: "Unknown",
-              content: "",
-              status: "sending" /* SENDING */,
-              trackOpens: true,
-              trackClicks: true,
-              createdAt: /* @__PURE__ */ new Date(),
-              updatedAt: /* @__PURE__ */ new Date(),
-              providerType: "resend"
-            };
-          }
-          throw new BroadcastProviderError(
-            "Sending broadcasts via API is not currently supported. Please check if Resend has released their Broadcasts API.",
-            "NOT_SUPPORTED" /* NOT_SUPPORTED */,
-            this.name
-          );
-        } catch (error) {
-          if (error instanceof BroadcastProviderError) throw error;
-          throw new BroadcastProviderError(
-            `Failed to send broadcast: ${error instanceof Error ? error.message : "Unknown error"}`,
-            "PROVIDER_ERROR" /* PROVIDER_ERROR */,
-            this.name,
-            error
-          );
-        }
-      }
-      async schedule(_id, _scheduledAt) {
-        throw new BroadcastProviderError(
-          "Scheduling broadcasts is not supported by Resend",
-          "NOT_SUPPORTED" /* NOT_SUPPORTED */,
-          this.name
-        );
-      }
-      async getAnalytics(_id) {
-        throw new BroadcastProviderError(
-          "Getting broadcast analytics via API is not currently supported. Analytics may be available in the Resend dashboard.",
-          "NOT_SUPPORTED" /* NOT_SUPPORTED */,
-          this.name
-        );
-      }
-      getCapabilities() {
-        return {
-          supportsScheduling: false,
-          // Not documented
-          supportsSegmentation: true,
-          // Via Audiences
-          supportsAnalytics: true,
-          // Available in dashboard, API unclear
-          supportsABTesting: false,
-          supportsTemplates: false,
-          // Not clear from docs
-          supportsPersonalization: true,
-          // Via merge tags
-          supportsMultipleChannels: true,
-          // Via multiple audiences
-          supportsChannelSegmentation: false,
-          // Not within a single audience
-          editableStatuses: [],
-          // Unclear which statuses can be edited
-          supportedContentTypes: ["html"]
-          // React components via SDK
-        };
-      }
-      async validateConfiguration() {
-        try {
-          const resendClient = this.client;
-          if (resendClient.audiences?.list) {
-            await resendClient.audiences.list({ limit: 1 });
-            return true;
-          }
-          await this.client.emails.send({
-            from: "onboarding@resend.dev",
-            to: "delivered@resend.dev",
-            subject: "Configuration Test",
-            html: "<p>Testing configuration</p>"
-          });
-          return true;
-        } catch {
-          return false;
-        }
-      }
-      /**
-       * Transform Resend broadcast to our Broadcast type
-       * NOTE: This is speculative based on what the API might return
-       */
-      transformResendToBroadcast(broadcast) {
-        return {
-          id: broadcast.id,
-          channelId: broadcast.audience_id || "1",
-          // Map audience_id to channelId
-          name: broadcast.name || "Untitled",
-          subject: broadcast.subject,
-          preheader: broadcast.preheader,
-          content: broadcast.content?.html || broadcast.html || "",
-          status: this.mapResendStatus(broadcast.status),
-          trackOpens: true,
-          // Resend tracks by default
-          trackClicks: true,
-          // Resend tracks by default
+          status: this.mapBroadcastStatus(broadcast.status),
+          trackOpens: broadcast.track_opens,
+          trackClicks: broadcast.track_clicks,
           replyTo: broadcast.reply_to,
-          recipientCount: broadcast.recipient_count,
+          recipientCount: broadcast.total_recipients,
           sentAt: broadcast.sent_at ? new Date(broadcast.sent_at) : void 0,
-          scheduledAt: broadcast.scheduled_at ? new Date(broadcast.scheduled_at) : void 0,
-          createdAt: new Date(broadcast.created_at || Date.now()),
-          updatedAt: new Date(broadcast.updated_at || Date.now()),
+          scheduledAt: broadcast.scheduled_send_at ? new Date(broadcast.scheduled_send_at) : void 0,
+          createdAt: new Date(broadcast.created_at),
+          updatedAt: new Date(broadcast.updated_at),
           providerData: { broadcast },
-          providerId: broadcast.id,
-          providerType: "resend"
+          providerId: broadcast.id.toString(),
+          providerType: "broadcast"
         };
       }
-      mapResendStatus(status) {
-        if (!status) return "draft" /* DRAFT */;
+      mapBroadcastStatus(status) {
         const statusMap = {
           "draft": "draft" /* DRAFT */,
           "scheduled": "scheduled" /* SCHEDULED */,
+          "queueing": "sending" /* SENDING */,
           "sending": "sending" /* SENDING */,
           "sent": "sent" /* SENT */,
-          "failed": "failed" /* FAILED */
+          "failed": "failed" /* FAILED */,
+          "partial_failure": "failed" /* FAILED */,
+          "paused": "paused" /* PAUSED */,
+          "aborted": "canceled" /* CANCELED */
         };
-        return statusMap[status.toLowerCase()] || "draft" /* DRAFT */;
+        return statusMap[status] || "draft" /* DRAFT */;
       }
     };
   }
@@ -1752,19 +1220,12 @@ var createNewsletterSettingsGlobal = (pluginConfig) => {
                     }
                   },
                   {
-                    name: "productionToken",
-                    type: "text",
-                    label: "Production Token",
-                    admin: {
-                      description: "Token for production environment"
-                    }
-                  },
-                  {
-                    name: "developmentToken",
+                    name: "token",
                     type: "text",
-                    label: "Development Token",
+                    label: "API Token",
+                    required: true,
                     admin: {
-                      description: "Token for development environment"
+                      description: "Your Broadcast API token"
                     }
                   }
                 ]
@@ -2090,10 +1551,10 @@ var ResendProvider = class {
 var BroadcastProvider = class {
   constructor(config) {
     this.apiUrl = config.apiUrl.replace(/\/$/, "");
-    this.isDevelopment = process.env.NODE_ENV !== "production";
-    this.token = this.isDevelopment ? config.tokens.development || config.tokens.production || "" : config.tokens.production || config.tokens.development || "";
+    this.token = config.token;
     this.fromAddress = config.fromAddress;
     this.fromName = config.fromName;
+    this.replyTo = config.replyTo;
   }
   getProvider() {
     return "broadcast";
@@ -2116,7 +1577,7 @@ var BroadcastProvider = class {
           // Broadcast API expects a single recipient for transactional emails
           subject: params.subject,
           body: params.html || params.text || "",
-          reply_to: params.replyTo || from.email
+          reply_to: params.replyTo || this.replyTo || from.email
         })
       });
       if (!response.ok) {
@@ -3293,8 +2754,7 @@ var createSendBroadcastEndpoint = (config, collectionSlug) => {
             error: auth.error
           }, { status: 401 });
         }
-        const broadcastProvider = req.payload.newsletterProvider;
-        if (!broadcastProvider) {
+        if (!config.features?.newsletterManagement?.enabled) {
           return Response.json({
             success: false,
             error: "Broadcast management is not enabled"
@@ -3321,7 +2781,16 @@ var createSendBroadcastEndpoint = (config, collectionSlug) => {
             error: "Broadcast not found or not synced with provider"
           }, { status: 404 });
         }
-        const broadcast = await broadcastProvider.send(broadcastDoc.providerId, data);
+        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.send(broadcastDoc.providerId, data);
         await req.payload.update({
           collection: collectionSlug,
           id,
@@ -3369,8 +2838,7 @@ var createScheduleBroadcastEndpoint = (config, collectionSlug) => {
             error: auth.error
           }, { status: 401 });
         }
-        const broadcastProvider = req.payload.newsletterProvider;
-        if (!broadcastProvider) {
+        if (!config.features?.newsletterManagement?.enabled) {
           return Response.json({
             success: false,
             error: "Broadcast management is not enabled"
@@ -3417,7 +2885,16 @@ var createScheduleBroadcastEndpoint = (config, collectionSlug) => {
             error: "Broadcast not found or not synced with provider"
           }, { status: 404 });
         }
-        const broadcast = await broadcastProvider.schedule(broadcastDoc.providerId, scheduledDate);
+        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,
@@ -3696,11 +3173,6 @@ var createTestBroadcastEndpoint = (config, collectionSlug) => {
             error: "Broadcast not found"
           }, { status: 404 });
         }
-        const channel = await req.payload.findByID({
-          collection: "channels",
-          id: typeof broadcast.channel === "string" ? broadcast.channel : broadcast.channel.id,
-          user: auth.user
-        });
         const htmlContent = await convertToEmailSafeHtml(broadcast.content, {
           wrapInTemplate: true,
           preheader: broadcast.preheader
@@ -3712,11 +3184,15 @@ var createTestBroadcastEndpoint = (config, collectionSlug) => {
             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: channel?.fromEmail || config.providers.resend?.fromAddress || "noreply@example.com",
-          fromName: channel?.fromName || config.providers.resend?.fromName || "Newsletter",
-          replyTo: broadcast.settings?.replyTo || channel?.replyTo,
+          from: fromEmail,
+          fromName,
+          replyTo,
           subject: `[TEST] ${broadcast.subject}`,
           html: htmlContent,
           trackOpens: false,
@@ -3964,7 +3440,7 @@ var createUnsubscribeSyncJob = (pluginConfig) => {
             throw new Error("Broadcast configuration not found");
           }
           const apiUrl = broadcastConfig.apiUrl.replace(/\/$/, "");
-          const token = process.env.NODE_ENV === "production" ? broadcastConfig.tokens.production : broadcastConfig.tokens.development;
+          const token = broadcastConfig.token;
           let page = 1;
           let hasMore = true;
           while (hasMore) {
@@ -4044,216 +3520,6 @@ var createUnsubscribeSyncJob = (pluginConfig) => {
   };
 };
 
-// src/collections/Channels.ts
-var createChannelsCollection = (pluginConfig) => {
-  const hasProviders = !!(pluginConfig.providers?.broadcast || pluginConfig.providers?.resend);
-  return {
-    slug: "channels",
-    labels: {
-      singular: "Channel",
-      plural: "Channels"
-    },
-    admin: {
-      useAsTitle: "name",
-      description: "Newsletter channels/publications that can send broadcasts",
-      defaultColumns: ["name", "fromEmail", "subscriberCount", "active"]
-    },
-    fields: [
-      {
-        name: "name",
-        type: "text",
-        required: true,
-        admin: {
-          description: "The name of this newsletter channel"
-        }
-      },
-      {
-        name: "description",
-        type: "textarea",
-        admin: {
-          description: "A brief description of what this channel is about"
-        }
-      },
-      {
-        name: "fromName",
-        type: "text",
-        required: true,
-        admin: {
-          description: "The sender name that appears in emails"
-        }
-      },
-      {
-        name: "fromEmail",
-        type: "email",
-        required: true,
-        admin: {
-          description: "The sender email address"
-        }
-      },
-      {
-        name: "replyTo",
-        type: "email",
-        admin: {
-          description: "Reply-to email address (optional)"
-        }
-      },
-      {
-        name: "providerType",
-        type: "select",
-        required: true,
-        options: [
-          ...pluginConfig.providers?.broadcast ? [{ label: "Broadcast", value: "broadcast" }] : [],
-          ...pluginConfig.providers?.resend ? [{ label: "Resend", value: "resend" }] : []
-        ],
-        admin: {
-          description: "Which email provider manages this channel"
-        }
-      },
-      {
-        name: "providerId",
-        type: "text",
-        admin: {
-          readOnly: true,
-          description: "ID from the email provider",
-          condition: (data) => hasProviders && data?.providerId
-        }
-      },
-      {
-        name: "subscriberCount",
-        type: "number",
-        admin: {
-          readOnly: true,
-          description: "Number of active subscribers"
-        },
-        defaultValue: 0
-      },
-      {
-        name: "active",
-        type: "checkbox",
-        defaultValue: true,
-        admin: {
-          description: "Whether this channel is currently active"
-        }
-      },
-      {
-        name: "settings",
-        type: "group",
-        fields: [
-          {
-            name: "defaultTrackOpens",
-            type: "checkbox",
-            defaultValue: true,
-            admin: {
-              description: "Track email opens by default for broadcasts in this channel"
-            }
-          },
-          {
-            name: "defaultTrackClicks",
-            type: "checkbox",
-            defaultValue: true,
-            admin: {
-              description: "Track link clicks by default for broadcasts in this channel"
-            }
-          },
-          {
-            name: "requireDoubleOptIn",
-            type: "checkbox",
-            defaultValue: false,
-            admin: {
-              description: "Require double opt-in for new subscribers"
-            }
-          }
-        ]
-      }
-    ],
-    hooks: {
-      // Sync with provider on create
-      afterChange: [
-        async ({ doc, operation, req }) => {
-          if (!hasProviders || operation !== "create") return doc;
-          try {
-            const provider = await getProvider(doc.providerType, pluginConfig);
-            if (!provider) return doc;
-            const providerChannel = await provider.createChannel({
-              name: doc.name,
-              description: doc.description,
-              fromName: doc.fromName,
-              fromEmail: doc.fromEmail,
-              replyTo: doc.replyTo
-            });
-            await req.payload.update({
-              collection: "channels",
-              id: doc.id,
-              data: {
-                providerId: providerChannel.id,
-                subscriberCount: providerChannel.subscriberCount || 0
-              },
-              req
-            });
-            return {
-              ...doc,
-              providerId: providerChannel.id,
-              subscriberCount: providerChannel.subscriberCount || 0
-            };
-          } catch (error) {
-            req.payload.logger.error("Failed to create channel in provider:", error);
-            return doc;
-          }
-        }
-      ],
-      // Sync updates with provider
-      beforeChange: [
-        async ({ data, originalDoc, operation, req }) => {
-          if (!hasProviders || !originalDoc?.providerId || operation !== "update") return data;
-          try {
-            const provider = await getProvider(originalDoc.providerType, pluginConfig);
-            if (!provider) return data;
-            const updates = {};
-            if (data.name !== originalDoc.name) updates.name = data.name;
-            if (data.description !== originalDoc.description) updates.description = data.description;
-            if (data.fromName !== originalDoc.fromName) updates.fromName = data.fromName;
-            if (data.fromEmail !== originalDoc.fromEmail) updates.fromEmail = data.fromEmail;
-            if (data.replyTo !== originalDoc.replyTo) updates.replyTo = data.replyTo;
-            if (Object.keys(updates).length > 0) {
-              await provider.updateChannel(originalDoc.providerId, updates);
-            }
-          } catch (error) {
-            req.payload.logger.error("Failed to update channel in provider:", error);
-          }
-          return data;
-        }
-      ],
-      // Handle deletion
-      afterDelete: [
-        async ({ doc, req }) => {
-          if (!hasProviders || !doc?.providerId) return doc;
-          try {
-            const provider = await getProvider(doc.providerType, pluginConfig);
-            if (!provider) return doc;
-            await provider.deleteChannel(doc.providerId);
-          } catch (error) {
-            req.payload.logger.error("Failed to delete channel from provider:", error);
-          }
-          return doc;
-        }
-      ]
-    }
-  };
-};
-async function getProvider(providerType, config) {
-  if (providerType === "broadcast") {
-    const { BroadcastApiProvider: BroadcastApiProvider2 } = await Promise.resolve().then(() => (init_broadcast2(), broadcast_exports));
-    const providerConfig = config.providers?.broadcast;
-    return providerConfig ? new BroadcastApiProvider2(providerConfig) : null;
-  }
-  if (providerType === "resend") {
-    const { ResendBroadcastProvider: ResendBroadcastProvider2 } = await Promise.resolve().then(() => (init_broadcast3(), broadcast_exports2));
-    const providerConfig = config.providers?.resend;
-    return providerConfig ? new ResendBroadcastProvider2(providerConfig) : null;
-  }
-  return null;
-}
-
 // src/collections/Broadcasts.ts
 init_types();
 
@@ -4317,18 +3583,9 @@ var createBroadcastsCollection = (pluginConfig) => {
     admin: {
       useAsTitle: "name",
       description: "Individual email campaigns sent to subscribers",
-      defaultColumns: ["name", "subject", "status", "channel", "sentAt", "actions"]
+      defaultColumns: ["name", "subject", "status", "sentAt", "actions"]
     },
     fields: [
-      {
-        name: "channel",
-        type: "relationship",
-        relationTo: "channels",
-        required: true,
-        admin: {
-          description: "The channel this broadcast belongs to"
-        }
-      },
       {
         name: "name",
         type: "text",
@@ -4540,23 +3797,22 @@ var createBroadcastsCollection = (pluginConfig) => {
         async ({ doc, operation, req }) => {
           if (!hasProviders || operation !== "create") return doc;
           try {
-            const channel = await req.payload.findByID({
-              collection: "channels",
-              id: typeof doc.channel === "string" ? doc.channel : doc.channel.id,
-              req
-            });
-            const provider = await getProvider2(channel.providerType, pluginConfig);
-            if (!provider) return doc;
+            const providerConfig = pluginConfig.providers?.broadcast;
+            if (!providerConfig) {
+              req.payload.logger.error("Broadcast provider not configured");
+              return doc;
+            }
+            const { BroadcastApiProvider: BroadcastApiProvider2 } = await Promise.resolve().then(() => (init_broadcast2(), broadcast_exports));
+            const provider = new BroadcastApiProvider2(providerConfig);
             const htmlContent = await convertToEmailSafeHtml(doc.content);
             const providerBroadcast = await provider.create({
-              channelId: channel.providerId || channel.id,
               name: doc.name,
               subject: doc.subject,
               preheader: doc.preheader,
               content: htmlContent,
               trackOpens: doc.settings?.trackOpens,
               trackClicks: doc.settings?.trackClicks,
-              replyTo: doc.settings?.replyTo,
+              replyTo: doc.settings?.replyTo || providerConfig.replyTo,
               audienceIds: doc.audienceIds?.map((a) => a.audienceId)
             });
             await req.payload.update({
@@ -4584,14 +3840,13 @@ var createBroadcastsCollection = (pluginConfig) => {
         async ({ data, originalDoc, operation, req }) => {
           if (!hasProviders || !originalDoc?.providerId || operation !== "update") return data;
           try {
-            const channelId = data.channel || originalDoc.channel;
-            const channel = await req.payload.findByID({
-              collection: "channels",
-              id: typeof channelId === "string" ? channelId : channelId.id,
-              req
-            });
-            const provider = await getProvider2(channel.providerType, pluginConfig);
-            if (!provider) return data;
+            const providerConfig = pluginConfig.providers?.broadcast;
+            if (!providerConfig) {
+              req.payload.logger.error("Broadcast provider not configured");
+              return data;
+            }
+            const { BroadcastApiProvider: BroadcastApiProvider2 } = await Promise.resolve().then(() => (init_broadcast2(), broadcast_exports));
+            const provider = new BroadcastApiProvider2(providerConfig);
             const capabilities = provider.getCapabilities();
             if (!capabilities.editableStatuses.includes(originalDoc.status)) {
               return data;
@@ -4610,7 +3865,7 @@ var createBroadcastsCollection = (pluginConfig) => {
               updates.trackClicks = data.settings.trackClicks;
             }
             if (data.settings?.replyTo !== originalDoc.settings?.replyTo) {
-              updates.replyTo = data.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);
@@ -4629,13 +3884,13 @@ var createBroadcastsCollection = (pluginConfig) => {
         async ({ doc, req }) => {
           if (!hasProviders || !doc?.providerId) return doc;
           try {
-            const channel = await req.payload.findByID({
-              collection: "channels",
-              id: typeof doc.channel === "string" ? doc.channel : doc.channel.id,
-              req
-            });
-            const provider = await getProvider2(channel.providerType, pluginConfig);
-            if (!provider) return doc;
+            const providerConfig = pluginConfig.providers?.broadcast;
+            if (!providerConfig) {
+              req.payload.logger.error("Broadcast provider not configured");
+              return doc;
+            }
+            const { BroadcastApiProvider: BroadcastApiProvider2 } = await Promise.resolve().then(() => (init_broadcast2(), broadcast_exports));
+            const provider = new BroadcastApiProvider2(providerConfig);
             const capabilities = provider.getCapabilities();
             if (capabilities.editableStatuses.includes(doc.status)) {
               await provider.delete(doc.providerId);
@@ -4649,23 +3904,223 @@ var createBroadcastsCollection = (pluginConfig) => {
     }
   };
 };
-async function getProvider2(providerType, config) {
-  if (providerType === "broadcast") {
-    const { BroadcastApiProvider: BroadcastApiProvider2 } = await Promise.resolve().then(() => (init_broadcast2(), broadcast_exports));
-    const providerConfig = config.providers?.broadcast;
-    return providerConfig ? new BroadcastApiProvider2(providerConfig) : null;
-  }
-  if (providerType === "resend") {
-    const { ResendBroadcastProvider: ResendBroadcastProvider2 } = await Promise.resolve().then(() => (init_broadcast3(), broadcast_exports2));
-    const providerConfig = config.providers?.resend;
-    return providerConfig ? new ResendBroadcastProvider2(providerConfig) : null;
-  }
-  return null;
-}
 
 // src/index.ts
 init_broadcast2();
-init_broadcast3();
+
+// src/providers/resend/broadcast.ts
+var import_resend3 = require("resend");
+init_types();
+var ResendBroadcastProvider = class extends BaseBroadcastProvider {
+  constructor(config) {
+    super(config);
+    this.name = "resend";
+    this.client = new import_resend3.Resend(config.apiKey);
+    this.audienceIds = config.audienceIds || {};
+    this.isDevelopment = process.env.NODE_ENV !== "production";
+    if (!config.apiKey) {
+      throw new BroadcastProviderError(
+        "Resend API key is required",
+        "CONFIGURATION_ERROR" /* CONFIGURATION_ERROR */,
+        this.name
+      );
+    }
+  }
+  // Broadcast Management Methods
+  async list(_options) {
+    throw new BroadcastProviderError(
+      "Listing broadcasts is not currently supported by Resend API. This feature may be available in the dashboard only.",
+      "NOT_SUPPORTED" /* NOT_SUPPORTED */,
+      this.name
+    );
+  }
+  async get(_id) {
+    throw new BroadcastProviderError(
+      "Getting individual broadcasts is not currently supported by Resend API. This feature may be available in the dashboard only.",
+      "NOT_SUPPORTED" /* NOT_SUPPORTED */,
+      this.name
+    );
+  }
+  async create(data) {
+    try {
+      this.validateRequiredFields(data, ["name", "subject", "content"]);
+      const locale = "en";
+      const audienceConfig = this.audienceIds?.[locale];
+      const audienceId = this.isDevelopment ? audienceConfig?.development || audienceConfig?.production : audienceConfig?.production || audienceConfig?.development;
+      if (!audienceId && data.audienceIds?.length) {
+      }
+      const resendClient = this.client;
+      if (resendClient.broadcasts?.create) {
+        const broadcast = await resendClient.broadcasts.create({
+          name: data.name,
+          subject: data.subject,
+          from: `${this.config.fromName || "Newsletter"} <${this.config.fromEmail || "noreply@example.com"}>`,
+          reply_to: data.replyTo,
+          audience_id: audienceId || data.audienceIds?.[0],
+          content: {
+            html: data.content
+            // TODO: Handle plain text version
+          }
+        });
+        return this.transformResendToBroadcast(broadcast);
+      }
+      throw new BroadcastProviderError(
+        "Creating broadcasts via API is not currently supported. Please check if Resend has released their Broadcasts API.",
+        "NOT_SUPPORTED" /* NOT_SUPPORTED */,
+        this.name
+      );
+    } catch (error) {
+      if (error instanceof BroadcastProviderError) throw error;
+      throw new BroadcastProviderError(
+        `Failed to create broadcast: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "PROVIDER_ERROR" /* PROVIDER_ERROR */,
+        this.name,
+        error
+      );
+    }
+  }
+  async update(_id, _data) {
+    throw new BroadcastProviderError(
+      "Updating broadcasts is not currently supported by Resend API. Note: Resend broadcasts can only be edited where they were created.",
+      "NOT_SUPPORTED" /* NOT_SUPPORTED */,
+      this.name
+    );
+  }
+  async delete(_id) {
+    throw new BroadcastProviderError(
+      "Deleting broadcasts is not currently supported by Resend API.",
+      "NOT_SUPPORTED" /* NOT_SUPPORTED */,
+      this.name
+    );
+  }
+  async send(id, options) {
+    try {
+      const resendClient = this.client;
+      if (resendClient.broadcasts?.send) {
+        await resendClient.broadcasts.send(id, {
+          audience_id: options?.audienceIds?.[0]
+          // TODO: Handle test mode if supported
+        });
+        return {
+          id,
+          name: "Unknown",
+          subject: "Unknown",
+          content: "",
+          status: "sending" /* SENDING */,
+          trackOpens: true,
+          trackClicks: true,
+          createdAt: /* @__PURE__ */ new Date(),
+          updatedAt: /* @__PURE__ */ new Date(),
+          providerType: "resend"
+        };
+      }
+      throw new BroadcastProviderError(
+        "Sending broadcasts via API is not currently supported. Please check if Resend has released their Broadcasts API.",
+        "NOT_SUPPORTED" /* NOT_SUPPORTED */,
+        this.name
+      );
+    } catch (error) {
+      if (error instanceof BroadcastProviderError) throw error;
+      throw new BroadcastProviderError(
+        `Failed to send broadcast: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "PROVIDER_ERROR" /* PROVIDER_ERROR */,
+        this.name,
+        error
+      );
+    }
+  }
+  async schedule(_id, _scheduledAt) {
+    throw new BroadcastProviderError(
+      "Scheduling broadcasts is not supported by Resend",
+      "NOT_SUPPORTED" /* NOT_SUPPORTED */,
+      this.name
+    );
+  }
+  async getAnalytics(_id) {
+    throw new BroadcastProviderError(
+      "Getting broadcast analytics via API is not currently supported. Analytics may be available in the Resend dashboard.",
+      "NOT_SUPPORTED" /* NOT_SUPPORTED */,
+      this.name
+    );
+  }
+  getCapabilities() {
+    return {
+      supportsScheduling: false,
+      // Not documented
+      supportsSegmentation: true,
+      // Via Audiences
+      supportsAnalytics: true,
+      // Available in dashboard, API unclear
+      supportsABTesting: false,
+      supportsTemplates: false,
+      // Not clear from docs
+      supportsPersonalization: true,
+      // Via merge tags
+      supportsMultipleChannels: false,
+      supportsChannelSegmentation: false,
+      editableStatuses: [],
+      // Unclear which statuses can be edited
+      supportedContentTypes: ["html"]
+      // React components via SDK
+    };
+  }
+  async validateConfiguration() {
+    try {
+      const resendClient = this.client;
+      if (resendClient.audiences?.list) {
+        await resendClient.audiences.list({ limit: 1 });
+        return true;
+      }
+      await this.client.emails.send({
+        from: "onboarding@resend.dev",
+        to: "delivered@resend.dev",
+        subject: "Configuration Test",
+        html: "<p>Testing configuration</p>"
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Transform Resend broadcast to our Broadcast type
+   * NOTE: This is speculative based on what the API might return
+   */
+  transformResendToBroadcast(broadcast) {
+    return {
+      id: broadcast.id,
+      name: broadcast.name || "Untitled",
+      subject: broadcast.subject,
+      preheader: broadcast.preheader,
+      content: broadcast.content?.html || broadcast.html || "",
+      status: this.mapResendStatus(broadcast.status),
+      trackOpens: true,
+      // Resend tracks by default
+      trackClicks: true,
+      // Resend tracks by default
+      replyTo: broadcast.reply_to,
+      recipientCount: broadcast.recipient_count,
+      sentAt: broadcast.sent_at ? new Date(broadcast.sent_at) : void 0,
+      scheduledAt: broadcast.scheduled_at ? new Date(broadcast.scheduled_at) : void 0,
+      createdAt: new Date(broadcast.created_at || Date.now()),
+      updatedAt: new Date(broadcast.updated_at || Date.now()),
+      providerData: { broadcast },
+      providerId: broadcast.id,
+      providerType: "resend"
+    };
+  }
+  mapResendStatus(status) {
+    if (!status) return "draft" /* DRAFT */;
+    const statusMap = {
+      "draft": "draft" /* DRAFT */,
+      "scheduled": "scheduled" /* SCHEDULED */,
+      "sending": "sending" /* SENDING */,
+      "sent": "sent" /* SENT */,
+      "failed": "failed" /* FAILED */
+    };
+    return statusMap[status.toLowerCase()] || "draft" /* DRAFT */;
+  }
+};
 
 // src/utilities/session.ts
 var import_jsonwebtoken2 = __toESM(require("jsonwebtoken"), 1);
@@ -4765,9 +4220,8 @@ var newsletterPlugin = (pluginConfig) => (incomingConfig) => {
   const settingsGlobal = createNewsletterSettingsGlobal(config);
   let collections = [...incomingConfig.collections || [], subscribersCollection];
   if (config.features?.newsletterManagement?.enabled) {
-    const channelsCollection = createChannelsCollection(config);
     const broadcastsCollection = createBroadcastsCollection(config);
-    collections.push(channelsCollection, broadcastsCollection);
+    collections.push(broadcastsCollection);
   }
   if (config.features?.newsletterScheduling?.enabled) {
     const targetCollections = config.features.newsletterScheduling.collections || "articles";
@@ -4848,10 +4302,10 @@ var newsletterPlugin = (pluginConfig) => (incomingConfig) => {
             } : config.providers.resend,
             broadcast: settings.provider === "broadcast" ? {
               apiUrl: settings.broadcastSettings?.apiUrl || config.providers.broadcast?.apiUrl || "",
-              tokens: {
-                production: settings.broadcastSettings?.productionToken || config.providers.broadcast?.tokens.production,
-                development: settings.broadcastSettings?.developmentToken || config.providers.broadcast?.tokens.development
-              }
+              token: settings.broadcastSettings?.token || config.providers.broadcast?.token || "",
+              fromAddress: settings.fromAddress || config.providers.broadcast?.fromAddress,
+              fromName: settings.fromName || config.providers.broadcast?.fromName,
+              replyTo: settings.replyTo || config.providers.broadcast?.replyTo
             } : config.providers.broadcast
           };
         } else {