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.

Resolve merged fraud groups on the partner who owns the held commissions

Kiran K9913d5df7873
diff --git a/apps/web/app/(ee)/api/workflows/merge-partner-accounts/route.ts b/apps/web/app/(ee)/api/workflows/merge-partner-accounts/route.ts
index 6c76809fc2..3e64978c27 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
@@ -16,8 +16,8 @@ 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 { prettyPrint, R2_URL } from "@dub/utils";
-import { FraudRuleType } from "@prisma/client";
+import { pluck, prettyPrint, R2_URL } from "@dub/utils";
+import { FraudEventStatus, FraudRuleType } from "@prisma/client";
import { serve } from "@upstash/workflow/nextjs";
import * as z from "zod/v4";
import { logAndReturn } from "../../cron/utils";
@@ -146,6 +146,7 @@ export const { POST } = serve<Input>(
sourcePartnerId,
targetPartnerId,
});
+
logs.push(fraudLog);
const movedApplications = await prisma.programApplication.updateMany({
@@ -940,6 +941,7 @@ async function cleanupFraudEvents({
sourcePartnerId: string;
targetPartnerId: string;
}) {
+ // Events that name the source as the duplicate, including the one in its own group.
const fraudEventsToDelete = await prisma.fraudEvent.findMany({
where: {
partnerId: sourcePartnerId,
@@ -951,6 +953,7 @@ async function cleanupFraudEvents({
fraudEventGroup: {
select: {
id: true,
+ partnerId: true,
_count: {
select: {
fraudEvents: true,
@@ -961,6 +964,7 @@ async function cleanupFraudEvents({
},
});
+ // Remove those events so the source is no longer listed as a duplicate.
if (fraudEventsToDelete.length > 0) {
await prisma.fraudEvent.deleteMany({
where: {
@@ -969,42 +973,83 @@ async function cleanupFraudEvents({
});
}
+ // A group that had exactly two events now has only the partner left, so it can be resolved.
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({
+ const resolutionReason =
+ "Automatically resolved because the duplicate partner accounts were merged.";
+
+ // Move the source's pending groups onto the target, which now holds the commissions.
+ const sourceFraudGroups = await prisma.fraudEventGroup.findMany({
where: {
- OR: [
- {
- partnerId: sourcePartnerId,
- },
- ...(fraudEventGroupsToResolve.length > 0
- ? [
- {
- id: {
- in: fraudEventGroupsToResolve.map(
- (e) => e.fraudEventGroup.id,
- ),
- },
- },
- ]
- : []),
- ],
+ partnerId: sourcePartnerId,
type: FraudRuleType.partnerDuplicateAccount,
+ status: FraudEventStatus.pending,
+ },
+ select: {
+ id: true,
},
- resolutionReason:
- "Automatically resolved because the duplicate partner accounts were merged.",
- // Commissions may have been held for the duplicate-account risk; release
- // them now that the merge resolved those fraud groups. By this point
- // commissions have already been transferred to the target partner, so
- // release against the surviving account.
- releaseHoldCommissions: true,
- releasePartnerId: targetPartnerId,
});
+ if (sourceFraudGroups.length > 0) {
+ await prisma.fraudEventGroup.updateMany({
+ where: {
+ id: {
+ in: pluck(sourceFraudGroups, "id"),
+ },
+ status: FraudEventStatus.pending,
+ },
+ data: {
+ partnerId: targetPartnerId,
+ },
+ });
+ }
+
+ // Bucket group ids by the partner whose held commissions should be released.
+ const groupIdsByPartnerId = new Map<string, string[]>();
+
+ if (sourceFraudGroups.length > 0) {
+ groupIdsByPartnerId.set(
+ targetPartnerId,
+ sourceFraudGroups.map((group) => group.id),
+ );
+ }
+
+ for (const event of fraudEventGroupsToResolve) {
+ const { id, partnerId } = event.fraudEventGroup;
+
+ if (partnerId === sourcePartnerId) {
+ continue;
+ }
+
+ const groupIds = groupIdsByPartnerId.get(partnerId) ?? [];
+
+ if (!groupIds.includes(id)) {
+ groupIds.push(id);
+ }
+
+ groupIdsByPartnerId.set(partnerId, groupIds);
+ }
+
+ // Resolve each partner's groups and release holds only for that partner.
+ for (const [partnerId, groupIds] of groupIdsByPartnerId) {
+ await resolveFraudGroups({
+ where: {
+ partnerId,
+ id: {
+ in: groupIds,
+ },
+ type: FraudRuleType.partnerDuplicateAccount,
+ },
+ resolutionReason,
+ releaseHoldCommissions: true,
+ });
+ }
+
return logAndReturn({
outputLog: `Deleted ${fraudEventsToDelete.length} duplicate-account fraud events`,
});
diff --git a/apps/web/lib/api/fraud/release-hold-commissions.ts b/apps/web/lib/api/fraud/release-hold-commissions.ts
index b9dda77c83..163a884a65 100644
--- a/apps/web/lib/api/fraud/release-hold-commissions.ts
+++ b/apps/web/lib/api/fraud/release-hold-commissions.ts
@@ -249,16 +249,7 @@ export async function releaseHoldCommissions({
// Groups resolved/expired fraud groups by program+partner and enqueues a cron
// job per pair so releaseHoldCommissions runs asynchronously via QStash.
-export async function queueReleaseHoldCommissions(
- riskGroupIds: string[],
- {
- releasePartnerId,
- }: {
- // Override the partner whose hold commissions should be released. Used when
- // commissions have already moved to a different partner (e.g. account merge).
- releasePartnerId?: string;
- } = {},
-) {
+export async function queueReleaseHoldCommissions(riskGroupIds: string[]) {
if (riskGroupIds.length === 0) {
return 0;
}
@@ -289,8 +280,7 @@ export async function queueReleaseHoldCommissions(
>();
for (const riskGroup of riskGroups) {
- const partnerId = releasePartnerId ?? riskGroup.partnerId;
- const key = `${riskGroup.programId}:${partnerId}`;
+ const key = `${riskGroup.programId}:${riskGroup.partnerId}`;
const existing = pairs.get(key);
if (existing) {
@@ -298,7 +288,7 @@ export async function queueReleaseHoldCommissions(
} else {
pairs.set(key, {
programId: riskGroup.programId,
- partnerId,
+ partnerId: riskGroup.partnerId,
resolvedGroupIds: [riskGroup.id],
});
}
diff --git a/apps/web/lib/api/fraud/resolve-fraud-groups.ts b/apps/web/lib/api/fraud/resolve-fraud-groups.ts
index b532aea027..f3014d4387 100644
--- a/apps/web/lib/api/fraud/resolve-fraud-groups.ts
+++ b/apps/web/lib/api/fraud/resolve-fraud-groups.ts
@@ -8,16 +8,11 @@ export async function resolveFraudGroups({
userId,
resolutionReason,
releaseHoldCommissions = false,
- // When set, hold-commission release jobs run against this partner instead of
- // each group's partnerId. Used by account merges where commissions have
- // already been transferred to the surviving partner.
- releasePartnerId,
}: {
where: Prisma.FraudEventGroupWhereInput;
userId?: string;
resolutionReason?: string;
releaseHoldCommissions?: boolean;
- releasePartnerId?: string;
}) {
const riskGroups = await prisma.fraudEventGroup.findMany({
where: {
@@ -53,7 +48,7 @@ export async function resolveFraudGroups({
console.info(`Resolved ${count} fraud event groups ${prettyPrint(where)}`);
if (releaseHoldCommissions && count > 0) {
- await queueReleaseHoldCommissions(riskGroupIds, { releasePartnerId });
+ await queueReleaseHoldCommissions(riskGroupIds);
}
return count;