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.

Fix build

Kiran Kba79c1acf5ed
diff --git a/apps/web/scripts/migrations/backfill-fraud-event-hashes.ts b/apps/web/scripts/migrations/backfill-fraud-event-hashes.ts
deleted file mode 100644
index e40abed7c7..0000000000
--- a/apps/web/scripts/migrations/backfill-fraud-event-hashes.ts
+++ /dev/null
@@ -1,40 +0,0 @@
-import { createFraudEventHash } from "@/lib/api/fraud/utils";
-import { prisma } from "@dub/prisma";
-import { chunk } from "@dub/utils";
-import "dotenv-flow/config";
-
-/**
- * Backfill hashes for existing fraud events.
- * Generates and updates hash values for fraud events that are missing them.
- * Hashes are used for deduplication to prevent creating duplicate fraud events.
- */
-async function main() {
- const fraudEvents = await prisma.fraudEvent.findMany({
- where: {
- hash: null,
- },
- });
-
- console.log(`Found ${fraudEvents.length} fraud events without hashes.`);
-
- const chunks = chunk(fraudEvents, 100);
-
- for (const batch of chunks) {
- await Promise.all(
- batch.map((event) =>
- prisma.fraudEvent.update({
- where: {
- id: event.id,
- },
- data: {
- hash: createFraudEventHash(event),
- },
- }),
- ),
- );
- }
-
- console.log("Hash backfill completed.");
-}
-
-main();
diff --git a/apps/web/scripts/migrations/backfill-fraud-event-metadata.ts b/apps/web/scripts/migrations/backfill-fraud-event-metadata.ts
deleted file mode 100644
index b9e66c6ad0..0000000000
--- a/apps/web/scripts/migrations/backfill-fraud-event-metadata.ts
+++ /dev/null
@@ -1,96 +0,0 @@
-import { prisma } from "@dub/prisma";
-import { chunk } from "@dub/utils";
-import "dotenv-flow/config";
-import { getLeadEvents } from "../../lib/tinybird/get-lead-events";
-
-async function main() {
- const fraudEvents = await prisma.fraudEvent.findMany({
- where: {
- type: "paidTrafficDetected",
- customerId: {
- not: null,
- },
- },
- select: {
- id: true,
- customerId: true,
- metadata: true,
- },
- });
-
- console.log(`Found ${fraudEvents.length} paidTrafficDetected fraud events.`);
-
- const fraudEventsToUpdate = fraudEvents.filter((event) => {
- const metadata = event.metadata as { url: string | null };
- return !metadata.url;
- });
-
- console.log(
- `Found ${fraudEventsToUpdate.length} paidTrafficDetected fraud events without metadata.url`,
- );
-
- // Group events by customerId
- const eventsByCustomerId = fraudEventsToUpdate
- .filter((event) => event.customerId !== null)
- .reduce(
- (acc, event) => {
- acc[event.customerId!] = acc[event.customerId!] || [];
- acc[event.customerId!].push(event);
- return acc;
- },
- {} as Record<string, typeof fraudEventsToUpdate>,
- );
-
- const customerIds = Object.keys(eventsByCustomerId);
- const batches = chunk(customerIds, 100);
-
- // Find the URL for each customerId
- const customerIdToUrl = new Map<string, string>();
-
- for (const batch of batches) {
- const { data: events } = await getLeadEvents({
- customerIds: batch,
- });
- console.log(
- `Found ${events.length} lead events from Tinybird for customerIds ${batch.join(", ")}`,
- );
-
- events.forEach((event) => {
- customerIdToUrl.set(event.customer_id, event.url);
- });
- }
-
- // Update the fraud events with the new metadata
- const eventsBatch = chunk(fraudEventsToUpdate, 100);
-
- for (const batch of eventsBatch) {
- await Promise.all(
- batch.map((event) => {
- const url = customerIdToUrl.get(event.customerId!);
-
- if (!url) {
- console.log(
- `Skipping fraud event ${event.id}: No URL found for customerId ${event.customerId}`,
- );
-
- return Promise.resolve(null);
- }
-
- console.log(`Updating fraud event ${event.id} with URL ${url}`);
- return prisma.fraudEvent.update({
- where: {
- id: event.id,
- },
- data: {
- metadata: {
- ...(event.metadata as any),
- url,
- },
- },
- });
- }),
- );
- }
-}
-
-main();
diff --git a/apps/web/scripts/migrations/backfill-fraud-group-events-count.ts b/apps/web/scripts/migrations/backfill-fraud-group-events-count.ts
deleted file mode 100644
index dbdb2dc283..0000000000
--- a/apps/web/scripts/migrations/backfill-fraud-group-events-count.ts
+++ /dev/null
@@ -1,73 +0,0 @@
-import { prisma } from "@dub/prisma";
-import "dotenv-flow/config";
-
-async function main() {
- // Step 1: Find and delete fraud groups without any events
- console.log("Finding fraud groups without events...");
-
- const fraudGroupsWithoutEvents = await prisma.fraudEventGroup.findMany({
- where: {
- fraudEvents: {
- none: {},
- },
- },
- select: {
- id: true,
- },
- });
-
- console.log(
- `Found ${fraudGroupsWithoutEvents.length} fraud groups without events.`,
- );
-
- console.table(fraudGroupsWithoutEvents);
-
- if (fraudGroupsWithoutEvents.length > 0) {
- const deleteResult = await prisma.fraudEventGroup.deleteMany({
- where: {
- id: {
- in: fraudGroupsWithoutEvents.map((g) => g.id),
- },
- },
- });
- console.log(`Deleted ${deleteResult.count} fraud groups without events.`);
- }
-
- // Sync event counts for all remaining fraud groups
-
- const allFraudGroups = await prisma.fraudEventGroup.findMany({
- select: {
- id: true,
- eventCount: true,
- _count: {
- select: {
- fraudEvents: true,
- },
- },
- },
- });
-
- console.log(`Found ${allFraudGroups.length} total fraud groups.`);
-
- // Find groups where the count doesn't match
- const groupsToUpdate = allFraudGroups.filter(
- (g) => g.eventCount !== g._count.fraudEvents,
- );
-
- console.log(
- `Found ${groupsToUpdate.length} fraud groups with mismatched event counts.`,
- );
-
- console.table(groupsToUpdate);
-
- if (groupsToUpdate.length > 0) {
- for (const group of groupsToUpdate) {
- await prisma.fraudEventGroup.update({
- where: { id: group.id },
- data: { eventCount: group._count.fraudEvents },
- });
- }
- }
-}
-
-main();
diff --git a/apps/web/scripts/migrations/cleanup-fraud-events.ts b/apps/web/scripts/migrations/cleanup-fraud-events.ts
deleted file mode 100644
index 7a4a066650..0000000000
--- a/apps/web/scripts/migrations/cleanup-fraud-events.ts
+++ /dev/null
@@ -1,34 +0,0 @@
-import { prisma } from "@dub/prisma";
-import "dotenv-flow/config";
-
-// Remove partnerDuplicatePayoutMethod fraud events without a group
-async function main() {
- const fraudEvents = await prisma.fraudEvent.findMany({
- where: {
- type: "partnerDuplicatePayoutMethod",
- fraudEventGroupId: null,
- },
- select: {
- id: true,
- fraudEventGroupId: true,
- },
- });
-
- console.log(
- `Found ${fraudEvents.length} partnerDuplicatePayoutMethod fraud events without a group.`,
- );
-
- const deletedEvents = await prisma.fraudEvent.deleteMany({
- where: {
- id: {
- in: fraudEvents.map(({ id }) => id),
- },
- },
- });
-
- console.log(
- `Deleted ${deletedEvents.count} partnerDuplicatePayoutMethod fraud events without a group.`,
- );
-}
-
-main();
diff --git a/apps/web/scripts/migrations/migrate-duplicate-payout-fraud-events.ts b/apps/web/scripts/migrations/migrate-duplicate-payout-fraud-events.ts
deleted file mode 100644
index e2f0a4439b..0000000000
--- a/apps/web/scripts/migrations/migrate-duplicate-payout-fraud-events.ts
+++ /dev/null
@@ -1,122 +0,0 @@
-import { createId } from "@/lib/api/create-id";
-import { prisma } from "@dub/prisma";
-import { Prisma } from "@prisma/client";
-import "dotenv-flow/config";
-
-/**
- * Migrate partnerDuplicatePayoutMethod fraud events to the new FraudEventGroup structure.
- *
- * These events require special handling because a single groupKey (payout method hash)
- * can contain events from multiple partners who share the same payout method.
- *
- * Migration strategy:
- * 1. For each groupKey, identify all unique partners
- * 2. Create a separate FraudEventGroup for each partner
- * 3. For the first partner, update existing events in place
- * 4. For additional partners, duplicate the events and link to their respective groups
- */
-async function main() {
- const duplicatePayoutGroups = await prisma.fraudEvent.groupBy({
- by: ["groupKey"],
- where: {
- fraudEventGroupId: null,
- type: "partnerDuplicatePayoutMethod",
- },
- _count: true,
- });
-
- console.log(
- `Migrating ${duplicatePayoutGroups.length} partnerDuplicatePayoutMethod fraud event groups...`,
- );
-
- for (const fraudGroup of duplicatePayoutGroups) {
- console.log(`Migrating fraud group ${fraudGroup.groupKey}...`);
-
- // Get all fraud events for this groupKey (payout method hash)
- const fraudEvents = await prisma.fraudEvent.findMany({
- where: {
- groupKey: fraudGroup.groupKey,
- fraudEventGroupId: null,
- type: "partnerDuplicatePayoutMethod",
- },
- orderBy: {
- createdAt: "asc",
- },
- });
-
- if (fraudEvents.length === 0) {
- continue;
- }
-
- // Extract unique partner IDs that share this payout method
- const uniquePartnerIds = Array.from(
- new Set(fraudEvents.map((e) => e.partnerId)),
- ).filter((id): id is string => id !== null);
-
- // Create a FraudEventGroup for each unique partner
- const fraudEventGroups: Prisma.FraudEventGroupCreateManyInput[] = [];
-
- for (const partnerId of uniquePartnerIds) {
- const firstFraudEvent = fraudEvents[0];
- const lastFraudEvent = fraudEvents[fraudEvents.length - 1];
-
- fraudEventGroups.push({
- id: createId({ prefix: "frg_" }),
- programId: firstFraudEvent.programId,
- partnerId: partnerId,
- type: "partnerDuplicatePayoutMethod",
- lastEventAt: lastFraudEvent.createdAt,
- eventCount: fraudEvents.length,
- userId: firstFraudEvent.userId,
- resolutionReason: firstFraudEvent.resolutionReason,
- resolvedAt: firstFraudEvent.resolvedAt,
- status: firstFraudEvent.status,
- createdAt: firstFraudEvent.createdAt,
- updatedAt: lastFraudEvent.createdAt,
- });
- }
-
- await prisma.fraudEventGroup.createMany({
- data: fraudEventGroups,
- });
-
- // Link fraud events to their respective FraudEventGroups
- for (const partnerId of uniquePartnerIds) {
- if (partnerId === uniquePartnerIds[0]) {
- // For the first partner, update existing events in place to link them to the new group
- await prisma.fraudEvent.updateMany({
- where: {
- groupKey: fraudGroup.groupKey,
- fraudEventGroupId: null,
- type: "partnerDuplicatePayoutMethod",
- },
- data: {
- fraudEventGroupId: fraudEventGroups.find(
- (group) => group.partnerId === partnerId,
- )?.id,
- },
- });
-
- continue;
- }
-
- // For additional partners, duplicate the events and link to their respective groups
- // This is necessary because the old model had all partners' events under one groupKey,
- // but the new model requires separate FraudEventGroups per partner
- await prisma.fraudEvent.createMany({
- data: fraudEvents.map((event) => ({
- ...event,
- id: createId({ prefix: "fre_" }),
- metadata: event.metadata ?? undefined,
- fraudEventGroupId: fraudEventGroups.find(
- (group) => group.partnerId === partnerId,
- )?.id,
- })),
- });
- }
- }
-
- console.log("partnerDuplicatePayoutMethod migration completed.");
-}
-
-main();
diff --git a/apps/web/scripts/migrations/migrate-fraud-events.ts b/apps/web/scripts/migrations/migrate-fraud-events.ts
deleted file mode 100644
index 027d31495c..0000000000
--- a/apps/web/scripts/migrations/migrate-fraud-events.ts
+++ /dev/null
@@ -1,84 +0,0 @@
-import { createId } from "@/lib/api/create-id";
-import { prisma } from "@dub/prisma";
-import { FraudEvent, Prisma } from "@dub/prisma/client";
-import { chunk } from "@dub/utils";
-import "dotenv-flow/config";
-
-async function main() {
- const fraudEvents = await prisma.fraudEvent.findMany({
- where: {
- fraudEventGroupId: null,
- type: {
- not: "partnerDuplicatePayoutMethod",
- },
- },
- orderBy: {
- createdAt: "desc",
- },
- });
-
- if (fraudEvents.length === 0) {
- console.log("No fraud events to migrate.");
- return;
- }
-
- console.log(`Found ${fraudEvents.length} fraud events to migrate.`);
-
- const fraudEventsByGroupKey = fraudEvents.reduce(
- (acc, event) => {
- acc[event.groupKey] = acc[event.groupKey] || [];
- acc[event.groupKey].push(event);
- return acc;
- },
- {} as Record<string, FraudEvent[]>,
- );
-
- const groupsToCreate: Prisma.FraudEventGroupCreateManyInput[] = [];
- const groupKeyToGroupId = new Map<string, string>();
-
- for (const [groupKey, events] of Object.entries(fraudEventsByGroupKey)) {
- const groupId = createId({ prefix: "frg_" });
- const latestEvent = events[0]; // Newest (desc order)
- const earliestEvent = events[events.length - 1]; // Oldest
-
- groupsToCreate.push({
- id: groupId,
- programId: latestEvent.programId,
- partnerId: latestEvent.partnerId,
- type: latestEvent.type,
- lastEventAt: latestEvent.createdAt,
- eventCount: events.length,
- userId: latestEvent.userId,
- resolutionReason: latestEvent.resolutionReason,
- resolvedAt: latestEvent.resolvedAt,
- status: latestEvent.status,
- createdAt: earliestEvent.createdAt,
- updatedAt: latestEvent.createdAt,
- });
-
- groupKeyToGroupId.set(groupKey, groupId);
- }
-
- await prisma.fraudEventGroup.createMany({
- data: groupsToCreate,
- });
-
- const chunks = chunk(Array.from(groupKeyToGroupId.entries()), 100);
-
- for (const batch of chunks) {
- await Promise.all(
- batch.map(([groupKey, groupId]) =>
- prisma.fraudEvent.updateMany({
- where: {
- groupKey,
- },
- data: {
- fraudEventGroupId: groupId,
- },
- }),
- ),
- );
- }
-}
-
-main();