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.

move merge-partner-accounts into qstash workflow

Pedro Ladeiraa2f83d9c8232
diff --git a/apps/web/app/(ee)/api/cron/partners/merge-accounts/route.ts b/apps/web/app/(ee)/api/cron/partners/merge-accounts/route.ts
deleted file mode 100644
index 0ff389e192..0000000000
--- a/apps/web/app/(ee)/api/cron/partners/merge-accounts/route.ts
+++ /dev/null
@@ -1,561 +0,0 @@
-import { handleAndReturnErrorResponse } from "@/lib/api/errors";
-import { resolveFraudGroups } from "@/lib/api/fraud/resolve-fraud-groups";
-import { linkCache } from "@/lib/api/links/cache";
-import { includeProgramEnrollment } from "@/lib/api/links/include-program-enrollment";
-import { includeTags } from "@/lib/api/links/include-tags";
-import { syncTotalCommissions } from "@/lib/api/partners/sync-total-commissions";
-import { verifyQstashSignature } from "@/lib/cron/verify-qstash";
-import { conn } from "@/lib/planetscale";
-import { storage } from "@/lib/storage";
-import { recordLink } from "@/lib/tinybird";
-import { redis } from "@/lib/upstash";
-import { sendBatchEmail } from "@dub/email";
-import PartnerAccountMerged from "@dub/email/templates/partner-account-merged";
-import { prisma } from "@dub/prisma";
-import { FraudRuleType, Prisma, ProgramEnrollment } from "@dub/prisma/client";
-import { log, prettyPrint, R2_URL } from "@dub/utils";
-import * as z from "zod/v4";
-
-export const dynamic = "force-dynamic";
-
-const schema = z.object({
- userId: z.string(),
- sourceEmail: z.string(),
- targetEmail: z.string(),
-});
-
-const CACHE_KEY_PREFIX = "merge-partner-accounts";
-
-async function transferPartnerProgramData(
- tx: Prisma.TransactionClient,
- {
- sourcePartnerId,
- targetPartnerId,
- programId,
- }: {
- sourcePartnerId: string;
- targetPartnerId: string;
- programId: string;
- },
-) {
- const payload = {
- where: {
- programId,
- partnerId: sourcePartnerId,
- },
- data: {
- partnerId: targetPartnerId,
- },
- };
-
- await Promise.all([
- tx.link.updateMany(payload),
- tx.customer.updateMany(payload),
- tx.commission.updateMany(payload),
- tx.payout.updateMany(payload),
- tx.discountCode.updateMany(payload),
- tx.notificationEmail.updateMany(payload),
- tx.message.updateMany(payload),
- tx.partnerComment.updateMany(payload),
- ]);
-}
-
-async function mergeOverlappingProgramEnrollment(
- tx: Prisma.TransactionClient,
- {
- sourceEnrollment,
- targetEnrollment,
- mergeSourcePartnerId,
- mergeTargetPartnerId,
- }: {
- sourceEnrollment: ProgramEnrollment;
- targetEnrollment: ProgramEnrollment;
- mergeSourcePartnerId: string;
- mergeTargetPartnerId: string;
- },
-) {
- await transferPartnerProgramData(tx, {
- sourcePartnerId: mergeSourcePartnerId,
- targetPartnerId: mergeTargetPartnerId,
- programId: sourceEnrollment.programId,
- });
-
- if (
- sourceEnrollment.status === "approved" &&
- ["pending", "invited"].includes(targetEnrollment.status)
- ) {
- await tx.programEnrollment.update({
- where: {
- partnerId_programId: {
- partnerId: mergeTargetPartnerId,
- programId: sourceEnrollment.programId,
- },
- },
- data: { status: "approved" },
- });
- }
-
- if (sourceEnrollment.applicationId) {
- await tx.programEnrollment.update({
- where: { id: sourceEnrollment.id },
- data: { applicationId: null },
- });
- }
-
- await tx.programEnrollment.delete({
- where: { id: sourceEnrollment.id },
- });
-
- const tenantIdToCopy = targetEnrollment.tenantId ?? sourceEnrollment.tenantId;
-
- if (tenantIdToCopy && tenantIdToCopy !== targetEnrollment.tenantId) {
- const existingTenantEnrollment = await tx.programEnrollment.findUnique({
- where: {
- tenantId_programId: {
- tenantId: tenantIdToCopy,
- programId: sourceEnrollment.programId,
- },
- },
- });
-
- if (!existingTenantEnrollment) {
- await tx.programEnrollment.update({
- where: {
- partnerId_programId: {
- partnerId: mergeTargetPartnerId,
- programId: sourceEnrollment.programId,
- },
- },
- data: { tenantId: tenantIdToCopy },
- });
- }
- }
-}
-
-async function transferProgramEnrollment(
- tx: Prisma.TransactionClient,
- {
- sourceEnrollment,
- mergeSourcePartnerId,
- mergeTargetPartnerId,
- }: {
- sourceEnrollment: ProgramEnrollment;
- mergeSourcePartnerId: string;
- mergeTargetPartnerId: string;
- },
-) {
- await tx.programEnrollment.update({
- where: { id: sourceEnrollment.id },
- data: { partnerId: mergeTargetPartnerId },
- });
-
- await transferPartnerProgramData(tx, {
- sourcePartnerId: mergeSourcePartnerId,
- targetPartnerId: mergeTargetPartnerId,
- programId: sourceEnrollment.programId,
- });
-}
-
-// POST /api/cron/partners/merge-accounts
-// This route is used to merge a partner account into another account
-export async function POST(req: Request) {
- let userId: string | null = null;
- let sourceEmail: string | null = null;
- let targetEmail: string | null = null;
- let sourcePartnerId: string | null = null;
- let targetPartnerId: string | null = null;
- let mergedProgramIds: string[] = [];
-
- try {
- const rawBody = await req.text();
-
- await verifyQstashSignature({
- req,
- rawBody,
- });
-
- const {
- userId: parsedUserId,
- sourceEmail: parsedSourceEmail,
- targetEmail: parsedTargetEmail,
- } = schema.parse(JSON.parse(rawBody));
-
- userId = parsedUserId;
- sourceEmail = parsedSourceEmail;
- targetEmail = parsedTargetEmail;
-
- console.log({
- userId,
- sourceEmail,
- targetEmail,
- });
-
- const partnerAccounts = await prisma.partner.findMany({
- where: {
- email: {
- in: [sourceEmail, targetEmail],
- },
- },
- select: {
- id: true,
- email: true,
- image: true,
- users: {
- select: {
- userId: true,
- },
- },
- partnerRewinds: true,
- },
- });
-
- if (partnerAccounts.length === 0) {
- return new Response("Partner accounts not found.");
- }
-
- const sourceAccount = partnerAccounts.find(
- ({ email }) => email?.toLowerCase() === sourceEmail!.toLowerCase(),
- );
-
- const targetAccount = partnerAccounts.find(
- ({ email }) => email?.toLowerCase() === targetEmail!.toLowerCase(),
- );
-
- if (!sourceAccount) {
- return new Response(
- `Partner account with email ${sourceEmail} not found.`,
- );
- }
-
- if (!targetAccount) {
- return new Response(
- `Partner account with email ${targetEmail} not found.`,
- );
- }
-
- if (sourceAccount.id === targetAccount.id) {
- return new Response(
- `Source and target partner accounts must be different. Source account: ${sourceAccount.email} (${sourceAccount.id}), Target account: ${targetAccount.email} (${targetAccount.id})`,
- );
- }
-
- const mergeSourcePartnerId = sourceAccount.id;
- const mergeTargetPartnerId = targetAccount.id;
- sourcePartnerId = mergeSourcePartnerId;
- targetPartnerId = mergeTargetPartnerId;
-
- const { users: sourcePartnerUsers } = sourceAccount;
-
- const [sourceEnrollments, targetEnrollments] = await Promise.all([
- prisma.programEnrollment.findMany({
- where: { partnerId: mergeSourcePartnerId },
- }),
- prisma.programEnrollment.findMany({
- where: { partnerId: mergeTargetPartnerId },
- }),
- ]);
-
- const targetEnrollmentByProgramId = new Map(
- targetEnrollments.map((enrollment) => [enrollment.programId, enrollment]),
- );
-
- const overlappingEnrollments = sourceEnrollments.filter((enrollment) =>
- targetEnrollmentByProgramId.has(enrollment.programId),
- );
-
- const transferEnrollments = sourceEnrollments.filter(
- (enrollment) => !targetEnrollmentByProgramId.has(enrollment.programId),
- );
-
- // Overlaps first, then transfers. Re-check target enrollment inside each
- // transaction so a stale read cannot trigger [partnerId, programId] errors.
- for (const sourceEnrollment of [
- ...overlappingEnrollments,
- ...transferEnrollments,
- ]) {
- let mergedAsOverlap = false;
-
- await prisma.$transaction(async (tx) => {
- const targetEnrollment = await tx.programEnrollment.findUnique({
- where: {
- partnerId_programId: {
- partnerId: mergeTargetPartnerId,
- programId: sourceEnrollment.programId,
- },
- },
- });
-
- if (targetEnrollment) {
- mergedAsOverlap = true;
- await mergeOverlappingProgramEnrollment(tx, {
- sourceEnrollment,
- targetEnrollment,
- mergeSourcePartnerId,
- mergeTargetPartnerId,
- });
- return;
- }
-
- await transferProgramEnrollment(tx, {
- sourceEnrollment,
- mergeSourcePartnerId,
- mergeTargetPartnerId,
- });
- });
-
- mergedProgramIds.push(sourceEnrollment.programId);
-
- console.log(
- mergedAsOverlap
- ? `Merged overlapping enrollment for program ${sourceEnrollment.programId}`
- : `Transferred enrollment for program ${sourceEnrollment.programId}`,
- );
- }
-
- const programIdsToTransfer = sourceEnrollments.map(
- ({ programId }) => programId,
- );
-
- if (programIdsToTransfer.length > 0) {
- const updatedLinks = await prisma.link.findMany({
- where: {
- programId: {
- in: programIdsToTransfer,
- },
- partnerId: mergeTargetPartnerId,
- },
- include: {
- ...includeTags,
- ...includeProgramEnrollment,
- },
- });
-
- // only transfer bounty submissions if the target partner has no submissions for the same bounty
- const bountySubmissionStats = await prisma.bountySubmission.groupBy({
- by: ["bountyId"],
- where: {
- partnerId: {
- in: [mergeSourcePartnerId, mergeTargetPartnerId],
- },
- },
- _count: {
- partnerId: true,
- },
- });
- const bountiesToTransfer = bountySubmissionStats
- .filter(({ _count }) => _count.partnerId === 1)
- .map(({ bountyId }) => bountyId);
-
- if (bountiesToTransfer.length > 0) {
- const updatedBountySubmissions =
- await prisma.bountySubmission.updateMany({
- where: {
- bountyId: { in: bountiesToTransfer },
- partnerId: mergeSourcePartnerId,
- },
- data: {
- partnerId: mergeTargetPartnerId,
- },
- });
- console.log(
- `Transferred ${updatedBountySubmissions.count} bounty submissions`,
- );
- }
-
- const res = await Promise.allSettled([
- // update link metadata in Tinybird
- recordLink(updatedLinks),
- // expire link cache in Redis
- linkCache.expireMany(updatedLinks),
- // Sync total commissions for the target partner in each program
- ...programIdsToTransfer.map((programId) =>
- syncTotalCommissions({
- partnerId: mergeTargetPartnerId,
- programId,
- }),
- ),
- ]);
- console.log(prettyPrint(res));
- }
-
- // If source account has rewind, need to delete and recalculate for the target account
- if (sourceAccount.partnerRewinds.length > 0) {
- const deletedRewinds = await prisma.partnerRewind.deleteMany({
- where: {
- partnerId: mergeSourcePartnerId,
- },
- });
- console.log(`Deleted ${deletedRewinds.count} partner rewinds`);
- }
-
- // Remove the user if there are no workspaces left
- // TODO: we need to handle deleting multiple users when we allow partners to invite their team members in the future
- const sourcePartnerUser = sourcePartnerUsers[0];
-
- if (sourcePartnerUser) {
- const workspaceCount = await prisma.projectUsers.count({
- where: {
- userId: sourcePartnerUser.userId,
- },
- });
-
- if (workspaceCount === 0) {
- try {
- const deletedUser = await prisma.user.delete({
- where: {
- id: sourcePartnerUser.userId,
- },
- select: {
- id: true,
- email: true,
- image: true,
- },
- });
- console.log(`Deleted user ${deletedUser.email} (${deletedUser.id})`);
-
- if (deletedUser.image) {
- await storage.delete({
- key: deletedUser.image.replace(`${R2_URL}/`, ""),
- });
- }
- } catch (error) {
- console.error(
- `Error deleting user ${sourcePartnerUser.userId}: ${error.message}`,
- );
- }
- }
- }
-
- const fraudEventsToDelete = await prisma.fraudEvent.findMany({
- where: {
- partnerId: mergeSourcePartnerId,
- fraudEventGroup: {
- type: FraudRuleType.partnerDuplicateAccount,
- },
- },
- include: {
- fraudEventGroup: {
- select: {
- id: true,
- _count: {
- select: {
- fraudEvents: true,
- },
- },
- },
- },
- },
- });
-
- if (fraudEventsToDelete.length > 0) {
- await prisma.fraudEvent.deleteMany({
- where: {
- id: { in: fraudEventsToDelete.map((e) => e.id) },
- },
- });
- }
-
- const fraudEventGroupsToResolve = fraudEventsToDelete.filter(
- // this is the count pre-deletion the fraud event, so if there are 2 fraud events
- // that means post-deletion will leave 1 fraud event in the group (no additional duplicates), hence can be resolved
- (e) => e.fraudEventGroup._count.fraudEvents === 2,
- );
-
- await resolveFraudGroups({
- where: {
- OR: [
- {
- partnerId: mergeSourcePartnerId,
- },
- ...(fraudEventGroupsToResolve.length > 0
- ? [
- {
- id: {
- in: fraudEventGroupsToResolve.map(
- (e) => e.fraudEventGroup.id,
- ),
- },
- },
- ]
- : []),
- ],
- type: FraudRuleType.partnerDuplicateAccount,
- },
- resolutionReason:
- "Automatically resolved because partners with duplicate payout methods were merged. No other partners share this payout method.",
- });
-
- try {
- // Finally, delete the partner account
- await conn.execute(`DELETE FROM Partner WHERE id = ?`, [
- mergeSourcePartnerId,
- ]);
- console.log(
- `Deleted partner ${sourceAccount.email} (${sourceAccount.id})`,
- );
-
- if (sourceAccount.image) {
- await storage.delete({
- key: sourceAccount.image.replace(`${R2_URL}/`, ""),
- });
- }
- } catch (error) {
- console.error(
- `Error deleting partner ${mergeSourcePartnerId}: ${error.message}`,
- );
- }
-
- // Make sure the cache is cleared
- await redis.del(`${CACHE_KEY_PREFIX}:${userId}`);
-
- const resendBatchEmailRes = await sendBatchEmail(
- [
- {
- variant: "notifications",
- to: sourceEmail,
- subject: "Your Dub partner accounts are now merged",
- react: PartnerAccountMerged({
- email: sourceEmail,
- sourceEmail,
- targetEmail,
- }),
- },
- {
- variant: "notifications",
- to: targetEmail,
- subject: "Your Dub partner accounts are now merged",
- react: PartnerAccountMerged({
- email: targetEmail,
- sourceEmail,
- targetEmail,
- }),
- },
- ],
- {
- idempotencyKey: `${CACHE_KEY_PREFIX}/${userId}`,
- },
- );
- console.log(prettyPrint(resendBatchEmailRes));
-
- return new Response(
- `Partner account ${sourceEmail} merged into ${targetEmail}.`,
- );
- } catch (error) {
- if (userId) {
- await redis.del(`${CACHE_KEY_PREFIX}:${userId}`);
- }
-
- const partialMergeNote =
- mergedProgramIds.length > 0
- ? ` Partial merge: ${mergedProgramIds.length} program(s) already merged (${mergedProgramIds.join(", ")}). Manual cleanup may be required.`
- : "";
-
- await log({
- message: `Error merging partner accounts: userId=${userId}, sourcePartnerId=${sourcePartnerId}, targetPartnerId=${targetPartnerId}, error=${error.message}.${partialMergeNote}`,
- type: "alerts",
- mention: true,
- });
-
- return handleAndReturnErrorResponse(error);
- }
-}
diff --git a/apps/web/app/(ee)/api/workflows/merge-partner-account/route.ts b/apps/web/app/(ee)/api/workflows/merge-partner-account/route.ts
new file mode 100644
index 0000000000..29bdd7ec7c
--- /dev/null
+++ b/apps/web/app/(ee)/api/workflows/merge-partner-account/route.ts
@@ -0,0 +1,750 @@
+import { resolveFraudGroups } from "@/lib/api/fraud/resolve-fraud-groups";
+import { linkCache } from "@/lib/api/links/cache";
+import { includeProgramEnrollment } from "@/lib/api/links/include-program-enrollment";
+import { includeTags } from "@/lib/api/links/include-tags";
+import { syncTotalCommissions } from "@/lib/api/partners/sync-total-commissions";
+import { logger } from "@/lib/axiom/server";
+import { getWorkflowConfig } from "@/lib/cron/qstash-workflow";
+import { conn } from "@/lib/planetscale";
+import { storage } from "@/lib/storage";
+import { recordLink } from "@/lib/tinybird";
+import { redis } from "@/lib/upstash";
+import { sendBatchEmail } from "@dub/email";
+import PartnerAccountMerged from "@dub/email/templates/partner-account-merged";
+import { prisma } from "@dub/prisma";
+import { FraudRuleType } from "@dub/prisma/client";
+import { log, prettyPrint, R2_URL } from "@dub/utils";
+import { serve } from "@upstash/workflow/nextjs";
+import * as z from "zod/v4";
+import { logAndReturn } from "../../cron/utils";
+
+const inputSchema = z.object({
+ userId: z.string(),
+ sourceEmail: z.string(),
+ targetEmail: z.string(),
+});
+
+type Input = z.infer<typeof inputSchema>;
+
+const CACHE_KEY_PREFIX = "merge-partner-accounts";
+const MERGE_BATCH_SIZE = 500;
+
+/**
+ * Steps:
+ * 1. load-merge-plan: resolve + validate accounts, build the ordered list of
+ * source enrollments to process (overlaps first, then transfers).
+ * 2. merge-enrollment-<id> (one per enrollment): transfer the enrollment's
+ * program data to the target and either merge into the existing target
+ * enrollment (overlap) or move the enrollment over (transfer).
+ * 3. transfer-bounty-submissions
+ * 4. sync-links-and-commissions
+ * 5. delete-partner-rewinds
+ * 6. delete-source-user
+ * 7. cleanup-fraud-events
+ * 8. delete-source-partner
+ * 9. send-merged-emails
+ */
+
+// POST /api/workflows/merge-partner-account
+export const { POST } = serve<Input>(
+ async (context) => {
+ const { userId, sourceEmail, targetEmail } = context.requestPayload;
+
+ // Step 1: Resolve + validate accounts and build the merge plan
+ const plan = await context.run("load-merge-plan", async () => {
+ return await loadMergePlan({ sourceEmail, targetEmail });
+ });
+
+ if (!plan.proceed) {
+ console.log(`Skipping merge: ${plan.reason}`);
+ return;
+ }
+
+ const {
+ sourcePartnerId,
+ targetPartnerId,
+ sourceImage,
+ sourceUserId,
+ hasRewinds,
+ orderedSourceEnrollmentIds,
+ programIdsToTransfer,
+ } = plan;
+
+ // Step 2: Merge each source enrollment in its own durable step.
+ // Overlaps are ordered first, then transfers. Each step re-fetches the
+ // live enrollment so it is safe to retry after a partial run.
+ for (const enrollmentId of orderedSourceEnrollmentIds) {
+ await context.run(`merge-enrollment-${enrollmentId}`, async () => {
+ return await mergeSingleEnrollment({
+ enrollmentId,
+ sourcePartnerId,
+ targetPartnerId,
+ });
+ });
+ }
+
+ // Step 3: Transfer bounty submissions (only when the target has none for the same bounty)
+ await context.run("transfer-bounty-submissions", async () => {
+ if (programIdsToTransfer.length === 0) {
+ return logAndReturn({
+ outputLog: "No programs to transfer bounties for.",
+ });
+ }
+
+ return await transferBountySubmissions({
+ sourcePartnerId,
+ targetPartnerId,
+ });
+ });
+
+ // Step 4: Sync transferred links (Tinybird + cache) and total commissions
+ await context.run("sync-links-and-commissions", async () => {
+ if (programIdsToTransfer.length === 0) {
+ return logAndReturn({ outputLog: "No programs to sync." });
+ }
+
+ return await syncLinksAndCommissions({
+ targetPartnerId,
+ programIdsToTransfer,
+ });
+ });
+
+ // Step 5: Delete the source partner's rewinds (target will be recalculated separately)
+ if (hasRewinds) {
+ await context.run("delete-partner-rewinds", async () => {
+ const deletedRewinds = await prisma.partnerRewind.deleteMany({
+ where: { partnerId: sourcePartnerId },
+ });
+
+ return logAndReturn({
+ outputLog: `Deleted ${deletedRewinds.count} partner rewinds`,
+ });
+ });
+ }
+
+ // Step 6: Remove the source user if there are no workspaces left
+ if (sourceUserId) {
+ await context.run("delete-source-user", async () => {
+ return await deleteSourceUser({ sourceUserId });
+ });
+ }
+
+ // Step 7: Clean up duplicate-account fraud events + resolve their groups
+ await context.run("cleanup-fraud-events", async () => {
+ return await cleanupFraudEvents({ sourcePartnerId });
+ });
+
+ // Step 8: Delete the source partner account
+ await context.run("delete-source-partner", async () => {
+ return await deleteSourcePartner({
+ sourcePartnerId,
+ sourceEmail,
+ sourceImage,
+ });
+ });
+
+ // Step 9: Clear the verification cache and notify both accounts
+ await context.run("send-merged-emails", async () => {
+ await redis.del(`${CACHE_KEY_PREFIX}:${userId}`);
+
+ const resendBatchEmailRes = await sendBatchEmail(
+ [
+ {
+ variant: "notifications",
+ to: sourceEmail,
+ subject: "Your Dub partner accounts are now merged",
+ react: PartnerAccountMerged({
+ email: sourceEmail,
+ sourceEmail,
+ targetEmail,
+ }),
+ },
+ {
+ variant: "notifications",
+ to: targetEmail,
+ subject: "Your Dub partner accounts are now merged",
+ react: PartnerAccountMerged({
+ email: targetEmail,
+ sourceEmail,
+ targetEmail,
+ }),
+ },
+ ],
+ {
+ idempotencyKey: `${CACHE_KEY_PREFIX}/${userId}`,
+ },
+ );
+
+ return logAndReturn({
+ outputLog: `Partner account ${sourceEmail} merged into ${targetEmail}. ${prettyPrint(resendBatchEmailRes)}`,
+ });
+ });
+ },
+ {
+ initialPayloadParser: (requestPayload) => {
+ return inputSchema.parse(JSON.parse(requestPayload));
+ },
+ failureFunction: async ({
+ context,
+ failStatus,
+ failResponse,
+ failHeaders,
+ }) => {
+ const { userId } = inputSchema.parse(context.requestPayload);
+
+ // Clear the verification cache so the partner can retry from the start
+ await redis.del(`${CACHE_KEY_PREFIX}:${userId}`);
+
+ const { correlation } = getWorkflowConfig({
+ workflowType: "merge-partner-account",
+ body: context.requestPayload,
+ });
+
+ await log({
+ message: `Error merging partner accounts: ${JSON.stringify(correlation)}, workflowRunId=${context.workflowRunId}, failStatus=${failStatus}, failResponse=${failResponse}. Some enrollments may already be merged (see workflow run for completed steps) - manual cleanup may be required.`,
+ type: "alerts",
+ mention: true,
+ });
+
+ logger.error("workflow.failed", {
+ service: "qstash",
+ event: "workflow.failed",
+ workflowType: "merge-partner-account",
+ workflowRunId: context.workflowRunId,
+ failStatus,
+ failResponse,
+ failHeaders,
+ correlation,
+ });
+
+ await logger.flush();
+ },
+ },
+);
+
+type MergePlan =
+ | { proceed: false; reason: string }
+ | {
+ proceed: true;
+ sourcePartnerId: string;
+ targetPartnerId: string;
+ sourceImage: string | null;
+ sourceUserId: string | null;
+ hasRewinds: boolean;
+ orderedSourceEnrollmentIds: string[];
+ programIdsToTransfer: string[];
+ };
+
+async function loadMergePlan({
+ sourceEmail,
+ targetEmail,
+}: {
+ sourceEmail: string;
+ targetEmail: string;
+}): Promise<MergePlan> {
+ const partnerAccounts = await prisma.partner.findMany({
+ where: {
+ email: {
+ in: [sourceEmail, targetEmail],
+ },
+ },
+ select: {
+ id: true,
+ email: true,
+ image: true,
+ users: {
+ select: {
+ userId: true,
+ },
+ },
+ partnerRewinds: true,
+ },
+ });
+
+ if (partnerAccounts.length === 0) {
+ return { proceed: false, reason: "Partner accounts not found." };
+ }
+
+ const sourceAccount = partnerAccounts.find(
+ ({ email }) => email?.toLowerCase() === sourceEmail.toLowerCase(),
+ );
+
+ const targetAccount = partnerAccounts.find(
+ ({ email }) => email?.toLowerCase() === targetEmail.toLowerCase(),
+ );
+
+ if (!sourceAccount) {
+ return {
+ proceed: false,
+ reason: `Partner account with email ${sourceEmail} not found.`,
+ };
+ }
+
+ if (!targetAccount) {
+ return {
+ proceed: false,
+ reason: `Partner account with email ${targetEmail} not found.`,
+ };
+ }
+
+ if (sourceAccount.id === targetAccount.id) {
+ return {
+ proceed: false,
+ reason: `Source and target partner accounts must be different. Source account: ${sourceAccount.email} (${sourceAccount.id}), Target account: ${targetAccount.email} (${targetAccount.id})`,
+ };
+ }
+
+ const sourcePartnerId = sourceAccount.id;
+ const targetPartnerId = targetAccount.id;
+
+ const [sourceEnrollments, targetEnrollments] = await Promise.all([
+ prisma.programEnrollment.findMany({
+ where: { partnerId: sourcePartnerId },
+ select: { id: true, programId: true },
+ }),
+ prisma.programEnrollment.findMany({
+ where: { partnerId: targetPartnerId },
+ select: { programId: true },
+ }),
+ ]);
+
+ const targetProgramIds = new Set(
+ targetEnrollments.map((enrollment) => enrollment.programId),
+ );
+
+ const overlappingEnrollments = sourceEnrollments.filter((enrollment) =>
+ targetProgramIds.has(enrollment.programId),
+ );
+
+ const transferEnrollments = sourceEnrollments.filter(
+ (enrollment) => !targetProgramIds.has(enrollment.programId),
+ );
+
+ // Overlaps first, then transfers (preserves the original processing order).
+ const orderedSourceEnrollmentIds = [
+ ...overlappingEnrollments,
+ ...transferEnrollments,
+ ].map(({ id }) => id);
+
+ return {
+ proceed: true,
+ sourcePartnerId,
+ targetPartnerId,
+ sourceImage: sourceAccount.image,
+ sourceUserId: sourceAccount.users[0]?.userId ?? null,
+ hasRewinds: sourceAccount.partnerRewinds.length > 0,
+ orderedSourceEnrollmentIds,
+ programIdsToTransfer: sourceEnrollments.map(({ programId }) => programId),
+ };
+}
+
+async function transferRowsInBatches(updateBatch: () => Promise<number>) {
+ while (true) {
+ const count = await updateBatch();
+ if (count < MERGE_BATCH_SIZE) {
+ break;
+ }
+ }
+}
+
+async function transferPartnerProgramData({
+ sourcePartnerId,
+ targetPartnerId,
+ programId,
+}: {
+ sourcePartnerId: string;
+ targetPartnerId: string;
+ programId: string;
+}) {
+ const where = {
+ programId,
+ partnerId: sourcePartnerId,
+ };
+ const payload = {
+ where,
+ data: {
+ partnerId: targetPartnerId,
+ },
+ };
+
+ await Promise.all([
+ // High-volume tables: move in batches of MERGE_BATCH_SIZE
+ transferRowsInBatches(
+ async () =>
+ (
+ await prisma.commission.updateMany({
+ ...payload,
+ limit: MERGE_BATCH_SIZE,
+ })
+ ).count,
+ ),
+ transferRowsInBatches(
+ async () =>
+ (
+ await prisma.link.updateMany({
+ ...payload,
+ limit: MERGE_BATCH_SIZE,
+ })
+ ).count,
+ ),
+ transferRowsInBatches(
+ async () =>
+ (
+ await prisma.customer.updateMany({
+ ...payload,
+ limit: MERGE_BATCH_SIZE,
+ })
+ ).count,
+ ),
+ transferRowsInBatches(
+ async () =>
+ (
+ await prisma.payout.updateMany({
+ ...payload,
+ limit: MERGE_BATCH_SIZE,
+ })
+ ).count,
+ ),
+ // Low-volume tables: single updateMany is fine
+ prisma.discountCode.updateMany(payload),
+ prisma.notificationEmail.updateMany(payload),
+ prisma.message.updateMany(payload),
+ prisma.partnerComment.updateMany(payload),
+ ]);
+}
+
+async function mergeSingleEnrollment({
+ enrollmentId,
+ sourcePartnerId,
+ targetPartnerId,
+}: {
+ enrollmentId: string;
+ sourcePartnerId: string;
+ targetPartnerId: string;
+}) {
+ const sourceEnrollment = await prisma.programEnrollment.findUnique({
+ where: { id: enrollmentId },
+ });
+
+ if (!sourceEnrollment) {
+ return logAndReturn({
+ programId: null,
+ action: "skip",
+ outputLog: `Enrollment ${enrollmentId} no longer exists, skipping`,
+ });
+ }
+
+ if (sourceEnrollment.partnerId === targetPartnerId) {
+ return logAndReturn({
+ programId: sourceEnrollment.programId,
+ action: "skip",
+ outputLog: `Enrollment ${enrollmentId} already on target partner, skipping`,
+ });
+ }
+
+ const { programId } = sourceEnrollment;
+
+ const targetEnrollment = await prisma.programEnrollment.findUnique({
+ where: {
+ partnerId_programId: {
+ partnerId: targetPartnerId,
+ programId,
+ },
+ },
+ });
+
+ await transferPartnerProgramData({
+ sourcePartnerId,
+ targetPartnerId,
+ programId,
+ });
+
+ if (targetEnrollment) {
+ await prisma.$transaction(async (tx) => {
+ if (
+ sourceEnrollment.status === "approved" &&
+ ["pending", "invited"].includes(targetEnrollment.status)
+ ) {
+ await tx.programEnrollment.update({
+ where: {
+ partnerId_programId: {
+ partnerId: targetPartnerId,
+ programId,
+ },
+ },
+ data: { status: "approved" },
+ });
+ }
+
+ if (sourceEnrollment.applicationId) {
+ await tx.programEnrollment.update({
+ where: { id: sourceEnrollment.id },
+ data: { applicationId: null },
+ });
+ }
+
+ await tx.programEnrollment.delete({
+ where: { id: sourceEnrollment.id },
+ });
+
+ const tenantIdToCopy =
+ targetEnrollment.tenantId ?? sourceEnrollment.tenantId;
+
+ if (tenantIdToCopy && tenantIdToCopy !== targetEnrollment.tenantId) {
+ const existingTenantEnrollment = await tx.programEnrollment.findUnique({
+ where: {
+ tenantId_programId: {
+ tenantId: tenantIdToCopy,
+ programId,
+ },
+ },
+ });
+
+ if (!existingTenantEnrollment) {
+ await tx.programEnrollment.update({
+ where: {
+ partnerId_programId: {
+ partnerId: targetPartnerId,
+ programId,
+ },
+ },
+ data: { tenantId: tenantIdToCopy },
+ });
+ }
+ }
+ });
+
+ return logAndReturn({
+ programId,
+ action: "overlap",
+ outputLog: `Merged overlapping enrollment for program ${programId}`,
+ });
+ }
+
+ await prisma.programEnrollment.update({
+ where: { id: sourceEnrollment.id },
+ data: { partnerId: targetPartnerId },
+ });
+
+ return logAndReturn({
+ programId,
+ action: "transfer",
+ outputLog: `Transferred enrollment for program ${programId}`,
+ });
+}
+
+async function transferBountySubmissions({
+ sourcePartnerId,
+ targetPartnerId,
+}: {
+ sourcePartnerId: string;
+ targetPartnerId: string;
+}) {
+ const bountySubmissionStats = await prisma.bountySubmission.groupBy({
+ by: ["bountyId"],
+ where: {
+ partnerId: {
+ in: [sourcePartnerId, targetPartnerId],
+ },
+ },
+ _count: {
+ partnerId: true,
+ },
+ });
+
+ const bountiesToTransfer = bountySubmissionStats
+ .filter(({ _count }) => _count.partnerId === 1)
+ .map(({ bountyId }) => bountyId);
+
+ if (bountiesToTransfer.length === 0) {
+ return logAndReturn({ outputLog: "No bounty submissions to transfer." });
+ }
+
+ const updatedBountySubmissions = await prisma.bountySubmission.updateMany({
+ where: {
+ bountyId: { in: bountiesToTransfer },
+ partnerId: sourcePartnerId,
+ },
+ data: {
+ partnerId: targetPartnerId,
+ },
+ });
+
+ return logAndReturn({
+ outputLog: `Transferred ${updatedBountySubmissions.count} bounty submissions`,
+ });
+}
+
+async function syncLinksAndCommissions({
+ targetPartnerId,
+ programIdsToTransfer,
+}: {
+ targetPartnerId: string;
+ programIdsToTransfer: string[];
+}) {
+ const updatedLinks = await prisma.link.findMany({
+ where: {
+ programId: {
+ in: programIdsToTransfer,
+ },
+ partnerId: targetPartnerId,
+ },
+ include: {
+ ...includeTags,
+ ...includeProgramEnrollment,
+ },
+ });
+
+ const res = await Promise.allSettled([
+ recordLink(updatedLinks),
+ linkCache.expireMany(updatedLinks),
+ ...programIdsToTransfer.map((programId) =>
+ syncTotalCommissions({
+ partnerId: targetPartnerId,
+ programId,
+ }),
+ ),
+ ]);
+
+ return logAndReturn({
+ outputLog: `Synced ${updatedLinks.length} links and commissions. ${prettyPrint(res)}`,
+ });
+}
+
+async function deleteSourceUser({ sourceUserId }: { sourceUserId: string }) {
+ const workspaceCount = await prisma.projectUsers.count({
+ where: {
+ userId: sourceUserId,
+ },
+ });
+
+ if (workspaceCount > 0) {
+ return logAndReturn({
+ outputLog: `User ${sourceUserId} still has ${workspaceCount} workspace(s), not deleting.`,
+ });
+ }
+
+ try {
+ const deletedUser = await prisma.user.delete({
+ where: {
+ id: sourceUserId,
+ },
+ select: {
+ id: true,
+ email: true,
+ image: true,
+ },
+ });
+
+ if (deletedUser.image) {
+ await storage.delete({
+ key: deletedUser.image.replace(`${R2_URL}/`, ""),
+ });
+ }
+
+ return logAndReturn({
+ outputLog: `Deleted user ${deletedUser.email} (${deletedUser.id})`,
+ });
+ } catch (error) {
+ return logAndReturn({
+ outputLog: `Error deleting user ${sourceUserId}: ${error.message}`,
+ });
+ }
+}
+
+async function cleanupFraudEvents({
+ sourcePartnerId,
+}: {
+ sourcePartnerId: string;
+}) {
+ const fraudEventsToDelete = await prisma.fraudEvent.findMany({
+ where: {
+ partnerId: sourcePartnerId,
+ fraudEventGroup: {
+ type: FraudRuleType.partnerDuplicateAccount,
+ },
+ },
+ include: {
+ fraudEventGroup: {
+ select: {
+ id: true,
+ _count: {
+ select: {
+ fraudEvents: true,
+ },
+ },
+ },
+ },
+ },
+ });
+
+ if (fraudEventsToDelete.length > 0) {
+ await prisma.fraudEvent.deleteMany({
+ where: {
+ id: { in: fraudEventsToDelete.map((e) => e.id) },
+ },
+ });
+ }
+
+ const fraudEventGroupsToResolve = fraudEventsToDelete.filter(
+ // this is the count pre-deletion the fraud event, so if there are 2 fraud events
+ // that means post-deletion will leave 1 fraud event in the group (no additional duplicates), hence can be resolved
+ (e) => e.fraudEventGroup._count.fraudEvents === 2,
+ );
+
+ await resolveFraudGroups({
+ where: {
+ OR: [
+ {
+ partnerId: sourcePartnerId,
+ },
+ ...(fraudEventGroupsToResolve.length > 0
+ ? [
+ {
+ id: {
+ in: fraudEventGroupsToResolve.map(
+ (e) => e.fraudEventGroup.id,
+ ),
+ },
+ },
+ ]
+ : []),
+ ],
+ type: FraudRuleType.partnerDuplicateAccount,
+ },
+ resolutionReason:
+ "Automatically resolved because partners with duplicate payout methods were merged. No other partners share this payout method.",
+ });
+
+ return logAndReturn({
+ outputLog: `Deleted ${fraudEventsToDelete.length} duplicate-account fraud events`,
+ });
+}
+
+async function deleteSourcePartner({
+ sourcePartnerId,
+ sourceEmail,
+ sourceImage,
+}: {
+ sourcePartnerId: string;
+ sourceEmail: string;
+ sourceImage: string | null;
+}) {
+ try {
+ await conn.execute(`DELETE FROM Partner WHERE id = ?`, [sourcePartnerId]);
+
+ if (sourceImage) {
+ await storage.delete({
+ key: sourceImage.replace(`${R2_URL}/`, ""),
+ });
+ }
+
+ return logAndReturn({
+ outputLog: `Deleted partner ${sourceEmail} (${sourcePartnerId})`,
+ });
+ } catch (error) {
+ return logAndReturn({
+ outputLog: `Error deleting partner ${sourcePartnerId}: ${error.message}`,
+ });
+ }
+}
diff --git a/apps/web/lib/actions/partners/merge-partner-accounts.ts b/apps/web/lib/actions/partners/merge-partner-accounts.ts
index d817fe14ab..ec4933751e 100644
--- a/apps/web/lib/actions/partners/merge-partner-accounts.ts
+++ b/apps/web/lib/actions/partners/merge-partner-accounts.ts
@@ -1,13 +1,12 @@
"use server";
import { generateOTP } from "@/lib/auth/utils";
-import { qstash } from "@/lib/cron";
+import { triggerQStashWorkflow } from "@/lib/cron/qstash-workflow";
import { ratelimit, redis } from "@/lib/upstash";
import { emailSchema } from "@/lib/zod/schemas/auth";
import { sendBatchEmail } from "@dub/email";
import VerifyEmailForAccountMerge from "@dub/email/templates/verify-email-for-account-merge";
import { prisma } from "@dub/prisma";
-import { APP_DOMAIN_WITH_NGROK } from "@dub/utils";
import * as z from "zod/v4";
import { authPartnerActionClient } from "../safe-action";
@@ -341,12 +340,17 @@ const mergeAccounts = async ({ userId }: { userId: string }) => {
const { sourceEmail, targetEmail } = accounts;
- await qstash.publishJSON({
- url: `${APP_DOMAIN_WITH_NGROK}/api/cron/partners/merge-accounts`,
+ await triggerQStashWorkflow({
+ workflowType: "merge-partner-account",
+ workflowLabel: userId,
body: {
userId,
sourceEmail,
targetEmail,
},
+ flowControl: {
+ key: userId,
+ parallelism: 1,
+ },
});
};
diff --git a/apps/web/lib/cron/qstash-workflow.ts b/apps/web/lib/cron/qstash-workflow.ts
index b0b99a36e5..6a8f82ef68 100644
--- a/apps/web/lib/cron/qstash-workflow.ts
+++ b/apps/web/lib/cron/qstash-workflow.ts
@@ -8,7 +8,10 @@ const client = new Client({
token: process.env.QSTASH_TOKEN || "",
});
-type WorkflowType = "partner-approved" | "create-partner-commission";
+type WorkflowType =
+ | "partner-approved"
+ | "create-partner-commission"
+ | "merge-partner-account";
interface QStashWorkflow {
workflowType: WorkflowType;
@@ -102,6 +105,16 @@ export function getWorkflowConfig({
};
}
+ case "merge-partner-account": {
+ return {
+ correlation: {
+ userId: body.userId,
+ sourceEmail: body.sourceEmail,
+ targetEmail: body.targetEmail,
+ },
+ };
+ }
+
default:
return {
correlation: {},