dubinc · steven-tey · Aug 6, 2025 · Jul 31, 2025 · Jul 31, 2025 · Jul 31, 2025
diff --git a/apps/web/app/(ee)/api/admin/payouts/route.ts b/apps/web/app/(ee)/api/admin/payouts/route.ts
@@ -42,9 +42,18 @@ export const GET = withAdmin(async ({ searchParams }) => {
   // Fetch invoices
   const invoices = await prisma.invoice.findMany({
     where: {
-      programId: {
-        not: ACME_PROGRAM_ID,
-      },
+      AND: [
+        {
+          programId: {
+            not: ACME_PROGRAM_ID,
+          },
+        },
+        {
+          program: {
+            isNot: null,
+          },
+        },
+      ],
       status: {
         not: "failed",
       },
@@ -90,8 +99,9 @@ export const GET = withAdmin(async ({ searchParams }) => {
 
   const formattedInvoices = invoices.map((invoice) => ({
     date: invoice.createdAt,
-    programName: invoice.program.name,
-    programLogo: invoice.program.logo,
+    // we're coercing this cause we've filtered out invoices without a programId above
+    programName: invoice.program!.name,
+    programLogo: invoice.program!.logo,
     status: invoice.status,
     amount: invoice.amount,
     fee: invoice.fee,

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
@@ -0,0 +1,151 @@
+import { createId } from "@/lib/api/create-id";
+import { handleAndReturnErrorResponse } from "@/lib/api/errors";
+import { verifyVercelSignature } from "@/lib/cron/verify-vercel";
+import { createPaymentIntent } from "@/lib/stripe/create-payment-intent";
+import { prisma } from "@dub/prisma";
+import { log } from "@dub/utils";
+import { Invoice, Project, RegisteredDomain } from "@prisma/client";
+import { addDays, endOfDay, startOfDay } from "date-fns";
+import { NextResponse } from "next/server";
+
+/**
+ * Daily cron job to create payment intents for `.link` domain renewals.
+ *
+ * Payment intents are created 14 days before domain expiration to ensure
+ * timely processing and avoid domain expiration.
+ */
+
+export const dynamic = "force-dynamic";
+
+interface GroupedWorkspace {
+  workspace: Pick<Project, "id" | "stripeId" | "invoicePrefix">;
+  domains: Pick<RegisteredDomain, "id" | "slug" | "expiresAt" | "renewalFee">[];
+}
+
+// GET /api/cron/domains/renewal-payments
+export async function GET(req: Request) {
+  try {
+    await verifyVercelSignature(req);
+
+    const targetDate = addDays(new Date(), 14);
+
+    // 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,
+          },
+        },
+      },
+    });
+
+    if (domains.length === 0) {
+      return NextResponse.json(
+        "No domains found expiring exactly 14 days from today.",
+      );
+    }
+
+    // Group domains by workspaceId
+    const groupedByWorkspace = domains.reduce(
+      (acc, domain) => {
+        const workspaceId = domain.projectId;
+
+        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,
+        });
+
+        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 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,
+          },
+        });
+      });
+
+      console.log(
+        `Invoice ${invoice.id} created for workspace ${workspace.id} to renew ${domains.length} domains.`,
+      );
+
+      invoices.push(invoice);
+    }
+
+    // Create payment intent for each invoice
+    for (const invoice of invoices) {
+      const { workspace } = groupedByWorkspace[invoice.workspaceId];
+
+      if (!workspace.stripeId) {
+        console.log(`Workspace ${workspace.id} has no stripeId, skipping...`);
+        continue;
+      }
+
+      await createPaymentIntent({
+        stripeId: workspace.stripeId!,
+        amount: invoice.total,
+        invoiceId: invoice.id,
+        statementDescriptor: "Dub",
+        description: `Domain renewal invoice (${invoice.id})`,
+        idempotencyKey: `${invoice.id}-${invoice.failedAttempts}`,
+      });
+    }
+
+    return NextResponse.json("OK");
+  } catch (error) {
+    await log({
+      message: "Domains renewal cron failed. Error: " + error.message,
+      type: "errors",
+    });
+
+    return handleAndReturnErrorResponse(error);
-    await log({
-      message: "Domains renewal cron failed. Error: " + error.message,
-      type: "errors",
-    });
-
-    return handleAndReturnErrorResponse(error);
+    await log({
+      message: "Domains renewal cron failed. Error: " + (error instanceof Error ? error.message : String(error)),
+      type: "errors",
+    });
+
+    return handleAndReturnErrorResponse(error);
-    await log({
-      message: "Domains renewal cron failed. Error: " + error.message,
-      type: "errors",
-    });
-
-    return handleAndReturnErrorResponse(error);
+    await log({
+      message: "Domains renewal cron failed. Error: " + (error instanceof Error ? error.message : String(error)),
+      type: "errors",
+    });
+
+    return handleAndReturnErrorResponse(error);
+  }
+}
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
@@ -0,0 +1,136 @@
+import { handleAndReturnErrorResponse } from "@/lib/api/errors";
+import { verifyVercelSignature } from "@/lib/cron/verify-vercel";
+import { resend } from "@dub/email/resend";
+import { VARIANT_TO_FROM_MAP } from "@dub/email/resend/constants";
+import DomainRenewalReminder from "@dub/email/templates/domain-renewal-reminder";
+import { prisma } from "@dub/prisma";
+import { chunk, log } from "@dub/utils";
+import {
+  addDays,
+  differenceInCalendarDays,
+  endOfDay,
+  formatDistanceStrict,
+  startOfDay,
+  subDays,
+} from "date-fns";
+import { NextResponse } from "next/server";
+
+/**
+ * Daily cron job to send `.link` domain renewal reminders.
+ *
+ * Reminders are sent at the following intervals before the domain expiration date:
+ *  - First reminder: 30 days prior
+ *  - Second reminder: 23 days prior
+ *  - Third reminder: 16 days prior
+ */
+
+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,
+      };
+    });
+
+    // 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) {
+      return NextResponse.json("No domains found to send reminders for.");
+    }
+
+    const reminderDomains = domains.flatMap(
+      ({ slug, expiresAt, renewalFee, project }) => {
+        const reminderWindow = differenceInCalendarDays(expiresAt, now);
+        const chargeAt: Date = addDays(now, reminderWindow);
+
+        return project.users.map(({ user }) => ({
+          domain: {
+            slug,
+            renewalFee,
+            expiresAt,
+            reminderWindow,
+            chargeAt,
+            chargeInText: formatDistanceStrict(chargeAt, now),
+          },
+          workspace: {
+            slug: project.slug,
+          },
+          user: {
+            email: user.email,
+          },
+        }));
+      },
+    );
+
+    const reminderDomainsChunks = chunk(reminderDomains, 100);
+
+    if (!resend) {
+      return NextResponse.json(
+        "Resend is not configured, skipping email sending.",
+      );
+    }
+
+    for (const reminderDomainsChunk of reminderDomainsChunks) {
+      await resend.batch.send(
+        reminderDomainsChunk.map(({ workspace, user, domain }) => ({
+          from: VARIANT_TO_FROM_MAP.notifications,
+          to: user.email!,
+          subject: "Your domain is expiring soon",
+          variant: "notifications",
+          react: DomainRenewalReminder({
+            email: user.email!,
+            workspace,
+            domain,
+          }),
+        })),
+      );
+    }
+
+    return NextResponse.json(reminderDomains);
+  } catch (error) {
+    await log({
+      message: "Domains renewal reminders cron failed. Error: " + error.message,
+      type: "errors",
+    });
+
+    return handleAndReturnErrorResponse(error);
+  }
+}