The modern link attribution platform. Loved by world-class engineering teams at Twilio, Zillow, Jobber, Vercel, Raycast, and more.
TypeScript clickhousemysqlnextjsopen-sourceplanetscaleprismatailwindcsstinybirdtypescriptupstashvercel
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.tsindex 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/partnersexport 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.tsnew file mode 100644index 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.tsindex 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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",+ to: "[email protected]",+ 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",+ to: "[email protected]",+ 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({+ to: "[email protected]",+ }),+ ]);+ 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);+ });+});