Discount code attribution tracking

apps/web/app/(ee)/api/commissions/[commissionId]/route.ts

@@ -166,29 +166,27 @@ export const PATCH = withWorkspace(
     }
 
     waitUntil(
-      (async () => {
-        await Promise.allSettled([
-          syncTotalCommissions({
-            partnerId: commission.partnerId,
-            programId: commission.programId,
-          }),
-
-          recordAuditLog({
-            workspaceId: workspace.id,
-            programId,
-            action: "commission.updated",
-            description: `Commission ${commissionId} updated`,
-            actor: session.user,
-            targets: [
-              {
-                type: "commission",
-                id: commission.id,
-                metadata: updatedCommission,
-              },
-            ],
-          }),
-        ]);
-      })(),
+      Promise.allSettled([
+        syncTotalCommissions({
+          partnerId: commission.partnerId,
+          programId: commission.programId,
+        }),
+
+        recordAuditLog({
+          workspaceId: workspace.id,
+          programId,
+          action: "commission.updated",
+          description: `Commission ${commissionId} updated`,
+          actor: session.user,
+          targets: [
+            {
+              type: "commission",
+              id: commission.id,
+              metadata: updatedCommission,
+            },
+          ],
+        }),
+      ]),
     );
 
     return NextResponse.json(CommissionEnrichedSchema.parse(updatedCommission));

apps/web/app/(ee)/api/cron/discount-codes/[discountCodeId]/delete/route.ts

@@ -0,0 +1,62 @@
+import { handleAndReturnErrorResponse } from "@/lib/api/errors";
+import { verifyQstashSignature } from "@/lib/cron/verify-qstash";
+import { disableStripeDiscountCode } from "@/lib/stripe/disable-stripe-discount-code";
+import { prisma } from "@dub/prisma";
+import { logAndRespond } from "../../../utils";
+
+export const dynamic = "force-dynamic";
+
+// POST /api/cron/discount-codes/[discountCodeId]/delete
+export async function POST(
+  req: Request,
+  { params }: { params: Promise<{ discountCodeId: string }> },
+) {
+  try {
+    const { discountCodeId } = await params;
+
+    const rawBody = await req.text();
+
+    await verifyQstashSignature({
+      req,
+      rawBody,
+    });
+
+    const discountCode = await prisma.discountCode.findUnique({
+      where: {
+        id: discountCodeId,
+      },
+    });
+
+    if (!discountCode) {
+      return logAndRespond(`Discount code ${discountCodeId} not found.`);
+    }
+
+    const workspace = await prisma.project.findUniqueOrThrow({
+      where: {
+        defaultProgramId: discountCode.programId,
+      },
+      select: {
+        stripeConnectId: true,
+      },
+    });
+
+    const disabledDiscountCode = await disableStripeDiscountCode({
+      code: discountCode.code,
+      stripeConnectId: workspace.stripeConnectId,
+    });
+
+    if (disabledDiscountCode) {
+      await prisma.discountCode.delete({
+        where: {
+          id: discountCodeId,
+        },
+      });
+    }
+
+    return logAndRespond(
+      `Discount code ${discountCode.code} disabled from Stripe for ${workspace.stripeConnectId}.`,
+    );
+  } catch (error) {
+    return handleAndReturnErrorResponse(error);
+  }
+}

apps/web/app/(ee)/api/cron/groups/remap-discount-codes/route.ts

@@ -0,0 +1,113 @@
+import { isDiscountEquivalent } from "@/lib/api/discounts/is-discount-equivalent";
+import { queueDiscountCodeDeletion } from "@/lib/api/discounts/queue-discount-code-deletion";
+import { handleAndReturnErrorResponse } from "@/lib/api/errors";
+import { verifyQstashSignature } from "@/lib/cron/verify-qstash";
+import { prisma } from "@dub/prisma";
+import { z } from "zod";
+import { logAndRespond } from "../../utils";
+
+export const dynamic = "force-dynamic";
+
+const schema = z.object({
+  programId: z.string(),
+  partnerIds: z.array(z.string()),
+  groupId: z.string(),
+});
+
+// POST /api/cron/groups/remap-discount-codes
+export async function POST(req: Request) {
+  try {
+    const rawBody = await req.text();
+
+    await verifyQstashSignature({
+      req,
+      rawBody,
+    });
+
+    const { programId, partnerIds, groupId } = schema.parse(
+      JSON.parse(rawBody),
+    );
+
+    if (partnerIds.length === 0) {
+      return logAndRespond("No partner IDs provided.");
+    }
+
+    const programEnrollments = await prisma.programEnrollment.findMany({
+      where: {
+        partnerId: {
+          in: partnerIds,
+        },
+        programId,
+      },
+      include: {
+        discountCodes: {
+          include: {
+            discount: true,
+          },
+        },
+      },
+    });
+
+    if (programEnrollments.length === 0) {
+      return logAndRespond("No program enrollments found.");
+    }
+
+    const group = await prisma.partnerGroup.findUnique({
+      where: {
+        id: groupId,
+      },
+      include: {
+        discount: true,
+      },
+    });
+
+    if (!group) {
+      return logAndRespond("Group not found.");
+    }
+
+    const discountCodes = programEnrollments.flatMap(
+      ({ discountCodes }) => discountCodes,
+    );
+
+    const discountCodesToUpdate: string[] = [];
+    const discountCodesToRemove: string[] = [];
+
+    for (const discountCode of discountCodes) {
+      const keepDiscountCode = isDiscountEquivalent(
+        group.discount,
+        discountCode.discount,
+      );
+
+      if (keepDiscountCode) {
+        discountCodesToUpdate.push(discountCode.id);
+      } else {
+        discountCodesToRemove.push(discountCode.id);
+      }
+    }
+
+    // Update the discount codes to use the new discount
+    if (discountCodesToUpdate.length > 0) {
+      await prisma.discountCode.updateMany({
+        where: {
+          id: {
+            in: discountCodesToUpdate,
+          },
+        },
+        data: {
+          discountId: group.discount?.id,
+        },
+      });
+    }
+
+    // Remove the discount codes from the group
+    if (discountCodesToRemove.length > 0) {
+      await queueDiscountCodeDeletion(discountCodesToRemove);
+    }
+
+    return logAndRespond(
+      `Updated ${discountCodesToUpdate.length} discount codes and removed ${discountCodesToRemove.length} discount codes.`,
+    );
+  } catch (error) {
+    return handleAndReturnErrorResponse(error);
+  }
+}

