Tremendous

apps/web/.env.example

@@ -169,6 +169,9 @@ PAYPAL_CLIENT_ID=
 PAYPAL_CLIENT_SECRET=
 PAYPAL_WEBHOOK_ID=
 
+# Tremendous
+TREMENDOUS_API_KEY=
+
 # Program lander generation
 FIRECRAWL_API_KEY=
 

apps/web/app/(ee)/api/cron/disposable-emails/route.ts

@@ -1,44 +1,68 @@
-import { handleAndReturnErrorResponse } from "@/lib/api/errors";
-import { verifyQstashSignature } from "@/lib/cron/verify-qstash";
+import { withCron } from "@/lib/cron/with-cron";
 import { redis } from "@/lib/upstash";
-import { log } from "@dub/utils";
-import { NextResponse } from "next/server";
+import { logAndRespond } from "../utils";
 
 export const dynamic = "force-dynamic";
 
-// Cron to update the disposable email domains list in Redis
+// POST /api/cron/disposable-emails
+// Sync disposable and Tremendous prohibited email domain blocklists into Redis.
 // Runs every Monday at noon UTC (0 12 * * 1)
-export async function POST(req: Request) {
-  try {
-    const rawBody = await req.text();
+export const POST = withCron(async () => {
+  const [disposableRes, tremendousRes] = await Promise.allSettled([
+    fetch(
+      "https://raw.githubusercontent.com/disposable-email-domains/disposable-email-domains/master/disposable_email_blocklist.conf",
+    ),
+    fetch("https://api.tremendous.com/prohibited_email_domains.txt"),
+  ]);
 
-    await verifyQstashSignature({
-      req,
-      rawBody,
-    });
+  if (disposableRes.status === "rejected") {
+    console.warn(
+      `Failed to fetch disposable email domains list: ${disposableRes.status} ${disposableRes.reason}`,
+    );
+  }
 
-    const disposableEmails = await fetch(
-      "https://raw.githubusercontent.com/disposable-email-domains/disposable-email-domains/master/disposable_email_blocklist.conf",
+  if (tremendousRes.status === "rejected") {
+    console.warn(
+      `Failed to fetch Tremendous prohibited email domains list: ${tremendousRes.status} ${tremendousRes.reason}`,
     );
+  }
 
-    const domains = (await disposableEmails.text()).split("\n").filter(Boolean);
+  const disposableDomains =
+    disposableRes.status === "fulfilled"
+      ? (await disposableRes.value.text()).split("\n").filter(Boolean)
+      : [];
 
-    if (domains.length < 100) {
-      throw new Error("Disposable email domains list is too short");
-    }
+  const tremendousDomains =
+    tremendousRes.status === "fulfilled"
+      ? (await tremendousRes.value.text())
+          .split("\n")
+          .map((d) => d.trim().toLowerCase())
+          .filter(Boolean)
+      : [];
 
-    // Use a temporary set to avoid emptying the old set
+  if (disposableDomains.length > 0) {
+    // Use temporary sets to avoid emptying the old sets
     await redis.del("disposableEmailDomainsTmp");
-    await redis.sadd("disposableEmailDomainsTmp", ...(domains as [string]));
+    await redis.sadd(
+      "disposableEmailDomainsTmp",
+      ...(disposableDomains as [string]),
+    );
     await redis.rename("disposableEmailDomainsTmp", "disposableEmailDomains");
+  }
 
-    return NextResponse.json({ status: "OK" });
-  } catch (error) {
-    await log({
-      message: `Error updating disposable email domains list: ${error.message}`,
-      type: "cron",
-    });
-
-    return handleAndReturnErrorResponse(error);
+  if (tremendousDomains.length > 0) {
+    await redis.del("tremendousProhibitedEmailDomainsTmp");
+    await redis.sadd(
+      "tremendousProhibitedEmailDomainsTmp",
+      ...(tremendousDomains as [string]),
+    );
+    await redis.rename(
+      "tremendousProhibitedEmailDomainsTmp",
+      "tremendousProhibitedEmailDomains",
+    );
   }
-}
+
+  return logAndRespond(
+    `Synced ${disposableDomains.length} disposable and ${tremendousDomains.length} Tremendous prohibited email domains.`,
+  );
+});

apps/web/app/(ee)/api/cron/payouts/charge-succeeded/queue-tremendous-payouts.ts

@@ -0,0 +1,89 @@
+import { qstash } from "@/lib/cron";
+import { TREMENDOUS_MAX_PAYOUT_AMOUNT_CENTS } from "@/lib/tremendous/constants";
+import { createTremendousCampaign } from "@/lib/tremendous/create-tremendous-campaign";
+import { prisma } from "@dub/prisma";
+import {
+  Invoice,
+  PartnerPayoutMethod,
+  PayoutMode,
+  PayoutStatus,
+} from "@dub/prisma/client";
+import { APP_DOMAIN_WITH_NGROK, chunk } from "@dub/utils";
+
+const queue = qstash.queue({
+  queueName: "send-tremendous-payout",
+});
+
+export async function queueTremendousPayouts(
+  invoice: Pick<Invoice, "id" | "paymentMethod" | "payoutMode" | "programId">,
+) {
+  if (invoice.payoutMode === "external" || !invoice.programId) {
+    return;
+  }
+
+  const program = await prisma.program.findUniqueOrThrow({
+    where: {
+      id: invoice.programId,
+    },
+    select: {
+      id: true,
+      name: true,
+      logo: true,
+      tremendousCampaignId: true,
+    },
+  });
+
+  if (!program.tremendousCampaignId) {
+    await createTremendousCampaign(program);
+  }
+
+  const partnersInCurrentInvoice = await prisma.payout.groupBy({
+    by: ["partnerId"],
+    where: {
+      invoiceId: invoice.id,
+      status: PayoutStatus.processing,
+      mode: PayoutMode.internal,
+      method: PartnerPayoutMethod.tremendous,
+      amount: {
+        lte: TREMENDOUS_MAX_PAYOUT_AMOUNT_CENTS,
+      },
+      partner: {
+        tremendousEmail: {
+          not: null,
+        },
+        payoutsEnabledAt: {
+          not: null,
+        },
+      },
+    },
+  });
+
+  if (partnersInCurrentInvoice.length === 0) {
+    console.log("No partners for sending via Tremendous, skipping...");
+    return;
+  }
+
+  const chunkedPartners = chunk(partnersInCurrentInvoice, 100);
+
+  for (let i = 0; i < chunkedPartners.length; i++) {
+    const partnersInChunk = chunkedPartners[i];
+
+    await Promise.all(
+      partnersInChunk.map(({ partnerId }) =>
+        queue.enqueueJSON({
+          url: `${APP_DOMAIN_WITH_NGROK}/api/cron/payouts/send-tremendous-payout`,
+          deduplicationId: `${invoice.id}-${partnerId}`,
+          method: "POST",
+          body: {
+            partnerId,
+            invoiceId: invoice.id,
+          },
+        }),
+      ),
+    );
+
+    console.log(
+      `Enqueued Tremendous payout for ${partnersInChunk.length} partners in chunk ${i + 1} of ${chunkedPartners.length}`,
+    );
+  }
+}

apps/web/app/(ee)/api/cron/payouts/charge-succeeded/route.ts

@@ -11,6 +11,7 @@ import * as z from "zod/v4";
 import { logAndRespond } from "../../utils";
 import { queueExternalPayouts } from "./queue-external-payouts";
 import { queueStripePayouts } from "./queue-stripe-payouts";
+import { queueTremendousPayouts } from "./queue-tremendous-payouts";
 import { sendPaypalPayouts } from "./send-paypal-payouts";
 import { scheduleDelayedStablecoinPayouts } from "./utils";
 
@@ -122,6 +123,8 @@ export async function POST(req: Request) {
       sendPaypalPayouts(invoice),
       // Queue external payouts
       queueExternalPayouts(invoice),
+      // Queue Tremendous payouts
+      queueTremendousPayouts(invoice),
     ]);
 
     return logAndRespond(

apps/web/app/(ee)/api/cron/payouts/send-tremendous-payout/route.ts

@@ -0,0 +1,25 @@
+import { withCron } from "@/lib/cron/with-cron";
+import { sendTremendousPayouts } from "@/lib/tremendous/send-tremendous-payouts";
+import * as z from "zod/v4";
+import { logAndRespond } from "../../utils";
+
+export const dynamic = "force-dynamic";
+
+const inputSchema = z.object({
+  partnerId: z.string(),
+  invoiceId: z.string().optional(),
+});
+
+// POST /api/cron/payouts/send-tremendous-payout
+export const POST = withCron(async ({ rawBody }) => {
+  const { partnerId, invoiceId } = inputSchema.parse(JSON.parse(rawBody));
+
+  await sendTremendousPayouts({
+    partnerId,
+    invoiceId,
+  });
+
+  return logAndRespond(
+    `Processed send-tremendous-payout job for partner ${partnerId}.`,
+  );
+});