Merge pull request #1972 from dubinc/earnings-events

Supporting CPC earnings (+ lead events)

Author: steven-tey

apps/web/app/api/cron/aggregate-clicks/route.ts

@@ -0,0 +1,110 @@
+import { getAnalytics } from "@/lib/analytics/get-analytics";
+import { handleAndReturnErrorResponse } from "@/lib/api/errors";
+import { createId } from "@/lib/api/utils";
+import { verifyVercelSignature } from "@/lib/cron/verify-vercel";
+import { prisma } from "@dub/prisma";
+import { EventType, Prisma } from "@prisma/client";
+import { NextResponse } from "next/server";
+
+export const dynamic = "force-dynamic";
+
+/**
+ * TODO:
+ * - Use a cron job (similar to how we do it for usage cron) to account for the future where we have a lot of links to process
+ * - Might be better to read directly from the Reward table and fetch relevant links from there
+ * - Once these are ready, we'll add back the cron job in vercel.json
+    {
+      "path": "/api/cron/aggregate-clicks",
+      "schedule": "0 0 * * *"
+    },
+ */
+
+// This route is used aggregate clicks events on daily basis for Program links and add to the Commission table
+// Runs every day at 00:00 (0 0 * * *)
+// GET /api/cron/aggregate-clicks
+export async function GET(req: Request) {
+  try {
+    await verifyVercelSignature(req);
+
+    const links = await prisma.link.findMany({
+      where: {
+        programId: {
+          not: null,
+        },
+        partnerId: {
+          not: null,
+        },
+        clicks: {
+          gt: 0,
+        },
+        lastClicked: {
+          gte: new Date(Date.now() - 24 * 60 * 60 * 1000), // find links that were clicked in the last 24 hours
+        },
+      },
+      select: {
+        id: true,
+        programId: true,
+        partnerId: true,
+      },
+    });
+
+    if (!links.length) {
+      return NextResponse.json({
+        message: "No program links found. Skipping...",
+      });
+    }
+
+    const now = new Date();
+
+    // Set 'start' to the beginning of the previous day (00:00:00)
+    const start = new Date(now);
+    start.setDate(start.getDate() - 1);
+    start.setHours(0, 0, 0, 0);
+
+    // Set 'end' to the end of the previous day (23:59:59)
+    const end = new Date(now);
+    end.setDate(end.getDate() - 1);
+    end.setHours(23, 59, 59, 999);
+
+    let commissions: Prisma.CommissionUncheckedCreateInput[] =
+      await Promise.all(
+        links.map(async ({ id: linkId, programId, partnerId }) => {
+          const { clicks: quantity } = await getAnalytics({
+            start,
+            end,
+            linkId,
+            groupBy: "count",
+            event: "clicks",
+          });
+
+          return {
+            id: createId({ prefix: "cm_" }),
+            linkId,
+            programId: programId!,
+            partnerId: partnerId!,
+            type: EventType.click,
+            quantity,
+            amount: 0,
+          };
+        }),
+      );
+
+    commissions = commissions.filter((earning) => earning.amount > 0);
+
+    console.log({ start, end, commissions });
+
+    if (commissions.length) {
+      await prisma.commission.createMany({
+        data: commissions,
+      });
+    }
+
+    return NextResponse.json({
+      start,
+      end,
+      commissions,
+    });
+  } catch (error) {
+    return handleAndReturnErrorResponse(error);
+  }
+}

apps/web/app/api/cron/payouts/clicks/route.ts

@@ -0,0 +1,46 @@
+import { handleAndReturnErrorResponse } from "@/lib/api/errors";
+import { verifyVercelSignature } from "@/lib/cron/verify-vercel";
+import { prisma } from "@dub/prisma";
+import { NextResponse } from "next/server";
+import { createPayout } from "../create-payout";
+
+export const dynamic = "force-dynamic";
+
+// This route is used to calculate payouts for clicks.
+// Runs once every day at 00:00 (0 0 * * *)
+// GET /api/cron/payouts/clicks
+export async function GET(req: Request) {
+  try {
+    await verifyVercelSignature(req);
+
+    const clicks = await prisma.commission.groupBy({
+      by: ["programId", "partnerId"],
+      where: {
+        type: "click",
+        status: "pending",
+        payoutId: null,
+      },
+    });
+
+    if (!clicks.length) {
+      return NextResponse.json({
+        message: "No pending clicks found. Skipping...",
+      });
+    }
+
+    for (const { programId, partnerId } of clicks) {
+      await createPayout({
+        programId,
+        partnerId,
+        type: "click",
+      });
+    }
+
+    return NextResponse.json({
+      message: "Clicks payout created.",
+      clicks,
+    });
+  } catch (error) {
+    return handleAndReturnErrorResponse(error);
+  }
+}