apps/web/app/(ee)/api/cron/links/invalidate-for-discounts/route.ts

@@ -4,6 +4,7 @@ import { verifyQstashSignature } from "@/lib/cron/verify-qstash";
 import { prisma } from "@dub/prisma";
 import { chunk } from "@dub/utils";
 import { z } from "zod";
+import { logAndRespond } from "../../utils";
 
 export const dynamic = "force-dynamic";
 
@@ -34,8 +35,9 @@ export async function POST(req: Request) {
     });
 
     if (!group) {
-      console.error(`Group ${groupId} not found.`);
-      return new Response("OK");
+      return logAndRespond(`Group ${groupId} not found.`, {
+        logLevel: "error",
+      });
     }
 
     // Find all the links of the partners in the group
@@ -59,30 +61,28 @@ export async function POST(req: Request) {
     });
 
     if (programEnrollments.length === 0) {
-      console.log(`No program enrollments found for group ${groupId}.`);
-      return new Response("OK");
+      return logAndRespond(
+        `No program enrollments found for group ${groupId}.`,
+      );
     }
 
     const links = programEnrollments.flatMap((enrollment) => enrollment.links);
 
     if (links.length === 0) {
-      console.log(`No links found for partners in the group ${groupId}.`);
-      return new Response("OK");
+      return logAndRespond(
+        `No links found for partners in the group ${groupId}.`,
+      );
     }
 
-    console.log(`Found ${links.length} links to invalidate the cache for.`);
-
     const linkChunks = chunk(links, 100);
 
     // Expire the cache for the links
     for (const linkChunk of linkChunks) {
       const toExpire = linkChunk.map(({ domain, key }) => ({ domain, key }));
       await linkCache.expireMany(toExpire);
-      console.log(toExpire);
-      console.log(`Expired cache for ${toExpire.length} links.`);
     }
 
-    return new Response("OK");
+    return logAndRespond(`Expired cache for ${links.length} links.`);
   } catch (error) {
     return handleAndReturnErrorResponse(error);
   }

apps/web/app/(ee)/api/discount-codes/[discountCodeId]/route.ts

@@ -0,0 +1,78 @@
+import { recordAuditLog } from "@/lib/api/audit-logs/record-audit-log";
+import { queueDiscountCodeDeletion } from "@/lib/api/discounts/queue-discount-code-deletion";
+import { DubApiError } from "@/lib/api/errors";
+import { getDefaultProgramIdOrThrow } from "@/lib/api/programs/get-default-program-id-or-throw";
+import { withWorkspace } from "@/lib/auth";
+import { prisma } from "@dub/prisma";
+import { waitUntil } from "@vercel/functions";
+import { NextResponse } from "next/server";
+
+// DELETE /api/discount-codes/[discountCodeId] - soft delete a discount code
+export const DELETE = withWorkspace(
+  async ({ workspace, params, session }) => {
+    const { discountCodeId } = params;
+    const programId = getDefaultProgramIdOrThrow(workspace);
+
+    const discountCode = await prisma.discountCode.findUnique({
+      where: {
+        id: discountCodeId,
+      },
+    });
+
+    if (!discountCode || !discountCode.discountId) {
+      throw new DubApiError({
+        message: `Discount code (${discountCodeId}) not found.`,
+        code: "bad_request",
+      });
+    }
+
+    if (discountCode.programId !== programId) {
+      throw new DubApiError({
+        message: `Discount code (${discountCodeId}) is not associated with the program.`,
+        code: "bad_request",
+      });
+    }
+
+    await prisma.discountCode.update({
+      where: {
+        id: discountCodeId,
+      },
+      data: {
+        discountId: null,
+      },
+    });
+
+    waitUntil(
+      Promise.allSettled([
+        recordAuditLog({
+          workspaceId: workspace.id,
+          programId,
+          action: "discount_code.deleted",
+          description: `Discount code (${discountCode.code}) deleted`,
+          actor: session.user,
+          targets: [
+            {
+              type: "discount_code",
+              id: discountCode.id,
+              metadata: discountCode,
+            },
+          ],
+        }),
+
+        queueDiscountCodeDeletion(discountCode.id),
+      ]),
+    );
+
+    return NextResponse.json({ id: discountCode.id });
+  },
+  {
+    requiredPlan: [
+      "business",
+      "business plus",
+      "business extra",
+      "business max",
+      "advanced",
+      "enterprise",
+    ],
+  },
+);