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.

Merge branch 'feature/partner-full-text-search-rollout' into feature/partner-full-text-search-sync

Rafiffbdda0e574c
diff --cc apps/web/app/(ee)/api/workflows/merge-partner-accounts/route.ts
index 0000000000,a67d8cd004..63c67595e4
mode 000000,100644..100644
--- a/apps/web/app/(ee)/api/workflows/merge-partner-accounts/route.ts
+++ b/apps/web/app/(ee)/api/workflows/merge-partner-accounts/route.ts
@@@ -1,0 -1,984 +1,995 @@@
+ 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 { queuePartnerSearchSync } from "@/lib/api/partners/queue-partner-search-sync";
+ import { syncTotalCommissions } from "@/lib/api/partners/sync-total-commissions";
+ import { logger } from "@/lib/axiom/server";
+ import { PRISMA_UPDATEMANY_LIMIT } from "@/lib/cron";
+ import { getWorkflowConfig } from "@/lib/cron/qstash-workflow";
+ import { conn } from "@/lib/planetscale";
+ import { prisma } from "@/lib/prisma";
+ import { storage } from "@/lib/storage";
+ import { recordLink } from "@/lib/tinybird";
+ import { redis } from "@/lib/upstash";
+ import { sendWorkspaceWebhook } from "@/lib/webhook/publish";
+ import { partnerMergedWebhookSchema } from "@/lib/zod/schemas/partners";
+ import { sendBatchEmail } from "@dub/email";
+ import PartnerAccountMerged from "@dub/email/templates/partner-account-merged";
+ import { log, prettyPrint, R2_URL } from "@dub/utils";
+ import { FraudRuleType } from "@prisma/client";
+ 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";
+
+ /**
+ * 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. finalize-transfers: transfer bounty submissions + sync transferred links
+ * (Tinybird/cache) and total commissions.
+ * 4. cleanup-source-account: delete the source partner's rewinds, source user,
+ * duplicate-account fraud events, and finally the source partner itself.
+ * 5. send-merged-emails: clear the verification cache + notify both accounts.
+ */
+
+ // POST /api/workflows/merge-partner-accounts
+ 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}`);
+
+ // Clear the verification cache so the user can cleanly retry (sendTokens
+ // rejects a new request while this key is still set).
+ await context.run("clear-cache-after-skip", async () => {
+ await redis.del(`${CACHE_KEY_PREFIX}:${userId}`);
+ return logAndReturn({
+ outputLog: `Cleared merge cache after skipped 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,
+ sourceEmail,
+ targetEmail,
+ });
+ });
+ }
+
+ // Step 3: Finalize the transfers. Both the bounty transfer and the
+ // link/commission sync are idempotent post-transfer reconciliation
+ await context.run("finalize-transfers", async () => {
+ if (programIdsToTransfer.length === 0) {
+ return logAndReturn({ outputLog: "No programs to finalize." });
+ }
+
+ // Transfer bounty submissions
+ const { outputLog: bountyLog } = await transferBountySubmissions({
+ sourcePartnerId,
+ targetPartnerId,
+ });
+
+ // Sync transferred links (Tinybird + cache) and total commissions
+ const { outputLog: syncLog } = await syncLinksAndCommissions({
+ targetPartnerId,
+ programIdsToTransfer,
+ });
+
+ return logAndReturn({ outputLog: `${bountyLog} | ${syncLog}` });
+ });
+
+ // Step 4: Tear down the source account
+ await context.run("cleanup-source-account", async () => {
+ const logs: string[] = [];
+
+ // Delete the source partner's rewinds
+ if (hasRewinds) {
+ const deletedRewinds = await prisma.partnerRewind.deleteMany({
+ where: { partnerId: sourcePartnerId },
+ });
+ logs.push(`Deleted ${deletedRewinds.count} partner rewinds`);
+ }
+
+ // Remove the source user if there are no workspaces left
+ if (sourceUserId) {
+ const { outputLog } = await deleteSourceUser({ sourceUserId });
+ logs.push(outputLog);
+ }
+
+ // Clean up duplicate-account fraud events + resolve their groups
+ const { outputLog: fraudLog } = await cleanupFraudEvents({
+ sourcePartnerId,
+ });
+ logs.push(fraudLog);
+
+ // Delete the source partner account (must be last)
+ const { outputLog: partnerLog } = await deleteSourcePartner({
+ sourcePartnerId,
+ sourceEmail,
+ sourceImage,
+ });
+ logs.push(partnerLog);
+
+ return logAndReturn({ outputLog: logs.join(" | ") });
+ });
+
+ // Step 5: 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-accounts",
+ 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-accounts",
+ 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),
+ };
+ }
+
+ // High-volume resources: move in batches of PRISMA_UPDATEMANY_LIMIT
+ async function transferRowsInBatches(
+ updateBatch: () => Promise<number>,
+ {
+ resourceName,
+ }: {
+ resourceName: string;
+ },
+ ) {
+ while (true) {
+ const count = await updateBatch();
+ console.log(`Transferred ${count} ${resourceName} in batch`);
+ if (count < PRISMA_UPDATEMANY_LIMIT) {
+ break;
+ }
+ }
+ }
+
+ // Rows unique on (programId, partnerId): move the source row when the target
+ // has none, otherwise delete it so rewriting enrollment.partnerId cannot collide.
+ async function transferIfNotExistElseDelete({
+ findTarget,
+ transferSource,
+ deleteSource,
+ resourceName,
+ }: {
+ findTarget: () => Promise<unknown>;
+ transferSource: () => Promise<number>;
+ deleteSource: () => Promise<number>;
+ resourceName: string;
+ }) {
+ if (await findTarget()) {
+ const count = await deleteSource();
+ console.log(
+ `Deleted ${count} source ${resourceName} (target already exists)`,
+ );
+ return;
+ }
+
+ const count = await transferSource();
+ console.log(`Transferred ${count} ${resourceName}`);
+ }
+
+ 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 PRISMA_UPDATEMANY_LIMIT
+ transferRowsInBatches(
+ async () =>
+ (
+ await prisma.commission.updateMany({
+ ...payload,
+ limit: PRISMA_UPDATEMANY_LIMIT,
+ })
+ ).count,
+ { resourceName: "commission" },
+ ),
+ transferRowsInBatches(
+ async () =>
+ (
+ await prisma.link.updateMany({
+ ...payload,
+ limit: PRISMA_UPDATEMANY_LIMIT,
+ })
+ ).count,
+ { resourceName: "link" },
+ ),
+ transferRowsInBatches(
+ async () =>
+ (
+ await prisma.customer.updateMany({
+ ...payload,
+ limit: PRISMA_UPDATEMANY_LIMIT,
+ })
+ ).count,
+ { resourceName: "customer" },
+ ),
+ // Low-volume tables: single updateMany is fine
+ prisma.payout.updateMany(payload),
+ prisma.discountCode.updateMany(payload),
+ prisma.notificationEmail.updateMany(payload),
+ prisma.message.updateMany(payload),
+ prisma.partnerComment.updateMany(payload),
+ // Unique on (programId, partnerId) — transfer or delete, never rewrite over
+ transferIfNotExistElseDelete({
+ findTarget: () =>
+ prisma.programApplicationEvent.findUnique({
+ where: {
+ programId_partnerId: { programId, partnerId: targetPartnerId },
+ },
+ }),
+ transferSource: async () =>
+ (await prisma.programApplicationEvent.updateMany(payload)).count,
+ deleteSource: async () =>
+ (await prisma.programApplicationEvent.deleteMany({ where })).count,
+ resourceName: "application event",
+ }),
+ transferIfNotExistElseDelete({
+ findTarget: () =>
+ prisma.discoveredPartner.findUnique({
+ where: {
+ programId_partnerId: { programId, partnerId: targetPartnerId },
+ },
+ }),
+ transferSource: async () =>
+ (await prisma.discoveredPartner.updateMany(payload)).count,
+ deleteSource: async () =>
+ (await prisma.discoveredPartner.deleteMany({ where })).count,
+ resourceName: "discovered partner",
+ }),
+ ]);
+
+ // After payouts are moved onto the target partner, fold any duplicate
+ // pending payouts for this program into a single payout.
+ await combinePendingPayouts({
+ partnerId: targetPartnerId,
+ programId,
+ });
+ }
+
+ async function mergeSingleEnrollment({
+ enrollmentId,
+ sourcePartnerId,
+ targetPartnerId,
+ sourceEmail,
+ targetEmail,
+ }: {
+ enrollmentId: string;
+ sourcePartnerId: string;
+ targetPartnerId: string;
+ sourceEmail: string;
+ targetEmail: string;
+ }) {
+ const sourceEnrollment = await prisma.programEnrollment.findUnique({
+ where: { id: enrollmentId },
+ include: {
+ program: {
+ select: {
+ workspace: {
+ select: {
+ id: true,
+ webhookEnabled: true,
+ },
+ },
+ },
+ },
+ },
+ });
+
+ 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`,
+ });
+ }
+
+ // Another process could have reassigned this enrollment away from the source
+ // partner; only the source partner's own enrollments should be merged.
+ if (sourceEnrollment.partnerId !== sourcePartnerId) {
+ return logAndReturn({
+ programId: sourceEnrollment.programId,
+ action: "skip",
+ outputLog: `Enrollment ${enrollmentId} no longer belongs to ${sourcePartnerId} (now ${sourceEnrollment.partnerId}), skipping`,
+ });
+ }
+
+ const { programId } = sourceEnrollment;
+
+ const targetEnrollment = await prisma.programEnrollment.findUnique({
+ where: {
+ partnerId_programId: {
+ partnerId: targetPartnerId,
+ programId,
+ },
+ },
+ });
+
+ await transferPartnerProgramData({
+ sourcePartnerId,
+ targetPartnerId,
+ programId,
+ });
+
+ let action: "overlap" | "transfer";
+
+ 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.updateMany({
+ where: { id: sourceEnrollment.id, partnerId: sourcePartnerId },
+ data: { applicationId: null },
+ });
+ }
+
+ await tx.programEnrollment.deleteMany({
+ where: { id: sourceEnrollment.id, partnerId: sourcePartnerId },
+ });
+
+ 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 },
+ });
+ }
+ }
+ });
+
+ action = "overlap";
+ } else {
+ // Scope the transfer to the source partner so a concurrent reassignment
+ // can't make us steal another partner's enrollment.
+ const { count } = await prisma.programEnrollment.updateMany({
+ where: { id: sourceEnrollment.id, partnerId: sourcePartnerId },
+ data: { partnerId: targetPartnerId },
+ });
+
+ if (count === 0) {
+ return logAndReturn({
+ programId,
+ action: "skip",
+ outputLog: `Enrollment ${sourceEnrollment.id} no longer owned by ${sourcePartnerId}, skipping transfer`,
+ });
+ }
+
+ action = "transfer";
+ }
+
++ // Queue an index update because the merge either reassigned the source
++ // enrollment to the target partner or deleted it. Passing both sides lets the
++ // job work out which.
++ await queuePartnerSearchSync({
++ enrollmentIds: [
++ sourceEnrollment.id,
++ ...(targetEnrollment ? [targetEnrollment.id] : []),
++ ],
++ });
++
+ await sendWorkspaceWebhook({
+ workspace: sourceEnrollment.program.workspace,
+ trigger: "partner.merged",
+ data: partnerMergedWebhookSchema.parse({
+ sourcePartner: {
+ id: sourcePartnerId,
+ tenantId: sourceEnrollment.tenantId,
+ email: sourceEmail,
+ },
+ targetPartner: {
+ id: targetPartnerId,
+ tenantId: targetEnrollment?.tenantId ?? sourceEnrollment.tenantId,
+ email: targetEmail,
+ },
+ targetAlreadyEnrolled: Boolean(targetEnrollment),
+ }),
+ });
+
+ return logAndReturn({
+ programId,
+ action,
+ outputLog:
+ action === "overlap"
+ ? `Merged overlapping enrollment for program ${programId}: ${sourceEmail} (${sourcePartnerId}) -> ${targetEmail} (${targetPartnerId}).`
+ : `Transferred enrollment for program ${programId}: ${sourceEmail} (${sourcePartnerId}) -> ${targetEmail} (${targetPartnerId}).`,
+ });
+ }
+
+ 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,
+ },
+ });
+
+ // only transfer bounty submissions if the target partner has no submissions for the same bounty
+ 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 combinePendingPayouts({
+ partnerId,
+ programId,
+ }: {
+ partnerId: string;
+ programId: string;
+ }) {
+ const payoutsToCombine = await prisma.payout.findMany({
+ where: {
+ programId,
+ partnerId,
+ status: "pending",
+ },
+ orderBy: {
+ createdAt: "asc",
+ },
+ });
+
+ if (payoutsToCombine.length < 2) {
+ return;
+ }
+
+ const periodStarts = payoutsToCombine
+ .map((payout) => payout.periodStart)
+ .filter((date): date is Date => date !== null);
+ const periodEnds = payoutsToCombine
+ .map((payout) => payout.periodEnd)
+ .filter((date): date is Date => date !== null);
+
+ const periodStart =
+ periodStarts.length > 0
+ ? new Date(Math.min(...periodStarts.map((date) => date.getTime())))
+ : payoutsToCombine[0].periodStart;
+ const periodEnd =
+ periodEnds.length > 0
+ ? new Date(Math.max(...periodEnds.map((date) => date.getTime())))
+ : payoutsToCombine[0].periodEnd;
+
+ const totalAmount = payoutsToCombine.reduce(
+ (sum, payout) => sum + payout.amount,
+ 0,
+ );
+
+ const combinedPayoutId = payoutsToCombine[0].id;
+ const payoutIdsToDelete = payoutsToCombine.slice(1).map((p) => p.id);
+
+ await prisma.payout.update({
+ where: {
+ id: combinedPayoutId,
+ },
+ data: {
+ amount: totalAmount,
+ periodStart,
+ periodEnd,
+ },
+ });
+
+ await transferRowsInBatches(
+ async () =>
+ (
+ await prisma.commission.updateMany({
+ where: {
+ payoutId: {
+ in: payoutIdsToDelete,
+ },
+ },
+ data: {
+ payoutId: combinedPayoutId,
+ },
+ limit: PRISMA_UPDATEMANY_LIMIT,
+ })
+ ).count,
+ { resourceName: "commission" },
+ );
+
+ const deletedPayouts = await prisma.payout.deleteMany({
+ where: {
+ id: {
+ in: payoutIdsToDelete,
+ },
+ },
+ });
+
+ return logAndReturn({
+ outputLog: `Combined ${payoutsToCombine.length} pending payouts for program ${programId} into ${combinedPayoutId} (deleted ${deletedPayouts.count})`,
+ });
+ }
+
+ 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,
+ }),
+ ),
+ ]);
+
+ // Fail the step (so QStash retries it) if any sync rejected. All of these
+ // ops are idempotent, so re-running the step is safe.
+ const rejected = res.filter(
+ (result): result is PromiseRejectedResult => result.status === "rejected",
+ );
+
+ if (rejected.length > 0) {
+ throw new Error(
+ `Failed to sync links/commissions: ${prettyPrint(
+ rejected.map(({ reason }) => reason),
+ )}`,
+ );
+ }
+
+ 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;
+ }) {
+ await conn.execute(`DELETE FROM Partner WHERE id = ?`, [sourcePartnerId]);
+
+ if (sourceImage) {
+ try {
+ await storage.delete({
+ key: sourceImage.replace(`${R2_URL}/`, ""),
+ });
+ } catch (error) {
+ logger.error("partner.image_delete_failed", {
+ sourcePartnerId,
+ sourceImage,
+ error,
+ });
+ }
+ }
+
+ return logAndReturn({
+ outputLog: `Deleted partner ${sourceEmail} (${sourcePartnerId})`,
+ });
+ }
diff --cc apps/web/lib/api/links/delete-link.ts
index fe22434032,a6509c292e..791767c8af
--- a/apps/web/lib/api/links/delete-link.ts
+++ b/apps/web/lib/api/links/delete-link.ts
@@@ -1,8 -1,4 +1,8 @@@
+import {
+ PARTNER_SEARCH_LINK_SYNC_DELAY_SECONDS,
+ queuePartnerSearchSync,
+} from "@/lib/api/partners/queue-partner-search-sync";
- import { enqueueDeleteDiscountCode } from "@/lib/discounts/delete-discount-code";
+ import { deleteDiscountCodes } from "@/lib/discounts/delete-discount-code";
import { prisma } from "@/lib/prisma";
import { storage } from "@/lib/storage";
import { recordLink } from "@/lib/tinybird";
@@@ -76,18 -59,6 +63,16 @@@ export async function deleteLink(linkId
},
},
}),
+
- link.discountCode && enqueueDeleteDiscountCode([link.discountCode]),
-
+ // Queue an index update because the link was deleted. The enrollment
+ // outlives it, so the document is re-serialized without it.
+ link.programId &&
+ link.partnerId &&
+ queuePartnerSearchSync({
+ partnerIds: [link.partnerId],
+ programId: link.programId,
+ delay: PARTNER_SEARCH_LINK_SYNC_DELAY_SECONDS,
+ }),
]),
);
diff --cc apps/web/lib/tapfiliate/cleanup-partners.ts
index bf6b002c9e,c8ae2081a3..06045dcf68
--- a/apps/web/lib/tapfiliate/cleanup-partners.ts
+++ b/apps/web/lib/tapfiliate/cleanup-partners.ts
@@@ -1,5 -1,5 +1,6 @@@
import { bulkDeleteLinks } from "@/lib/api/links/bulk-delete-links";
+import { queuePartnerSearchSync } from "@/lib/api/partners/queue-partner-search-sync";
+ import { conn } from "@/lib/planetscale";
import { prisma } from "@/lib/prisma";
import { sendEmail } from "@dub/email";
import ProgramImported from "@dub/email/templates/program-imported";
diff --cc apps/web/lib/tolt/cleanup-partners.ts
index 361d1d1d7e,cc840ec538..d7009dd7b0
--- a/apps/web/lib/tolt/cleanup-partners.ts
+++ b/apps/web/lib/tolt/cleanup-partners.ts
@@@ -1,5 -1,5 +1,6 @@@
import { bulkDeleteLinks } from "@/lib/api/links/bulk-delete-links";
+import { queuePartnerSearchSync } from "@/lib/api/partners/queue-partner-search-sync";
+ import { conn } from "@/lib/planetscale";
import { prisma } from "@/lib/prisma";
import { toltImporter } from "./importer";
diff --cc apps/web/vercel.json
index 82212ce77d,e59dfb5eda..e6200d1dbc
--- a/apps/web/vercel.json
+++ b/apps/web/vercel.json
@@@ -92,9 -92,9 +92,13 @@@
"path": "/api/cron/queue/retry",
"schedule": "* * * * *"
},
+ {
+ "path": "/api/cron/campaigns/queue-scheduled",
+ "schedule": "* * * * *"
++ },
+ {
+ "path": "/api/cron/partners/search-sweep",
+ "schedule": "0 3 * * 0"
}
],
"functions": {