apps/web/app/api/cron/payouts/create-payout.ts

@@ -0,0 +1,136 @@
+import { createId } from "@/lib/api/utils";
+import { prisma } from "@dub/prisma";
+import { EventType, Payout } from "@dub/prisma/client";
+
+export const createPayout = async ({
+  programId,
+  partnerId,
+  type,
+}: {
+  programId: string;
+  partnerId: string;
+  type: EventType;
+}) => {
+  await prisma.$transaction(async (tx) => {
+    const commissions = await tx.commission.findMany({
+      where: {
+        programId,
+        partnerId,
+        payoutId: null,
+        type,
+        status: "pending",
+      },
+      select: {
+        id: true,
+        createdAt: true,
+        earnings: true,
+        quantity: true,
+      },
+      orderBy: {
+        createdAt: "asc",
+      },
+    });
+
+    if (!commissions.length) {
+      console.log("No pending commissions found for processing payout.", {
+        programId,
+        partnerId,
+        type,
+      });
+
+      return;
+    }
+
+    // earliest commission date
+    const periodStart = commissions[0].createdAt;
+
+    // end of the month of the latest commission date
+    // e.g. if the latest sale is 2024-12-16, the periodEnd should be 2024-12-31
+    let periodEnd = commissions[commissions.length - 1].createdAt;
+    periodEnd = new Date(periodEnd.getFullYear(), periodEnd.getMonth() + 1);
+
+    const totalQuantity = commissions.reduce(
+      (total, { quantity }) => total + quantity,
+      0,
+    );
+
+    const totalAmount = commissions.reduce(
+      (total, { earnings }) => total + earnings,
+      0,
+    );
+
+    if (totalAmount === 0) {
+      console.log("Total amount is 0, skipping payout.", {
+        programId,
+        partnerId,
+        type,
+        totalQuantity,
+        totalAmount,
+      });
+
+      return;
+    }
+
+    // check if the partner has another pending payout
+    const existingPayout = await tx.payout.findFirst({
+      where: {
+        programId,
+        partnerId,
+        type: `${type}s`,
+        status: "pending",
+      },
+    });
+
+    let payout: Payout | null = null;
+
+    if (existingPayout) {
+      payout = await tx.payout.update({
+        where: {
+          id: existingPayout.id,
+        },
+        data: {
+          amount: {
+            increment: totalAmount,
+          },
+          quantity: {
+            increment: totalQuantity,
+          },
+          periodEnd,
+          description: existingPayout.description ?? "Dub Partners payout",
+        },
+      });
+    } else {
+      payout = await tx.payout.create({
+        data: {
+          id: createId({ prefix: "po_" }),
+          programId,
+          partnerId,
+          periodStart,
+          periodEnd,
+          amount: totalAmount,
+          quantity: totalQuantity,
+          description: "Dub Partners payout",
+          type: `${type}s`,
+        },
+      });
+    }
+
+    if (!payout) {
+      throw new Error("Payout not created.");
+    }
+
+    await tx.commission.updateMany({
+      where: {
+        id: {
+          in: commissions.map(({ id }) => id),
+        },
+      },
+      data: {
+        status: "processed",
+        payoutId: payout.id,
+      },
+    });
+
+    console.log("Payout created", payout);
+  });
+};

apps/web/app/api/cron/payouts/leads/route.ts

@@ -0,0 +1,46 @@
+import { handleAndReturnErrorResponse } from "@/lib/api/errors";
+import { verifyVercelSignature } from "@/lib/cron/verify-vercel";
+import { prisma } from "@dub/prisma";
+import { NextResponse } from "next/server";
+import { createPayout } from "../create-payout";
+
+export const dynamic = "force-dynamic";
+
+// This route is used to calculate payouts for leads.
+// Runs once every day at 00:00 (0 0 * * *)
+// GET /api/cron/payouts/leads
+export async function GET(req: Request) {
+  try {
+    await verifyVercelSignature(req);
+
+    const leads = await prisma.commission.groupBy({
+      by: ["programId", "partnerId"],
+      where: {
+        type: "lead",
+        status: "pending",
+        payoutId: null,
+      },
+    });
+
+    if (!leads.length) {
+      return NextResponse.json({
+        message: "No pending leads found. Skipping...",
+      });
+    }
+
+    for (const { programId, partnerId } of leads) {
+      await createPayout({
+        programId,
+        partnerId,
+        type: "lead",
+      });
+    }
+
+    return NextResponse.json({
+      message: "Leads payout created.",
+      leads,
+    });
+  } catch (error) {
+    return handleAndReturnErrorResponse(error);
+  }
+}