payload-plugin-newsletter 0.20.7 → 0.21.0

package/dist/server.js

@@ -369,6 +369,15 @@ var createSubscribersCollection = (pluginConfig) => {
       type: "date",
       hidden: true
     },
+    // External ID for webhook integration
+    {
+      name: "externalId",
+      type: "text",
+      admin: {
+        description: "ID from email service provider",
+        readOnly: true
+      }
+    },
     // Subscription status
     {
       name: "subscriptionStatus",
@@ -384,6 +393,14 @@ var createSubscribersCollection = (pluginConfig) => {
         description: "Current subscription status"
       }
     },
+    {
+      name: "subscribedAt",
+      type: "date",
+      admin: {
+        description: "When the user subscribed",
+        readOnly: true
+      }
+    },
     {
       name: "unsubscribedAt",
       type: "date",
@@ -393,6 +410,15 @@ var createSubscribersCollection = (pluginConfig) => {
         readOnly: true
       }
     },
+    {
+      name: "unsubscribeReason",
+      type: "text",
+      admin: {
+        condition: (data) => data?.subscriptionStatus === "unsubscribed",
+        description: "Reason for unsubscribing",
+        readOnly: true
+      }
+    },
     // Email preferences
     {
       name: "emailPreferences",
@@ -725,6 +751,75 @@ var createNewsletterSettingsGlobal = (pluginConfig) => {
                     admin: {
                       description: "Your Broadcast API token"
                     }
+                  },
+                  {
+                    type: "collapsible",
+                    label: "Webhook Configuration",
+                    fields: [
+                      {
+                        name: "webhookUrl",
+                        type: "text",
+                        label: "Webhook URL",
+                        admin: {
+                          readOnly: true,
+                          description: "Copy this URL to your Broadcast webhook settings",
+                          placeholder: "URL will be generated after save"
+                        },
+                        hooks: {
+                          beforeChange: [
+                            ({ req }) => {
+                              const host = req.headers.get("host") || "localhost:3000";
+                              const protocol = req.headers.get("x-forwarded-proto") || "http";
+                              const baseUrl = process.env.PAYLOAD_PUBLIC_SERVER_URL || `${protocol}://${host}`;
+                              return `${baseUrl}/api/newsletter/webhooks/broadcast`;
+                            }
+                          ]
+                        }
+                      },
+                      {
+                        name: "webhookConfiguration",
+                        type: "ui",
+                        admin: {
+                          components: {
+                            Field: "payload-plugin-newsletter/admin#WebhookConfiguration"
+                          }
+                        }
+                      },
+                      {
+                        name: "webhookSecret",
+                        type: "text",
+                        label: "Webhook Secret",
+                        admin: {
+                          description: "Paste the webhook secret from Broadcast here"
+                        }
+                      },
+                      {
+                        name: "webhookStatus",
+                        type: "select",
+                        label: "Status",
+                        options: [
+                          { label: "Not Configured", value: "not_configured" },
+                          { label: "Configured", value: "configured" },
+                          { label: "Verified", value: "verified" },
+                          { label: "Error", value: "error" }
+                        ],
+                        defaultValue: "not_configured",
+                        admin: {
+                          readOnly: true
+                        }
+                      },
+                      {
+                        name: "lastWebhookReceived",
+                        type: "date",
+                        label: "Last Event Received",
+                        admin: {
+                          readOnly: true,
+                          date: {
+                            displayFormat: "yyyy-MM-dd HH:mm:ss"
+                          }
+                        }
+                      }
+                    ]
                   }
                 ]
               },
@@ -2332,6 +2427,415 @@ var createBroadcastManagementEndpoints = (_config) => {
   return [];
 };
 
