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.

Gate commission holds by plan and always record conversion fraud events

Kiran Kc73fe2569674
diff --git a/apps/web/app/(ee)/api/cron/partners/ban/cancel-commissions.ts b/apps/web/app/(ee)/api/cron/partners/ban/cancel-commissions.ts
index 80dfe43b46..021051173c 100644
--- a/apps/web/app/(ee)/api/cron/partners/ban/cancel-commissions.ts
+++ b/apps/web/app/(ee)/api/cron/partners/ban/cancel-commissions.ts
@@ -21,11 +21,13 @@ export async function cancelCommissions({
where: {
programId,
partnerId,
- // cancel all commissions that are pending
+ // cancel all commissions that are pending or hold
// as well as processed commissions (added to a payout) but the payout was canceled
OR: [
{
- status: "pending",
+ status: {
+ in: ["pending", "hold"],
+ },
},
{
status: "processed",
diff --git a/apps/web/app/(ee)/api/workflows/create-partner-commission/route.ts b/apps/web/app/(ee)/api/workflows/create-partner-commission/route.ts
index ff61e3796d..c2ed6d1f2f 100644
--- a/apps/web/app/(ee)/api/workflows/create-partner-commission/route.ts
+++ b/apps/web/app/(ee)/api/workflows/create-partner-commission/route.ts
@@ -436,61 +436,74 @@ async function stepCreateCommission(
const { canManageFraudEvents } = getPlanCapabilities(program.workspace.plan);
- // 1. Partner-level: any pending partner-scope fraud group → hold (all commission types for this partner).
- // 2. Conversion-event: run fraud detection before create; if rules trigger → hold (customer-scoped).
- // An explicit `status` input (e.g. imports) wins; clawbacks (earnings <= 0) are never held.
- if (!status && earnings > 0 && canManageFraudEvents) {
- const hasPendingRiskGroups = await prisma.fraudEventGroup.findFirst({
+ // Conversion-event fraud detection always runs (regardless of plan capabilities,
+ // explicit `status` input, or pending partner-level groups) so fraud events are
+ // recorded for every conversion; only the hold decision below is gated.
+ let riskRulesTriggered = false;
+
+ if (customerId && eventId && clickEvent) {
+ const customer = await prisma.customer.findUnique({
where: {
- programId,
- partnerId,
- status: FraudEventStatus.pending,
- type: {
- in: PARTNER_LEVEL_FRAUD_RULES,
- },
+ id: customerId,
},
select: {
id: true,
+ email: true,
+ name: true,
},
});
- if (hasPendingRiskGroups) {
- status = CommissionStatus.hold;
- } else if (customerId && eventId && clickEvent) {
- const customer = await prisma.customer.findUnique({
+ if (customer) {
+ const triggeredRules = await detectAndRecordFraudEvent({
+ program: { id: programId },
+ partner: pick(programEnrollment.partner, ["id", "email", "name"]),
+ programEnrollment: pick(programEnrollment, [
+ "status",
+ "riskMonitoringDisabledAt",
+ ]),
+ customer: {
+ ...pick(customer, ["id", "email", "name"]),
+ ...(typeof isFirstConversion === "boolean" && {
+ isFirstConversion,
+ }),
+ },
+ link: { id: linkId },
+ click: pick(clickEvent, ["url", "referer"]),
+ event: { id: eventId },
+ });
+
+ riskRulesTriggered = triggeredRules.length > 0;
+ }
+ }
+
+ // 1. Partner-level: any pending partner-scope fraud group → hold (all commission types for this partner).
+ // 2. Conversion-event: run fraud detection before create; if rules trigger → hold (customer-scoped).
+ // An explicit `status` input (e.g. imports) wins; clawbacks (earnings <= 0) are never held.
+ if (!status && earnings > 0 && canManageFraudEvents) {
+ let shouldHoldCommission = false;
+
+ if (riskRulesTriggered) {
+ shouldHoldCommission = true;
+ } else {
+ const hasPendingRiskGroups = await prisma.fraudEventGroup.findFirst({
where: {
- id: customerId,
+ programId,
+ partnerId,
+ status: FraudEventStatus.pending,
+ type: {
+ in: PARTNER_LEVEL_FRAUD_RULES,
+ },
},
select: {
id: true,
- email: true,
- name: true,
},
});
- if (customer) {
- const triggeredRules = await detectAndRecordFraudEvent({
- program: { id: programId },
- partner: pick(programEnrollment.partner, ["id", "email", "name"]),
- programEnrollment: pick(programEnrollment, [
- "status",
- "riskMonitoringDisabledAt",
- ]),
- customer: {
- ...pick(customer, ["id", "email", "name"]),
- ...(typeof isFirstConversion === "boolean" && {
- isFirstConversion,
- }),
- },
- link: { id: linkId },
- click: pick(clickEvent, ["url", "referer"]),
- event: { id: eventId },
- });
+ shouldHoldCommission = hasPendingRiskGroups !== null;
+ }
- if (triggeredRules.length > 0) {
- status = CommissionStatus.hold;
- }
- }
+ if (shouldHoldCommission) {
+ status = CommissionStatus.hold;
}
}
@@ -737,7 +750,7 @@ async function clampEarningsToSpendLimit({
...(reward.event === "sale" ? { customerId } : {}),
type: reward.event,
status: {
- in: ["pending", "processed", "paid"],
+ in: ["pending", "processed", "paid", "hold"],
},
// only need to filter if not all-time spend limit (no startDate or endDate)
...(startDate && endDate
diff --git a/apps/web/lib/api/fraud/hold-pending-commissions.ts b/apps/web/lib/api/fraud/hold-pending-commissions.ts
index ea16e12308..58623f8224 100644
--- a/apps/web/lib/api/fraud/hold-pending-commissions.ts
+++ b/apps/web/lib/api/fraud/hold-pending-commissions.ts
@@ -20,13 +20,22 @@ export async function holdPendingCommissions(
const chunks = chunk(uniquePairs, 50);
for (const chunk of chunks) {
- const commissionsToHold = await prisma.commission.findMany({
+ const pendingCommissions = await prisma.commission.findMany({
where: {
OR: chunk.map(({ programId, partnerId }) => ({
programId,
partnerId,
})),
status: CommissionStatus.pending,
+ // Only hold commissions for workspaces whose plan can manage fraud events,
+ // Other plans have no way to review or resolve fraud groups, so their commissions should never be frozen.
+ program: {
+ workspace: {
+ plan: {
+ in: ["enterprise", "advanced"],
+ },
+ },
+ },
},
select: {
id: true,
@@ -43,14 +52,14 @@ export async function holdPendingCommissions(
},
});
- if (commissionsToHold.length === 0) {
+ if (pendingCommissions.length === 0) {
continue;
}
await prisma.commission.updateMany({
where: {
id: {
- in: commissionsToHold.map((c) => c.id),
+ in: pendingCommissions.map((c) => c.id),
},
},
data: {
@@ -58,7 +67,10 @@ export async function holdPendingCommissions(
},
});
- const commissionsByProgram = groupBy(commissionsToHold, (c) => c.programId);
+ const commissionsByProgram = groupBy(
+ pendingCommissions,
+ (c) => c.programId,
+ );
for (const commissions of Object.values(commissionsByProgram)) {
await trackCommissionStatusUpdate({
@@ -71,7 +83,7 @@ export async function holdPendingCommissions(
const affectedPairs = [
...new Map(
- commissionsToHold.map((c) => [
+ pendingCommissions.map((c) => [
`${c.programId}:${c.partnerId}`,
{ programId: c.programId, partnerId: c.partnerId },
]),
diff --git a/apps/web/lib/api/fraud/release-hold-commissions.ts b/apps/web/lib/api/fraud/release-hold-commissions.ts
new file mode 100644
index 0000000000..69ae2341c6
--- /dev/null
+++ b/apps/web/lib/api/fraud/release-hold-commissions.ts
@@ -0,0 +1,139 @@
+import { trackCommissionStatusUpdate } from "@/lib/api/commissions/track-commission-update-activity-log";
+import { syncTotalCommissions } from "@/lib/api/partners/sync-total-commissions";
+import { prisma } from "@/lib/prisma";
+import { FraudEventStatus, FraudRuleType, Prisma } from "@prisma/client";
+import { FRAUD_RULES_BY_TYPE, PARTNER_LEVEL_FRAUD_RULES } from "./constants";
+
+// When fraud groups are resolved or expired, move eligible hold commissions back to pending
+export async function releaseHoldCommissions(riskGroupIds: string[]) {
+ if (riskGroupIds.length === 0) {
+ return 0;
+ }
+
+ const riskGroups = await prisma.fraudEventGroup.findMany({
+ where: {
+ id: {
+ in: riskGroupIds,
+ },
+ },
+ select: {
+ id: true,
+ programId: true,
+ partnerId: true,
+ type: true,
+ program: {
+ select: {
+ workspaceId: true,
+ },
+ },
+ },
+ });
+
+ if (riskGroups.length === 0) {
+ return 0;
+ }
+
+ let releasedCount = 0;
+
+ const partnerProgramKeys = [
+ ...new Set(riskGroups.map((g) => `${g.programId}:${g.partnerId}`)),
+ ];
+
+ for (const key of partnerProgramKeys) {
+ const [programId, partnerId] = key.split(":");
+
+ const otherPendingGroups = await prisma.fraudEventGroup.findMany({
+ where: {
+ programId,
+ partnerId,
+ status: FraudEventStatus.pending,
+ id: {
+ notIn: riskGroupIds,
+ },
+ },
+ select: {
+ type: true,
+ fraudEvents: {
+ select: {
+ customerId: true,
+ },
+ },
+ },
+ });
+
+ const hasOtherPendingPartnerLevelGroup = otherPendingGroups.some((g) =>
+ (PARTNER_LEVEL_FRAUD_RULES as readonly FraudRuleType[]).includes(g.type),
+ );
+
+ if (hasOtherPendingPartnerLevelGroup) {
+ continue;
+ }
+
+ const blockedCustomerIds = new Set(
+ otherPendingGroups
+ .filter((g) => FRAUD_RULES_BY_TYPE[g.type]?.scope === "conversionEvent")
+ .flatMap((g) =>
+ g.fraudEvents
+ .map((e) => e.customerId)
+ .filter((id): id is string => id !== null),
+ ),
+ );
+
+ const groupsForPartner = riskGroups.filter(
+ (g) => g.programId === programId && g.partnerId === partnerId,
+ );
+
+ const releaseWhere: Prisma.CommissionWhereInput = {
+ programId,
+ partnerId,
+ status: "hold",
+ };
+
+ if (blockedCustomerIds.size > 0) {
+ releaseWhere.customerId = {
+ notIn: [...blockedCustomerIds],
+ };
+ }
+
+ const commissionsToRelease = await prisma.commission.findMany({
+ where: releaseWhere,
+ select: {
+ id: true,
+ amount: true,
+ earnings: true,
+ status: true,
+ },
+ });
+
+ if (commissionsToRelease.length === 0) {
+ continue;
+ }
+
+ await prisma.commission.updateMany({
+ where: {
+ id: {
+ in: commissionsToRelease.map((c) => c.id),
+ },
+ },
+ data: {
+ status: "pending",
+ },
+ });
+
+ await trackCommissionStatusUpdate({
+ workspaceId: groupsForPartner[0].program.workspaceId,
+ programId,
+ commissions: commissionsToRelease,
+ newStatus: "pending",
+ });
+
+ await syncTotalCommissions({
+ partnerId,
+ programId,
+ });
+
+ releasedCount += commissionsToRelease.length;
+ }
+
+ return releasedCount;
+}
diff --git a/apps/web/ui/partners/commission-status-badges.tsx b/apps/web/ui/partners/commission-status-badges.tsx
index 1ca7a95ba2..d10e94947a 100644
--- a/apps/web/ui/partners/commission-status-badges.tsx
+++ b/apps/web/ui/partners/commission-status-badges.tsx
@@ -128,7 +128,6 @@ export const CommissionStatusBadges = {
return title;
},
},
- // extra status for hold (not in OpenAPI spec)
hold: {
label: "On Hold",
variant: "error",