@btst/stack 5.0.0 → 5.2.0

package/dist/packages/stack/src/plugins/newsletter/api/operations.cjs

@@ -0,0 +1,722 @@
+'use strict';
+
+const api = require('@btst/stack/plugins/api');
+const z = require('zod');
+const plugins_newsletter_permissions = require('../../../../../../plugins/newsletter/permissions.cjs');
+const schemas = require('../schemas.cjs');
+const csv = require('./csv.cjs');
+const email = require('./email.cjs');
+const getters = require('./getters.cjs');
+const mutations = require('./mutations.cjs');
+const serializers = require('./serializers.cjs');
+
+const empty = z.z.object({});
+const subscriberUpdateInput = schemas.idSchema.extend({ data: schemas.updateSubscriberSchema });
+const campaignUpdateInput = schemas.idSchema.extend({ data: schemas.updateCampaignSchema });
+const scheduleInput = schemas.idSchema.extend(schemas.scheduleCampaignSchema.shape);
+const testInput = schemas.idSchema.extend(schemas.testCampaignSchema.shape);
+const clickInput = schemas.tokenSchema.extend({
+  link: z.z.coerce.number().int().min(0).max(1e4)
+});
+const genericSubscriptionResult = {
+  success: true,
+  message: "If confirmation is required, check your email to finish subscribing."
+};
+function fail(status, message, code = "NEWSLETTER_ERROR") {
+  throw new api.OperationHttpError(status, message, code);
+}
+async function requireSubscriber(adapter, id) {
+  return await getters.getSubscriberRecord(adapter, id) ?? fail(404, "Subscriber not found");
+}
+async function requireCampaign(adapter, id) {
+  return await getters.getCampaignRecord(adapter, id) ?? fail(404, "Campaign not found");
+}
+async function subscriberFacts(adapter, id) {
+  const row = await requireSubscriber(adapter, id);
+  return { subscriberId: row.id, status: row.status };
+}
+async function campaignFacts(adapter, id) {
+  const row = await requireCampaign(adapter, id);
+  return { campaignId: row.id, status: row.status };
+}
+async function findReceipt(adapter, field, token) {
+  return await adapter.findOne({
+    model: "newsletterSend",
+    where: [{ field, value: mutations.hashToken(token), operator: "eq" }]
+  }) ?? fail(404, "Link not found or expired");
+}
+function createNewsletterOperations(adapter, options) {
+  const base = options.unsubscribeBaseURL.replace(/\/$/, "");
+  const hooks = options.hooks;
+  async function sendConfirmation(subscriber) {
+    const latest = await requireSubscriber(adapter, subscriber.id);
+    if (latest.status !== "unsubscribed" || latest.confirmationSentAt && Date.now() - new Date(latest.confirmationSentAt).getTime() < 6e4)
+      return;
+    const token = mutations.newToken();
+    const digest = mutations.hashToken(token);
+    const claimed = await adapter.incrementOne({
+      model: "newsletterSubscriber",
+      where: [
+        { field: "id", value: latest.id, operator: "eq" },
+        { field: "email", value: latest.email, operator: "eq" },
+        { field: "status", value: "unsubscribed", operator: "eq" },
+        {
+          field: "confirmationToken",
+          value: latest.confirmationToken ?? null,
+          operator: "eq"
+        }
+      ],
+      increment: {},
+      set: {
+        confirmationToken: digest,
+        confirmationExpiresAt: new Date(Date.now() + 24 * 60 * 60 * 1e3),
+        confirmationSentAt: /* @__PURE__ */ new Date()
+      }
+    });
+    if (!claimed) return;
+    try {
+      const url = email.tokenUrl(base, "confirm", token);
+      if (hooks?.onConfirmationRequired) {
+        await hooks.onConfirmationRequired({ email: latest.email, url });
+        return;
+      }
+      const from = options.confirmationFrom ?? fail(500, "A confirmation sender is required");
+      const receipt = await mutations.createSendReceipt(
+        adapter,
+        `confirmation-${crypto.randomUUID()}`,
+        subscriber.id,
+        latest.email
+      );
+      await options.emailAdapter.send({
+        to: latest.email,
+        subject: "Confirm your subscription",
+        from: email.formatSender(from.name ?? "Newsletter", from.email),
+        html: email.appendUnsubscribe(
+          `<p><a href="${email.escapeHtml(url)}">Confirm your subscription</a></p><p>This link expires in 24 hours.</p>`,
+          email.tokenUrl(base, "unsubscribe", receipt.unsubscribeToken)
+        ),
+        idempotencyKey: receipt.record.key
+      });
+    } catch (error) {
+      await adapter.incrementOne({
+        model: "newsletterSubscriber",
+        where: [
+          { field: "id", value: latest.id, operator: "eq" },
+          { field: "confirmationToken", value: digest, operator: "eq" }
+        ],
+        increment: {},
+        set: {
+          confirmationToken: null,
+          confirmationExpiresAt: null,
+          confirmationSentAt: null
+        }
+      });
+      throw error;
+    }
+  }
+  async function deliverCampaign(id, dueBefore, authorizedStatus) {
+    const current = await requireCampaign(adapter, id);
+    if (authorizedStatus && current.status !== authorizedStatus)
+      fail(409, "Campaign changed after authorization");
+    if (current.status !== "draft" && current.status !== "scheduled")
+      fail(
+        409,
+        "Campaign has already started sending",
+        "CAMPAIGN_ALREADY_STARTED"
+      );
+    const campaign = await mutations.claimCampaign(adapter, id, current.status, dueBefore) ?? fail(
+      409,
+      "Campaign has already started sending",
+      "CAMPAIGN_ALREADY_STARTED"
+    );
+    const tags = JSON.parse(campaign.tags || "[]");
+    const recipients = (await getters.getAllRows(adapter, "newsletterSubscriber", [
+      { field: "status", value: "subscribed", operator: "eq" }
+    ])).filter(
+      (subscriber) => !tags.length || JSON.parse(subscriber.tags || "[]").some(
+        (tag) => tags.includes(tag)
+      )
+    );
+    const body = await email.renderEmailBody(campaign);
+    for (const recipient of recipients) {
+      const subscriber = await getters.getSubscriberRecord(adapter, recipient.id);
+      if (subscriber?.status !== "subscribed" || options.doubleOptIn && !subscriber.confirmedAt)
+        continue;
+      const receipt = await mutations.createSendReceipt(
+        adapter,
+        campaign.id,
+        subscriber.id,
+        subscriber.email
+      );
+      const tracked = email.trackEmailLinks(body, base, receipt.trackingToken);
+      await adapter.update({
+        model: "newsletterSend",
+        where: [{ field: "id", value: receipt.record.id, operator: "eq" }],
+        update: { links: JSON.stringify(tracked.links) }
+      });
+      const html = `${email.appendUnsubscribe(tracked.html, email.tokenUrl(base, "unsubscribe", receipt.unsubscribeToken))}<img src="${email.escapeHtml(email.tokenUrl(base, "track/open", receipt.trackingToken))}" width="1" height="1" alt="" />`;
+      let result;
+      try {
+        result = await options.emailAdapter.send({
+          to: subscriber.email,
+          from: email.formatSender(campaign.fromName, campaign.fromEmail),
+          replyTo: campaign.replyTo ?? void 0,
+          subject: campaign.subject,
+          html,
+          idempotencyKey: receipt.record.key
+        });
+      } catch {
+        await adapter.update({
+          model: "newsletterSend",
+          where: [{ field: "id", value: receipt.record.id, operator: "eq" }],
+          update: { status: "failed" }
+        });
+        continue;
+      }
+      await adapter.update({
+        model: "newsletterSend",
+        where: [{ field: "id", value: receipt.record.id, operator: "eq" }],
+        update: {
+          status: "delivered",
+          sentAt: /* @__PURE__ */ new Date(),
+          messageId: result.messageId
+        }
+      });
+    }
+    const sent = await adapter.update({
+      model: "newsletterCampaign",
+      where: [{ field: "id", value: campaign.id, operator: "eq" }],
+      update: { status: "sent", sentAt: /* @__PURE__ */ new Date(), updatedAt: /* @__PURE__ */ new Date() }
+    });
+    return serializers.serializeCampaign(
+      sent ?? fail(409, "Campaign changed while sending")
+    );
+  }
+  return {
+    listSubscribers: api.defineOperation({
+      input: schemas.listSubscribersSchema,
+      permission: plugins_newsletter_permissions.newsletterPermissions.subscriber.read,
+      facts: () => ({ scope: "collection" }),
+      execute: ({ input }) => getters.listSubscribers(adapter, input)
+    }),
+    getSubscriber: api.defineOperation({
+      input: schemas.idSchema,
+      permission: plugins_newsletter_permissions.newsletterPermissions.subscriber.read,
+      facts: ({ input }) => ({
+        scope: "record",
+        subscriberId: input.id
+      }),
+      execute: async ({ input }) => serializers.serializeSubscriber(await requireSubscriber(adapter, input.id))
+    }),
+    createSubscriber: api.defineOperation({
+      input: schemas.createSubscriberSchema,
+      permission: plugins_newsletter_permissions.newsletterPermissions.subscriber.create,
+      facts: () => void 0,
+      execute: async ({ input }) => {
+        if (await getters.getSubscriberByEmail(adapter, input.email))
+          fail(409, "This email is already in the subscriber list");
+        return serializers.serializeSubscriber(
+          await mutations.createSubscriber(adapter, {
+            ...input,
+            tags: [...input.tags]
+          })
+        );
+      }
+    }),
+    updateSubscriber: api.defineOperation({
+      input: subscriberUpdateInput,
+      permission: plugins_newsletter_permissions.newsletterPermissions.subscriber.update,
+      facts: ({ input }) => subscriberFacts(adapter, input.id),
+      execute: async ({ input, facts }) => {
+        if (input.data.email) {
+          const existing = await getters.getSubscriberByEmail(
+            adapter,
+            input.data.email
+          );
+          if (existing && existing.id !== input.id)
+            fail(409, "This email is already in the subscriber list");
+        }
+        const subscriber = await mutations.updateSubscriber(
+          adapter,
+          input.id,
+          {
+            ...input.data,
+            tags: input.data.tags ? [...input.data.tags] : void 0
+          },
+          facts.status
+        );
+        return serializers.serializeSubscriber(
+          subscriber ?? fail(404, "Subscriber not found")
+        );
+      }
+    }),
+    deleteSubscriber: api.defineOperation({
+      input: schemas.idSchema,
+      permission: plugins_newsletter_permissions.newsletterPermissions.subscriber.delete,
+      facts: ({ input }) => subscriberFacts(adapter, input.id),
+      execute: async ({ input, facts }) => {
+        const removed = await adapter.consumeOne({
+          model: "newsletterSubscriber",
+          where: [
+            { field: "id", value: input.id, operator: "eq" },
+            { field: "status", value: facts.status, operator: "eq" }
+          ]
+        });
+        if (!removed) fail(409, "Subscriber changed after authorization");
+        await adapter.deleteMany({
+          model: "newsletterSend",
+          where: [{ field: "subscriberId", value: input.id, operator: "eq" }]
+        });
+        return { success: true };
+      }
+    }),
+    importSubscribers: api.defineOperation({
+      input: schemas.importSubscribersSchema,
+      permission: plugins_newsletter_permissions.newsletterPermissions.subscriber.import,
+      facts: () => void 0,
+      execute: async ({ input }) => {
+        let rows;
+        try {
+          rows = csv.parseSubscriberCsv(input.csv).map(
+            (row) => schemas.createSubscriberSchema.parse({
+              email: row.email,
+              name: row.name || void 0,
+              status: row.status || "subscribed",
+              tags: row.tags ? row.tags.startsWith("[") ? JSON.parse(row.tags) : row.tags.split(";").map((tag) => tag.trim()).filter(Boolean) : []
+            })
+          );
+        } catch (error) {
+          if (error instanceof api.OperationHttpError) throw error;
+          fail(
+            400,
+            "CSV contains an invalid email, status, or tags",
+            "INVALID_CSV"
+          );
+        }
+        let imported = 0;
+        for (const row of rows) {
+          if (await getters.getSubscriberByEmail(adapter, row.email)) continue;
+          await mutations.createSubscriber(adapter, row);
+          imported++;
+        }
+        return { imported };
+      }
+    }),
+    exportSubscribers: api.defineOperation({
+      input: empty,
+      permission: plugins_newsletter_permissions.newsletterPermissions.subscriber.export,
+      facts: () => void 0,
+      execute: async () => ({
+        csv: csv.exportSubscriberCsv(
+          (await getters.getAllRows(adapter, "newsletterSubscriber")).map(serializers.serializeSubscriber)
+        )
+      })
+    }),
+    subscribe: api.defineOperation({
+      input: schemas.subscribeSchema,
+      permission: plugins_newsletter_permissions.newsletterPermissions.subscriber.subscribe,
+      access: "public",
+      facts: () => void 0,
+      before: ({ input, request }) => hooks?.onBeforeSubscribe?.(input.email, { request }),
+      execute: async ({ input, request }) => {
+        let { subscriber, created } = await mutations.findOrCreateSubscriber(
+          adapter,
+          {
+            ...input,
+            tags: [...input.tags],
+            status: options.doubleOptIn ? "unsubscribed" : "subscribed"
+          }
+        );
+        if (!created && subscriber.transactionOnly) {
+          const enrolled = await adapter.incrementOne({
+            model: "newsletterSubscriber",
+            where: [
+              { field: "id", value: subscriber.id, operator: "eq" },
+              { field: "email", value: input.email, operator: "eq" },
+              { field: "status", value: "unsubscribed", operator: "eq" },
+              { field: "transactionOnly", value: true, operator: "eq" }
+            ],
+            increment: {},
+            set: {
+              transactionOnly: false,
+              status: options.doubleOptIn ? "unsubscribed" : "subscribed",
+              confirmedAt: options.doubleOptIn ? null : /* @__PURE__ */ new Date(),
+              name: input.name ?? subscriber.name,
+              tags: JSON.stringify([...new Set(input.tags)])
+            }
+          });
+          if (enrolled) {
+            subscriber = enrolled;
+            created = true;
+          }
+        }
+        if (!created) {
+          if (subscriber.status === "unsubscribed" && (options.doubleOptIn || options.confirmationFrom || hooks?.onConfirmationRequired))
+            await sendConfirmation(subscriber);
+          return genericSubscriptionResult;
+        }
+        if (options.doubleOptIn) await sendConfirmation(subscriber);
+        else
+          await hooks?.onAfterSubscribe?.(serializers.serializeSubscriber(subscriber), {
+            request
+          });
+        return genericSubscriptionResult;
+      }
+    }),
+    confirmSubscription: api.defineOperation({
+      input: schemas.tokenSchema,
+      permission: plugins_newsletter_permissions.newsletterPermissions.subscriber.confirm,
+      access: "public",
+      facts: () => void 0,
+      execute: async ({ input, request }) => {
+        const subscriber = await adapter.incrementOne({
+          model: "newsletterSubscriber",
+          where: [
+            {
+              field: "confirmationToken",
+              value: mutations.hashToken(input.token),
+              operator: "eq"
+            },
+            {
+              field: "confirmationExpiresAt",
+              value: /* @__PURE__ */ new Date(),
+              operator: "gt"
+            }
+          ],
+          increment: {},
+          set: {
+            confirmationToken: null,
+            confirmationExpiresAt: null,
+            status: "subscribed",
+            confirmedAt: /* @__PURE__ */ new Date()
+          }
+        });
+        if (!subscriber)
+          fail(
+            400,
+            "Confirmation link is invalid or expired",
+            "INVALID_CONFIRMATION"
+          );
+        await hooks?.onAfterSubscribe?.(serializers.serializeSubscriber(subscriber), {
+          request
+        });
+        return {
+          success: true,
+          message: "Your subscription is confirmed."
+        };
+      }
+    }),
+    unsubscribe: api.defineOperation({
+      input: schemas.tokenSchema,
+      permission: plugins_newsletter_permissions.newsletterPermissions.subscriber.unsubscribe,
+      access: "public",
+      facts: () => void 0,
+      execute: async ({ input, request }) => {
+        const receipt = await findReceipt(
+          adapter,
+          "unsubscribeToken",
+          input.token
+        );
+        const subscriber = await requireSubscriber(
+          adapter,
+          receipt.subscriberId
+        );
+        if (receipt.email !== subscriber.email)
+          fail(404, "Link not found or expired");
+        if (subscriber.status !== "unsubscribed" || subscriber.confirmationToken || subscriber.transactionOnly) {
+          await hooks?.onBeforeUnsubscribe?.(serializers.serializeSubscriber(subscriber), {
+            request
+          });
+          const updated = await adapter.incrementOne({
+            model: "newsletterSubscriber",
+            where: [
+              { field: "id", value: subscriber.id, operator: "eq" },
+              { field: "email", value: subscriber.email, operator: "eq" }
+            ],
+            increment: {},
+            set: {
+              status: "unsubscribed",
+              transactionOnly: false,
+              confirmationToken: null,
+              confirmationExpiresAt: null
+            }
+          });
+          if (updated)
+            await hooks?.onAfterUnsubscribe?.(serializers.serializeSubscriber(updated), {
+              request
+            });
+        }
+        return {
+          success: true,
+          message: "You have been unsubscribed."
+        };
+      }
+    }),
+    listCampaigns: api.defineOperation({
+      input: schemas.listCampaignsSchema,
+      permission: plugins_newsletter_permissions.newsletterPermissions.campaign.read,
+      facts: () => ({ scope: "collection" }),
+      execute: ({ input }) => getters.listCampaigns(adapter, input)
+    }),
+    getCampaign: api.defineOperation({
+      input: schemas.idSchema,
+      permission: plugins_newsletter_permissions.newsletterPermissions.campaign.read,
+      facts: ({ input }) => ({
+        scope: "record",
+        campaignId: input.id
+      }),
+      execute: async ({ input }) => serializers.serializeCampaign(await requireCampaign(adapter, input.id))
+    }),
+    createCampaign: api.defineOperation({
+      input: schemas.createCampaignSchema,
+      permission: plugins_newsletter_permissions.newsletterPermissions.campaign.create,
+      facts: () => void 0,
+      execute: async ({ input }) => serializers.serializeCampaign(
+        await mutations.createCampaign(adapter, {
+          ...input,
+          tags: [...input.tags]
+        })
+      )
+    }),
+    updateCampaign: api.defineOperation({
+      input: campaignUpdateInput,
+      permission: plugins_newsletter_permissions.newsletterPermissions.campaign.update,
+      facts: ({ input }) => campaignFacts(adapter, input.id),
+      execute: async ({ input }) => serializers.serializeCampaign(
+        await mutations.updateCampaign(adapter, input.id, {
+          ...input.data,
+          tags: input.data.tags ? [...input.data.tags] : void 0
+        })
+      )
+    }),
+    deleteCampaign: api.defineOperation({
+      input: schemas.idSchema,
+      permission: plugins_newsletter_permissions.newsletterPermissions.campaign.delete,
+      facts: ({ input }) => campaignFacts(adapter, input.id),
+      execute: async ({ input, facts }) => {
+        const current = await requireCampaign(adapter, input.id);
+        if (current.status !== facts.status)
+          fail(409, "Campaign changed after authorization");
+        if (current.status === "sending" || current.status === "sent")
+          fail(409, "Only draft or scheduled campaigns can be deleted");
+        const removed = await adapter.consumeOne({
+          model: "newsletterCampaign",
+          where: [
+            { field: "id", value: input.id, operator: "eq" },
+            { field: "status", value: current.status, operator: "eq" }
+          ]
+        });
+        if (!removed) fail(409, "Campaign changed while deleting");
+        return { success: true };
+      }
+    }),
+    sendCampaign: api.defineOperation({
+      input: schemas.idSchema,
+      permission: plugins_newsletter_permissions.newsletterPermissions.campaign.send,
+      facts: ({ input }) => campaignFacts(adapter, input.id),
+      execute: ({ input, facts }) => deliverCampaign(input.id, void 0, facts.status),
+      after: ({ result, request }) => hooks?.onAfterSend?.(result, { request })
+    }),
+    scheduleCampaign: api.defineOperation({
+      input: scheduleInput,
+      permission: plugins_newsletter_permissions.newsletterPermissions.campaign.schedule,
+      facts: ({ input }) => campaignFacts(adapter, input.id),
+      execute: async ({ input, facts }) => {
+        const scheduledAt = new Date(input.scheduledAt);
+        if (scheduledAt.getTime() <= Date.now())
+          fail(400, "Choose a future send time");
+        const current = await requireCampaign(adapter, input.id);
+        if (current.status !== facts.status)
+          fail(409, "Campaign changed after authorization");
+        if (current.status !== "draft" && current.status !== "scheduled")
+          fail(409, "Campaign has already started sending");
+        const scheduled = await adapter.incrementOne({
+          model: "newsletterCampaign",
+          where: [
+            { field: "id", value: input.id, operator: "eq" },
+            { field: "status", value: current.status, operator: "eq" }
+          ],
+          increment: {},
+          set: { status: "scheduled", scheduledAt, updatedAt: /* @__PURE__ */ new Date() }
+        });
+        return serializers.serializeCampaign(
+          scheduled ?? fail(409, "Campaign changed while scheduling")
+        );
+      }
+    }),
+    sendTestEmail: api.defineOperation({
+      input: testInput,
+      permission: plugins_newsletter_permissions.newsletterPermissions.campaign.test,
+      facts: ({ input }) => campaignFacts(adapter, input.id),
+      execute: async ({ input, facts }) => {
+        const campaign = await requireCampaign(adapter, input.id);
+        if (campaign.status !== facts.status)
+          fail(409, "Campaign changed after authorization");
+        const { subscriber } = await mutations.findOrCreateSubscriber(
+          adapter,
+          {
+            email: input.email,
+            status: "unsubscribed",
+            tags: []
+          },
+          true
+        );
+        const receipt = await mutations.createSendReceipt(
+          adapter,
+          `test-${crypto.randomUUID()}`,
+          subscriber.id,
+          input.email
+        );
+        await options.emailAdapter.send({
+          to: input.email,
+          subject: `[Test] ${campaign.subject}`,
+          from: email.formatSender(campaign.fromName, campaign.fromEmail),
+          replyTo: campaign.replyTo ?? void 0,
+          html: email.appendUnsubscribe(
+            await email.renderEmailBody(campaign),
+            email.tokenUrl(base, "unsubscribe", receipt.unsubscribeToken)
+          ),
+          idempotencyKey: receipt.record.key
+        });
+        return { success: true };
+      }
+    }),
+    getCampaignStats: api.defineOperation({
+      input: schemas.idSchema,
+      permission: plugins_newsletter_permissions.newsletterPermissions.analytics.read,
+      facts: () => void 0,
+      execute: async ({ input }) => {
+        await requireCampaign(adapter, input.id);
+        return getters.getCampaignStats(adapter, input.id);
+      }
+    }),
+    getSubscriberGrowth: api.defineOperation({
+      input: empty,
+      permission: plugins_newsletter_permissions.newsletterPermissions.analytics.read,
+      facts: () => void 0,
+      execute: () => getters.getSubscriberGrowth(adapter)
+    }),
+    trackOpen: api.definePassthroughOperation({
+      input: schemas.tokenSchema,
+      permission: plugins_newsletter_permissions.newsletterPermissions.analytics.track,
+      access: "public",
+      facts: () => void 0,
+      execute: async ({ input }) => {
+        const receipt = await findReceipt(
+          adapter,
+          "trackingToken",
+          input.token
+        );
+        if (!receipt.openedAt)
+          await adapter.update({
+            model: "newsletterSend",
+            where: [{ field: "id", value: receipt.id, operator: "eq" }],
+            update: { openedAt: /* @__PURE__ */ new Date() }
+          });
+        return new Response(
+          Uint8Array.from(
+            Buffer.from(
+              "R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7",
+              "base64"
+            )
+          ),
+          {
+            headers: {
+              "Content-Type": "image/gif",
+              "Cache-Control": "no-store, private",
+              "Referrer-Policy": "no-referrer"
+            }
+          }
+        );
+      }
+    }),
+    trackClick: api.definePassthroughOperation({
+      input: clickInput,
+      permission: plugins_newsletter_permissions.newsletterPermissions.analytics.track,
+      access: "public",
+      facts: () => void 0,
+      execute: async ({ input }) => {
+        const receipt = await findReceipt(
+          adapter,
+          "trackingToken",
+          input.token
+        );
+        const destination = JSON.parse(receipt.links)[input.link];
+        if (!destination) fail(404, "Link not found");
+        if (!receipt.clickedAt)
+          await adapter.update({
+            model: "newsletterSend",
+            where: [{ field: "id", value: receipt.id, operator: "eq" }],
+            update: {
+              clickedAt: /* @__PURE__ */ new Date(),
+              ...!receipt.openedAt ? { openedAt: /* @__PURE__ */ new Date() } : {}
+            }
+          });
+        return new Response(null, {
+          status: 302,
+          headers: {
+            Location: destination,
+            "Cache-Control": "no-store, private",
+            "Referrer-Policy": "no-referrer"
+          }
+        });
+      }
+    }),
+    sendScheduledCampaigns: api.defineOperation({
+      input: empty,
+      permission: plugins_newsletter_permissions.newsletterPermissions.scheduler.run,
+      facts: () => void 0,
+      execute: async ({ request }) => {
+        const due = (await getters.getAllRows(adapter, "newsletterCampaign", [
+          { field: "status", value: "scheduled", operator: "eq" }
+        ])).filter(
+          (campaign) => campaign.scheduledAt && new Date(campaign.scheduledAt).getTime() <= Date.now()
+        );
+        let sent = 0;
+        for (const campaign of due) {
+          try {
+            const result = await deliverCampaign(campaign.id, /* @__PURE__ */ new Date());
+            await hooks?.onAfterSend?.(result, { request });
+            sent++;
+          } catch (error) {
+            if (!(error instanceof api.OperationHttpError && error.code === "CAMPAIGN_ALREADY_STARTED"))
+              throw error;
+          }
+        }
+        return { sent };
+      }
+    }),
+    sendTransactionalEmail: api.defineOperation({
+      input: schemas.transactionalEmailSchema,
+      permission: plugins_newsletter_permissions.newsletterPermissions.transactional.send,
+      facts: () => void 0,
+      execute: async ({ input }) => {
+        const { subscriber } = await mutations.findOrCreateSubscriber(
+          adapter,
+          {
+            email: input.to,
+            status: "unsubscribed",
+            tags: []
+          },
+          true
+        );
+        const receipt = await mutations.createSendReceipt(
+          adapter,
+          `transactional-${crypto.randomUUID()}`,
+          subscriber.id,
+          input.to
+        );
+        return options.emailAdapter.send({
+          ...input,
+          html: email.appendUnsubscribe(
+            input.html,
+            email.tokenUrl(base, "unsubscribe", receipt.unsubscribeToken)
+          ),
+          idempotencyKey: receipt.record.key
+        });
+      }
+    })
+  };
+}
+
+exports.createNewsletterOperations = createNewsletterOperations;