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.

Use withCron for more cron route handlers

Kiran Kca81c608390c
diff --git a/apps/web/app/(ee)/api/cron/domains/renewal-payments/route.ts b/apps/web/app/(ee)/api/cron/domains/renewal-payments/route.ts
index 85b77d0675..10e1e28c72 100644
--- a/apps/web/app/(ee)/api/cron/domains/renewal-payments/route.ts
+++ b/apps/web/app/(ee)/api/cron/domains/renewal-payments/route.ts
@@ -1,9 +1,8 @@
import { createId } from "@/lib/api/create-id";
-import { handleAndReturnErrorResponse } from "@/lib/api/errors";
-import { verifyVercelSignature } from "@/lib/cron/verify-vercel";
+import { withCron } from "@/lib/cron/with-cron";
import { prisma } from "@/lib/prisma";
import { createPaymentIntent } from "@/lib/stripe/create-payment-intent";
-import { ACME_WORKSPACE_ID, DUB_WORKSPACE_ID, log } from "@dub/utils";
+import { ACME_WORKSPACE_ID, DUB_WORKSPACE_ID } from "@dub/utils";
import { Invoice, Project, RegisteredDomain } from "@prisma/client";
import { addDays, endOfDay, startOfDay } from "date-fns";
import { NextResponse } from "next/server";
@@ -23,159 +22,146 @@ interface GroupedWorkspace {
}
// GET /api/cron/domains/renewal-payments
-export async function GET(req: Request) {
- try {
- await verifyVercelSignature(req);
-
- const targetDate = addDays(new Date(), 14);
-
- console.log("targetDate", targetDate);
-
- // Find all domains expiring in 14 days
- const domains = await prisma.registeredDomain.findMany({
- where: {
- autoRenewalDisabledAt: null,
- expiresAt: {
- gte: startOfDay(targetDate),
- lte: endOfDay(targetDate),
- },
+export const GET = withCron(async () => {
+ const targetDate = addDays(new Date(), 14);
+
+ console.log("targetDate", targetDate);
+
+ // Find all domains expiring in 14 days
+ const domains = await prisma.registeredDomain.findMany({
+ where: {
+ autoRenewalDisabledAt: null,
+ expiresAt: {
+ gte: startOfDay(targetDate),
+ lte: endOfDay(targetDate),
},
- include: {
- project: {
- select: {
- id: true,
- stripeId: true,
- invoicePrefix: true,
- },
+ },
+ include: {
+ project: {
+ select: {
+ id: true,
+ stripeId: true,
+ invoicePrefix: true,
},
},
- });
+ },
+ });
- if (domains.length === 0) {
- console.log(
- "No domains found expiring exactly 14 days from today. Skipping...",
- );
- return NextResponse.json(
- "No domains found expiring exactly 14 days from today.",
- );
- }
+ if (domains.length === 0) {
+ console.log(
+ "No domains found expiring exactly 14 days from today. Skipping...",
+ );
+ return NextResponse.json(
+ "No domains found expiring exactly 14 days from today.",
+ );
+ }
- console.table(domains, ["slug", "expiresAt", "renewalFee"]);
+ console.table(domains, ["slug", "expiresAt", "renewalFee"]);
- // Group domains by workspaceId
- const groupedByWorkspace = domains.reduce(
- (acc, domain) => {
- const workspaceId = domain.projectId;
+ // Group domains by workspaceId
+ const groupedByWorkspace = domains.reduce(
+ (acc, domain) => {
+ const workspaceId = domain.projectId;
- if (!acc[workspaceId]) {
- acc[workspaceId] = {
- workspace: domain.project,
- domains: [],
- };
- }
+ if (!acc[workspaceId]) {
+ acc[workspaceId] = {
+ workspace: domain.project,
+ domains: [],
+ };
+ }
- acc[workspaceId].domains.push({
- id: domain.id,
- slug: domain.slug,
- expiresAt: domain.expiresAt,
- renewalFee: domain.renewalFee,
- });
+ acc[workspaceId].domains.push({
+ id: domain.id,
+ slug: domain.slug,
+ expiresAt: domain.expiresAt,
+ renewalFee: domain.renewalFee,
+ });
- return acc;
- },
- {} as Record<string, GroupedWorkspace>,
- );
+ return acc;
+ },
+ {} as Record<string, GroupedWorkspace>,
+ );
+
+ const invoices: Invoice[] = [];
+
+ // Create invoice for each workspace + domains group
+ for (const workspaceId in groupedByWorkspace) {
+ const { workspace, domains } = groupedByWorkspace[workspaceId];
- const invoices: Invoice[] = [];
-
- // Create invoice for each workspace + domains group
- for (const workspaceId in groupedByWorkspace) {
- const { workspace, domains } = groupedByWorkspace[workspaceId];
-
- const invoice = await prisma.$transaction(async (tx) => {
- // Generate the next invoice number by counting the number of invoices for the workspace
- const totalInvoices = await tx.invoice.count({
- where: {
- workspaceId: workspace.id,
- },
- });
- const paddedNumber = String(totalInvoices + 1).padStart(4, "0");
- const invoiceNumber = `${workspace.invoicePrefix}-${paddedNumber}`;
-
- const totalAmount = domains.reduce(
- (acc, domain) => acc + domain.renewalFee,
- 0,
- );
-
- return await tx.invoice.create({
- data: {
- id: createId({ prefix: "inv_" }),
- workspaceId: workspace.id,
- number: invoiceNumber,
- type: "domainRenewal",
- amount: totalAmount,
- total: totalAmount,
- registeredDomains: domains.map(({ slug }) => slug), // array of domain slugs,
- },
- });
+ const invoice = await prisma.$transaction(async (tx) => {
+ // Generate the next invoice number by counting the number of invoices for the workspace
+ const totalInvoices = await tx.invoice.count({
+ where: {
+ workspaceId: workspace.id,
+ },
});
+ const paddedNumber = String(totalInvoices + 1).padStart(4, "0");
+ const invoiceNumber = `${workspace.invoicePrefix}-${paddedNumber}`;
- console.log(
- `Invoice ${invoice.id} with total ${invoice.total} created for workspace ${workspace.id} to renew ${domains.length} domains.`,
+ const totalAmount = domains.reduce(
+ (acc, domain) => acc + domain.renewalFee,
+ 0,
);
- invoices.push(invoice);
- }
+ return await tx.invoice.create({
+ data: {
+ id: createId({ prefix: "inv_" }),
+ workspaceId: workspace.id,
+ number: invoiceNumber,
+ type: "domainRenewal",
+ amount: totalAmount,
+ total: totalAmount,
+ registeredDomains: domains.map(({ slug }) => slug), // array of domain slugs,
+ },
+ });
+ });
- // Create payment intent for each invoice
- for (const invoice of invoices) {
- let { workspace } = groupedByWorkspace[invoice.workspaceId];
-
- // If Acme workspace, use Dub workspace stripeId
- if (workspace.id === ACME_WORKSPACE_ID) {
- const dubWorkspace = await prisma.project.findUniqueOrThrow({
- where: {
- id: DUB_WORKSPACE_ID,
- },
- select: {
- stripeId: true,
- },
- });
-
- workspace = {
- ...workspace,
- stripeId: dubWorkspace.stripeId,
- };
+ console.log(
+ `Invoice ${invoice.id} with total ${invoice.total} created for workspace ${workspace.id} to renew ${domains.length} domains.`,
+ );
- console.log(
- `Using Dub workspace stripeId for Acme workspace domains...`,
- );
- }
+ invoices.push(invoice);
+ }
- if (!workspace.stripeId) {
- console.log(`Workspace ${workspace.id} has no stripeId, skipping...`);
- continue;
- }
+ // Create payment intent for each invoice
+ for (const invoice of invoices) {
+ let { workspace } = groupedByWorkspace[invoice.workspaceId];
- const res = await createPaymentIntent({
- stripeId: workspace.stripeId,
- amount: invoice.total,
- invoiceId: invoice.id,
- statementDescriptor: "DUB.CO DOMAIN RENEWAL",
- description: `Domain renewal invoice (${invoice.id})`,
- idempotencyKey: `${invoice.id}-${invoice.failedAttempts}`,
+ // If Acme workspace, use Dub workspace stripeId
+ if (workspace.id === ACME_WORKSPACE_ID) {
+ const dubWorkspace = await prisma.project.findUniqueOrThrow({
+ where: {
+ id: DUB_WORKSPACE_ID,
+ },
+ select: {
+ stripeId: true,
+ },
});
- console.log(`Payment intent created for invoice ${invoice.id}`, res);
+ workspace = {
+ ...workspace,
+ stripeId: dubWorkspace.stripeId,
+ };
+
+ console.log(`Using Dub workspace stripeId for Acme workspace domains...`);
}
- return NextResponse.json("OK");
- } catch (error) {
- await log({
- message: "Domains renewal cron failed. Error: " + error.message,
- type: "errors",
+ if (!workspace.stripeId) {
+ console.log(`Workspace ${workspace.id} has no stripeId, skipping...`);
+ continue;
+ }
+
+ const res = await createPaymentIntent({
+ stripeId: workspace.stripeId,
+ amount: invoice.total,
+ invoiceId: invoice.id,
+ statementDescriptor: "DUB.CO DOMAIN RENEWAL",
+ description: `Domain renewal invoice (${invoice.id})`,
+ idempotencyKey: `${invoice.id}-${invoice.failedAttempts}`,
});
- return handleAndReturnErrorResponse(error);
+ console.log(`Payment intent created for invoice ${invoice.id}`, res);
}
-}
+
+ return NextResponse.json("OK");
+});
diff --git a/apps/web/app/(ee)/api/cron/domains/renewal-reminders/route.ts b/apps/web/app/(ee)/api/cron/domains/renewal-reminders/route.ts
index 2768cc354f..37fdbd27c9 100644
--- a/apps/web/app/(ee)/api/cron/domains/renewal-reminders/route.ts
+++ b/apps/web/app/(ee)/api/cron/domains/renewal-reminders/route.ts
@@ -1,9 +1,8 @@
-import { handleAndReturnErrorResponse } from "@/lib/api/errors";
-import { verifyVercelSignature } from "@/lib/cron/verify-vercel";
+import { withCron } from "@/lib/cron/with-cron";
import { prisma } from "@/lib/prisma";
import { sendBatchEmail } from "@dub/email";
import DomainRenewalReminder from "@dub/email/templates/domain-renewal-reminder";
-import { chunk, log } from "@dub/utils";
+import { chunk } from "@dub/utils";
import {
differenceInCalendarDays,
endOfDay,
@@ -27,109 +26,98 @@ export const dynamic = "force-dynamic";
const REMINDER_WINDOWS = [30, 23, 16];
// GET /api/cron/domains/renewal-reminders
-export async function GET(req: Request) {
- try {
- await verifyVercelSignature(req);
-
- const now = new Date();
-
- const targetDates = REMINDER_WINDOWS.map((days) => {
- const date = subDays(now, -days);
-
- return {
- start: startOfDay(date),
- end: endOfDay(date),
- days,
- };
- });
-
- console.log("targetDates", targetDates);
-
- // Find all domains that are eligible for renewal reminders
- const domains = await prisma.registeredDomain.findMany({
- where: {
- autoRenewalDisabledAt: null,
- OR: targetDates.map((t) => ({
- expiresAt: {
- gte: t.start,
- lte: t.end,
- },
- })),
- },
- include: {
- project: {
- include: {
- users: {
- where: {
- role: "owner",
- },
- include: {
- user: true,
- },
+export const GET = withCron(async () => {
+ const now = new Date();
+
+ const targetDates = REMINDER_WINDOWS.map((days) => {
+ const date = subDays(now, -days);
+
+ return {
+ start: startOfDay(date),
+ end: endOfDay(date),
+ days,
+ };
+ });
+
+ console.log("targetDates", targetDates);
+
+ // Find all domains that are eligible for renewal reminders
+ const domains = await prisma.registeredDomain.findMany({
+ where: {
+ autoRenewalDisabledAt: null,
+ OR: targetDates.map((t) => ({
+ expiresAt: {
+ gte: t.start,
+ lte: t.end,
+ },
+ })),
+ },
+ include: {
+ project: {
+ include: {
+ users: {
+ where: {
+ role: "owner",
+ },
+ include: {
+ user: true,
},
},
},
},
- });
-
- if (domains.length === 0) {
- console.log("No domains found to send reminders for. Skipping...");
- return NextResponse.json("No domains found to send reminders for.");
- }
-
- const reminderDomains = domains.flatMap(
- ({ slug, expiresAt, renewalFee, project }) => {
- const reminderWindow = differenceInCalendarDays(expiresAt, now);
-
- // we charge 14 days before the expiration date to ensure timely processing
- const chargeAt: Date = subDays(expiresAt, 14);
-
- return project.users.map(({ user }) => ({
- domain: {
- slug,
- renewalFee,
- expiresAt,
- reminderWindow,
- chargeAt,
- chargeAtInText: formatDistanceStrict(chargeAt, now),
- },
- workspace: {
- slug: project.slug,
- },
- user: {
- email: user.email,
- },
- }));
- },
- );
+ },
+ });
+
+ if (domains.length === 0) {
+ console.log("No domains found to send reminders for. Skipping...");
+ return NextResponse.json("No domains found to send reminders for.");
+ }
- console.table(reminderDomains);
-
- const reminderDomainsChunks = chunk(reminderDomains, 100);
-
- for (const reminderDomainsChunk of reminderDomainsChunks) {
- const res = await sendBatchEmail(
- reminderDomainsChunk.map(({ workspace, user, domain }) => ({
- to: user.email!,
- subject: "Your domain is expiring soon",
- variant: "notifications",
- react: DomainRenewalReminder({
- email: user.email!,
- workspace,
- domain,
- }),
- })),
- );
- console.log(`Sent ${reminderDomainsChunk.length} emails`, res);
- }
-
- return NextResponse.json(reminderDomains);
- } catch (error) {
- await log({
- message: "Domains renewal reminders cron failed. Error: " + error.message,
- type: "errors",
- });
-
- return handleAndReturnErrorResponse(error);
+ const reminderDomains = domains.flatMap(
+ ({ slug, expiresAt, renewalFee, project }) => {
+ const reminderWindow = differenceInCalendarDays(expiresAt, now);
+
+ // we charge 14 days before the expiration date to ensure timely processing
+ const chargeAt: Date = subDays(expiresAt, 14);
+
+ return project.users.map(({ user }) => ({
+ domain: {
+ slug,
+ renewalFee,
+ expiresAt,
+ reminderWindow,
+ chargeAt,
+ chargeAtInText: formatDistanceStrict(chargeAt, now),
+ },
+ workspace: {
+ slug: project.slug,
+ },
+ user: {
+ email: user.email,
+ },
+ }));
+ },
+ );
+
+ console.table(reminderDomains);
+
+ const reminderDomainsChunks = chunk(reminderDomains, 100);
+
+ for (const reminderDomainsChunk of reminderDomainsChunks) {
+ const res = await sendBatchEmail(
+ reminderDomainsChunk.map(({ workspace, user, domain }) => ({
+ to: user.email!,
+ subject: "Your domain is expiring soon",
+ variant: "notifications",
+ react: DomainRenewalReminder({
+ email: user.email!,
+ workspace,
+ domain,
+ }),
+ })),
+ );
+ console.log(`Sent ${reminderDomainsChunk.length} emails`, res);
}
-}
+
+ return NextResponse.json(reminderDomains);
+});
diff --git a/apps/web/app/(ee)/api/cron/domains/verify/route.ts b/apps/web/app/(ee)/api/cron/domains/verify/route.ts
index b60ae2a1d7..4f4faa3826 100644
--- a/apps/web/app/(ee)/api/cron/domains/verify/route.ts
+++ b/apps/web/app/(ee)/api/cron/domains/verify/route.ts
@@ -1,10 +1,8 @@
import { getConfigResponse } from "@/lib/api/domains/get-config-response";
import { getDomainResponse } from "@/lib/api/domains/get-domain-response";
import { verifyDomain } from "@/lib/api/domains/verify-domain";
-import { handleAndReturnErrorResponse } from "@/lib/api/errors";
-import { verifyVercelSignature } from "@/lib/cron/verify-vercel";
+import { withCron } from "@/lib/cron/with-cron";
import { prisma } from "@/lib/prisma";
-import { log } from "@dub/utils";
import { NextResponse } from "next/server";
import { handleDomainUpdates } from "./utils";
@@ -18,102 +16,93 @@ import { handleDomainUpdates } from "./utils";
export const dynamic = "force-dynamic";
-export async function GET(req: Request) {
- try {
- await verifyVercelSignature(req);
-
- const domains = await prisma.domain.findMany({
- where: {
- slug: {
- // exclude domains that belong to us
- notIn: [
- "dub.sh",
- "chatg.pt",
- "amzn.id",
- "spti.fi",
- "stey.me",
- "steven.yt",
- "steven.blue",
- "owd.li",
- "elegance.ai",
- ],
- },
- // only check domains that do not belong to a partner program
- partnerProgram: null,
- },
- select: {
- slug: true,
- verified: true,
- primary: true,
- createdAt: true,
+export const GET = withCron(async () => {
+ const domains = await prisma.domain.findMany({
+ where: {
+ slug: {
+ // exclude domains that belong to us
+ notIn: [
+ "dub.sh",
+ "chatg.pt",
+ "amzn.id",
+ "spti.fi",
+ "stey.me",
+ "steven.yt",
+ "steven.blue",
+ "owd.li",
+ "elegance.ai",
+ ],
},
- orderBy: {
- lastChecked: "asc",
- },
- take: 30,
- });
+ // only check domains that do not belong to a partner program
+ partnerProgram: null,
+ },
+ select: {
+ slug: true,
+ verified: true,
+ primary: true,
+ createdAt: true,
+ },
+ orderBy: {
+ lastChecked: "asc",
+ },
+ take: 30,
+ });
- const results = await Promise.allSettled(
- domains.map(async (domain) => {
- const { slug, verified, primary, createdAt } = domain;
- const [domainJson, configJson] = await Promise.all([
- getDomainResponse(slug),
- getConfigResponse(slug),
- ]);
+ const results = await Promise.allSettled(
+ domains.map(async (domain) => {
+ const { slug, verified, primary, createdAt } = domain;
+ const [domainJson, configJson] = await Promise.all([
+ getDomainResponse(slug),
+ getConfigResponse(slug),
+ ]);
- let newVerified;
+ let newVerified;
- if (domainJson?.error?.code === "not_found") {
- newVerified = false;
- } else if (!domainJson.verified) {
- const verificationJson = await verifyDomain(slug);
- if (verificationJson && verificationJson.verified) {
- newVerified = true;
- } else {
- newVerified = false;
- }
- } else if (!configJson.misconfigured) {
+ if (domainJson?.error?.code === "not_found") {
+ newVerified = false;
+ } else if (!domainJson.verified) {
+ const verificationJson = await verifyDomain(slug);
+ if (verificationJson && verificationJson.verified) {
newVerified = true;
} else {
newVerified = false;
}
+ } else if (!configJson.misconfigured) {
+ newVerified = true;
+ } else {
+ newVerified = false;
+ }
- const prismaResponse = await prisma.domain.update({
- where: {
- slug,
- },
- data: {
- verified: newVerified,
- lastChecked: new Date(),
- },
- });
+ const prismaResponse = await prisma.domain.update({
+ where: {
+ slug,
+ },
+ data: {
+ verified: newVerified,
+ lastChecked: new Date(),
+ },
+ });
- const changed = newVerified !== verified;
+ const changed = newVerified !== verified;
- const updates = await handleDomainUpdates({
- domain: slug,
- createdAt,
- verified: newVerified,
- primary,
- changed,
- });
+ const updates = await handleDomainUpdates({
+ domain: slug,
+ createdAt,
+ verified: newVerified,
+ primary,
+ changed,
+ });
+
+ return {
+ domain,
+ previousStatus: verified,
+ currentStatus: newVerified,
+ changed,
+ updates,
+ prismaResponse,
+ };
+ }),
+ );
- return {
- domain,
- previousStatus: verified,
- currentStatus: newVerified,
- changed,
- updates,
- prismaResponse,
- };
- }),
- );
- return NextResponse.json(results);
- } catch (error) {
- await log({
- message: "Domains cron failed. Error: " + error.message,
- type: "errors",
- });
- return handleAndReturnErrorResponse(error);
- }
-}
+ return NextResponse.json(results);
+});
diff --git a/apps/web/app/(ee)/api/cron/fraud/summary/route.ts b/apps/web/app/(ee)/api/cron/fraud/summary/route.ts
index 4113257882..3630f58606 100644
--- a/apps/web/app/(ee)/api/cron/fraud/summary/route.ts
+++ b/apps/web/app/(ee)/api/cron/fraud/summary/route.ts
@@ -1,9 +1,7 @@
-import { handleAndReturnErrorResponse } from "@/lib/api/errors";
import { FRAUD_RULES_BY_TYPE } from "@/lib/api/fraud/constants";
import { getWorkspaceUsers } from "@/lib/api/get-workspace-users";
import { qstash } from "@/lib/cron";
-import { verifyQstashSignature } from "@/lib/cron/verify-qstash";
-import { verifyVercelSignature } from "@/lib/cron/verify-vercel";
+import { withCron } from "@/lib/cron/with-cron";
import { queueBatchEmail } from "@/lib/email/queue-batch-email";
import { prisma } from "@/lib/prisma";
import type UnresolvedRiskEventsSummary from "@dub/email/templates/unresolved-risk-events-summary";
@@ -20,166 +18,147 @@ const schema = z.object({
startingAfter: z.string().optional(),
});
-// POST /api/cron/fraud/summary
// This route sends a daily summary of unresolved risk events to program owners
// Runs daily at 4:00 PM UTC
-async function handler(req: Request) {
- try {
- let { startingAfter } = schema.parse({});
-
- if (req.method === "GET") {
- await verifyVercelSignature(req);
- } else if (req.method === "POST") {
- const rawBody = await req.text();
- await verifyQstashSignature({
- req,
- rawBody,
- });
-
- ({ startingAfter } = schema.parse(JSON.parse(rawBody)));
- }
-
- // Get batch of programs with unresolved risk events
- const programs = await prisma.program.findMany({
- where: {
- deactivatedAt: null,
- fraudEventGroups: {
- some: {
- status: "pending",
- lastEventAt: {
- gte: startOfDay(new Date()),
- },
+// GET/POST /api/cron/fraud/summary
+export const GET = withCron(async ({ rawBody }) => {
+ let { startingAfter } = schema.parse(rawBody ? JSON.parse(rawBody) : {});
+
+ // Get batch of programs with unresolved risk events
+ const programs = await prisma.program.findMany({
+ where: {
+ deactivatedAt: null,
+ fraudEventGroups: {
+ some: {
+ status: "pending",
+ lastEventAt: {
+ gte: startOfDay(new Date()),
},
},
},
- select: {
- id: true,
- name: true,
- slug: true,
- workspace: {
- select: {
- slug: true,
- },
+ },
+ select: {
+ id: true,
+ name: true,
+ slug: true,
+ workspace: {
+ select: {
+ slug: true,
},
},
- take: PROGRAMS_BATCH_SIZE,
- ...(startingAfter && {
- skip: 1,
- cursor: {
- id: startingAfter,
- },
- }),
- orderBy: {
- id: "asc",
+ },
+ take: PROGRAMS_BATCH_SIZE,
+ ...(startingAfter && {
+ skip: 1,
+ cursor: {
+ id: startingAfter,
},
- });
-
- if (programs.length === 0) {
- return logAndRespond(
- "No more programs found to send risk events summary.",
- );
- }
+ }),
+ orderBy: {
+ id: "asc",
+ },
+ });
+
+ if (programs.length === 0) {
+ return logAndRespond("No more programs found to send risk events summary.");
+ }
- const batchDate = format(new Date(), "yyyy-MM-dd");
+ const batchDate = format(new Date(), "yyyy-MM-dd");
- for (const program of programs) {
- try {
- const fraudGroups = await prisma.fraudEventGroup.findMany({
- where: {
- programId: program.id,
- status: "pending",
- lastEventAt: {
- gte: startOfDay(new Date()),
- },
+ for (const program of programs) {
+ try {
+ const fraudGroups = await prisma.fraudEventGroup.findMany({
+ where: {
+ programId: program.id,
+ status: "pending",
+ lastEventAt: {
+ gte: startOfDay(new Date()),
},
- select: {
- id: true,
- type: true,
- eventCount: true,
- partner: {
- select: {
- id: true,
- name: true,
- image: true,
- },
+ },
+ select: {
+ id: true,
+ type: true,
+ eventCount: true,
+ partner: {
+ select: {
+ id: true,
+ name: true,
+ image: true,
},
},
- orderBy: {
- lastEventAt: "desc",
- },
- take: 6,
- });
+ },
+ orderBy: {
+ lastEventAt: "desc",
+ },
+ take: 6,
+ });
- if (fraudGroups.length === 0) {
- continue;
- }
+ if (fraudGroups.length === 0) {
+ continue;
+ }
- // Get workspace users to send the email to
- const { users } = await getWorkspaceUsers({
- role: "owner",
- programId: program.id,
- notificationPreference: "fraudEventsSummary",
- });
-
- if (users.length === 0) {
- continue;
- }
-
- const transformedFraudGroups = fraudGroups.map(
- ({ id, type, eventCount, partner }) => ({
- id,
- name: FRAUD_RULES_BY_TYPE[type].name,
- count: eventCount,
- partner,
- }),
- );
-
- await queueBatchEmail<typeof UnresolvedRiskEventsSummary>(
- users.map((user) => ({
- to: user.email,
- subject: `Risk events pending review for ${program.name}`,
- variant: "notifications",
- templateName: "UnresolvedRiskEventsSummary",
- templateProps: {
- email: user.email,
- workspace: program.workspace,
- program,
- fraudGroups: transformedFraudGroups,
- },
- })),
- {
- idempotencyKey: `fraud-events-summary/${program.id}/${batchDate}`,
- },
- );
- } catch (error) {
- console.error(
- `Error collecting email payloads for program ${program.id}: ${error.message}`,
- );
+ // Get workspace users to send the email to
+ const { users } = await getWorkspaceUsers({
+ role: "owner",
+ programId: program.id,
+ notificationPreference: "fraudEventsSummary",
+ });
+
+ if (users.length === 0) {
continue;
}
- }
- if (programs.length === PROGRAMS_BATCH_SIZE) {
- startingAfter = programs[programs.length - 1].id;
+ const transformedFraudGroups = fraudGroups.map(
+ ({ id, type, eventCount, partner }) => ({
+ id,
+ name: FRAUD_RULES_BY_TYPE[type].name,
+ count: eventCount,
+ partner,
+ }),
+ );
- await qstash.publishJSON({
- url: `${APP_DOMAIN_WITH_NGROK}/api/cron/fraud/summary`,
- method: "POST",
- body: {
- startingAfter,
+ await queueBatchEmail<typeof UnresolvedRiskEventsSummary>(
+ users.map((user) => ({
+ to: user.email,
+ subject: `Risk events pending review for ${program.name}`,
+ variant: "notifications",
+ templateName: "UnresolvedRiskEventsSummary",
+ templateProps: {
+ email: user.email,
+ workspace: program.workspace,
+ program,
+ fraudGroups: transformedFraudGroups,
+ },
+ })),
+ {
+ idempotencyKey: `fraud-events-summary/${program.id}/${batchDate}`,
},
- });
-
- return logAndRespond(
- `Scheduled next batch for fraud events summary (startingAfter: ${startingAfter})`,
);
+ } catch (error) {
+ console.error(
+ `Error collecting email payloads for program ${program.id}: ${error.message}`,
+ );
+ continue;
}
+ }
+
+ if (programs.length === PROGRAMS_BATCH_SIZE) {
+ startingAfter = programs[programs.length - 1].id;
+
+ await qstash.publishJSON({
+ url: `${APP_DOMAIN_WITH_NGROK}/api/cron/fraud/summary`,
+ method: "POST",
+ body: {
+ startingAfter,
+ },
+ });
- return logAndRespond("Finished sending fraud events summary.");
- } catch (error) {
- return handleAndReturnErrorResponse(error);
+ return logAndRespond(
+ `Scheduled next batch for fraud events summary (startingAfter: ${startingAfter})`,
+ );
}
-}
-// GET/POST /api/cron/fraud/summary
-export { handler as GET, handler as POST };
+ return logAndRespond("Finished sending fraud events summary.");
+});
+
+export const POST = GET;
diff --git a/apps/web/app/(ee)/api/cron/payouts/aggregate-due-commissions/route.ts b/apps/web/app/(ee)/api/cron/payouts/aggregate-due-commissions/route.ts
index af700a96e8..80299c22a4 100644
--- a/apps/web/app/(ee)/api/cron/payouts/aggregate-due-commissions/route.ts
+++ b/apps/web/app/(ee)/api/cron/payouts/aggregate-due-commissions/route.ts
@@ -1,11 +1,9 @@
import { trackCommissionStatusUpdate } from "@/lib/api/commissions/track-commission-update-activity-log";
import { createId } from "@/lib/api/create-id";
-import { handleAndReturnErrorResponse } from "@/lib/api/errors";
import { qstash } from "@/lib/cron";
-import { verifyQstashSignature } from "@/lib/cron/verify-qstash";
-import { verifyVercelSignature } from "@/lib/cron/verify-vercel";
+import { withCron } from "@/lib/cron/with-cron";
import { prisma } from "@/lib/prisma";
-import { APP_DOMAIN_WITH_NGROK, chunk, log } from "@dub/utils";
+import { APP_DOMAIN_WITH_NGROK, chunk } from "@dub/utils";
import * as z from "zod/v4";
import { logAndRespond } from "../../utils";
@@ -19,292 +17,266 @@ const schema = z.object({
// This cron job aggregates due commissions (pending commissions that are past the partner group's holding period) into payouts.
// Runs once every hour (0 * * * *) + calls itself recursively to look through all pending commissions available.
-async function handler(req: Request) {
- try {
- let programId: string | undefined = undefined;
-
- if (req.method === "GET") {
- await verifyVercelSignature(req);
- } else if (req.method === "POST") {
- const rawBody = await req.text();
- await verifyQstashSignature({
- req,
- rawBody,
- });
-
- ({ programId } = schema.parse(JSON.parse(rawBody)));
- }
-
- const partnerGroupsByHoldingPeriod = await prisma.partnerGroup.groupBy({
- by: ["holdingPeriodDays"],
- ...(programId ? { where: { programId } } : {}),
+// GET/POST /api/cron/payouts/aggregate-due-commissions
+export const GET = withCron(async ({ rawBody }) => {
+ let { programId } = schema.parse(rawBody ? JSON.parse(rawBody) : {});
+
+ const partnerGroupsByHoldingPeriod = await prisma.partnerGroup.groupBy({
+ by: ["holdingPeriodDays"],
+ ...(programId ? { where: { programId } } : {}),
+ _count: {
+ id: true,
+ },
+ orderBy: {
_count: {
- id: true,
+ id: "desc",
},
- orderBy: {
- _count: {
- id: "desc",
- },
- },
- });
+ },
+ });
- console.log(JSON.stringify(partnerGroupsByHoldingPeriod, null, 2));
+ console.log(JSON.stringify(partnerGroupsByHoldingPeriod, null, 2));
- let holdingPeriodsWithMoreToProcess: number[] = [];
- for (const { holdingPeriodDays } of partnerGroupsByHoldingPeriod) {
- const partnerGroups = await prisma.partnerGroup.findMany({
- where: {
- holdingPeriodDays,
- ...(programId ? { programId } : {}),
- },
- select: {
- id: true,
- program: {
- select: {
- id: true,
- name: true,
- workspaceId: true,
- },
+ let holdingPeriodsWithMoreToProcess: number[] = [];
+ for (const { holdingPeriodDays } of partnerGroupsByHoldingPeriod) {
+ const partnerGroups = await prisma.partnerGroup.findMany({
+ where: {
+ holdingPeriodDays,
+ ...(programId ? { programId } : {}),
+ },
+ select: {
+ id: true,
+ program: {
+ select: {
+ id: true,
+ name: true,
+ workspaceId: true,
},
},
- });
+ },
+ });
- console.log(
- `Found ${partnerGroups.length} partner groups with holding period days: ${holdingPeriodDays}`,
- );
+ console.log(
+ `Found ${partnerGroups.length} partner groups with holding period days: ${holdingPeriodDays}`,
+ );
- // Find all due commissions (limit by BATCH_SIZE)
- const dueCommissions = await prisma.commission.findMany({
- where: {
- status: "pending",
- programEnrollment: {
- groupId: {
- in: partnerGroups.map((p) => p.id),
- },
+ // Find all due commissions (limit by BATCH_SIZE)
+ const dueCommissions = await prisma.commission.findMany({
+ where: {
+ status: "pending",
+ programEnrollment: {
+ groupId: {
+ in: partnerGroups.map((p) => p.id),
},
- // If holding period days is greater than 0:
- // we only process commissions that were created before the holding period
- // but custom commissions are always included
- ...(holdingPeriodDays > 0
- ? {
- OR: [
- {
- type: {
- // includes manual + referral commissions + clawbacks
- in: ["custom", "referral"],
- },
+ },
+ // If holding period days is greater than 0:
+ // we only process commissions that were created before the holding period
+ // but custom commissions are always included
+ ...(holdingPeriodDays > 0
+ ? {
+ OR: [
+ {
+ type: {
+ // includes manual + referral commissions + clawbacks
+ in: ["custom", "referral"],
},
- {
- createdAt: {
- lt: new Date(
- Date.now() - holdingPeriodDays * 24 * 60 * 60 * 1000,
- ),
- },
+ },
+ {
+ createdAt: {
+ lt: new Date(
+ Date.now() - holdingPeriodDays * 24 * 60 * 60 * 1000,
+ ),
},
- ],
- }
- : {}),
- },
- select: {
- id: true,
- createdAt: true,
- amount: true,
- earnings: true,
- status: true,
- partnerId: true,
- programId: true,
- },
- orderBy: {
- createdAt: "asc",
- },
- take: BATCH_SIZE,
- });
-
- if (dueCommissions.length === 0) {
- console.log(
- `No more due commissions found for partner groups with holding period days: ${holdingPeriodDays}, skipping...`,
- );
- continue;
- }
-
- if (dueCommissions.length === BATCH_SIZE) {
- holdingPeriodsWithMoreToProcess.push(holdingPeriodDays);
- }
+ },
+ ],
+ }
+ : {}),
+ },
+ select: {
+ id: true,
+ createdAt: true,
+ amount: true,
+ earnings: true,
+ status: true,
+ partnerId: true,
+ programId: true,
+ },
+ orderBy: {
+ createdAt: "asc",
+ },
+ take: BATCH_SIZE,
+ });
+ if (dueCommissions.length === 0) {
console.log(
- `Found ${dueCommissions.length} due commissions for partner groups with holding period days: ${holdingPeriodDays}`,
+ `No more due commissions found for partner groups with holding period days: ${holdingPeriodDays}, skipping...`,
);
+ continue;
+ }
- const partnerProgramCommissions = dueCommissions.reduce<
- Record<string, typeof dueCommissions>
- >((acc, commission) => {
- const key = `${commission.partnerId}:${commission.programId}`;
- if (!acc[key]) {
- acc[key] = [];
- }
- acc[key].push(commission);
- return acc;
- }, {});
-
- const partnerProgramCommissionsArray = Object.entries(
- partnerProgramCommissions,
- ).map(([key, commissions]) => ({
- partnerId: key.split(":")[0],
- programId: key.split(":")[1],
- commissions,
- }));
-
- const existingPendingPayouts = await prisma.payout.findMany({
- where: {
- programId: {
- in: partnerProgramCommissionsArray.map((p) => p.programId),
- },
- partnerId: {
- in: partnerProgramCommissionsArray.map((p) => p.partnerId),
- },
- status: "pending",
- },
- });
+ if (dueCommissions.length === BATCH_SIZE) {
+ holdingPeriodsWithMoreToProcess.push(holdingPeriodDays);
+ }
- console.log(
- `Processing ${partnerProgramCommissionsArray.length} partners with due commissions for partner groups with holding period days: ${holdingPeriodDays}`,
- );
- let totalProcessed = 0;
-
- const chunks = chunk(partnerProgramCommissionsArray, 50);
- for (let i = 0; i < chunks.length; i++) {
- const chunk = chunks[i];
- await Promise.allSettled(
- chunk.map(async ({ partnerId, programId, commissions }) => {
- // sort the commissions by createdAt
- const sortedCommissions = commissions.sort(
- (a, b) => a.createdAt.getTime() - b.createdAt.getTime(),
- );
-
- // sum the earnings of the commissions
- const totalEarnings = sortedCommissions.reduce(
- (total, commission) => total + commission.earnings,
- 0,
- );
-
- // earliest commission date
- const periodStart = sortedCommissions[0].createdAt;
-
- // last commission date
- const periodEnd =
- sortedCommissions[sortedCommissions.length - 1].createdAt;
-
- let payoutToUse = existingPendingPayouts.find(
- (p) => p.partnerId === partnerId && p.programId === programId,
- );
-
- if (!payoutToUse) {
- const programName = partnerGroups.find(
- (p) => p.program.id === programId,
- )?.program.name;
- payoutToUse = await prisma.payout.create({
- data: {
- id: createId({ prefix: "po_" }),
- programId,
- partnerId,
- periodStart,
- periodEnd,
- amount: totalEarnings,
- description: `Dub Partners payout${programName ? ` (${programName})` : ""}`,
- },
- });
- }
+ console.log(
+ `Found ${dueCommissions.length} due commissions for partner groups with holding period days: ${holdingPeriodDays}`,
+ );
- // update the commissions to have the payoutId
- await prisma.commission.updateMany({
- where: {
- id: { in: commissions.map((c) => c.id) },
- },
+ const partnerProgramCommissions = dueCommissions.reduce<
+ Record<string, typeof dueCommissions>
+ >((acc, commission) => {
+ const key = `${commission.partnerId}:${commission.programId}`;
+ if (!acc[key]) {
+ acc[key] = [];
+ }
+ acc[key].push(commission);
+ return acc;
+ }, {});
+
+ const partnerProgramCommissionsArray = Object.entries(
+ partnerProgramCommissions,
+ ).map(([key, commissions]) => ({
+ partnerId: key.split(":")[0],
+ programId: key.split(":")[1],
+ commissions,
+ }));
+
+ const existingPendingPayouts = await prisma.payout.findMany({
+ where: {
+ programId: {
+ in: partnerProgramCommissionsArray.map((p) => p.programId),
+ },
+ partnerId: {
+ in: partnerProgramCommissionsArray.map((p) => p.partnerId),
+ },
+ status: "pending",
+ },
+ });
+
+ console.log(
+ `Processing ${partnerProgramCommissionsArray.length} partners with due commissions for partner groups with holding period days: ${holdingPeriodDays}`,
+ );
+ let totalProcessed = 0;
+
+ const chunks = chunk(partnerProgramCommissionsArray, 50);
+ for (let i = 0; i < chunks.length; i++) {
+ const chunk = chunks[i];
+ await Promise.allSettled(
+ chunk.map(async ({ partnerId, programId, commissions }) => {
+ // sort the commissions by createdAt
+ const sortedCommissions = commissions.sort(
+ (a, b) => a.createdAt.getTime() - b.createdAt.getTime(),
+ );
+
+ // sum the earnings of the commissions
+ const totalEarnings = sortedCommissions.reduce(
+ (total, commission) => total + commission.earnings,
+ 0,
+ );
+
+ // earliest commission date
+ const periodStart = sortedCommissions[0].createdAt;
+
+ // last commission date
+ const periodEnd =
+ sortedCommissions[sortedCommissions.length - 1].createdAt;
+
+ let payoutToUse = existingPendingPayouts.find(
+ (p) => p.partnerId === partnerId && p.programId === programId,
+ );
+
+ if (!payoutToUse) {
+ const programName = partnerGroups.find(
+ (p) => p.program.id === programId,
+ )?.program.name;
+ payoutToUse = await prisma.payout.create({
data: {
- status: "processed",
- payoutId: payoutToUse.id,
+ id: createId({ prefix: "po_" }),
+ programId,
+ partnerId,
+ periodStart,
+ periodEnd,
+ amount: totalEarnings,
+ description: `Dub Partners payout${programName ? ` (${programName})` : ""}`,
},
});
+ }
- const workspaceId = partnerGroups.find(
- (p) => p.program.id === programId,
- )?.program.workspaceId;
-
- if (workspaceId) {
- await trackCommissionStatusUpdate({
- workspaceId,
- programId,
- commissions,
- newStatus: "processed",
- });
- }
+ // update the commissions to have the payoutId
+ await prisma.commission.updateMany({
+ where: {
+ id: { in: commissions.map((c) => c.id) },
+ },
+ data: {
+ status: "processed",
+ payoutId: payoutToUse.id,
+ },
+ });
+
+ const workspaceId = partnerGroups.find(
+ (p) => p.program.id === programId,
+ )?.program.workspaceId;
+
+ if (workspaceId) {
+ await trackCommissionStatusUpdate({
+ workspaceId,
+ programId,
+ commissions,
+ newStatus: "processed",
+ });
+ }
- // if we're reusing a pending payout, we need to update the amount and periodEnd
- if (existingPendingPayouts.find((p) => p.id === payoutToUse.id)) {
- await prisma.payout.update({
- where: {
- id: payoutToUse.id,
- },
- data: {
- amount: {
- increment: totalEarnings,
- },
- periodEnd,
+ // if we're reusing a pending payout, we need to update the amount and periodEnd
+ if (existingPendingPayouts.find((p) => p.id === payoutToUse.id)) {
+ await prisma.payout.update({
+ where: {
+ id: payoutToUse.id,
+ },
+ data: {
+ amount: {
+ increment: totalEarnings,
},
- });
- }
-
- totalProcessed++;
- }),
- );
- console.log(`Processed chunk ${i + 1} of ${chunks.length}`);
- }
+ periodEnd,
+ },
+ });
+ }
- const successRate =
- (totalProcessed / partnerProgramCommissionsArray.length) * 100;
- console.log(
- `Processed ${totalProcessed}/${partnerProgramCommissionsArray.length} partners with due commissions for partner groups with holding period days: ${holdingPeriodDays} (${successRate.toFixed(1)}% success rate)`,
+ totalProcessed++;
+ }),
);
+ console.log(`Processed chunk ${i + 1} of ${chunks.length}`);
}
- if (holdingPeriodsWithMoreToProcess.length > 0) {
- console.log(
- `Several holding periods still have more due commissions: ${holdingPeriodsWithMoreToProcess.join(", ")}`,
- );
+ const successRate =
+ (totalProcessed / partnerProgramCommissionsArray.length) * 100;
+ console.log(
+ `Processed ${totalProcessed}/${partnerProgramCommissionsArray.length} partners with due commissions for partner groups with holding period days: ${holdingPeriodDays} (${successRate.toFixed(1)}% success rate)`,
+ );
+ }
- const qstashResponse = await qstash.publishJSON({
- url: `${APP_DOMAIN_WITH_NGROK}/api/cron/payouts/aggregate-due-commissions`,
- body: programId ? { programId } : {}, // pass programId if defined, else pass an empty object
- });
- if (qstashResponse.messageId) {
- console.log(
- `Message sent to Qstash with id ${qstashResponse.messageId}`,
- );
- } else {
- // should never happen, but just in case
- await log({
- message: `Error sending message to Qstash to schedule next batch of payouts: ${JSON.stringify(qstashResponse)}`,
- type: "errors",
- mention: true,
- });
- }
- return logAndRespond(
- "Finished aggregating due commissions into payouts for current batch. Scheduling next batch...",
+ if (holdingPeriodsWithMoreToProcess.length > 0) {
+ console.log(
+ `Several holding periods still have more due commissions: ${holdingPeriodsWithMoreToProcess.join(", ")}`,
+ );
+
+ const qstashResponse = await qstash.publishJSON({
+ url: `${APP_DOMAIN_WITH_NGROK}/api/cron/payouts/aggregate-due-commissions`,
+ body: programId ? { programId } : {}, // pass programId if defined, else pass an empty object
+ });
+
+ if (!qstashResponse.messageId) {
+ throw new Error(
+ `Error sending message to Qstash to schedule next batch of payouts: ${JSON.stringify(qstashResponse)}`,
);
}
return logAndRespond(
- "Finished aggregating due commissions into payouts for all batches.",
+ "Finished aggregating due commissions into payouts for current batch. Scheduling next batch...",
);
- } catch (error) {
- await log({
- message: `Error aggregating due commissions into payouts: ${error.message}`,
- type: "errors",
- mention: true,
- });
- return handleAndReturnErrorResponse(error);
}
-}
-// GET/POST /api/cron/payouts/aggregate-due-commissions
-export { handler as GET, handler as POST };
+ return logAndRespond(
+ "Finished aggregating due commissions into payouts for all batches.",
+ );
+});
+
+export const POST = GET;
diff --git a/apps/web/app/(ee)/api/cron/payouts/force-withdrawals/route.ts b/apps/web/app/(ee)/api/cron/payouts/force-withdrawals/route.ts
index 8b572e2ee5..70a996a3b2 100644
--- a/apps/web/app/(ee)/api/cron/payouts/force-withdrawals/route.ts
+++ b/apps/web/app/(ee)/api/cron/payouts/force-withdrawals/route.ts
@@ -1,11 +1,9 @@
import { forceWithdrawal } from "@/lib/actions/partners/force-withdrawal";
-import { handleAndReturnErrorResponse } from "@/lib/api/errors";
import { MIN_FORCE_WITHDRAWAL_AMOUNT_CENTS } from "@/lib/constants/payouts";
import { qstash } from "@/lib/cron";
-import { verifyQstashSignature } from "@/lib/cron/verify-qstash";
-import { verifyVercelSignature } from "@/lib/cron/verify-vercel";
+import { withCron } from "@/lib/cron/with-cron";
import { prisma } from "@/lib/prisma";
-import { APP_DOMAIN_WITH_NGROK, log } from "@dub/utils";
+import { APP_DOMAIN_WITH_NGROK } from "@dub/utils";
import * as z from "zod/v4";
import { logAndRespond } from "../../utils";
@@ -19,122 +17,92 @@ const schema = z.object({
// This route is used to force withdrawals for partners that haven't withdrew their earnings for than 90 days
// Runs once a day at 5AM PST (0 12 * * *) + calls itself recursively to process all partners in batches
-async function handler(req: Request) {
- try {
- let rawBody: string | undefined;
- if (req.method === "GET") {
- await verifyVercelSignature(req);
- } else if (req.method === "POST") {
- rawBody = await req.text();
- await verifyQstashSignature({
- req,
- rawBody,
- });
- }
+// GET/POST /api/cron/payouts/force-withdrawals
- let startingAfter: string | undefined;
- try {
- startingAfter = schema.parse(
- rawBody ? JSON.parse(rawBody) : {},
- ).startingAfter;
- } catch {
- startingAfter = undefined;
- }
+export const GET = withCron(async ({ rawBody }) => {
+ let { startingAfter } = schema.parse(rawBody ? JSON.parse(rawBody) : {});
- // Get batch of partners with processed payouts (cursor-based pagination)
- const partnersToProcess = await prisma.partner.findMany({
- where: {
- payoutsEnabledAt: {
- not: null,
- },
- defaultPayoutMethod: {
- in: ["stablecoin", "connect"],
- },
- payouts: {
- some: {
- status: "processed",
- amount: {
- gte: MIN_FORCE_WITHDRAWAL_AMOUNT_CENTS,
- },
- paidAt: {
- lte: new Date(Date.now() - 90 * 24 * 60 * 60 * 1000), // 90 days ago
- },
- },
- },
+ // Get batch of partners with processed payouts (cursor-based pagination)
+ const partnersToProcess = await prisma.partner.findMany({
+ where: {
+ payoutsEnabledAt: {
+ not: null,
},
- take: BATCH_SIZE,
- orderBy: {
- id: "asc",
+ defaultPayoutMethod: {
+ in: ["stablecoin", "connect"],
},
- ...(startingAfter && {
- skip: 1,
- cursor: {
- id: startingAfter,
+ payouts: {
+ some: {
+ status: "processed",
+ amount: {
+ gte: MIN_FORCE_WITHDRAWAL_AMOUNT_CENTS,
+ },
+ paidAt: {
+ lte: new Date(Date.now() - 90 * 24 * 60 * 60 * 1000), // 90 days ago
+ },
},
- }),
- select: {
- id: true,
- defaultPayoutMethod: true,
},
- });
+ },
+ take: BATCH_SIZE,
+ orderBy: {
+ id: "asc",
+ },
+ ...(startingAfter && {
+ skip: 1,
+ cursor: {
+ id: startingAfter,
+ },
+ }),
+ select: {
+ id: true,
+ defaultPayoutMethod: true,
+ },
+ });
- if (!partnersToProcess.length) {
- return logAndRespond(
- "No partners to process. Skipping force withdrawals...",
- );
- }
+ if (!partnersToProcess.length) {
+ return logAndRespond(
+ "No partners to process. Skipping force withdrawals...",
+ );
+ }
- const hasMoreToProcess = partnersToProcess.length === BATCH_SIZE;
+ const hasMoreToProcess = partnersToProcess.length === BATCH_SIZE;
- console.log(
- `Found ${partnersToProcess.length} partners to process${hasMoreToProcess ? " (more to process)" : ""}`,
- );
+ console.log(
+ `Found ${partnersToProcess.length} partners to process${hasMoreToProcess ? " (more to process)" : ""}`,
+ );
+
+ await Promise.allSettled(
+ partnersToProcess.map((partner) => forceWithdrawal(partner)),
+ );
- await Promise.allSettled(
- partnersToProcess.map((partner) => forceWithdrawal(partner)),
+ if (hasMoreToProcess) {
+ console.log(
+ "More partners need force withdrawals, scheduling next batch...",
);
- if (hasMoreToProcess) {
- console.log(
- "More partners need force withdrawals, scheduling next batch...",
- );
+ const nextStartingAfter =
+ partnersToProcess[partnersToProcess.length - 1].id;
- const nextStartingAfter =
- partnersToProcess[partnersToProcess.length - 1].id;
+ const qstashResponse = await qstash.publishJSON({
+ url: `${APP_DOMAIN_WITH_NGROK}/api/cron/payouts/force-withdrawals`,
+ method: "POST",
+ body: {
+ startingAfter: nextStartingAfter,
+ },
+ });
- const qstashResponse = await qstash.publishJSON({
- url: `${APP_DOMAIN_WITH_NGROK}/api/cron/payouts/force-withdrawals`,
- method: "POST",
- body: {
- startingAfter: nextStartingAfter,
- },
- });
- if (qstashResponse.messageId) {
- console.log(
- `Message sent to Qstash with id ${qstashResponse.messageId}`,
- );
- } else {
- await log({
- message: `Error sending message to Qstash to schedule next batch of force withdrawals: ${JSON.stringify(qstashResponse)}`,
- type: "errors",
- mention: true,
- });
- }
- return logAndRespond(
- `Finished force withdrawals for current batch. Scheduling next batch (startingAfter: ${nextStartingAfter})...`,
+ if (!qstashResponse.messageId) {
+ throw new Error(
+ `Error sending message to Qstash to schedule next batch of force withdrawals: ${JSON.stringify(qstashResponse)}`,
);
}
- return logAndRespond("Finished force withdrawals for all batches.");
- } catch (error) {
- await log({
- message: `Error force withdrawing: ${error.message}`,
- type: "errors",
- mention: true,
- });
- return handleAndReturnErrorResponse(error);
+ return logAndRespond(
+ `Finished force withdrawals for current batch. Scheduling next batch (startingAfter: ${nextStartingAfter})...`,
+ );
}
-}
-// GET/POST /api/cron/payouts/force-withdrawals
-export { handler as GET, handler as POST };
+ return logAndRespond("Finished force withdrawals for all batches.");
+});
+
+export const POST = GET;
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 27b1f77c9c..0a30f5c043 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,12 +1,10 @@
-import { handleAndReturnErrorResponse } from "@/lib/api/errors";
import { MIN_PAYOUT_AMOUNT_FOR_REMINDERS } from "@/lib/constants/misc";
import { qstash } from "@/lib/cron";
-import { verifyQstashSignature } from "@/lib/cron/verify-qstash";
-import { verifyVercelSignature } from "@/lib/cron/verify-vercel";
+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, log } from "@dub/utils";
+import { ACME_PROGRAM_ID, APP_DOMAIN_WITH_NGROK } from "@dub/utils";
import { logAndRespond } from "../../../utils";
export const dynamic = "force-dynamic";
@@ -17,218 +15,195 @@ const BATCH_SIZE = 1000;
// 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
-async function handler(req: Request) {
- try {
- if (req.method === "GET") {
- await verifyVercelSignature(req);
- } else if (req.method === "POST") {
- const rawBody = await req.text();
- await verifyQstashSignature({
- req,
- rawBody,
- });
- }
+// GET/POST /api/cron/payouts/reminders/partners
- // 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,
- // programs that are in the migration process
- "prog_1KPAZMF49X9A1WEWRBM55KZY7",
- ],
- },
- partner: {
- payoutsEnabledAt: null,
- OR: [
- { connectPayoutsLastRemindedAt: null },
- {
- connectPayoutsLastRemindedAt: {
- lte: new Date(Date.now() - 3 * 24 * 60 * 60 * 1000), // Last notified was at least 3 days ago
- },
+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,
+ // programs that are in the migration process
+ "prog_1KPAZMF49X9A1WEWRBM55KZY7",
+ ],
+ },
+ partner: {
+ payoutsEnabledAt: null,
+ OR: [
+ { connectPayoutsLastRemindedAt: null },
+ {
+ connectPayoutsLastRemindedAt: {
+ lte: new Date(Date.now() - 3 * 24 * 60 * 60 * 1000), // Last notified was at least 3 days ago
},
- ],
- },
- amount: {
- gte: MIN_PAYOUT_AMOUNT_FOR_REMINDERS,
- },
+ },
+ ],
},
- _sum: {
- amount: true,
+ amount: {
+ gte: MIN_PAYOUT_AMOUNT_FOR_REMINDERS,
},
- orderBy: {
- _sum: {
- amount: "desc",
- },
+ },
+ _sum: {
+ amount: true,
+ },
+ orderBy: {
+ _sum: {
+ amount: "desc",
},
- take: BATCH_SIZE,
- });
+ },
+ take: BATCH_SIZE,
+ });
- if (!unsentPayouts.length) {
- return logAndRespond("No action needed.");
- }
+ if (!unsentPayouts.length) {
+ return logAndRespond("No action needed.");
+ }
- const hasMoreToProcess = unsentPayouts.length === BATCH_SIZE;
+ const hasMoreToProcess = unsentPayouts.length === BATCH_SIZE;
- console.log(
- `Found ${unsentPayouts.length} partner-program combinations needing reminders${hasMoreToProcess ? " (more to process)" : ""}`,
- );
+ 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: {},
- },
+ 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,
- },
+ },
+ {
+ 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: [],
- });
- }
-
- partnerProgramMap.get(partnerId)!.programs.push({
- id: program.id,
- name: program.name,
- logo: program.logo!,
- amount: amount ?? 0,
- });
+ 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;
+ }[];
}
+ >();
- const partnerPrograms = Array.from(partnerProgramMap.values());
- const connectPayoutsLastRemindedAt = new Date();
+ for (const payout of unsentPayouts) {
+ const { partnerId, programId } = payout;
+ const { amount } = payout._sum;
- console.log(
- `Processing ConnectPayoutReminder for ${partnerPrograms.length} partners`,
- );
+ const partner = partnerData.find((p) => p.id === partnerId);
+ const program = programData.find((p) => p.id === programId);
+
+ if (!partner?.email || !program) {
+ continue;
+ }
- await queueBatchEmail<typeof ConnectPayoutReminder>(
- partnerPrograms.map(({ partner, programs }) => ({
- variant: "notifications",
- to: partner.email,
- subject: "Connect your payout details on Dub Partners",
- templateName: "ConnectPayoutReminder",
- templateProps: {
+ if (!partnerProgramMap.has(partnerId)) {
+ partnerProgramMap.set(partnerId, {
+ partner: {
+ id: partner.id,
+ name: partner.name,
email: partner.email,
- programs,
},
- })),
- );
+ programs: [],
+ });
+ }
- console.log(
- `Queued ConnectPayoutReminder emails for ${partnerPrograms.length} partners`,
- );
+ partnerProgramMap.get(partnerId)!.programs.push({
+ id: program.id,
+ name: program.name,
+ logo: program.logo!,
+ amount: amount ?? 0,
+ });
+ }
- await prisma.partner.updateMany({
- where: {
- id: {
- in: partnerPrograms.map(({ partner }) => partner.id),
- },
+ 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,
},
- data: {
- connectPayoutsLastRemindedAt,
+ })),
+ );
+
+ 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 (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) {
- console.log(
- `Message sent to Qstash with id ${qstashResponse.messageId}`,
- );
- } else {
- // should never happen, but just in case
- await log({
- message: `Error sending message to Qstash to schedule next batch of payout reminders: ${JSON.stringify(qstashResponse)}`,
- type: "errors",
- mention: true,
- });
- }
- return logAndRespond(
- "Finished sending payout reminders for current batch. Scheduling next batch...",
+ 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 all batches.");
- } catch (error) {
- await log({
- message: `Error sending payout reminders: ${error.message}`,
- type: "errors",
- mention: true,
- });
- return handleAndReturnErrorResponse(error);
+ return logAndRespond(
+ "Finished sending payout reminders for current batch. Scheduling next batch...",
+ );
}
-}
-// GET/POST /api/cron/payouts/reminders/partners
-export { handler as GET, handler as POST };
+ return logAndRespond("Finished sending payout reminders for all batches.");
+});
+
+export const POST = GET;
diff --git a/apps/web/app/(ee)/api/cron/payouts/reminders/program-owners/route.ts b/apps/web/app/(ee)/api/cron/payouts/reminders/program-owners/route.ts
index 0a94997c1e..fad0e2537b 100644
--- a/apps/web/app/(ee)/api/cron/payouts/reminders/program-owners/route.ts
+++ b/apps/web/app/(ee)/api/cron/payouts/reminders/program-owners/route.ts
@@ -1,6 +1,5 @@
-import { handleAndReturnErrorResponse } from "@/lib/api/errors";
import { INVOICE_MIN_PAYOUT_AMOUNT_CENTS } from "@/lib/constants/payouts";
-import { verifyVercelSignature } from "@/lib/cron/verify-vercel";
+import { withCron } from "@/lib/cron/with-cron";
import { prisma } from "@/lib/prisma";
import { sendBatchEmail } from "@dub/email";
import ProgramPayoutReminder from "@dub/email/templates/program-payout-reminder";
@@ -9,45 +8,68 @@ import { NextResponse } from "next/server";
export const dynamic = "force-dynamic";
-// GET /api/cron/payouts/reminders/program-owners
// This route is used to send reminders to program owners about pending payouts
// Runs every weekday at 1:00 PM UTC between 25th of current month and 5th of next month
// Cron expression: 0 13 25-31,1-5 * * (runs daily at 1:00 PM UTC on days 25-31 and 1-5, filtered for weekdays in code)
-export async function GET(req: Request) {
- try {
- await verifyVercelSignature(req);
-
- // Only run on weekdays (Monday = 1, Friday = 5)
- const today = new Date();
- const dayOfWeek = today.getUTCDay(); // 0 = Sunday, 1 = Monday, ..., 6 = Saturday
-
- if (dayOfWeek === 0 || dayOfWeek === 6) {
- return NextResponse.json(
- "Skipping execution on weekend. Only runs on weekdays.",
- );
- }
+// GET /api/cron/payouts/reminders/program-owners
+export const GET = withCron(async () => {
+ // Only run on weekdays (Monday = 1, Friday = 5)
+ const today = new Date();
+ const dayOfWeek = today.getUTCDay(); // 0 = Sunday, 1 = Monday, ..., 6 = Saturday
+
+ if (dayOfWeek === 0 || dayOfWeek === 6) {
+ return NextResponse.json(
+ "Skipping execution on weekend. Only runs on weekdays.",
+ );
+ }
- const programsWithCustomMinPayouts = await prisma.program.findMany({
- where: {
- minPayoutAmount: {
- gt: 0,
+ const programsWithCustomMinPayouts = await prisma.program.findMany({
+ where: {
+ minPayoutAmount: {
+ gt: 0,
+ },
+ deactivatedAt: null,
+ },
+ });
+
+ const pendingPayouts = await prisma.payout.groupBy({
+ by: ["programId"],
+ where: {
+ status: "pending",
+ amount: {
+ gt: 0,
+ },
+ program: {
+ id: {
+ notIn: programsWithCustomMinPayouts.map((p) => p.id),
},
deactivatedAt: null,
},
- });
-
- const pendingPayouts = await prisma.payout.groupBy({
- by: ["programId"],
+ partner: {
+ payoutsEnabledAt: {
+ not: null,
+ },
+ },
+ },
+ _sum: {
+ amount: true,
+ },
+ _count: {
+ _all: true,
+ },
+ });
+
+ for (const program of programsWithCustomMinPayouts) {
+ console.log(
+ `Manually calculating pending payout for program ${program.id} which has a custom min payout amount of ${program.minPayoutAmount}`,
+ );
+
+ const pendingPayout = await prisma.payout.aggregate({
where: {
+ programId: program.id,
status: "pending",
amount: {
- gt: 0,
- },
- program: {
- id: {
- notIn: programsWithCustomMinPayouts.map((p) => p.id),
- },
- deactivatedAt: null,
+ gte: program.minPayoutAmount,
},
partner: {
payoutsEnabledAt: {
@@ -63,159 +85,130 @@ export async function GET(req: Request) {
},
});
- for (const program of programsWithCustomMinPayouts) {
- console.log(
- `Manually calculating pending payout for program ${program.id} which has a custom min payout amount of ${program.minPayoutAmount}`,
- );
-
- const pendingPayout = await prisma.payout.aggregate({
- where: {
- programId: program.id,
- status: "pending",
- amount: {
- gte: program.minPayoutAmount,
- },
- partner: {
- payoutsEnabledAt: {
- not: null,
- },
- },
- },
- _sum: {
- amount: true,
- },
- _count: {
- _all: true,
- },
- });
-
- // if there are no pending payouts, skip this program
- if (!pendingPayout._sum?.amount) {
- continue;
- }
-
- pendingPayouts.push({
- programId: program.id,
- _sum: pendingPayout._sum,
- _count: pendingPayout._count,
- });
- }
-
- if (!pendingPayouts.length) {
- return NextResponse.json("No pending payouts found. Skipping...");
+ // if there are no pending payouts, skip this program
+ if (!pendingPayout._sum?.amount) {
+ continue;
}
- const recentPaidInvoices = await prisma.invoice.findMany({
- where: {
- programId: {
- in: pendingPayouts.map((p) => p.programId),
- },
- // take invoices from the last 2 weeks
- createdAt: {
- gte: new Date(Date.now() - 14 * 24 * 60 * 60 * 1000),
- },
- },
+ pendingPayouts.push({
+ programId: program.id,
+ _sum: pendingPayout._sum,
+ _count: pendingPayout._count,
});
+ }
- // only send notifications for programs that:
- // - have a total payout amount greater than or equal to $10 (INVOICE_MIN_PAYOUT_AMOUNT_CENTS)
- // - have not paid out any invoices in the last 2 weeks
- const payoutsToNotify = pendingPayouts.filter((p) => {
- const invoiceTotal = p._sum?.amount ?? 0;
- const recentPaidInvoicesForProgram = recentPaidInvoices.filter(
- (i) => i.programId === p.programId,
- );
- return (
- invoiceTotal >= INVOICE_MIN_PAYOUT_AMOUNT_CENTS ||
- recentPaidInvoicesForProgram.length === 0
- );
- });
+ if (!pendingPayouts.length) {
+ return NextResponse.json("No pending payouts found. Skipping...");
+ }
- const programs = await prisma.program.findMany({
- where: {
- id: {
- in: payoutsToNotify.map((p) => p.programId),
- },
+ const recentPaidInvoices = await prisma.invoice.findMany({
+ where: {
+ programId: {
+ in: pendingPayouts.map((p) => p.programId),
},
- include: {
- workspace: {
- select: {
- id: true,
- slug: true,
- users: {
- where: {
- role: "owner",
- },
- select: {
- user: {
- select: {
- email: true,
- },
+ // take invoices from the last 2 weeks
+ createdAt: {
+ gte: new Date(Date.now() - 14 * 24 * 60 * 60 * 1000),
+ },
+ },
+ });
+
+ // only send notifications for programs that:
+ // - have a total payout amount greater than or equal to $10 (INVOICE_MIN_PAYOUT_AMOUNT_CENTS)
+ // - have not paid out any invoices in the last 2 weeks
+ const payoutsToNotify = pendingPayouts.filter((p) => {
+ const invoiceTotal = p._sum?.amount ?? 0;
+ const recentPaidInvoicesForProgram = recentPaidInvoices.filter(
+ (i) => i.programId === p.programId,
+ );
+ return (
+ invoiceTotal >= INVOICE_MIN_PAYOUT_AMOUNT_CENTS ||
+ recentPaidInvoicesForProgram.length === 0
+ );
+ });
+
+ const programs = await prisma.program.findMany({
+ where: {
+ id: {
+ in: payoutsToNotify.map((p) => p.programId),
+ },
+ },
+ include: {
+ workspace: {
+ select: {
+ id: true,
+ slug: true,
+ users: {
+ where: {
+ role: "owner",
+ },
+ select: {
+ user: {
+ select: {
+ email: true,
},
},
},
},
},
},
- });
+ },
+ });
- if (!programs.length) {
- return NextResponse.json("No programs found. Skipping...");
- }
-
- const programsWithPendingPayoutsToNotify = await Promise.all(
- programs.map(async (program) => {
- const payoutDetails = payoutsToNotify.find(
- (p) => p.programId === program.id,
- );
-
- const workspace = program.workspace;
+ if (!programs.length) {
+ return NextResponse.json("No programs found. Skipping...");
+ }
- return workspace.users.map(({ user }) => ({
- workspace: {
- slug: workspace.slug,
- },
- user: {
- email: user.email,
- },
- program: {
- name: program.name,
- },
- payout: {
- amount: payoutDetails?._sum?.amount ?? 0,
- partnersCount: payoutDetails?._count?._all ?? 0,
- },
- }));
- }),
- ).then((p) => p.flat());
-
- console.table(programsWithPendingPayoutsToNotify);
-
- const programOwnerChunks = chunk(programsWithPendingPayoutsToNotify, 100);
-
- for (const programOwnerChunk of programOwnerChunks) {
- const res = await sendBatchEmail(
- programOwnerChunk.map(({ workspace, user, program, payout }) => ({
- variant: "notifications",
- to: user.email!,
- subject: `${payout.partnersCount} ${pluralize(
- "partner",
- payout.partnersCount,
- )} awaiting your payout for ${program.name}`,
- react: ProgramPayoutReminder({
- email: user.email!,
- workspace,
- program,
- payout,
- }),
- })),
+ const programsWithPendingPayoutsToNotify = await Promise.all(
+ programs.map(async (program) => {
+ const payoutDetails = payoutsToNotify.find(
+ (p) => p.programId === program.id,
);
- console.log(`Sent ${programOwnerChunk.length} emails`, res);
- }
+ const workspace = program.workspace;
- return NextResponse.json("OK");
- } catch (error) {
- return handleAndReturnErrorResponse(error);
+ return workspace.users.map(({ user }) => ({
+ workspace: {
+ slug: workspace.slug,
+ },
+ user: {
+ email: user.email,
+ },
+ program: {
+ name: program.name,
+ },
+ payout: {
+ amount: payoutDetails?._sum?.amount ?? 0,
+ partnersCount: payoutDetails?._count?._all ?? 0,
+ },
+ }));
+ }),
+ ).then((p) => p.flat());
+
+ console.table(programsWithPendingPayoutsToNotify);
+
+ const programOwnerChunks = chunk(programsWithPendingPayoutsToNotify, 100);
+
+ for (const programOwnerChunk of programOwnerChunks) {
+ const res = await sendBatchEmail(
+ programOwnerChunk.map(({ workspace, user, program, payout }) => ({
+ variant: "notifications",
+ to: user.email!,
+ subject: `${payout.partnersCount} ${pluralize(
+ "partner",
+ payout.partnersCount,
+ )} awaiting your payout for ${program.name}`,
+ react: ProgramPayoutReminder({
+ email: user.email!,
+ workspace,
+ program,
+ payout,
+ }),
+ })),
+ );
+
+ console.log(`Sent ${programOwnerChunk.length} emails`, res);
}
-}
+
+ return NextResponse.json("OK");
+});
diff --git a/apps/web/app/(ee)/api/cron/streams/update-partner-stats/route.ts b/apps/web/app/(ee)/api/cron/streams/update-partner-stats/route.ts
index 2181f0bf7c..9205796015 100644
--- a/apps/web/app/(ee)/api/cron/streams/update-partner-stats/route.ts
+++ b/apps/web/app/(ee)/api/cron/streams/update-partner-stats/route.ts
@@ -1,5 +1,4 @@
-import { handleAndReturnErrorResponse } from "@/lib/api/errors";
-import { verifyVercelSignature } from "@/lib/cron/verify-vercel";
+import { withCron } from "@/lib/cron/with-cron";
import { conn } from "@/lib/planetscale";
import { prisma } from "@/lib/prisma";
import {
@@ -346,37 +345,30 @@ const processPartnerActivityStreamBatch = () =>
// This route is used to process partner activity events from Redis streams
// It runs every 5 minutes with a batch size of 6,000 to consume high-frequency partner activity updates
// GET /api/cron/streams/update-partner-stats
-export async function GET(req: Request) {
- try {
- await verifyVercelSignature(req);
- console.log("Processing partner activity events from Redis stream...");
+export const GET = withCron(async () => {
+ const { updates, errors, totalProcessed } =
+ await processPartnerActivityStreamBatch();
- const { updates, errors, totalProcessed } =
- await processPartnerActivityStreamBatch();
-
- if (!updates.length) {
- return NextResponse.json({
- success: true,
- message: "No updates to process",
- processed: 0,
- });
- }
-
- // Get stream info for monitoring
- const streamInfo = await partnerActivityStream.getStreamInfo();
- const response = {
+ if (!updates.length) {
+ return NextResponse.json({
success: true,
- processed: totalProcessed,
- errors: errors?.length || 0,
- streamInfo,
- message: `Successfully processed ${totalProcessed} partner activity updates`,
- };
- console.log(response);
-
- return NextResponse.json(response);
- } catch (error) {
- console.error("Failed to process partner activity updates:", error);
- return handleAndReturnErrorResponse(error);
+ message: "No updates to process",
+ processed: 0,
+ });
}
-}
+
+ const streamInfo = await partnerActivityStream.getStreamInfo();
+
+ const response = {
+ success: true,
+ processed: totalProcessed,
+ errors: errors?.length || 0,
+ streamInfo,
+ message: `Successfully processed ${totalProcessed} partner activity updates`,
+ };
+
+ console.log(response);
+
+ return NextResponse.json(response);
+});
diff --git a/apps/web/app/(ee)/api/cron/streams/update-workspace-clicks/route.ts b/apps/web/app/(ee)/api/cron/streams/update-workspace-clicks/route.ts
index 0ddc6fcf11..4055d92da7 100644
--- a/apps/web/app/(ee)/api/cron/streams/update-workspace-clicks/route.ts
+++ b/apps/web/app/(ee)/api/cron/streams/update-workspace-clicks/route.ts
@@ -1,5 +1,4 @@
-import { handleAndReturnErrorResponse } from "@/lib/api/errors";
-import { verifyVercelSignature } from "@/lib/cron/verify-vercel";
+import { withCron } from "@/lib/cron/with-cron";
import { conn } from "@/lib/planetscale";
import { RedisStreamEntry } from "@/lib/upstash/redis-streams/client";
import {
@@ -179,38 +178,30 @@ const processWorkspaceUpdateStreamBatch = () =>
// This route is used to process aggregated workspace usage events from Redis streams
// It runs every minute with a batch size of 10,000 to consume high-frequency usage updates
-export async function GET(req: Request) {
- try {
- await verifyVercelSignature(req);
+export const GET = withCron(async () => {
+ const { updates, errors, totalProcessed, lastProcessedId } =
+ await processWorkspaceUpdateStreamBatch();
- console.log("Processing workspace usage updates from Redis stream...");
+ if (!updates.length) {
+ return NextResponse.json({
+ success: true,
+ message: "No updates to process",
+ processed: 0,
+ });
+ }
- const { updates, errors, totalProcessed, lastProcessedId } =
- await processWorkspaceUpdateStreamBatch();
+ const streamInfo = await workspaceClicksUsageStream.getStreamInfo();
- if (!updates.length) {
- return NextResponse.json({
- success: true,
- message: "No updates to process",
- processed: 0,
- });
- }
+ const response = {
+ success: true,
+ processed: totalProcessed,
+ errors: errors?.length || 0,
+ lastProcessedId,
+ streamInfo,
+ message: `Successfully processed ${totalProcessed} workspace usage updates`,
+ };
- // Get stream info for monitoring
- const streamInfo = await workspaceClicksUsageStream.getStreamInfo();
- const response = {
- success: true,
- processed: totalProcessed,
- errors: errors?.length || 0,
- lastProcessedId,
- streamInfo,
- message: `Successfully processed ${totalProcessed} workspace usage updates`,
- };
- console.log(response);
-
- return NextResponse.json(response);
- } catch (error) {
- console.error("Failed to process workspace usage updates:", error);
- return handleAndReturnErrorResponse(error);
- }
-}
+ console.log(response);
+
+ return NextResponse.json(response);
+});
diff --git a/apps/web/app/(ee)/api/cron/streams/update-workspace-links-usage/route.ts b/apps/web/app/(ee)/api/cron/streams/update-workspace-links-usage/route.ts
index 3220b2572c..ac77b6019b 100644
--- a/apps/web/app/(ee)/api/cron/streams/update-workspace-links-usage/route.ts
+++ b/apps/web/app/(ee)/api/cron/streams/update-workspace-links-usage/route.ts
@@ -1,9 +1,8 @@
-import { handleAndReturnErrorResponse } from "@/lib/api/errors";
import {
getSlackWebhooks,
sendWorkspaceLimitAlert,
} from "@/lib/cron/send-limit-alert";
-import { verifyVercelSignature } from "@/lib/cron/verify-vercel";
+import { withCron } from "@/lib/cron/with-cron";
import { prisma } from "@/lib/prisma";
import { WorkspaceProps } from "@/lib/types";
import { RedisStreamEntry } from "@/lib/upstash/redis-streams/client";
@@ -308,41 +307,36 @@ const processWorkspaceLinksUsageBatch = () =>
},
);
-export async function GET(req: Request) {
- try {
- await verifyVercelSignature(req);
-
- const {
- updates,
- errors,
- totalProcessed,
- notificationsSent,
- lastProcessedId,
- } = await processWorkspaceLinksUsageBatch();
-
- if (!updates.length) {
- return NextResponse.json({
- success: true,
- message: "No updates to process",
- processed: 0,
- });
- }
+export const GET = withCron(async () => {
+ const {
+ updates,
+ errors,
+ totalProcessed,
+ notificationsSent,
+ lastProcessedId,
+ } = await processWorkspaceLinksUsageBatch();
- const streamInfo = await workspaceLinksUsageStream.getStreamInfo();
- const response = {
+ if (!updates.length) {
+ return NextResponse.json({
success: true,
- processed: totalProcessed,
- notificationsSent,
- errors: errors?.length || 0,
- lastProcessedId,
- streamInfo,
- message: `Successfully processed ${totalProcessed} workspace links usage updates`,
- };
-
- console.log(response);
- return NextResponse.json(response);
- } catch (error) {
- console.error("Failed to process workspace links usage updates:", error);
- return handleAndReturnErrorResponse(error);
+ message: "No updates to process",
+ processed: 0,
+ });
}
-}
+
+ const streamInfo = await workspaceLinksUsageStream.getStreamInfo();
+
+ const response = {
+ success: true,
+ processed: totalProcessed,
+ notificationsSent,
+ errors: errors?.length || 0,
+ lastProcessedId,
+ streamInfo,
+ message: `Successfully processed ${totalProcessed} workspace links usage updates`,
+ };
+
+ console.log(response);
+
+ return NextResponse.json(response);
+});
diff --git a/apps/web/app/(ee)/api/cron/trigger-backup/route.ts b/apps/web/app/(ee)/api/cron/trigger-backup/route.ts
index ebcc409d6b..f77ed1c64d 100644
--- a/apps/web/app/(ee)/api/cron/trigger-backup/route.ts
+++ b/apps/web/app/(ee)/api/cron/trigger-backup/route.ts
@@ -1,57 +1,50 @@
-import { DubApiError, handleAndReturnErrorResponse } from "@/lib/api/errors";
-import { verifyVercelSignature } from "@/lib/cron/verify-vercel";
+import { DubApiError } from "@/lib/api/errors";
+import { withCron } from "@/lib/cron/with-cron";
import { logAndRespond } from "../utils";
export const dynamic = "force-dynamic";
// Creates a PlanetScale branch backup
// Scheduled UTC: 12:40 AM, 8:40 AM, 12:40 PM, 8:40 PM (cron: 40 0,8,12,20 * * *)
+export const GET = withCron(async () => {
+ const tokenSecret = process.env.PLANETSCALE_SERVICE_TOKEN;
+
+ if (!tokenSecret) {
+ throw new DubApiError({
+ code: "internal_server_error",
+ message: "Missing PLANETSCALE_SERVICE_TOKEN",
+ });
+ }
-export async function GET(req: Request) {
- try {
- await verifyVercelSignature(req);
-
- const tokenSecret = process.env.PLANETSCALE_SERVICE_TOKEN;
-
- if (!tokenSecret) {
- throw new DubApiError({
- code: "internal_server_error",
- message: "Missing PLANETSCALE_SERVICE_TOKEN",
- });
- }
-
- const res = await fetch(
- `https://api.planetscale.com/v1/organizations/dub/databases/dub/branches/main/backups`,
- {
- method: "POST",
- headers: {
- Authorization: `jynn53mcug4l:${tokenSecret}`,
- "Content-Type": "application/json",
- },
- body: JSON.stringify({
- name: `cron-backup-${new Date().toISOString()}`,
- retention_value: 7,
- retention_unit: "day",
- }),
+ const res = await fetch(
+ `https://api.planetscale.com/v1/organizations/dub/databases/dub/branches/main/backups`,
+ {
+ method: "POST",
+ headers: {
+ Authorization: `jynn53mcug4l:${tokenSecret}`,
+ "Content-Type": "application/json",
},
- );
-
- const bodyText = await res.text();
-
- if (!res.ok) {
- throw new DubApiError({
- code: "internal_server_error",
- message: `PlanetScale backup failed (${res.status}): ${bodyText}`,
- });
- }
+ body: JSON.stringify({
+ name: `cron-backup-${new Date().toISOString()}`,
+ retention_value: 7,
+ retention_unit: "day",
+ }),
+ },
+ );
+
+ const bodyText = await res.text();
+
+ if (!res.ok) {
+ throw new DubApiError({
+ code: "internal_server_error",
+ message: `PlanetScale backup failed (${res.status}): ${bodyText}`,
+ });
+ }
- const backup = JSON.parse(bodyText);
- console.log({ backup });
+ const backup = JSON.parse(bodyText);
+ console.log({ backup });
- return logAndRespond(
- `Created PlanetScale backup: ${backup.id} (${backup.name}) state=${backup.state}`,
- );
- } catch (error) {
- return handleAndReturnErrorResponse(error);
- }
-}
+ return logAndRespond(
+ `Created PlanetScale backup: ${backup.id} (${backup.name}) state=${backup.state}`,
+ );
+});
diff --git a/apps/web/app/(ee)/api/cron/trigger-withdrawal/route.ts b/apps/web/app/(ee)/api/cron/trigger-withdrawal/route.ts
index 2ccdec3324..4a25eb507f 100644
--- a/apps/web/app/(ee)/api/cron/trigger-withdrawal/route.ts
+++ b/apps/web/app/(ee)/api/cron/trigger-withdrawal/route.ts
@@ -1,5 +1,4 @@
-import { handleAndReturnErrorResponse } from "@/lib/api/errors";
-import { verifyVercelSignature } from "@/lib/cron/verify-vercel";
+import { withCron } from "@/lib/cron/with-cron";
import { prisma } from "@/lib/prisma";
import { stripe } from "@/lib/stripe";
import { currencyFormatter } from "@dub/utils";
@@ -9,66 +8,60 @@ export const dynamic = "force-dynamic";
// This route is used to trigger withdrawal from Stripe (since we're using manual payouts)
// Runs twice a day at 1AM and 1PM UTC (0 1,13 * * *)
-export async function GET(req: Request) {
- try {
- await verifyVercelSignature(req);
-
- const [stripeBalanceData, payoutsToBeSentData] = await Promise.all([
- stripe.balance.retrieve(),
- prisma.payout.aggregate({
- where: {
- status: {
- in: ["processing", "processed"],
- },
- },
- _sum: {
- amount: true,
+// GET /api/cron/trigger-withdrawal
+export const GET = withCron(async () => {
+ const [stripeBalanceData, payoutsToBeSentData] = await Promise.all([
+ stripe.balance.retrieve(),
+ prisma.payout.aggregate({
+ where: {
+ status: {
+ in: ["processing", "processed"],
},
- }),
- ]);
-
- // available to withdraw (USD)
- const currentAvailableBalance =
- stripeBalanceData.available.find((b) => b.currency === "usd")?.amount ??
- 0;
- // balance waiting to settle (USD)
- const currentPendingBalance =
- stripeBalanceData.pending.find((b) => b.currency === "usd")?.amount ?? 0;
+ },
+ _sum: {
+ amount: true,
+ },
+ }),
+ ]);
- // x-slack-ref: https://dub.slack.com/archives/C074P7LMV9C/p1750185638973479
- const currentNetBalance =
- currentPendingBalance < 0
- ? currentAvailableBalance + currentPendingBalance
- : currentAvailableBalance;
+ // available to withdraw (USD)
+ const currentAvailableBalance =
+ stripeBalanceData.available.find((b) => b.currency === "usd")?.amount ?? 0;
+ // balance waiting to settle (USD)
+ const currentPendingBalance =
+ stripeBalanceData.pending.find((b) => b.currency === "usd")?.amount ?? 0;
- const payoutsToBeSent = payoutsToBeSentData._sum.amount ?? 0;
- const reservedBalance = 30_000_00; // keep at least $30,000 in the account
- const balanceToWithdraw =
- currentNetBalance - payoutsToBeSent - reservedBalance;
+ // x-slack-ref: https://dub.slack.com/archives/C074P7LMV9C/p1750185638973479
+ const currentNetBalance =
+ currentPendingBalance < 0
+ ? currentAvailableBalance + currentPendingBalance
+ : currentAvailableBalance;
- console.log({
- currentAvailableBalance: `${currencyFormatter(currentAvailableBalance)}`,
- currentPendingBalance: `${currencyFormatter(currentPendingBalance)}`,
- currentNetBalance: `${currencyFormatter(currentNetBalance)}`,
- payoutsToBeSent: `${currencyFormatter(payoutsToBeSent)}`,
- balanceToWithdraw: `${currencyFormatter(balanceToWithdraw)}`,
- });
+ const payoutsToBeSent = payoutsToBeSentData._sum.amount ?? 0;
+ const reservedBalance = 30_000_00; // keep at least $30,000 in the account
+ const balanceToWithdraw =
+ currentNetBalance - payoutsToBeSent - reservedBalance;
- if (balanceToWithdraw <= 0) {
- return logAndRespond(
- `Balance to withdraw (after deducting payouts to be sent and reserved balance) is less than $0, skipping...`,
- );
- }
-
- const createdPayout = await stripe.payouts.create({
- amount: balanceToWithdraw,
- currency: "usd",
- });
+ console.log({
+ currentAvailableBalance: `${currencyFormatter(currentAvailableBalance)}`,
+ currentPendingBalance: `${currencyFormatter(currentPendingBalance)}`,
+ currentNetBalance: `${currencyFormatter(currentNetBalance)}`,
+ payoutsToBeSent: `${currencyFormatter(payoutsToBeSent)}`,
+ balanceToWithdraw: `${currencyFormatter(balanceToWithdraw)}`,
+ });
+ if (balanceToWithdraw <= 0) {
return logAndRespond(
- `Created payout: ${createdPayout.id} (${currencyFormatter(createdPayout.amount)})`,
+ `Balance to withdraw (after deducting payouts to be sent and reserved balance) is less than $0, skipping...`,
);
- } catch (error) {
- return handleAndReturnErrorResponse(error);
}
-}
+
+ const createdPayout = await stripe.payouts.create({
+ amount: balanceToWithdraw,
+ currency: "usd",
+ });
+
+ return logAndRespond(
+ `Created payout: ${createdPayout.id} (${currencyFormatter(createdPayout.amount)})`,
+ );
+});