payload-plugin-newsletter 0.20.0 → 0.20.2

package/dist/broadcast-VMCYSZRY.js

@@ -0,0 +1,6 @@
+import {
+  BroadcastApiProvider
+} from "./chunk-XVMYJQRQ.js";
+export {
+  BroadcastApiProvider
+};

package/dist/chunk-XVMYJQRQ.js

@@ -0,0 +1,490 @@
+// src/types/newsletter.ts
+var NewsletterProviderError = class extends Error {
+  constructor(message, code, provider, details) {
+    super(message);
+    this.code = code;
+    this.provider = provider;
+    this.details = details;
+    this.name = "NewsletterProviderError";
+  }
+};
+
+// src/types/broadcast.ts
+var BroadcastProviderError = class extends Error {
+  constructor(message, code, provider, details) {
+    super(message);
+    this.code = code;
+    this.provider = provider;
+    this.details = details;
+    this.name = "BroadcastProviderError";
+  }
+};
+
+// src/types/providers.ts
+var BaseBroadcastProvider = class {
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Schedule a broadcast - default implementation throws not supported
+   */
+  async schedule(_id, _scheduledAt) {
+    const capabilities = this.getCapabilities();
+    if (!capabilities.supportsScheduling) {
+      throw new BroadcastProviderError(
+        "Scheduling is not supported by this provider",
+        "NOT_SUPPORTED" /* NOT_SUPPORTED */,
+        this.name
+      );
+    }
+    throw new Error("Method not implemented");
+  }
+  /**
+   * Cancel scheduled broadcast - default implementation throws not supported
+   */
+  async cancelSchedule(_id) {
+    const capabilities = this.getCapabilities();
+    if (!capabilities.supportsScheduling) {
+      throw new BroadcastProviderError(
+        "Scheduling is not supported by this provider",
+        "NOT_SUPPORTED" /* NOT_SUPPORTED */,
+        this.name
+      );
+    }
+    throw new Error("Method not implemented");
+  }
+  /**
+   * Get analytics - default implementation returns zeros
+   */
+  async getAnalytics(_id) {
+    const capabilities = this.getCapabilities();
+    if (!capabilities.supportsAnalytics) {
+      throw new BroadcastProviderError(
+        "Analytics are not supported by this provider",
+        "NOT_SUPPORTED" /* NOT_SUPPORTED */,
+        this.name
+      );
+    }
+    return {
+      sent: 0,
+      delivered: 0,
+      opened: 0,
+      clicked: 0,
+      bounced: 0,
+      complained: 0,
+      unsubscribed: 0
+    };
+  }
+  /**
+   * Helper method to validate required fields
+   */
+  validateRequiredFields(data, fields) {
+    const missing = fields.filter((field) => !data[field]);
+    if (missing.length > 0) {
+      throw new BroadcastProviderError(
+        `Missing required fields: ${missing.join(", ")}`,
+        "VALIDATION_ERROR" /* VALIDATION_ERROR */,
+        this.name
+      );
+    }
+  }
+  /**
+   * Helper method to check if a status transition is allowed
+   */
+  canEditInStatus(status) {
+    const capabilities = this.getCapabilities();
+    return capabilities.editableStatuses.includes(status);
+  }
+  /**
+   * Helper to build pagination response
+   */
+  buildListResponse(items, total, options = {}) {
+    const limit = options.limit || 20;
+    const offset = options.offset || 0;
+    return {
+      items,
+      total,
+      limit,
+      offset,
+      hasMore: offset + items.length < total
+    };
+  }
+};
+
+// src/providers/broadcast/broadcast.ts
+var BroadcastApiProvider = class extends BaseBroadcastProvider {
+  constructor(config) {
+    super(config);
+    this.name = "broadcast";
+    this.apiUrl = config.apiUrl.replace(/\/$/, "");
+    this.token = config.token;
+    if (!this.token) {
+      throw new BroadcastProviderError(
+        "Broadcast API token is required",
+        "CONFIGURATION_ERROR" /* CONFIGURATION_ERROR */,
+        this.name
+      );
+    }
+  }
+  // Broadcast Management Methods
+  async list(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/broadcasts?${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 broadcasts = data.data.map((broadcast) => this.transformBroadcastFromApi(broadcast));
+      return this.buildListResponse(broadcasts, data.total, options);
+    } catch (error) {
+      throw new BroadcastProviderError(
+        `Failed to list broadcasts: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "PROVIDER_ERROR" /* PROVIDER_ERROR */,
+        this.name,
+        error
+      );
+    }
+  }
+  async get(id) {
+    try {
+      const response = await fetch(`${this.apiUrl}/api/v1/broadcasts/${id}`, {
+        method: "GET",
+        headers: {
+          "Authorization": `Bearer ${this.token}`,
+          "Content-Type": "application/json"
+        }
+      });
+      if (!response.ok) {
+        if (response.status === 404) {
+          throw new BroadcastProviderError(
+            `Broadcast not found: ${id}`,
+            "NOT_FOUND" /* NOT_FOUND */,
+            this.name
+          );
+        }
+        const error = await response.text();
+        throw new Error(`Broadcast API error: ${response.status} - ${error}`);
+      }
+      const broadcast = await response.json();
+      return this.transformBroadcastFromApi(broadcast);
+    } catch (error) {
+      if (error instanceof BroadcastProviderError) throw error;
+      throw new BroadcastProviderError(
+        `Failed to get broadcast: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "PROVIDER_ERROR" /* PROVIDER_ERROR */,
+        this.name,
+        error
+      );
+    }
+  }
+  async create(data) {
+    try {
+      this.validateRequiredFields(data, ["name", "subject", "content"]);
+      const requestBody = {
+        broadcast: {
+          name: data.name,
+          subject: data.subject,
+          preheader: data.preheader,
+          body: data.content,
+          html_body: true,
+          track_opens: data.trackOpens ?? true,
+          track_clicks: data.trackClicks ?? true,
+          reply_to: data.replyTo,
+          segment_ids: data.audienceIds
+        }
+      };
+      console.log("[BroadcastApiProvider] Creating broadcast:", {
+        url: `${this.apiUrl}/api/v1/broadcasts`,
+        method: "POST",
+        hasToken: !!this.token,
+        tokenLength: this.token?.length,
+        body: JSON.stringify(requestBody, null, 2)
+      });
+      const response = await fetch(`${this.apiUrl}/api/v1/broadcasts`, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${this.token}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(requestBody)
+      });
+      console.log("[BroadcastApiProvider] Response status:", response.status);
+      console.log("[BroadcastApiProvider] Response headers:", Object.fromEntries(response.headers.entries()));
+      if (!response.ok) {
+        const errorText = await response.text();
+        console.error("[BroadcastApiProvider] Error response body:", errorText);
+        let errorDetails;
+        try {
+          errorDetails = JSON.parse(errorText);
+          console.error("[BroadcastApiProvider] Parsed error:", errorDetails);
+        } catch {
+        }
+        throw new Error(`Broadcast API error: ${response.status} - ${errorText}`);
+      }
+      const result = await response.json();
+      return this.get(result.id.toString());
+    } 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) {
+    try {
+      const existing = await this.get(id);
+      if (!this.canEditInStatus(existing.sendStatus)) {
+        throw new BroadcastProviderError(
+          `Cannot update broadcast in status: ${existing.sendStatus}`,
+          "INVALID_STATUS" /* INVALID_STATUS */,
+          this.name
+        );
+      }
+      const response = await fetch(`${this.apiUrl}/api/v1/broadcasts/${id}`, {
+        method: "PATCH",
+        headers: {
+          "Authorization": `Bearer ${this.token}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          broadcast: {
+            name: data.name,
+            subject: data.subject,
+            preheader: data.preheader,
+            body: data.content,
+            track_opens: data.trackOpens,
+            track_clicks: data.trackClicks,
+            reply_to: data.replyTo,
+            segment_ids: data.audienceIds
+          }
+        })
+      });
+      if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Broadcast API error: ${response.status} - ${error}`);
+      }
+      const broadcast = await response.json();
+      return this.transformBroadcastFromApi(broadcast);
+    } catch (error) {
+      if (error instanceof BroadcastProviderError) throw error;
+      throw new BroadcastProviderError(
+        `Failed to update broadcast: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "PROVIDER_ERROR" /* PROVIDER_ERROR */,
+        this.name,
+        error
+      );
+    }
+  }
+  async delete(id) {
+    try {
+      const existing = await this.get(id);
+      if (!this.canEditInStatus(existing.sendStatus)) {
+        throw new BroadcastProviderError(
+          `Cannot delete broadcast in status: ${existing.sendStatus}`,
+          "INVALID_STATUS" /* INVALID_STATUS */,
+          this.name
+        );
+      }
+      const response = await fetch(`${this.apiUrl}/api/v1/broadcasts/${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) {
+      if (error instanceof BroadcastProviderError) throw error;
+      throw new BroadcastProviderError(
+        `Failed to delete broadcast: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "PROVIDER_ERROR" /* PROVIDER_ERROR */,
+        this.name,
+        error
+      );
+    }
+  }
+  async send(id, options) {
+    try {
+      if (options?.testMode && options.testRecipients?.length) {
+        throw new BroadcastProviderError(
+          "Test send is not yet implemented for Broadcast provider",
+          "NOT_SUPPORTED" /* NOT_SUPPORTED */,
+          this.name
+        );
+      }
+      const response = await fetch(`${this.apiUrl}/api/v1/broadcasts/${id}/send_broadcast`, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${this.token}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          segment_ids: options?.audienceIds
+        })
+      });
+      if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Broadcast API error: ${response.status} - ${error}`);
+      }
+      const result = await response.json();
+      return this.get(result.id.toString());
+    } 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) {
+    try {
+      const response = await fetch(`${this.apiUrl}/api/v1/broadcasts/${id}`, {
+        method: "PATCH",
+        headers: {
+          "Authorization": `Bearer ${this.token}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          broadcast: {
+            scheduled_send_at: scheduledAt.toISOString(),
+            // TODO: Handle timezone properly
+            scheduled_timezone: Intl.DateTimeFormat().resolvedOptions().timeZone
+          }
+        })
+      });
+      if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Broadcast API error: ${response.status} - ${error}`);
+      }
+      const broadcast = await response.json();
+      return this.transformBroadcastFromApi(broadcast);
+    } catch (error) {
+      throw new BroadcastProviderError(
+        `Failed to schedule broadcast: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "PROVIDER_ERROR" /* PROVIDER_ERROR */,
+        this.name,
+        error
+      );
+    }
+  }
+  async cancelSchedule(id) {
+    try {
+      const response = await fetch(`${this.apiUrl}/api/v1/broadcasts/${id}`, {
+        method: "PATCH",
+        headers: {
+          "Authorization": `Bearer ${this.token}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          broadcast: {
+            scheduled_send_at: null,
+            scheduled_timezone: null
+          }
+        })
+      });
+      if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Broadcast API error: ${response.status} - ${error}`);
+      }
+      const broadcast = await response.json();
+      return this.transformBroadcastFromApi(broadcast);
+    } catch (error) {
+      throw new BroadcastProviderError(
+        `Failed to cancel scheduled broadcast: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "PROVIDER_ERROR" /* PROVIDER_ERROR */,
+        this.name,
+        error
+      );
+    }
+  }
+  async getAnalytics(_id) {
+    throw new BroadcastProviderError(
+      "Analytics API not yet implemented for Broadcast provider",
+      "NOT_SUPPORTED" /* NOT_SUPPORTED */,
+      this.name
+    );
+  }
+  getCapabilities() {
+    return {
+      supportsScheduling: true,
+      supportsSegmentation: true,
+      supportsAnalytics: false,
+      // Not documented yet
+      supportsABTesting: false,
+      supportsTemplates: false,
+      supportsPersonalization: true,
+      supportsMultipleChannels: false,
+      supportsChannelSegmentation: false,
+      editableStatuses: ["draft" /* DRAFT */, "scheduled" /* SCHEDULED */],
+      supportedContentTypes: ["html", "text"]
+    };
+  }
+  async validateConfiguration() {
+    try {
+      await this.list({ limit: 1 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  transformBroadcastFromApi(broadcast) {
+    return {
+      id: broadcast.id.toString(),
+      name: broadcast.name,
+      subject: broadcast.subject,
+      preheader: broadcast.preheader,
+      content: broadcast.body,
+      sendStatus: 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"
+    };
+  }
+  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 */;
+  }
+};
+
+export {
+  NewsletterProviderError,
+  BroadcastProviderError,
+  BaseBroadcastProvider,
+  BroadcastApiProvider
+};

package/dist/client.d.ts

@@ -1,12 +1,128 @@
-import React from 'react';
-import { SignupFormProps, PreferencesFormProps, Subscriber } from './types.js';
-import 'payload';
+import React$1 from 'react';
 
-declare const NewsletterForm: React.FC<SignupFormProps>;
-declare function createNewsletterForm(defaultProps: Partial<SignupFormProps>): React.FC<SignupFormProps>;
+interface Subscriber {
+    id: string;
+    email: string;
+    name?: string;
+    locale?: string;
+    subscriptionStatus: 'active' | 'unsubscribed' | 'pending';
+    emailPreferences?: {
+        newsletter?: boolean;
+        announcements?: boolean;
+        [key: string]: boolean | undefined;
+    };
+    source?: string;
+    utmParameters?: {
+        source?: string;
+        medium?: string;
+        campaign?: string;
+        content?: string;
+        term?: string;
+    };
+    signupMetadata?: {
+        ipAddress?: string;
+        userAgent?: string;
+        referrer?: string;
+        signupPage?: string;
+    };
+    leadMagnet?: string;
+    unsubscribedAt?: string;
+    magicLinkToken?: string;
+    magicLinkTokenExpiry?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface SignupFormProps {
+    onSuccess?: (subscriber: Subscriber) => void;
+    onError?: (error: Error) => void;
+    showName?: boolean;
+    showPreferences?: boolean;
+    leadMagnet?: {
+        id: string;
+        title: string;
+        description?: string;
+    };
+    className?: string;
+    styles?: {
+        form?: React.CSSProperties;
+        inputGroup?: React.CSSProperties;
+        label?: React.CSSProperties;
+        input?: React.CSSProperties;
+        button?: React.CSSProperties;
+        buttonDisabled?: React.CSSProperties;
+        error?: React.CSSProperties;
+        success?: React.CSSProperties;
+        checkbox?: React.CSSProperties;
+        checkboxInput?: React.CSSProperties;
+        checkboxLabel?: React.CSSProperties;
+    };
+    apiEndpoint?: string;
+    buttonText?: string;
+    loadingText?: string;
+    successMessage?: string;
+    placeholders?: {
+        email?: string;
+        name?: string;
+    };
+    labels?: {
+        email?: string;
+        name?: string;
+        newsletter?: string;
+        announcements?: string;
+    };
+}
+interface PreferencesFormProps {
+    subscriber?: Subscriber;
+    onSuccess?: (subscriber: Subscriber) => void;
+    onError?: (error: Error) => void;
+    className?: string;
+    styles?: {
+        container?: React.CSSProperties;
+        heading?: React.CSSProperties;
+        form?: React.CSSProperties;
+        section?: React.CSSProperties;
+        sectionTitle?: React.CSSProperties;
+        inputGroup?: React.CSSProperties;
+        label?: React.CSSProperties;
+        input?: React.CSSProperties;
+        select?: React.CSSProperties;
+        checkbox?: React.CSSProperties;
+        checkboxInput?: React.CSSProperties;
+        checkboxLabel?: React.CSSProperties;
+        buttonGroup?: React.CSSProperties;
+        button?: React.CSSProperties;
+        primaryButton?: React.CSSProperties;
+        secondaryButton?: React.CSSProperties;
+        dangerButton?: React.CSSProperties;
+        error?: React.CSSProperties;
+        success?: React.CSSProperties;
+        info?: React.CSSProperties;
+    };
+    sessionToken?: string;
+    apiEndpoint?: string;
+    showUnsubscribe?: boolean;
+    locales?: string[];
+    labels?: {
+        title?: string;
+        personalInfo?: string;
+        emailPreferences?: string;
+        name?: string;
+        language?: string;
+        newsletter?: string;
+        announcements?: string;
+        saveButton?: string;
+        unsubscribeButton?: string;
+        saving?: string;
+        saved?: string;
+        unsubscribeConfirm?: string;
+    };
+}
+
+declare const NewsletterForm: React$1.FC<SignupFormProps>;
+declare function createNewsletterForm(defaultProps: Partial<SignupFormProps>): React$1.FC<SignupFormProps>;
 
-declare const PreferencesForm: React.FC<PreferencesFormProps>;
-declare function createPreferencesForm(defaultProps: Partial<PreferencesFormProps>): React.FC<PreferencesFormProps>;
+declare const PreferencesForm: React$1.FC<PreferencesFormProps>;
+declare function createPreferencesForm(defaultProps: Partial<PreferencesFormProps>): React$1.FC<PreferencesFormProps>;
 
 interface MagicLinkVerifyProps {
     token?: string;
@@ -15,11 +131,11 @@ interface MagicLinkVerifyProps {
     apiEndpoint?: string;
     className?: string;
     styles?: {
-        container?: React.CSSProperties;
-        heading?: React.CSSProperties;
-        message?: React.CSSProperties;
-        error?: React.CSSProperties;
-        button?: React.CSSProperties;
+        container?: React$1.CSSProperties;
+        heading?: React$1.CSSProperties;
+        message?: React$1.CSSProperties;
+        error?: React$1.CSSProperties;
+        button?: React$1.CSSProperties;
     };
     labels?: {
         verifying?: string;
@@ -31,8 +147,8 @@ interface MagicLinkVerifyProps {
         tryAgain?: string;
     };
 }
-declare const MagicLinkVerify: React.FC<MagicLinkVerifyProps>;
-declare function createMagicLinkVerify(defaultProps: Partial<MagicLinkVerifyProps>): React.FC<MagicLinkVerifyProps>;
+declare const MagicLinkVerify: React$1.FC<MagicLinkVerifyProps>;
+declare function createMagicLinkVerify(defaultProps: Partial<MagicLinkVerifyProps>): React$1.FC<MagicLinkVerifyProps>;
 
 interface UseNewsletterAuthOptions {
 }
@@ -50,4 +166,4 @@ interface UseNewsletterAuthReturn {
 }
 declare function useNewsletterAuth(_options?: UseNewsletterAuthOptions): UseNewsletterAuthReturn;
 
-export { MagicLinkVerify, type MagicLinkVerifyProps, NewsletterForm, PreferencesForm, PreferencesFormProps, SignupFormProps, Subscriber, type UseNewsletterAuthOptions, type UseNewsletterAuthReturn, createMagicLinkVerify, createNewsletterForm, createPreferencesForm, useNewsletterAuth };
+export { MagicLinkVerify, type MagicLinkVerifyProps, NewsletterForm, PreferencesForm, createMagicLinkVerify, createNewsletterForm, createPreferencesForm, useNewsletterAuth };

package/dist/client.js

@@ -1,4 +1,5 @@
 "use client";
+"use client";
 
 // src/components/NewsletterForm.tsx
 import { useState } from "react";
@@ -856,4 +857,3 @@ export {
   createPreferencesForm,
   useNewsletterAuth
 };
-//# sourceMappingURL=client.js.map