The modern link attribution platform. Loved by world-class engineering teams at Twilio, Zillow, Jobber, Vercel, Raycast, and more.
TypeScript clickhousemysqlnextjsopen-sourceplanetscaleprismatailwindcsstinybirdtypescriptupstashvercel
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.tsindex 0000000000,a67d8cd004..63c67595e4mode 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.tsindex 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.tsindex 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.tsindex 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.jsonindex 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": {