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.

Refactor fraud event creation logic to improve deduplication and group handling. Removed unused group hash logic and optimized event processing by leveraging unique fingerprints and existing group checks. Updated related functions for better clarity and maintainability.

Kiran K2acb87e58c84
diff --git a/apps/web/lib/api/fraud/create-fraud-events.ts b/apps/web/lib/api/fraud/create-fraud-events.ts
index 285baaaf6d..2ade4a89d8 100644
--- a/apps/web/lib/api/fraud/create-fraud-events.ts
+++ b/apps/web/lib/api/fraud/create-fraud-events.ts
@@ -2,161 +2,171 @@ import { CreateFraudEventInput } from "@/lib/types";
import { prisma } from "@dub/prisma";
import { Prisma } from "@dub/prisma/client";
import { createId } from "../create-id";
-import {
- createFraudEventFingerprint,
- createFraudEventGroupKey,
- createFraudGroupHash,
- sanitizeFraudEventMetadata,
-} from "./utils";
+import { createFraudEventFingerprint, createFraudEventGroupKey } from "./utils";
export async function createFraudEvents(fraudEvents: CreateFraudEventInput[]) {
if (fraudEvents.length === 0) {
- return {
- createdEvents: 0,
- createdGroups: 0,
- };
+ return;
}
- // 1. Compute fingerprint + groupHash once
- const eventsWithComputed = fraudEvents.map((e) => ({
+ const eventsWithHash = fraudEvents.map((e) => ({
...e,
fingerprint: createFraudEventFingerprint(e),
- groupHash: createFraudGroupHash(e),
}));
- // Unique fingerprints & group hashes
- const uniqueFingerprints = Array.from(
- new Set(eventsWithComputed.map((e) => e.fingerprint)),
+ // Deduplicate by fingerprint in-memory first
+ const uniqueEvents = Array.from(
+ new Map(eventsWithHash.map((e) => [e.fingerprint, e])).values(),
);
- const uniqueGroupHashes = Array.from(
- new Set(eventsWithComputed.map((e) => e.groupHash)),
+ // Find existing groups to avoid creating duplicates and maintain group continuity
+ // Events with the same programId/partnerId/type should be grouped together
+ const existingGroups = await prisma.fraudEventGroup.findMany({
+ where: {
+ OR: uniqueEvents.map((e) => ({
+ programId: e.programId,
+ partnerId: e.partnerId,
+ type: e.type,
+ status: "pending",
+ })),
+ },
+ select: {
+ id: true,
+ programId: true,
+ partnerId: true,
+ type: true,
+ },
+ });
+
+ // Identify events that need new groups created because they represent
+ const groupsToCreate = uniqueEvents.filter(
+ (e) =>
+ !existingGroups.some(
+ (g) =>
+ g.programId === e.programId &&
+ g.partnerId === e.partnerId &&
+ g.type === e.type,
+ ),
);
- return await prisma.$transaction(async (tx) => {
- // 2. Fetch existing pending events with same fingerprint
- const existingEvents = await tx.fraudEvent.findMany({
- where: {
- fingerprint: {
- in: uniqueFingerprints,
- },
- fraudEventGroup: {
- status: "pending",
- },
- },
- select: {
- fingerprint: true,
- },
+ // Deduplicate groups to create since multiple events may require the same group
+ const newGroups = Array.from(
+ new Map(
+ groupsToCreate.map((e) => [`${e.programId}:${e.partnerId}:${e.type}`, e]),
+ ).values(),
+ ).map((e) => ({
+ id: createId({ prefix: "frg_" }),
+ programId: e.programId,
+ partnerId: e.partnerId,
+ type: e.type,
+ }));
+
+ // Create new groups
+ if (newGroups.length > 0) {
+ await prisma.fraudEventGroup.createMany({
+ data: newGroups,
});
+ }
- const existingFingerprintSet = new Set(
- existingEvents.map((e) => e.fingerprint),
- );
-
- // 3. Filter out events that already exist
- const filteredEvents = eventsWithComputed.filter(
- (e) => !existingFingerprintSet.has(e.fingerprint),
- );
-
- if (filteredEvents.length === 0) {
- return {
- createdEvents: 0,
- createdGroups: 0,
- };
- }
-
- // 4. Fetch existing pending groups
- const existingGroups = await tx.fraudEventGroup.findMany({
- where: {
- hash: {
- in: uniqueGroupHashes,
- },
+ // Final list of groups to use
+ const finalGroups = [...existingGroups, ...newGroups];
+
+ const finalGroupLookup = new Map(
+ finalGroups.map((g) => [createGroupCompositeKey(g), g.id]),
+ );
+
+ // Fetch existing events to prevent duplicate fraud event records
+ // A fraud event with the same fingerprint in a pending group is considered a duplicate
+ const existingEvents = await prisma.fraudEvent.findMany({
+ where: {
+ fingerprint: {
+ in: uniqueEvents.map((e) => e.fingerprint),
+ },
+ fraudEventGroup: {
status: "pending",
},
- });
+ },
+ select: {
+ id: true,
+ fraudEventGroupId: true,
+ fingerprint: true,
+ },
+ });
- const groupMap = new Map(existingGroups.map((g) => [g.hash, g.id]));
-
- // 5. Create missing groups bulk
- const groupsToCreate = uniqueGroupHashes
- .filter((hash) => !groupMap.has(hash))
- .map((hash) => {
- const anyEvent = filteredEvents.find((e) => e.groupHash === hash)!;
- const id = createId({ prefix: "frg_" });
- groupMap.set(hash, id);
-
- return {
- id,
- programId: anyEvent.programId,
- partnerId: anyEvent.partnerId,
- type: anyEvent.type,
- hash,
- };
- });
-
- if (groupsToCreate.length > 0) {
- await tx.fraudEventGroup.createMany({
- data: groupsToCreate,
- });
- }
-
- // 4) Bulk insert FraudEvents
- const eventsToInsert: Prisma.FraudEventCreateManyInput[] =
- filteredEvents.map((e) => ({
- id: createId({ prefix: "fre_" }),
- fraudEventGroupId: groupMap.get(e.groupHash),
- eventId: e.eventId,
- linkId: e.linkId,
- customerId: e.customerId,
- fingerprint: e.fingerprint,
- partnerId:
- e.type === "partnerDuplicatePayoutMethod"
- ? (e.metadata as Record<string, string>)?.duplicatePartnerId
- : e.partnerId,
- metadata: sanitizeFraudEventMetadata(e.metadata),
-
- // DEPRECATED FIELDS: TODO – remove after migration
+ // Deduplicate events by fingerprint
+ const newEvents = uniqueEvents.filter(
+ (e) =>
+ !existingEvents.some(
+ (existingEvent) => existingEvent.fingerprint === e.fingerprint,
+ ),
+ );
+
+ const newEventsWithGroup: Prisma.FraudEventCreateManyInput[] = newEvents.map(
+ (e) => ({
+ id: createId({ prefix: "fre_" }),
+ fraudEventGroupId: finalGroupLookup.get(createGroupCompositeKey(e)),
+ partnerId: getPartnerIdForFraudEvent(e),
+ linkId: e.linkId,
+ customerId: e.customerId,
+ eventId: e.eventId,
+ fingerprint: e.fingerprint,
+ metadata: e.metadata ?? undefined,
+
+ // DEPRECATED FIELDS: TODO – remove after migration
+ programId: e.programId,
+ type: e.type,
+ groupKey: createFraudEventGroupKey({
programId: e.programId,
type: e.type,
- groupKey: createFraudEventGroupKey({
- programId: e.programId,
- type: e.type,
- groupingKey: e.partnerId,
- }),
- }));
-
- await tx.fraudEvent.createMany({
- data: eventsToInsert,
- });
+ groupingKey: e.partnerId,
+ }),
+ }),
+ );
- // 5) Bulk update eventCount + lastEventAt
- const countsPerGroup = filteredEvents.reduce((map, e) => {
- const id = groupMap.get(e.groupHash)!;
- map.set(id, (map.get(id) || 0) + 1);
- return map;
- }, new Map<string, number>());
+ if (newEventsWithGroup.length === 0) {
+ return;
+ }
- const now = new Date();
+ await prisma.fraudEvent.createMany({
+ data: newEventsWithGroup,
+ });
- await Promise.all(
- Array.from(countsPerGroup.entries()).map(([id, count]) =>
- tx.fraudEventGroup.update({
- where: {
- id,
- },
- data: {
- lastEventAt: now,
- eventCount: {
- increment: count,
- },
+ await Promise.allSettled(
+ finalGroups.map((group) =>
+ prisma.fraudEventGroup.update({
+ where: {
+ id: group.id,
+ },
+ data: {
+ lastEventAt: new Date(),
+ eventCount: {
+ increment: newEventsWithGroup.filter(
+ (e) => e.fraudEventGroupId === group.id,
+ ).length,
},
- }),
- ),
- );
+ },
+ }),
+ ),
+ );
+}
- return {
- createdGroups: groupsToCreate.length,
- createdEvents: eventsToInsert.length,
- };
- });
+// Creates a composite key to uniquely identify fraud event groups
+function createGroupCompositeKey(
+ event: Pick<CreateFraudEventInput, "programId" | "partnerId" | "type">,
+) {
+ return `${event.programId}:${event.partnerId}:${event.type}`;
+}
+
+// Determine the correct partnerId for a fraud event.
+// For duplicate payout method events, uses the duplicatePartnerId from metadata.
+function getPartnerIdForFraudEvent(
+ event: Pick<CreateFraudEventInput, "partnerId" | "type" | "metadata">,
+) {
+ const metadata = event.metadata as Record<string, string> | undefined;
+
+ if (event.type === "partnerDuplicatePayoutMethod") {
+ return metadata?.duplicatePartnerId ?? event.partnerId;
+ }
+
+ return event.partnerId;
}
diff --git a/apps/web/lib/api/fraud/detect-duplicate-payout-method-fraud.ts b/apps/web/lib/api/fraud/detect-duplicate-payout-method-fraud.ts
index d4abe0942f..dddfe94e9c 100644
--- a/apps/web/lib/api/fraud/detect-duplicate-payout-method-fraud.ts
+++ b/apps/web/lib/api/fraud/detect-duplicate-payout-method-fraud.ts
@@ -1,7 +1,6 @@
import { CreateFraudEventInput } from "@/lib/types";
import { prisma } from "@dub/prisma";
import { FraudRuleType } from "@dub/prisma/client";
-import { prettyPrint } from "@dub/utils";
import { createFraudEvents } from "./create-fraud-events";
// Check for duplicate payout methods: if multiple partners share the same payout method hash,
@@ -40,10 +39,6 @@ export async function detectDuplicatePayoutMethodFraud(
};
}
- console.info(
- `Found ${duplicatePartners.length} partners with same payout method hash ${prettyPrint(duplicatePartners)}`,
- );
-
// Group program enrollments by programId
const partnersByProgram = new Map<string, string[]>();
diff --git a/apps/web/lib/api/fraud/utils.ts b/apps/web/lib/api/fraud/utils.ts
index 5ce2e51407..9146d7de90 100644
--- a/apps/web/lib/api/fraud/utils.ts
+++ b/apps/web/lib/api/fraud/utils.ts
@@ -17,11 +17,9 @@ interface CreateFingerprintInput
interface GetIdentityFieldsForFraudEventInput
extends Pick<FraudEventGroup, "partnerId" | "type"> {
customerId?: string | null | undefined;
+ metadata?: Prisma.JsonValue | undefined;
}
-interface CreateGroupHashInput
- extends Pick<CreateFraudEventInput, "type" | "programId" | "partnerId"> {}
-
// Normalize email for comparison
export function normalizeEmail(email: string): string {
const trimmed = email.toLowerCase().trim();
@@ -90,7 +88,10 @@ export function createFraudEventFingerprint(
function getIdentityFieldsForFraudEvent({
type,
customerId,
+ metadata,
}: GetIdentityFieldsForFraudEventInput): Record<string, string> {
+ const eventMetadata = metadata as Record<string, string>;
+
switch (type) {
case "customerEmailMatch":
case "customerEmailSuspiciousDomain":
@@ -104,25 +105,17 @@ function getIdentityFieldsForFraudEvent({
customerId,
};
+ case "partnerDuplicatePayoutMethod":
+ return {
+ duplicatePartnerId: eventMetadata?.duplicatePartnerId,
+ };
+
case "partnerCrossProgramBan":
case "partnerFraudReport":
- case "partnerDuplicatePayoutMethod":
return {};
}
}
-// Get the group hash for a fraud rule type.
-// This determines which events should be grouped together.
-export function createFraudGroupHash({
- programId,
- partnerId,
- type,
-}: CreateGroupHashInput) {
- const parts = [programId, type, partnerId].map((p) => p!.toLowerCase());
-
- return createHashKey(parts.join("|"));
-}
-
// Sanitize metadata by removing fields that are stored separately or shouldn't be persisted
export function sanitizeFraudEventMetadata(
metadata: Prisma.JsonValue | undefined,
diff --git a/apps/web/scripts/migrations/migrate-duplicate-payout-fraud-events.ts b/apps/web/scripts/migrations/migrate-duplicate-payout-fraud-events.ts
index 04c2b0ff10..f253f59a0d 100644
--- a/apps/web/scripts/migrations/migrate-duplicate-payout-fraud-events.ts
+++ b/apps/web/scripts/migrations/migrate-duplicate-payout-fraud-events.ts
@@ -1,5 +1,4 @@
import { createId } from "@/lib/api/create-id";
-import { createFraudGroupHash } from "@/lib/api/fraud/utils";
import { prisma } from "@dub/prisma";
import "dotenv-flow/config";
@@ -64,11 +63,6 @@ async function main() {
status: firstFraudEvent.status,
createdAt: firstFraudEvent.createdAt,
updatedAt: lastFraudEvent.createdAt,
- hash: createFraudGroupHash({
- programId: firstFraudEvent.programId,
- partnerId: partnerId,
- type: "partnerDuplicatePayoutMethod",
- }),
},
});
diff --git a/apps/web/scripts/migrations/migrate-fraud-events.ts b/apps/web/scripts/migrations/migrate-fraud-events.ts
index c931a21645..cc7b8e69d4 100644
--- a/apps/web/scripts/migrations/migrate-fraud-events.ts
+++ b/apps/web/scripts/migrations/migrate-fraud-events.ts
@@ -1,5 +1,4 @@
import { createId } from "@/lib/api/create-id";
-import { createFraudGroupHash } from "@/lib/api/fraud/utils";
import { prisma } from "@dub/prisma";
import "dotenv-flow/config";
@@ -54,11 +53,6 @@ async function main() {
status: firstFraudEvent.status,
createdAt: firstFraudEvent.createdAt,
updatedAt: lastFraudEvent.createdAt,
- hash: createFraudGroupHash({
- programId: firstFraudEvent.programId,
- partnerId: firstFraudEvent.partnerId!,
- type: firstFraudEvent.type,
- }),
},
});
diff --git a/packages/prisma/schema/fraud.prisma b/packages/prisma/schema/fraud.prisma
index 7f83e15c6c..21410acde8 100644
--- a/packages/prisma/schema/fraud.prisma
+++ b/packages/prisma/schema/fraud.prisma
@@ -38,7 +38,6 @@ model FraudEventGroup {
resolutionReason String? @db.Text
resolvedAt DateTime?
status FraudEventStatus @default(pending)
- hash String
createdAt DateTime @default(now())
updatedAt DateTime @updatedAt
@@ -48,10 +47,9 @@ model FraudEventGroup {
programEnrollment ProgramEnrollment @relation(fields: [programId, partnerId], references: [programId, partnerId], onDelete: Cascade)
fraudEvents FraudEvent[]
- @@index(programId)
+ @@index([programId, partnerId, type, status])
@@index(partnerId)
@@index(userId)
- @@index(hash)
}
model FraudEvent {
diff --git a/packages/utils/src/functions/pretty-print.ts b/packages/utils/src/functions/pretty-print.ts
index a0260890df..7575ecd3b8 100644
--- a/packages/utils/src/functions/pretty-print.ts
+++ b/packages/utils/src/functions/pretty-print.ts
@@ -1,15 +1,17 @@
-export function prettyPrint(value: any, indent = 2): string {
- return JSON.stringify(
- value,
- (_key, val) => {
- if (val instanceof Set) return { __type: "Set", values: [...val] };
- if (val instanceof Map)
- return { __type: "Map", entries: [...val.entries()] };
- if (val instanceof Date) return val.toISOString();
- if (val instanceof Error)
- return { __type: "Error", message: val.message, stack: val.stack };
- return val;
- },
- indent,
+export function prettyPrint(value: any, indent = 2) {
+ console.log(
+ JSON.stringify(
+ value,
+ (_key, val) => {
+ if (val instanceof Set) return { __type: "Set", values: [...val] };
+ if (val instanceof Map)
+ return { __type: "Map", entries: [...val.entries()] };
+ if (val instanceof Date) return val.toISOString();
+ if (val instanceof Error)
+ return { __type: "Error", message: val.message, stack: val.stack };
+ return val;
+ },
+ indent,
+ ),
);
}