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.

Sync ProgramApplication partnerId on merge, guard bulk reject, add status backfill

Kiran Kee81ba8d48ae
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 085831fea5..825ee82a1d 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
@@ -144,6 +144,17 @@ export const { POST } = serve<Input>(
});
logs.push(fraudLog);
+ const movedApplications = await prisma.programApplication.updateMany({
+ where: {
+ partnerId: sourcePartnerId,
+ },
+ data: {
+ partnerId: targetPartnerId,
+ },
+ });
+
+ logs.push(`Moved ${movedApplications.count} program applications`);
+
// Delete the source partner account (must be last)
const { outputLog: partnerLog } = await deleteSourcePartner({
sourcePartnerId,
@@ -584,6 +595,16 @@ async function mergeSingleEnrollment({
where: { id: sourceEnrollment.id, partnerId: sourcePartnerId },
});
+ await tx.programApplication.updateMany({
+ where: {
+ programId,
+ partnerId: sourcePartnerId,
+ },
+ data: {
+ partnerId: targetPartnerId,
+ },
+ });
+
const tenantIdToCopy =
targetEnrollment.tenantId ?? sourceEnrollment.tenantId;
@@ -628,6 +649,16 @@ async function mergeSingleEnrollment({
});
}
+ await prisma.programApplication.updateMany({
+ where: {
+ programId,
+ partnerId: sourcePartnerId,
+ },
+ data: {
+ partnerId: targetPartnerId,
+ },
+ });
+
action = "transfer";
}
diff --git a/apps/web/lib/actions/partners/bulk-reject-partner-applications.ts b/apps/web/lib/actions/partners/bulk-reject-partner-applications.ts
index 66d4506ef7..39eda5cc1a 100644
--- a/apps/web/lib/actions/partners/bulk-reject-partner-applications.ts
+++ b/apps/web/lib/actions/partners/bulk-reject-partner-applications.ts
@@ -9,7 +9,11 @@ import { prisma } from "@/lib/prisma";
import { bulkRejectPartnersSchema } from "@/lib/zod/schemas/partners";
import { sendBatchEmail } from "@dub/email";
import PartnerApplicationRejected from "@dub/email/templates/partner-application-rejected";
-import { ProgramEnrollmentStatus } from "@prisma/client";
+import { pluck } from "@dub/utils";
+import {
+ ProgramApplicationStatus,
+ ProgramEnrollmentStatus,
+} from "@prisma/client";
import { waitUntil } from "@vercel/functions";
import { authActionClient } from "../safe-action";
import { throwIfNoPermission } from "../throw-if-no-permission";
@@ -59,6 +63,7 @@ export const bulkRejectPartnerApplicationsAction = authActionClient
id: {
in: programEnrollments.map(({ id }) => id),
},
+ status: ProgramEnrollmentStatus.pending,
},
data: {
status: ProgramEnrollmentStatus.rejected,
@@ -77,8 +82,12 @@ export const bulkRejectPartnerApplicationsAction = authActionClient
id: {
in: applicationIds,
},
+ enrollment: {
+ status: ProgramEnrollmentStatus.rejected,
+ },
},
data: {
+ status: ProgramApplicationStatus.rejected,
reviewedAt,
rejectionReason: null,
rejectionNote: null,
@@ -88,16 +97,39 @@ export const bulkRejectPartnerApplicationsAction = authActionClient
}
});
+ // Find the rejected enrollments
+ const updatedEnrollments = await prisma.programEnrollment.findMany({
+ where: {
+ id: {
+ in: pluck(programEnrollments, "id"),
+ },
+ status: ProgramEnrollmentStatus.rejected,
+ },
+ select: {
+ id: true,
+ },
+ });
+
+ const rejectedEnrollmentIds = new Set(pluck(updatedEnrollments, "id"));
+
+ const rejectedEnrollments = programEnrollments.filter(({ id }) =>
+ rejectedEnrollmentIds.has(id),
+ );
+
+ if (rejectedEnrollments.length === 0) {
+ return;
+ }
+
waitUntil(
(async () => {
await Promise.allSettled([
// Queue an index update because the enrollment statuses moved to rejected
queuePartnerSearchSync({
- enrollmentIds: programEnrollments.map(({ id }) => id),
+ enrollmentIds: rejectedEnrollments.map(({ id }) => id),
}),
trackActivityLog(
- programEnrollments.map(({ partner }) => ({
+ rejectedEnrollments.map(({ partner }) => ({
workspaceId: workspace.id,
programId,
resourceType: "partner",
@@ -117,7 +149,7 @@ export const bulkRejectPartnerApplicationsAction = authActionClient
where: {
programEnrollment: {
id: {
- in: programEnrollments.map(({ id }) => id),
+ in: rejectedEnrollments.map(({ id }) => id),
},
},
},
@@ -129,7 +161,7 @@ export const bulkRejectPartnerApplicationsAction = authActionClient
trackApplicationEvents({
event: "rejected",
programId,
- partnerIds: programEnrollments.map(({ partner }) => partner.id),
+ partnerIds: rejectedEnrollments.map(({ partner }) => partner.id),
}),
]);
@@ -144,7 +176,7 @@ export const bulkRejectPartnerApplicationsAction = authActionClient
},
});
- const partnersWithEmail = programEnrollments
+ const partnersWithEmail = rejectedEnrollments
.filter(({ partner }) => partner.email)
.map(({ partner }) => partner);
diff --git a/apps/web/lib/partners/complete-program-applications.ts b/apps/web/lib/partners/complete-program-applications.ts
index 551fe41a70..2212b5c9e0 100644
--- a/apps/web/lib/partners/complete-program-applications.ts
+++ b/apps/web/lib/partners/complete-program-applications.ts
@@ -24,7 +24,9 @@ import {
export async function completeProgramApplications(userEmail: string) {
try {
const user = await prisma.user.findUniqueOrThrow({
- where: { email: userEmail },
+ where: {
+ email: userEmail,
+ },
select: {
partners: {
select: {
@@ -75,6 +77,8 @@ export async function completeProgramApplications(userEmail: string) {
return;
}
+ const partner = user.partners[0].partner;
+
// if there are duplicate program applications
// pick the latest one for each programId
// note: programApplications is already sorted by createdAt desc
@@ -89,8 +93,6 @@ export async function completeProgramApplications(userEmail: string) {
},
);
- const partner = user.partners[0].partner;
-
// Program enrollments to create. `id` is narrowed to required because the
// search sync below reads it back, and Prisma leaves it optional here.
const programEnrollments: (Prisma.ProgramEnrollmentCreateManyInput & {
@@ -98,7 +100,7 @@ export async function completeProgramApplications(userEmail: string) {
})[] = filteredProgramApplications.map((programApplication) => ({
id: createId({ prefix: "pge_" }),
programId: programApplication.programId,
- partnerId: user.partners[0].partnerId,
+ partnerId: partner.id,
applicationId: programApplication.id,
groupId: programApplication?.partnerGroup?.id,
clickRewardId: programApplication?.partnerGroup?.clickRewardId,
@@ -132,7 +134,7 @@ export async function completeProgramApplications(userEmail: string) {
},
},
data: {
- partnerId: user.partners[0].partnerId,
+ partnerId: partner.id,
},
}),
]);
diff --git a/apps/web/lib/partners/get-application-status-from-enrollment.ts b/apps/web/lib/partners/get-application-status-from-enrollment.ts
new file mode 100644
index 0000000000..b8b09b2236
--- /dev/null
+++ b/apps/web/lib/partners/get-application-status-from-enrollment.ts
@@ -0,0 +1,18 @@
+import {
+ ProgramApplicationStatus,
+ ProgramEnrollmentStatus,
+} from "@prisma/client";
+
+export function getApplicationStatusFromEnrollment(
+ enrollmentStatus: ProgramEnrollmentStatus,
+): ProgramApplicationStatus {
+ if (enrollmentStatus === ProgramEnrollmentStatus.pending) {
+ return ProgramApplicationStatus.pending;
+ }
+
+ if (enrollmentStatus === ProgramEnrollmentStatus.rejected) {
+ return ProgramApplicationStatus.rejected;
+ }
+
+ return ProgramApplicationStatus.approved;
+}
diff --git a/apps/web/scripts/migrations/backfill-program-application-status.ts b/apps/web/scripts/migrations/backfill-program-application-status.ts
new file mode 100644
index 0000000000..1c834bde57
--- /dev/null
+++ b/apps/web/scripts/migrations/backfill-program-application-status.ts
@@ -0,0 +1,260 @@
+import { getApplicationStatusFromEnrollment } from "@/lib/partners/get-application-status-from-enrollment";
+import { prisma } from "@/lib/prisma";
+import {
+ ProgramApplication,
+ ProgramApplicationStatus,
+ ProgramEnrollment,
+} from "@prisma/client";
+import "dotenv-flow/config";
+
+const DRY_RUN = true;
+const BATCH_SIZE = 500;
+
+// ProgramApplication.reviewedAt was introduced on this date (#3664) without a backfill
+const REVIEWED_AT_INTRODUCED_AT = new Date("2026-03-30");
+
+function getApplicationStatus({
+ application,
+ enrollment,
+ matchedPartnerId,
+}: {
+ application: Pick<ProgramApplication, "reviewedAt">;
+ enrollment: Pick<ProgramEnrollment, "status"> | null;
+ matchedPartnerId: string | null;
+}): ProgramApplicationStatus {
+ if (!enrollment) {
+ if (application.reviewedAt) {
+ return ProgramApplicationStatus.rejected;
+ }
+
+ // A partner signed up with this email, so the application was converted into an
+ // enrollment that has since been removed (e.g. by the rejected-applications cleanup cron)
+ return matchedPartnerId
+ ? ProgramApplicationStatus.rejected
+ : ProgramApplicationStatus.pending;
+ }
+
+ return getApplicationStatusFromEnrollment(enrollment.status);
+}
+
+async function main() {
+ console.log(`DRY_RUN=${DRY_RUN} BATCH_SIZE=${BATCH_SIZE}`);
+
+ const totals: Record<
+ | ProgramApplicationStatus
+ | "partnerIds"
+ | "inferredRejected"
+ | "inferredRejectedSinceReviewedAt",
+ number
+ > = {
+ pending: 0,
+ approved: 0,
+ rejected: 0,
+ partnerIds: 0,
+ inferredRejected: 0,
+ inferredRejectedSinceReviewedAt: 0,
+ };
+
+ let totalScanned = 0;
+ let cursor: string | undefined;
+
+ while (true) {
+ const applications = await prisma.programApplication.findMany({
+ select: {
+ id: true,
+ email: true,
+ partnerId: true,
+ status: true,
+ reviewedAt: true,
+ createdAt: true,
+ enrollment: {
+ select: {
+ partnerId: true,
+ status: true,
+ },
+ },
+ },
+ orderBy: {
+ id: "asc",
+ },
+ take: BATCH_SIZE,
+ ...(cursor && {
+ skip: 1,
+ cursor: {
+ id: cursor,
+ },
+ }),
+ });
+
+ if (applications.length === 0) {
+ break;
+ }
+
+ totalScanned += applications.length;
+ cursor = applications[applications.length - 1].id;
+
+ const unreviewedEmails = [
+ ...new Set(
+ applications
+ .filter(({ enrollment, reviewedAt }) => !enrollment && !reviewedAt)
+ .map(({ email }) => email.toLowerCase()),
+ ),
+ ];
+
+ const users =
+ unreviewedEmails.length > 0
+ ? await prisma.user.findMany({
+ where: {
+ email: {
+ in: unreviewedEmails,
+ },
+ partners: {
+ some: {},
+ },
+ },
+ select: {
+ email: true,
+ partners: {
+ select: {
+ partnerId: true,
+ },
+ take: 1,
+ },
+ },
+ })
+ : [];
+
+ const partnerIdByEmail = new Map(
+ users
+ .filter((user) => user.email && user.partners.length > 0)
+ .map((user) => [user.email!.toLowerCase(), user.partners[0].partnerId]),
+ );
+
+ const changes = applications.map((application) => {
+ const matchedPartnerId = application.enrollment
+ ? null
+ : partnerIdByEmail.get(application.email.toLowerCase()) ?? null;
+
+ const status = getApplicationStatus({
+ application,
+ enrollment: application.enrollment,
+ matchedPartnerId,
+ });
+
+ const partnerId =
+ application.enrollment?.partnerId ?? matchedPartnerId ?? null;
+
+ const updateStatus =
+ application.status === ProgramApplicationStatus.pending &&
+ status !== ProgramApplicationStatus.pending;
+
+ return {
+ id: application.id,
+ enrollmentStatus: application.enrollment?.status ?? null,
+ reviewedAt: application.reviewedAt,
+ createdAt: application.createdAt,
+ currentStatus: application.status,
+ status,
+ updateStatus,
+ inferredRejected: Boolean(
+ updateStatus && !application.reviewedAt && matchedPartnerId,
+ ),
+ currentPartnerId: application.partnerId,
+ partnerId,
+ updatePartnerId: Boolean(
+ partnerId && application.partnerId !== partnerId,
+ ),
+ };
+ });
+
+ console.table(changes.slice(0, 20));
+
+ const idsByStatus: Record<ProgramApplicationStatus, string[]> = {
+ pending: [],
+ approved: [],
+ rejected: [],
+ };
+
+ for (const change of changes) {
+ if (change.updateStatus) {
+ idsByStatus[change.status].push(change.id);
+ }
+ }
+
+ const partnerIdUpdates = changes.filter((change) => change.updatePartnerId);
+
+ const inferredRejected = changes.filter(
+ (change) => change.inferredRejected,
+ );
+
+ if (inferredRejected.length > 0) {
+ console.log(
+ `Inferred ${inferredRejected.length} rejected applications from matching partner emails`,
+ );
+ console.table(inferredRejected.slice(0, 20));
+ }
+
+ totals.inferredRejected += inferredRejected.length;
+ totals.inferredRejectedSinceReviewedAt += inferredRejected.filter(
+ (change) => change.createdAt >= REVIEWED_AT_INTRODUCED_AT,
+ ).length;
+
+ if (DRY_RUN) {
+ for (const status of Object.values(ProgramApplicationStatus)) {
+ totals[status] += idsByStatus[status].length;
+ }
+
+ totals.partnerIds += partnerIdUpdates.length;
+ } else {
+ for (const status of Object.values(ProgramApplicationStatus)) {
+ const ids = idsByStatus[status];
+
+ if (ids.length === 0) {
+ continue;
+ }
+
+ const { count } = await prisma.programApplication.updateMany({
+ where: {
+ id: {
+ in: ids,
+ },
+ status: ProgramApplicationStatus.pending,
+ },
+ data: {
+ status,
+ },
+ });
+
+ totals[status] += count;
+ }
+
+ if (partnerIdUpdates.length > 0) {
+ await prisma.$transaction(
+ partnerIdUpdates.map((change) =>
+ prisma.programApplication.update({
+ where: {
+ id: change.id,
+ },
+ data: {
+ partnerId: change.partnerId,
+ },
+ }),
+ ),
+ );
+
+ totals.partnerIds += partnerIdUpdates.length;
+ }
+ }
+
+ console.log(
+ `${DRY_RUN ? "Would process" : "Processed"} ${applications.length} applications up to ${cursor} (scanned=${totalScanned})`,
+ );
+ }
+
+ console.log(
+ `Finished. scanned=${totalScanned} ${DRY_RUN ? "would-update" : "updated"}:`,
+ );
+ console.table(totals);
+}
+
+main();