+// src/utils/webhooks/signature.ts
+import crypto from "crypto";
+function verifyBroadcastWebhookSignature(payload, signature, timestamp, secret) {
+  try {
+    const now = Math.floor(Date.now() / 1e3);
+    const webhookTimestamp = parseInt(timestamp, 10);
+    if (isNaN(webhookTimestamp)) {
+      console.error("[Webhook Signature] Invalid timestamp format");
+      return false;
+    }
+    if (Math.abs(now - webhookTimestamp) > 300) {
+      console.error("[Webhook Signature] Timestamp too old or in future");
+      return false;
+    }
+    const signatureParts = signature.split(",");
+    if (signatureParts.length !== 2 || signatureParts[0] !== "v1") {
+      console.error("[Webhook Signature] Invalid signature format");
+      return false;
+    }
+    const actualSignature = signatureParts[1];
+    const signedPayload = `${timestamp}.${payload}`;
+    const expectedSignature = crypto.createHmac("sha256", secret).update(signedPayload).digest("base64");
+    const actualBuffer = Buffer.from(actualSignature);
+    const expectedBuffer = Buffer.from(expectedSignature);
+    if (actualBuffer.length !== expectedBuffer.length) {
+      return false;
+    }
+    return crypto.timingSafeEqual(actualBuffer, expectedBuffer);
+  } catch (error) {
+    console.error("[Webhook Signature] Verification error:", error);
+    return false;
+  }
+}
+
+// src/types/webhooks.ts
+var WEBHOOK_EVENT_TYPES = {
+  // Subscriber events
+  SUBSCRIBER_SUBSCRIBED: "subscriber.subscribed",
+  SUBSCRIBER_UNSUBSCRIBED: "subscriber.unsubscribed",
+  // Broadcast events
+  BROADCAST_SCHEDULED: "broadcast.scheduled",
+  BROADCAST_QUEUEING: "broadcast.queueing",
+  BROADCAST_SENDING: "broadcast.sending",
+  BROADCAST_SENT: "broadcast.sent",
+  BROADCAST_FAILED: "broadcast.failed",
+  BROADCAST_PARTIAL_FAILURE: "broadcast.partial_failure",
+  BROADCAST_ABORTED: "broadcast.aborted",
+  BROADCAST_PAUSED: "broadcast.paused"
+};
+function isSubscriberEvent(event) {
+  return event.type.startsWith("subscriber.");
+}
+function isBroadcastEvent(event) {
+  return event.type.startsWith("broadcast.");
+}
+function isHandledEvent(event) {
+  return Object.values(WEBHOOK_EVENT_TYPES).includes(event.type);
+}
+
+// src/webhooks/handlers/subscriber.ts
+async function handleSubscriberEvent(event, req, config) {
+  const { payload } = req;
+  const subscribersSlug = config.subscribersSlug || "subscribers";
+  switch (event.type) {
+    case WEBHOOK_EVENT_TYPES.SUBSCRIBER_SUBSCRIBED:
+      await handleSubscriberSubscribed(event, payload, subscribersSlug);
+      break;
+    case WEBHOOK_EVENT_TYPES.SUBSCRIBER_UNSUBSCRIBED:
+      await handleSubscriberUnsubscribed(event, payload, subscribersSlug);
+      break;
+    default:
+      console.warn("[Subscriber Handler] Unhandled event type:", event.type);
+  }
+}
+async function handleSubscriberSubscribed(event, payload, subscribersSlug) {
+  const { data } = event;
+  try {
+    const existing = await payload.find({
+      collection: subscribersSlug,
+      where: {
+        email: {
+          equals: data.email
+        }
+      },
+      limit: 1
+    });
+    if (existing.docs.length > 0) {
+      const subscriber = existing.docs[0];
+      await payload.update({
+        collection: subscribersSlug,
+        id: subscriber.id,
+        data: {
+          subscriptionStatus: "active",
+          subscribedAt: data.subscribed_at,
+          // Store Broadcast ID for future reference
+          externalId: data.id,
+          // Update attributes if provided
+          ...data.attributes && { attributes: data.attributes }
+        }
+      });
+      console.log("[Subscriber Handler] Reactivated subscriber:", data.email);
+    } else {
+      await payload.create({
+        collection: subscribersSlug,
+        data: {
+          email: data.email,
+          name: data.name,
+          subscriptionStatus: "active",
+          subscribedAt: data.subscribed_at,
+          externalId: data.id,
+          attributes: data.attributes || {}
+        }
+      });
+      console.log("[Subscriber Handler] Created new subscriber:", data.email);
+    }
+  } catch (error) {
+    console.error("[Subscriber Handler] Error handling subscribed event:", error);
+    throw error;
+  }
+}
+async function handleSubscriberUnsubscribed(event, payload, subscribersSlug) {
+  const { data } = event;
+  try {
+    const existing = await payload.find({
+      collection: subscribersSlug,
+      where: {
+        email: {
+          equals: data.email
+        }
+      },
+      limit: 1
+    });
+    if (existing.docs.length > 0) {
+      const subscriber = existing.docs[0];
+      await payload.update({
+        collection: subscribersSlug,
+        id: subscriber.id,
+        data: {
+          subscriptionStatus: "unsubscribed",
+          unsubscribedAt: data.unsubscribed_at,
+          unsubscribeReason: data.reason
+        }
+      });
+      console.log("[Subscriber Handler] Unsubscribed:", data.email);
+    } else {
+      console.warn("[Subscriber Handler] Subscriber not found for unsubscribe:", data.email);
+    }
+  } catch (error) {
+    console.error("[Subscriber Handler] Error handling unsubscribed event:", error);
+    throw error;
+  }
+}
+
+// src/webhooks/handlers/broadcast.ts
+var STATUS_MAP = {
+  "broadcast.scheduled": "scheduled",
+  "broadcast.queueing": "sending",
+  "broadcast.sending": "sending",
+  "broadcast.sent": "sent",
+  "broadcast.failed": "failed",
+  "broadcast.partial_failure": "sent",
+  // With warning flag
+  "broadcast.aborted": "canceled",
+  "broadcast.paused": "paused"
+};
+async function handleBroadcastEvent(event, req, _config) {
+  const { payload } = req;
+  const broadcastsSlug = "broadcasts";
+  const status = STATUS_MAP[event.type];
+  if (!status) {
+    console.warn("[Broadcast Handler] Unknown event type:", event.type);
+    return;
+  }
+  try {
+    await updateBroadcastStatus(event, status, payload, broadcastsSlug);
+  } catch (error) {
+    console.error("[Broadcast Handler] Error handling event:", {
+      type: event.type,
+      error: error instanceof Error ? error.message : "Unknown error"
+    });
+    throw error;
+  }
+}
+async function updateBroadcastStatus(event, status, payload, broadcastsSlug) {
+  const { data } = event;
+  const broadcastId = data.broadcast_id;
+  if (!broadcastId) {
+    console.error("[Broadcast Handler] No broadcast_id in event data");
+    return;
+  }
+  try {
+    const existing = await payload.find({
+      collection: broadcastsSlug,
+      where: {
+        externalId: {
+          equals: broadcastId
+        }
+      },
+      limit: 1
+    });
+    if (existing.docs.length === 0) {
+      console.warn("[Broadcast Handler] Broadcast not found:", broadcastId);
+      return;
+    }
+    const broadcast = existing.docs[0];
+    const updateData = {
+      status,
+      lastWebhookEvent: event.type,
+      lastWebhookEventAt: event.occurred_at
+    };
+    switch (event.type) {
+      case WEBHOOK_EVENT_TYPES.BROADCAST_SCHEDULED:
+        updateData.scheduledAt = event.data.scheduled_for;
+        break;
+      case WEBHOOK_EVENT_TYPES.BROADCAST_SENDING: {
+        const sendingEvent = event;
+        updateData.sentCount = sendingEvent.data.sent_count;
+        updateData.totalCount = sendingEvent.data.total_count;
+        break;
+      }
+      case WEBHOOK_EVENT_TYPES.BROADCAST_SENT: {
+        const sentEvent = event;
+        updateData.sentCount = sentEvent.data.sent_count;
+        updateData.sentAt = sentEvent.data.completed_at;
+        updateData.sendingStartedAt = sentEvent.data.started_at;
+        break;
+      }
+      case WEBHOOK_EVENT_TYPES.BROADCAST_FAILED: {
+        const failedEvent = event;
+        updateData.failureReason = failedEvent.data.error;
+        updateData.failedAt = failedEvent.data.failed_at;
+        break;
+      }
+      case WEBHOOK_EVENT_TYPES.BROADCAST_PARTIAL_FAILURE: {
+        const partialFailureEvent = event;
+        updateData.sentCount = partialFailureEvent.data.sent_count;
+        updateData.failedCount = partialFailureEvent.data.failed_count;
+        updateData.totalCount = partialFailureEvent.data.total_count;
+        updateData.hasWarnings = true;
+        break;
+      }
+      case WEBHOOK_EVENT_TYPES.BROADCAST_ABORTED: {
+        const abortedEvent = event;
+        updateData.abortedAt = abortedEvent.data.aborted_at;
+        updateData.abortReason = abortedEvent.data.reason;
+        break;
+      }
+      case WEBHOOK_EVENT_TYPES.BROADCAST_PAUSED: {
+        const pausedEvent = event;
+        updateData.pausedAt = pausedEvent.data.paused_at;
+        updateData.sentCount = pausedEvent.data.sent_count;
+        updateData.remainingCount = pausedEvent.data.remaining_count;
+        break;
+      }
+    }
+    await payload.update({
+      collection: broadcastsSlug,
+      id: broadcast.id,
+      data: updateData
+    });
+    console.log("[Broadcast Handler] Updated broadcast status:", {
+      broadcastId,
+      status,
+      event: event.type
+    });
+  } catch (error) {
+    console.error("[Broadcast Handler] Error updating broadcast:", error);
+    throw error;
+  }
+}
+
+// src/webhooks/router.ts
+async function routeWebhookEvent(event, req, config) {
+  try {
+    if (!isHandledEvent(event)) {
+      console.log("[Webhook Router] Ignoring unhandled event type:", event.type);
+      return;
+    }
+    const handledEvent = event;
+    if (isSubscriberEvent(handledEvent)) {
+      await handleSubscriberEvent(handledEvent, req, config);
+    } else if (isBroadcastEvent(handledEvent)) {
+      await handleBroadcastEvent(handledEvent, req, config);
+    } else {
+      console.warn("[Webhook Router] Event type not routed:", event.type);
+    }
+  } catch (error) {
+    console.error("[Webhook Router] Error routing event:", {
+      type: event.type,
+      error: error instanceof Error ? error.message : "Unknown error"
+    });
+    throw error;
+  }
+}
+
+// src/endpoints/webhooks/broadcast.ts
+var createBroadcastWebhookEndpoint = (config) => {
+  return {
+    path: "/webhooks/broadcast",
+    method: "post",
+    handler: async (req) => {
+      try {
+        const settings = await req.payload.findGlobal({
+          slug: config.settingsSlug || "newsletter-settings"
+        });
+        const webhookSecret = settings?.broadcastSettings?.webhookSecret;
+        if (!webhookSecret) {
+          console.error("[Broadcast Webhook] No webhook secret configured");
+          return Response.json({ error: "Webhook not configured" }, { status: 401 });
+        }
+        const headers = req.headers;
+        const signature = headers.get("x-broadcast-signature");
+        const timestamp = headers.get("x-broadcast-timestamp");
+        if (!signature || !timestamp) {
+          console.error("[Broadcast Webhook] Missing signature or timestamp");
+          return Response.json({ error: "Invalid request" }, { status: 401 });
+        }
+        let rawBodyString;
+        let rawBody;
+        if (typeof req.json === "function") {
+          rawBody = await req.json();
+          rawBodyString = JSON.stringify(rawBody);
+        } else {
+          console.error("[Broadcast Webhook] Request does not support json() method");
+          return Response.json({ error: "Invalid request" }, { status: 400 });
+        }
+        const isValid = verifyBroadcastWebhookSignature(
+          rawBodyString,
+          signature,
+          timestamp,
+          webhookSecret
+        );
+        if (!isValid) {
+          console.error("[Broadcast Webhook] Invalid signature");
+          return Response.json({ error: "Invalid signature" }, { status: 401 });
+        }
+        const data = rawBody;
+        console.log("[Broadcast Webhook] Verified event:", {
+          type: data.type,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        await routeWebhookEvent(data, req, config);
+        await req.payload.updateGlobal({
+          slug: config.settingsSlug || "newsletter-settings",
+          data: {
+            broadcastSettings: {
+              ...settings?.broadcastSettings || {},
+              lastWebhookReceived: (/* @__PURE__ */ new Date()).toISOString(),
+              webhookStatus: "verified"
+            }
+          }
+        });
+        return Response.json({ success: true }, { status: 200 });
+      } catch (error) {
+        console.error("[Broadcast Webhook] Error processing webhook:", error);
+        return Response.json({ success: false }, { status: 200 });
+      }
+    }
+  };
+};
+
+// src/endpoints/webhooks/verify.ts
+var createWebhookVerifyEndpoint = (config) => {
+  return {
+    path: "/webhooks/verify",
+    method: "post",
+    handler: async (req) => {
+      try {
+        const settings = await req.payload.findGlobal({
+          slug: config.settingsSlug || "newsletter-settings"
+        });
+        if (!settings?.broadcastSettings?.webhookSecret) {
+          return Response.json({
+            success: false,
+            error: "Webhook secret not configured"
+          }, { status: 400 });
+        }
+        const apiUrl = settings.broadcastSettings.apiUrl;
+        const token = settings.broadcastSettings.token;
+        if (!apiUrl || !token) {
+          return Response.json({
+            success: false,
+            error: "Broadcast API not configured"
+          }, { status: 400 });
+        }
+        await req.payload.updateGlobal({
+          slug: config.settingsSlug || "newsletter-settings",
+          data: {
+            broadcastSettings: {
+              ...settings.broadcastSettings,
+              webhookStatus: "configured"
+            }
+          }
+        });
+        return Response.json({
+          success: true,
+          message: "Webhook configuration verified. Please configure the webhook in Broadcast."
+        });
+      } catch (error) {
+        console.error("[Webhook Verify] Error:", error);
+        return Response.json({
+          success: false,
+          error: "Failed to verify webhook configuration"
+        }, { status: 500 });
+      }
+    }
+  };
+};
+
 // src/endpoints/index.ts
 function createNewsletterEndpoints(config) {
   const endpoints = [
@@ -2349,6 +2853,12 @@ function createNewsletterEndpoints(config) {
     );
   }
   endpoints.push(...createBroadcastManagementEndpoints(config));
+  if (config.providers?.broadcast) {
+    endpoints.push(
+      createBroadcastWebhookEndpoint(config),
+      createWebhookVerifyEndpoint(config)
+    );
+  }
   return endpoints;
 }
 
@@ -2521,111 +3031,6 @@ function createMarkdownFieldInternal(config) {
   };
 }
 
-// src/jobs/sync-unsubscribes.ts
-var createUnsubscribeSyncJob = (pluginConfig) => {
-  return {
-    slug: "sync-unsubscribes",
-    label: "Sync Unsubscribes from Email Service",
-    handler: async ({ req }) => {
-      const subscribersSlug = pluginConfig.subscribersSlug || "subscribers";
-      const emailService = req.payload.newsletterEmailService;
-      if (!emailService) {
-        console.error("Email service not configured");
-        return {
-          output: {
-            syncedCount: 0
-          }
-        };
-      }
-      let syncedCount = 0;
-      try {
-        if (emailService.getProvider() === "broadcast") {
-          console.warn("Starting Broadcast unsubscribe sync...");
-          const broadcastConfig = pluginConfig.providers?.broadcast;
-          if (!broadcastConfig) {
-            throw new Error("Broadcast configuration not found");
-          }
-          const apiUrl = broadcastConfig.apiUrl.replace(/\/$/, "");
-          const token = broadcastConfig.token;
-          let page = 1;
-          let hasMore = true;
-          while (hasMore) {
-            const response = await fetch(
-              `${apiUrl}/api/v1/subscribers.json?page=${page}`,
-              {
-                headers: {
-                  "Authorization": `Bearer ${token}`
-                }
-              }
-            );
-            if (!response.ok) {
-              throw new Error(`Broadcast API error: ${response.status}`);
-            }
-            const data = await response.json();
-            const broadcastSubscribers = data.subscribers || [];
-            for (const broadcastSub of broadcastSubscribers) {
-              const payloadSubscribers = await req.payload.find({
-                collection: subscribersSlug,
-                where: {
-                  email: {
-                    equals: broadcastSub.email
-                  }
-                },
-                limit: 1
-              });
-              if (payloadSubscribers.docs.length > 0) {
-                const payloadSub = payloadSubscribers.docs[0];
-                const broadcastUnsubscribed = !broadcastSub.is_active || broadcastSub.unsubscribed_at;
-                const payloadUnsubscribed = payloadSub.subscriptionStatus === "unsubscribed";
-                if (broadcastUnsubscribed && !payloadUnsubscribed) {
-                  await req.payload.update({
-                    collection: subscribersSlug,
-                    id: payloadSub.id,
-                    data: {
-                      subscriptionStatus: "unsubscribed",
-                      unsubscribedAt: broadcastSub.unsubscribed_at || (/* @__PURE__ */ new Date()).toISOString()
-                    }
-                  });
-                  syncedCount++;
-                  console.warn(`Unsubscribed: ${broadcastSub.email}`);
-                }
-              }
-            }
-            if (data.pagination && data.pagination.current < data.pagination.total_pages) {
-              page++;
-            } else {
-              hasMore = false;
-            }
-          }
-          console.warn(`Broadcast sync complete. Unsubscribed ${syncedCount} contacts.`);
-        }
-        if (emailService.getProvider() === "resend") {
-          console.warn("Starting Resend unsubscribe sync...");
-          const resendConfig = pluginConfig.providers?.resend;
-          if (!resendConfig) {
-            throw new Error("Resend configuration not found");
-          }
-          console.warn("Resend polling implementation needed - webhooks recommended");
-        }
-        if (pluginConfig.hooks?.afterUnsubscribeSync) {
-          await pluginConfig.hooks.afterUnsubscribeSync({
-            req,
-            syncedCount
-          });
-        }
-      } catch (error) {
-        console.error("Unsubscribe sync error:", error);
-        throw error;
-      }
-      return {
-        output: {
-          syncedCount
-        }
-      };
-    }
-  };
-};
-
 // src/fields/emailContent.ts
 import {
   BoldFeature,
@@ -4165,6 +4570,14 @@ var createBroadcastsCollection = (pluginConfig) => {
           condition: (data) => hasProviders && data?.providerId
         }
       },
+      {
+        name: "externalId",
+        type: "text",
+        admin: {
+          readOnly: true,
+          description: "External ID for webhook integration"
+        }
+      },
       {
         name: "providerData",
         type: "json",
@@ -4173,6 +4586,77 @@ var createBroadcastsCollection = (pluginConfig) => {
           condition: () => false
           // Hidden by default
         }
+      },
+      // Webhook tracking fields
+      {
+        name: "webhookData",
+        type: "group",
+        label: "Webhook Data",
+        admin: {
+          condition: () => false
+          // Hidden by default, used for webhook tracking
+        },
+        fields: [
+          {
+            name: "lastWebhookEvent",
+            type: "text",
+            admin: {
+              readOnly: true
+            }
+          },
+          {
+            name: "lastWebhookEventAt",
+            type: "date",
+            admin: {
+              readOnly: true
+            }
+          },
+          {
+            name: "hasWarnings",
+            type: "checkbox",
+            defaultValue: false
+          },
+          {
+            name: "failureReason",
+            type: "text"
+          },
+          {
+            name: "sentCount",
+            type: "number"
+          },
+          {
+            name: "totalCount",
+            type: "number"
+          },
+          {
+            name: "failedCount",
+            type: "number"
+          },
+          {
+            name: "remainingCount",
+            type: "number"
+          },
+          {
+            name: "sendingStartedAt",
+            type: "date"
+          },
+          {
+            name: "failedAt",
+            type: "date"
+          },
+          {
+            name: "abortedAt",
+            type: "date"
+          },
+          {
+            name: "abortReason",
+            type: "text"
+          },
+          {
+            name: "pausedAt",
+            type: "date"
+          }
+        ]
       }
     ],
     hooks: {
@@ -4796,7 +5280,6 @@ var newsletterPlugin = (pluginConfig) => (incomingConfig) => {
     });
   }
   const endpoints = createNewsletterEndpoints(config);
