Skip to content

armgit / dub

Public Imported from GitHub
0

The modern link attribution platform. Loved by world-class engineering teams at Twilio, Zillow, Jobber, Vercel, Raycast, and more.

Move connect payout reminders to a background job.

Kiran Kb4af7026ad45
diff --git a/apps/web/app/(ee)/api/cron/payouts/reminders/partners/route.ts b/apps/web/app/(ee)/api/cron/payouts/reminders/partners/route.ts
index 494b992051..d8a23237a4 100644
--- a/apps/web/app/(ee)/api/cron/payouts/reminders/partners/route.ts
+++ b/apps/web/app/(ee)/api/cron/payouts/reminders/partners/route.ts
@@ -1,229 +1,16 @@
-import { MIN_PAYOUT_AMOUNT_FOR_REMINDERS } from "@/lib/constants/misc";
-import { PAYOUT_SUPPORTED_COUNTRIES } from "@/lib/constants/payouts-supported-countries";
-import { qstash } from "@/lib/cron";
import { withCron } from "@/lib/cron/with-cron";
-import { queueBatchEmail } from "@/lib/email/queue-batch-email";
-import { prisma } from "@/lib/prisma";
-import ConnectPayoutReminder from "@dub/email/templates/connect-payout-reminder";
-import {
- ACME_PROGRAM_ID,
- APP_DOMAIN_WITH_NGROK,
- DEMO_PROGRAM_ID,
-} from "@dub/utils";
+import { sendConnectPayoutRemindersJob } from "@/lib/jobs/handlers/send-connect-payout-reminders-job";
import { logAndRespond } from "../../../utils";
export const dynamic = "force-dynamic";
-const BATCH_SIZE = 1000;
-
// This route is used to send reminders to partners who have pending payouts
// but haven't configured payouts yet.
-// Runs once a day at 7AM PST but only notifies partners every 3 days
-// + calls itself recursively to process all partners in batches
-// GET/POST /api/cron/payouts/reminders/partners
-
+// Runs once a day at 7AM PST but only notifies partners every 3 days.
+// Further batches are dispatched by sendConnectPayoutRemindersJob.
+// GET /api/cron/payouts/reminders/partners
export const GET = withCron(async () => {
- // Get unsent payouts grouped by partner and program, ordered by amount desc
- const unsentPayouts = await prisma.payout.groupBy({
- by: ["partnerId", "programId"],
- where: {
- status: {
- in: ["pending", "processing", "processed", "failed"],
- },
- programId: {
- notIn: [
- ACME_PROGRAM_ID,
- DEMO_PROGRAM_ID,
- // programs that are in the migration process
- "prog_1M1EYH84K0ZGRA70CEGB4VC72",
- ],
- },
- partner: {
- payoutsEnabledAt: null,
- AND: [
- {
- OR: [
- { country: null },
- {
- country: {
- in: PAYOUT_SUPPORTED_COUNTRIES.map((c) => c.code),
- },
- },
- ],
- },
- {
- OR: [
- { connectPayoutsLastRemindedAt: null },
- {
- connectPayoutsLastRemindedAt: {
- lte: new Date(Date.now() - 3 * 24 * 60 * 60 * 1000),
- },
- },
- ],
- },
- ],
- },
- amount: {
- gte: MIN_PAYOUT_AMOUNT_FOR_REMINDERS,
- },
- },
- _sum: {
- amount: true,
- },
- orderBy: {
- _sum: {
- amount: "desc",
- },
- },
- take: BATCH_SIZE,
- });
-
- if (!unsentPayouts.length) {
- return logAndRespond("No action needed.");
- }
-
- const hasMoreToProcess = unsentPayouts.length === BATCH_SIZE;
-
- console.log(
- `Found ${unsentPayouts.length} partner-program combinations needing reminders${hasMoreToProcess ? " (more to process)" : ""}`,
- );
-
- const [partnerData, programData] = await Promise.all([
- prisma.partner.findMany({
- where: {
- id: {
- in: unsentPayouts.map((payout) => payout.partnerId),
- },
- OR: [
- {
- users: {
- none: {},
- },
- },
- {
- users: {
- some: {
- notificationPreferences: {
- connectPayoutReminder: true,
- },
- },
- },
- },
- ],
- },
- }),
-
- prisma.program.findMany({
- where: {
- id: {
- in: unsentPayouts.map((payout) => payout.programId),
- },
- },
- }),
- ]);
-
- const partnerProgramMap = new Map<
- string,
- {
- partner: {
- id: string;
- name: string;
- email: string;
- };
- programs: {
- id: string;
- name: string;
- logo: string;
- amount: number;
- }[];
- }
- >();
-
- for (const payout of unsentPayouts) {
- const { partnerId, programId } = payout;
- const { amount } = payout._sum;
-
- const partner = partnerData.find((p) => p.id === partnerId);
- const program = programData.find((p) => p.id === programId);
-
- if (!partner?.email || !program) {
- continue;
- }
-
- if (!partnerProgramMap.has(partnerId)) {
- partnerProgramMap.set(partnerId, {
- partner: {
- id: partner.id,
- name: partner.name,
- email: partner.email,
- },
- programs: [],
- });
- }
+ await sendConnectPayoutRemindersJob.dispatch({});
- partnerProgramMap.get(partnerId)!.programs.push({
- id: program.id,
- name: program.name,
- logo: program.logo!,
- amount: amount ?? 0,
- });
- }
-
- const partnerPrograms = Array.from(partnerProgramMap.values());
- const connectPayoutsLastRemindedAt = new Date();
-
- console.log(
- `Processing ConnectPayoutReminder for ${partnerPrograms.length} partners`,
- );
-
- await queueBatchEmail<typeof ConnectPayoutReminder>(
- partnerPrograms.map(({ partner, programs }) => ({
- variant: "notifications",
- to: partner.email,
- subject: "Connect your payout details on Dub Partners",
- templateName: "ConnectPayoutReminder",
- templateProps: {
- email: partner.email,
- programs,
- },
- })),
- );
-
- console.log(
- `Queued ConnectPayoutReminder emails for ${partnerPrograms.length} partners`,
- );
-
- await prisma.partner.updateMany({
- where: {
- id: {
- in: partnerPrograms.map(({ partner }) => partner.id),
- },
- },
- data: {
- connectPayoutsLastRemindedAt,
- },
- });
-
- if (hasMoreToProcess) {
- console.log("More partners need reminders, scheduling next batch...");
-
- const qstashResponse = await qstash.publishJSON({
- url: `${APP_DOMAIN_WITH_NGROK}/api/cron/payouts/reminders/partners`,
- body: {},
- });
-
- if (!qstashResponse.messageId) {
- throw new Error(
- `Error sending message to Qstash to schedule next batch of payout reminders: ${JSON.stringify(qstashResponse)}`,
- );
- }
-
- return logAndRespond(
- "Finished sending payout reminders for current batch. Scheduling next batch...",
- );
- }
-
- return logAndRespond("Finished sending payout reminders for all batches.");
+ return logAndRespond("Enqueued connect payout reminders job.");
});
-
-export const POST = GET;
diff --git a/apps/web/lib/jobs/handlers/send-connect-payout-reminders-job.ts b/apps/web/lib/jobs/handlers/send-connect-payout-reminders-job.ts
new file mode 100644
index 0000000000..f2fdb4564f
--- /dev/null
+++ b/apps/web/lib/jobs/handlers/send-connect-payout-reminders-job.ts
@@ -0,0 +1,19 @@
+import { sendPayoutReminder } from "@/lib/payouts/send-payout-reminder";
+import * as z from "zod/v4";
+import { defineJob } from "../index";
+
+const inputSchema = z.object({});
+
+// Sends ConnectPayoutReminder emails to partners with pending payouts
+// who have not configured payouts yet.
+export const sendConnectPayoutRemindersJob = defineJob({
+ name: "send-connect-payout-reminders-job",
+ schema: inputSchema,
+ async handle() {
+ const hasMore = await sendPayoutReminder();
+
+ if (hasMore) {
+ await sendConnectPayoutRemindersJob.dispatch({});
+ }
+ },
+});
diff --git a/apps/web/lib/jobs/registry.ts b/apps/web/lib/jobs/registry.ts
index 6c21044e63..eda21092f2 100644
--- a/apps/web/lib/jobs/registry.ts
+++ b/apps/web/lib/jobs/registry.ts
@@ -66,6 +66,11 @@ const jobLoaders = {
(m) => m.sendPartnerProgramSummaryJob,
),
+ "send-connect-payout-reminders-job": () =>
+ import("./handlers/send-connect-payout-reminders-job").then(
+ (m) => m.sendConnectPayoutRemindersJob,
+ ),
+
"create-custom-commission-job": () =>
import("./handlers/create-custom-commission-job").then(
(m) => m.createCustomCommissionJob,
diff --git a/apps/web/lib/payouts/send-payout-reminder.ts b/apps/web/lib/payouts/send-payout-reminder.ts
new file mode 100644
index 0000000000..1cb7e932b1
--- /dev/null
+++ b/apps/web/lib/payouts/send-payout-reminder.ts
@@ -0,0 +1,217 @@
+import { MIN_PAYOUT_AMOUNT_FOR_REMINDERS } from "@/lib/constants/misc";
+import { PAYOUT_SUPPORTED_COUNTRIES } from "@/lib/constants/payouts-supported-countries";
+import { queueBatchEmail } from "@/lib/email/queue-batch-email";
+import { prisma } from "@/lib/prisma";
+import ConnectPayoutReminder from "@dub/email/templates/connect-payout-reminder";
+import { ACME_PROGRAM_ID, DEMO_PROGRAM_ID, pluck } from "@dub/utils";
+import {
+ Partner,
+ PayoutStatus,
+ Program,
+ ProgramPayoutMode,
+} from "@prisma/client";
+
+const BATCH_SIZE = 1000;
+
+const EXCLUDED_PROGRAM_IDS = [
+ ACME_PROGRAM_ID,
+ DEMO_PROGRAM_ID,
+ // programs that are in the migration process
+ "prog_1M1EYH84K0ZGRA70CEGB4VC72",
+];
+
+type PartnerPayoutReminder = {
+ partner: Pick<Partner, "id" | "name"> & {
+ email: string;
+ };
+ programs: (Pick<Program, "id" | "name" | "logo"> & {
+ amount: number;
+ })[];
+};
+
+// This route is used to send reminders to partners who have pending payouts
+// but haven't configured payouts yet.
+export async function sendPayoutReminder() {
+ // Get unsent payouts grouped by partner and program, ordered by amount desc
+ const unsentPayouts = await prisma.payout.groupBy({
+ by: ["partnerId", "programId"],
+ where: {
+ status: {
+ in: [
+ PayoutStatus.pending,
+ PayoutStatus.processing,
+ PayoutStatus.processed,
+ PayoutStatus.failed,
+ ],
+ },
+ programId: {
+ notIn: EXCLUDED_PROGRAM_IDS,
+ },
+ partner: {
+ payoutsEnabledAt: null,
+ AND: [
+ {
+ OR: [
+ { country: null },
+ {
+ country: {
+ in: PAYOUT_SUPPORTED_COUNTRIES.map((c) => c.code),
+ },
+ },
+ ],
+ },
+ {
+ OR: [
+ { connectPayoutsLastRemindedAt: null },
+ {
+ connectPayoutsLastRemindedAt: {
+ lte: new Date(Date.now() - 3 * 24 * 60 * 60 * 1000),
+ },
+ },
+ ],
+ },
+ ],
+ },
+ amount: {
+ gte: MIN_PAYOUT_AMOUNT_FOR_REMINDERS,
+ },
+ programEnrollment: {
+ // Internal programs always pay through Dub, so those partners still need
+ // to connect payout details even if a tenantId is set.
+ // External and hybrid programs pay outside Dub once tenantId is set, so
+ // skip those. Without a tenantId they are still included.
+ OR: [
+ {
+ program: {
+ payoutMode: ProgramPayoutMode.internal,
+ },
+ },
+ {
+ tenantId: null,
+ },
+ ],
+ },
+ },
+ _sum: {
+ amount: true,
+ },
+ orderBy: {
+ _sum: {
+ amount: "desc",
+ },
+ },
+ take: BATCH_SIZE,
+ });
+
+ if (!unsentPayouts.length) {
+ console.log("No partners need reminders.");
+ return false;
+ }
+
+ const [partnerData, programData] = await Promise.all([
+ prisma.partner.findMany({
+ where: {
+ id: {
+ in: pluck(unsentPayouts, "partnerId"),
+ },
+ OR: [
+ {
+ users: {
+ none: {},
+ },
+ },
+ {
+ users: {
+ some: {
+ notificationPreferences: {
+ connectPayoutReminder: true,
+ },
+ },
+ },
+ },
+ ],
+ },
+ select: {
+ id: true,
+ name: true,
+ email: true,
+ },
+ }),
+
+ prisma.program.findMany({
+ where: {
+ id: {
+ in: pluck(unsentPayouts, "programId"),
+ },
+ },
+ select: {
+ id: true,
+ name: true,
+ logo: true,
+ },
+ }),
+ ]);
+
+ const partnerProgramMap = new Map<string, PartnerPayoutReminder>();
+
+ for (const payout of unsentPayouts) {
+ const { partnerId, programId } = payout;
+ const { amount } = payout._sum;
+
+ const partner = partnerData.find((p) => p.id === partnerId);
+ const program = programData.find((p) => p.id === programId);
+
+ if (!partner?.email || !program) {
+ continue;
+ }
+
+ if (!partnerProgramMap.has(partnerId)) {
+ partnerProgramMap.set(partnerId, {
+ partner: {
+ id: partner.id,
+ name: partner.name,
+ email: partner.email,
+ },
+ programs: [],
+ });
+ }
+
+ partnerProgramMap.get(partnerId)!.programs.push({
+ id: program.id,
+ name: program.name,
+ logo: program.logo!,
+ amount: amount ?? 0,
+ });
+ }
+
+ const partnerPrograms = Array.from(partnerProgramMap.values());
+ const connectPayoutsLastRemindedAt = new Date();
+
+ await queueBatchEmail<typeof ConnectPayoutReminder>(
+ partnerPrograms.map(({ partner, programs }) => ({
+ variant: "notifications",
+ to: partner.email,
+ subject: "Connect your payout details on Dub Partners",
+ templateName: "ConnectPayoutReminder",
+ templateProps: {
+ email: partner.email,
+ programs,
+ },
+ })),
+ );
+
+ await prisma.partner.updateMany({
+ where: {
+ id: {
+ in: partnerPrograms.map(({ partner }) => partner.id),
+ },
+ },
+ data: {
+ connectPayoutsLastRemindedAt,
+ },
+ });
+
+ const hasMore = unsentPayouts.length === BATCH_SIZE;
+
+ return hasMore;
+}
diff --git a/apps/web/tests/payouts/send-payout-reminder.test.ts b/apps/web/tests/payouts/send-payout-reminder.test.ts
new file mode 100644
index 0000000000..4e03ada70c
--- /dev/null
+++ b/apps/web/tests/payouts/send-payout-reminder.test.ts
@@ -0,0 +1,596 @@
+import { MIN_PAYOUT_AMOUNT_FOR_REMINDERS } from "@/lib/constants/misc";
+import { PAYOUT_SUPPORTED_COUNTRIES } from "@/lib/constants/payouts-supported-countries";
+import { sendPayoutReminder } from "@/lib/payouts/send-payout-reminder";
+import { ACME_PROGRAM_ID, DEMO_PROGRAM_ID } from "@dub/utils";
+import { PayoutStatus, ProgramPayoutMode } from "@prisma/client";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const BATCH_SIZE = 1000;
+const MIGRATION_PROGRAM_ID = "prog_1M1EYH84K0ZGRA70CEGB4VC72";
+const NOW = new Date("2026-09-24T09:00:00.000Z");
+
+const mocks = vi.hoisted(() => ({
+ groupBy: vi.fn(),
+ partnerFindMany: vi.fn(),
+ programFindMany: vi.fn(),
+ partnerUpdateMany: vi.fn(),
+ queueBatchEmail: vi.fn(),
+}));
+
+vi.mock("@/lib/prisma", () => ({
+ prisma: {
+ payout: {
+ groupBy: mocks.groupBy,
+ },
+ partner: {
+ findMany: mocks.partnerFindMany,
+ updateMany: mocks.partnerUpdateMany,
+ },
+ program: {
+ findMany: mocks.programFindMany,
+ },
+ },
+}));
+
+vi.mock("@/lib/email/queue-batch-email", () => ({
+ queueBatchEmail: mocks.queueBatchEmail,
+}));
+
+function payoutGroup({
+ partnerId,
+ programId,
+ amount,
+}: {
+ partnerId: string;
+ programId: string;
+ amount: number;
+}) {
+ return {
+ partnerId,
+ programId,
+ _sum: { amount },
+ };
+}
+
+function partner({ id, email }: { id: string; email: string | null }) {
+ return {
+ id,
+ name: `Partner ${id}`,
+ email,
+ };
+}
+
+function program({ id }: { id: string }) {
+ return {
+ id,
+ name: `Program ${id}`,
+ logo: `https://example.com/${id}.png`,
+ };
+}
+
+const THREE_DAYS_MS = 3 * 24 * 60 * 60 * 1000;
+const supportedCountry = PAYOUT_SUPPORTED_COUNTRIES[0].code;
+const unsupportedCountry = "ZZ";
+
+type ReminderCandidate = {
+ status: PayoutStatus;
+ programId: string;
+ amount: number;
+ payoutsEnabledAt: Date | null;
+ country: string | null;
+ connectPayoutsLastRemindedAt: Date | null;
+};
+
+const eligibleReminder: ReminderCandidate = {
+ status: PayoutStatus.pending,
+ programId: "prog_real",
+ amount: MIN_PAYOUT_AMOUNT_FOR_REMINDERS,
+ payoutsEnabledAt: null,
+ country: null,
+ connectPayoutsLastRemindedAt: null,
+};
+
+function matchesReminderFilters(
+ where: {
+ status?: { in?: PayoutStatus[] };
+ programId?: { notIn?: string[] };
+ amount?: { gte?: number };
+ partner?: {
+ payoutsEnabledAt?: Date | null;
+ AND?: Array<{
+ OR?: Array<{
+ country?: string | null | { in?: string[] };
+ connectPayoutsLastRemindedAt?: Date | null | { lte?: Date };
+ }>;
+ }>;
+ };
+ },
+ candidate: ReminderCandidate,
+) {
+ if (!where.status?.in) {
+ throw new Error("Missing status filter");
+ }
+
+ if (!where.status.in.includes(candidate.status)) {
+ return false;
+ }
+
+ if (!where.programId?.notIn) {
+ throw new Error("Missing program filter");
+ }
+
+ if (where.programId.notIn.includes(candidate.programId)) {
+ return false;
+ }
+
+ if (typeof where.amount?.gte !== "number") {
+ throw new Error("Missing amount filter");
+ }
+
+ if (candidate.amount < where.amount.gte) {
+ return false;
+ }
+
+ const partner = where.partner;
+
+ if (!partner || partner.payoutsEnabledAt !== null) {
+ throw new Error("Missing payoutsEnabledAt filter");
+ }
+
+ if (candidate.payoutsEnabledAt !== null) {
+ return false;
+ }
+
+ const countryOr = partner.AND?.find((clause) =>
+ clause.OR?.some((item) => "country" in item),
+ )?.OR;
+ const remindedOr = partner.AND?.find((clause) =>
+ clause.OR?.some((item) => "connectPayoutsLastRemindedAt" in item),
+ )?.OR;
+
+ if (!countryOr || !remindedOr) {
+ throw new Error("Missing partner country or reminder filter");
+ }
+
+ const countryMatches = countryOr.some((clause) => {
+ if (clause.country === null) {
+ return candidate.country === null;
+ }
+
+ if (
+ clause.country &&
+ typeof clause.country === "object" &&
+ clause.country.in
+ ) {
+ return (
+ candidate.country !== null &&
+ clause.country.in.includes(candidate.country)
+ );
+ }
+
+ return false;
+ });
+
+ if (!countryMatches) {
+ return false;
+ }
+
+ return remindedOr.some((clause) => {
+ const remindedAt = clause.connectPayoutsLastRemindedAt;
+
+ if (remindedAt === null) {
+ return candidate.connectPayoutsLastRemindedAt === null;
+ }
+
+ if (
+ !(remindedAt instanceof Date) &&
+ remindedAt?.lte instanceof Date &&
+ candidate.connectPayoutsLastRemindedAt !== null
+ ) {
+ return (
+ candidate.connectPayoutsLastRemindedAt.getTime() <=
+ remindedAt.lte.getTime()
+ );
+ }
+
+ return false;
+ });
+}
+
+function matchesProgramEnrollmentFilter(
+ filter: {
+ OR: Array<
+ | { program: { payoutMode: ProgramPayoutMode } }
+ | { tenantId: string | null }
+ >;
+ },
+ enrollment: {
+ payoutMode: ProgramPayoutMode;
+ tenantId: string | null;
+ },
+) {
+ return filter.OR.some((clause) => {
+ if ("program" in clause) {
+ return clause.program.payoutMode === enrollment.payoutMode;
+ }
+
+ return clause.tenantId === enrollment.tenantId;
+ });
+}
+
+describe("sendPayoutReminder", () => {
+ beforeEach(() => {
+ vi.useFakeTimers();
+ vi.setSystemTime(NOW);
+
+ mocks.groupBy.mockReset().mockResolvedValue([]);
+ mocks.partnerFindMany.mockReset().mockResolvedValue([]);
+ mocks.programFindMany.mockReset().mockResolvedValue([]);
+ mocks.partnerUpdateMany.mockReset().mockResolvedValue({ count: 0 });
+ mocks.queueBatchEmail.mockReset().mockResolvedValue([]);
+ });
+
+ afterEach(() => {
+ vi.useRealTimers();
+ });
+
+ it("returns false without emailing when no payouts match", async () => {
+ await expect(sendPayoutReminder()).resolves.toBe(false);
+
+ expect(mocks.partnerFindMany).not.toHaveBeenCalled();
+ expect(mocks.queueBatchEmail).not.toHaveBeenCalled();
+ expect(mocks.partnerUpdateMany).not.toHaveBeenCalled();
+ });
+
+ it.each([
+ {
+ label: "pending status",
+ patch: { status: PayoutStatus.pending },
+ included: true,
+ },
+ {
+ label: "processing status",
+ patch: { status: PayoutStatus.processing },
+ included: true,
+ },
+ {
+ label: "processed status",
+ patch: { status: PayoutStatus.processed },
+ included: true,
+ },
+ {
+ label: "failed status",
+ patch: { status: PayoutStatus.failed },
+ included: true,
+ },
+ {
+ label: "sent status",
+ patch: { status: PayoutStatus.sent },
+ included: false,
+ },
+ {
+ label: "completed status",
+ patch: { status: PayoutStatus.completed },
+ included: false,
+ },
+ {
+ label: "canceled status",
+ patch: { status: PayoutStatus.canceled },
+ included: false,
+ },
+ {
+ label: "Acme program",
+ patch: { programId: ACME_PROGRAM_ID },
+ included: false,
+ },
+ {
+ label: "demo program",
+ patch: { programId: DEMO_PROGRAM_ID },
+ included: false,
+ },
+ {
+ label: "migration program",
+ patch: { programId: MIGRATION_PROGRAM_ID },
+ included: false,
+ },
+ {
+ label: "payouts already connected",
+ patch: { payoutsEnabledAt: NOW },
+ included: false,
+ },
+ {
+ label: "missing country",
+ patch: { country: null },
+ included: true,
+ },
+ {
+ label: "supported country",
+ patch: { country: supportedCountry },
+ included: true,
+ },
+ {
+ label: "unsupported country",
+ patch: { country: unsupportedCountry },
+ included: false,
+ },
+ {
+ label: "never reminded",
+ patch: { connectPayoutsLastRemindedAt: null },
+ included: true,
+ },
+ {
+ label: "reminded exactly 3 days ago",
+ patch: {
+ connectPayoutsLastRemindedAt: new Date(NOW.getTime() - THREE_DAYS_MS),
+ },
+ included: true,
+ },
+ {
+ label: "reminded more than 3 days ago",
+ patch: {
+ connectPayoutsLastRemindedAt: new Date(
+ NOW.getTime() - THREE_DAYS_MS - 1,
+ ),
+ },
+ included: true,
+ },
+ {
+ label: "reminded within 3 days",
+ patch: {
+ connectPayoutsLastRemindedAt: new Date(
+ NOW.getTime() - THREE_DAYS_MS + 1,
+ ),
+ },
+ included: false,
+ },
+ {
+ label: "amount at the minimum",
+ patch: { amount: MIN_PAYOUT_AMOUNT_FOR_REMINDERS },
+ included: true,
+ },
+ {
+ label: "amount below the minimum",
+ patch: { amount: MIN_PAYOUT_AMOUNT_FOR_REMINDERS - 1 },
+ included: false,
+ },
+ ])("$label is included: $included", async ({ patch, included }) => {
+ await sendPayoutReminder();
+
+ const { where } = mocks.groupBy.mock.calls[0][0];
+
+ expect(
+ matchesReminderFilters(where, { ...eligibleReminder, ...patch }),
+ ).toBe(included);
+ });
+
+ it.each([
+ {
+ payoutMode: ProgramPayoutMode.internal,
+ tenantId: "tenant_1",
+ included: true,
+ },
+ {
+ payoutMode: ProgramPayoutMode.internal,
+ tenantId: null,
+ included: true,
+ },
+ {
+ payoutMode: ProgramPayoutMode.external,
+ tenantId: "tenant_1",
+ included: false,
+ },
+ {
+ payoutMode: ProgramPayoutMode.external,
+ tenantId: null,
+ included: true,
+ },
+ {
+ payoutMode: ProgramPayoutMode.hybrid,
+ tenantId: "tenant_1",
+ included: false,
+ },
+ {
+ payoutMode: ProgramPayoutMode.hybrid,
+ tenantId: null,
+ included: true,
+ },
+ ])(
+ "payout mode $payoutMode with tenantId $tenantId is included: $included",
+ async ({ payoutMode, tenantId, included }) => {
+ await sendPayoutReminder();
+
+ const { where } = mocks.groupBy.mock.calls[0][0];
+
+ expect(
+ matchesProgramEnrollmentFilter(where.programEnrollment, {
+ payoutMode,
+ tenantId,
+ }),
+ ).toBe(included);
+ },
+ );
+
+ it("sends one reminder per partner and records when they were reminded", async () => {
+ mocks.groupBy.mockResolvedValue([
+ payoutGroup({
+ partnerId: "pn_1",
+ programId: "prog_a",
+ amount: 2500,
+ }),
+ payoutGroup({
+ partnerId: "pn_1",
+ programId: "prog_b",
+ amount: 1500,
+ }),
+ payoutGroup({
+ partnerId: "pn_2",
+ programId: "prog_a",
+ amount: 1000,
+ }),
+ ]);
+ mocks.partnerFindMany.mockResolvedValue([
+ partner({ id: "pn_1", email: "[email protected]" }),
+ partner({ id: "pn_2", email: "[email protected]" }),
+ ]);
+ mocks.programFindMany.mockResolvedValue([
+ program({ id: "prog_a" }),
+ program({ id: "prog_b" }),
+ ]);
+
+ await expect(sendPayoutReminder()).resolves.toBe(false);
+
+ expect(mocks.partnerFindMany).toHaveBeenCalledWith({
+ where: {
+ id: {
+ in: ["pn_1", "pn_1", "pn_2"],
+ },
+ OR: [
+ {
+ users: {
+ none: {},
+ },
+ },
+ {
+ users: {
+ some: {
+ notificationPreferences: {
+ connectPayoutReminder: true,
+ },
+ },
+ },
+ },
+ ],
+ },
+ select: {
+ id: true,
+ name: true,
+ email: true,
+ },
+ });
+ expect(mocks.programFindMany).toHaveBeenCalledWith({
+ where: {
+ id: {
+ in: ["prog_a", "prog_b", "prog_a"],
+ },
+ },
+ select: {
+ id: true,
+ name: true,
+ logo: true,
+ },
+ });
+ expect(mocks.queueBatchEmail).toHaveBeenCalledWith([
+ {
+ variant: "notifications",
+ subject: "Connect your payout details on Dub Partners",
+ templateName: "ConnectPayoutReminder",
+ templateProps: {
+ email: "[email protected]",
+ programs: [
+ {
+ id: "prog_a",
+ name: "Program prog_a",
+ logo: "https://example.com/prog_a.png",
+ amount: 2500,
+ },
+ {
+ id: "prog_b",
+ name: "Program prog_b",
+ logo: "https://example.com/prog_b.png",
+ amount: 1500,
+ },
+ ],
+ },
+ },
+ {
+ variant: "notifications",
+ subject: "Connect your payout details on Dub Partners",
+ templateName: "ConnectPayoutReminder",
+ templateProps: {
+ email: "[email protected]",
+ programs: [
+ {
+ id: "prog_a",
+ name: "Program prog_a",
+ logo: "https://example.com/prog_a.png",
+ amount: 1000,
+ },
+ ],
+ },
+ },
+ ]);
+ expect(mocks.partnerUpdateMany).toHaveBeenCalledWith({
+ where: {
+ id: {
+ in: ["pn_1", "pn_2"],
+ },
+ },
+ data: {
+ connectPayoutsLastRemindedAt: NOW,
+ },
+ });
+ });
+
+ it("skips partners with no email and partners excluded by notification preferences", async () => {
+ mocks.groupBy.mockResolvedValue([
+ payoutGroup({
+ partnerId: "pn_no_email",
+ programId: "prog_a",
+ amount: 2000,
+ }),
+ payoutGroup({
+ partnerId: "pn_opted_out",
+ programId: "prog_a",
+ amount: 2000,
+ }),
+ payoutGroup({
+ partnerId: "pn_ok",
+ programId: "prog_a",
+ amount: 2000,
+ }),
+ ]);
+ mocks.partnerFindMany.mockResolvedValue([
+ partner({ id: "pn_no_email", email: null }),
+ partner({ id: "pn_ok", email: "[email protected]" }),
+ ]);
+ mocks.programFindMany.mockResolvedValue([program({ id: "prog_a" })]);
+
+ await expect(sendPayoutReminder()).resolves.toBe(false);
+
+ expect(mocks.queueBatchEmail).toHaveBeenCalledWith([
+ expect.objectContaining({
+ }),
+ ]);
+ expect(mocks.partnerUpdateMany).toHaveBeenCalledWith({
+ where: {
+ id: {
+ in: ["pn_ok"],
+ },
+ },
+ data: {
+ connectPayoutsLastRemindedAt: NOW,
+ },
+ });
+ });
+
+ it("returns true when the batch is full so another run can be scheduled", async () => {
+ mocks.groupBy.mockResolvedValue(
+ Array.from({ length: BATCH_SIZE }, (_, index) =>
+ payoutGroup({
+ partnerId: `pn_${index}`,
+ programId: "prog_a",
+ amount: 1000,
+ }),
+ ),
+ );
+ mocks.partnerFindMany.mockResolvedValue([
+ partner({ id: "pn_0", email: "[email protected]" }),
+ ]);
+ mocks.programFindMany.mockResolvedValue([program({ id: "prog_a" })]);
+
+ await expect(sendPayoutReminder()).resolves.toBe(true);
+ });
+});