-  const syncJob = config.features?.unsubscribeSync?.enabled ? createUnsubscribeSyncJob(config) : null;
   const modifiedConfig = {
     ...incomingConfig,
     collections,
@@ -4808,31 +5291,7 @@ var newsletterPlugin = (pluginConfig) => (incomingConfig) => {
       ...incomingConfig.endpoints || [],
       ...endpoints
     ],
-    jobs: syncJob ? {
-      ...incomingConfig.jobs || {},
-      tasks: [
-        ...incomingConfig.jobs?.tasks || [],
-        syncJob
-      ],
-      // Add cron schedule if specified
-      autoRun: config.features?.unsubscribeSync?.schedule ? Array.isArray(incomingConfig.jobs?.autoRun) ? [...incomingConfig.jobs.autoRun, {
-        cron: config.features.unsubscribeSync.schedule,
-        queue: "newsletter-sync",
-        limit: 100
-      }] : typeof incomingConfig.jobs?.autoRun === "function" ? async (payload) => {
-        const autoRunFn = incomingConfig.jobs.autoRun;
-        const existingConfigs = await autoRunFn(payload);
-        return [...existingConfigs, {
-          cron: config.features.unsubscribeSync.schedule,
-          queue: "newsletter-sync",
-          limit: 100
-        }];
-      } : [{
-        cron: config.features.unsubscribeSync.schedule,
-        queue: "newsletter-sync",
-        limit: 100
-      }] : incomingConfig.jobs?.autoRun
-    } : incomingConfig.jobs,
+    jobs: incomingConfig.jobs,
     onInit: async (payload) => {
       try {
         const settings = await payload.findGlobal({