The modern link attribution platform. Loved by world-class engineering teams at Twilio, Zillow, Jobber, Vercel, Raycast, and more.
TypeScript clickhousemysqlnextjsopen-sourceplanetscaleprismatailwindcsstinybirdtypescriptupstashvercel
reassign scripts
Pedro Ladeira1a2a319ab261
diff --git a/apps/web/scripts/customers/beehiiv/reassign-program-wide.ts b/apps/web/scripts/customers/beehiiv/reassign-program-wide.tsnew file mode 100644index 0000000000..a74d56c4ca--- /dev/null+++ b/apps/web/scripts/customers/beehiiv/reassign-program-wide.ts@@ -0,0 +1,148 @@+import { prisma } from "@/lib/prisma";+import "dotenv-flow/config";+import { moveCustomerEvents } from "./reassign-tinybird";+import {+ buildOwnerMap,+ DRY_RUN,+ fixDiscountCodeLink,+ getCsvPath,+ loadCrossref,+ printResultSummary,+ PROGRAM_ID,+ reassignCustomer,+ ReassignResult,+ resyncTouchedLinkStats,+ resyncTouchedPartnerStats,+ retallyPayouts,+} from "./reassign-utils";++// ---------------------------------------------------------------------------+// fix every link/coupon-token collision in the program.+//+// Run dry (default): pnpm script customers/beehiiv/reassign-program-wide+// Apply: pnpm script customers/beehiiv/reassign-program-wide --apply+// ---------------------------------------------------------------------------++async function main() {+ console.log(+ `\n${DRY_RUN ? "π‘ DRY RUN" : "π΄ APPLY"} β program-wide reassignment\n`,+ );++ const ownerMap = buildOwnerMap(loadCrossref(getCsvPath()));+ console.log(`Loaded ${ownerMap.size} unique customers from crossref CSV.`);++ const results: ReassignResult[] = [];+ const tbFailures: string[] = [];+ let processed = 0;++ for (const [stripeCustomerId, correctAffiliateEmail] of ownerMap) {+ const result = await reassignCustomer(+ stripeCustomerId,+ correctAffiliateEmail,+ );+ results.push(result);++ if (+ result.status === "reassigned" &&+ result.customerId &&+ result.fromLinkId &&+ result.toLinkId+ ) {+ try {+ await moveCustomerEvents({+ customerId: result.customerId,+ oldLinkId: result.fromLinkId,+ newLinkId: result.toLinkId,+ });+ } catch (error) {+ console.error(+ ` β οΈ Tinybird migration failed for ${stripeCustomerId}:`,+ error,+ );+ tbFailures.push(stripeCustomerId);+ }+ }++ if (++processed % 100 === 0) {+ console.log(` ...processed ${processed}/${ownerMap.size}`);+ }+ }++ printResultSummary(results);++ // Re-point every mis-linked discount code in the program.+ console.log("\n=== Fixing mis-linked discount codes ===");+ const misLinkedDiscountCodes = await prisma.$queryRaw<{ id: string }[]>`+ SELECT dc.id+ FROM DiscountCode dc+ JOIN Link l ON l.id = dc.linkId+ WHERE dc.programId = ${PROGRAM_ID}+ AND dc.partnerId <> l.partnerId+ `;++ console.log(+ `Found ${misLinkedDiscountCodes.length} mis-linked discount codes.`,+ );++ const tally = {+ fixed: 0,+ wouldFix: 0,+ alreadyCorrect: 0,+ failed: 0,+ notFound: 0,+ };++ for (const { id } of misLinkedDiscountCodes) {+ const fix = await fixDiscountCodeLink(id);+ switch (fix.status) {+ case "fixed":+ tally.fixed++;+ break;+ case "would_fix":+ tally.wouldFix++;+ break;+ case "already_correct":+ tally.alreadyCorrect++;+ break;+ case "link_creation_failed":+ tally.failed++;+ console.log(` β οΈ link creation failed for ${fix.code}`);+ break;+ case "not_found":+ tally.notFound++;+ break;+ }+ }++ console.log(`Discount code fixes: ${JSON.stringify(tally)}`);++ console.log("\n=== Resyncing link stats ===");+ await resyncTouchedLinkStats();++ console.log("\n=== Resyncing partner stats ===");+ await resyncTouchedPartnerStats();++ console.log("\n=== Retallying affected payouts ===");+ await retallyPayouts();++ if (tbFailures.length > 0) {+ console.log(+ `\nTinybird migration failed for ${tbFailures.length} customer(s) ` ++ `(DB is correct β redo their events): ${tbFailures.join(", ")}`,+ );+ }++ console.log(+ `\n${DRY_RUN ? "π‘ DRY RUN complete β no changes written. Re-run with --apply to execute." : "π΄ Done."}`,+ );+}++main()+ .then(async () => {+ if (!DRY_RUN) await new Promise((r) => setTimeout(r, 2000));+ process.exit(0);+ })+ .catch((error) => {+ console.error("\nβ Script failed:", error);+ process.exit(1);+ });diff --git a/apps/web/scripts/customers/beehiiv/reassign-single-link.ts b/apps/web/scripts/customers/beehiiv/reassign-single-link.tsnew file mode 100644index 0000000000..5d449b2381--- /dev/null+++ b/apps/web/scripts/customers/beehiiv/reassign-single-link.ts@@ -0,0 +1,141 @@+import { prisma } from "@/lib/prisma";+import "dotenv-flow/config";+import { moveCustomerEvents } from "./reassign-tinybird";+import {+ buildOwnerMap,+ DRY_RUN,+ fixDiscountCodeLink,+ getCsvPath,+ loadCrossref,+ printResultSummary,+ PROGRAM_ID,+ reassignCustomer,+ ReassignResult,+ resyncTouchedLinkStats,+ resyncTouchedPartnerStats,+ retallyPayouts,+ TARGET_DISCOUNT_CODE,+ TARGET_LINK_ID,+} from "./reassign-utils";++// ---------------------------------------------------------------------------+// fix a single colliding link (e.g. the one reported in a ticket).+//+// Dry run: pnpm script customers/beehiiv/reassign-single-link --csv="..."+// Apply: pnpm script customers/beehiiv/reassign-single-link --csv="..." --apply+// ---------------------------------------------------------------------------++async function main() {+ const targetLinkId = TARGET_LINK_ID;+ const discountCode = TARGET_DISCOUNT_CODE;++ console.log(+ `\n${DRY_RUN ? "π‘ DRY RUN" : "π΄ APPLY"} β reassignment for link ${targetLinkId}\n`,+ );++ const ownerMap = buildOwnerMap(loadCrossref(getCsvPath()));++ // Customers currently attributed to the target link.+ const customersOnLink = await prisma.customer.findMany({+ where: { programId: PROGRAM_ID, linkId: targetLinkId },+ select: { stripeCustomerId: true },+ });++ console.log(+ `Found ${customersOnLink.length} customers on link ${targetLinkId}.`,+ );++ const results: ReassignResult[] = [];+ const tbFailures: string[] = [];++ for (const { stripeCustomerId } of customersOnLink) {+ if (!stripeCustomerId) continue;++ // Only customers present in the mismatch CSV are misattributed; the rest are+ // genuinely the link owner's (link clicks) and stay put.+ const correctAffiliateEmail = ownerMap.get(stripeCustomerId);+ if (!correctAffiliateEmail) continue;++ const result = await reassignCustomer(+ stripeCustomerId,+ correctAffiliateEmail,+ );+ results.push(result);++ if (result.status === "reassigned") {+ console.log(+ ` ${DRY_RUN ? "would move" : "moved"} ${stripeCustomerId} β ${correctAffiliateEmail} ` ++ `(commissions: ${result.movedCommissions} moved, ${result.processedReset} reset, ${result.paidWithPayoutSkipped} paid-skipped)`,+ );+ // DB is committed (in its own transaction) before touching Tinybird, so a+ // TB failure leaves money/attribution correct and only needs an events redo.+ await migrateEvents(result, tbFailures);+ }+ }++ printResultSummary(results);++ // Re-point the colliding discount code to a fresh link owned by its partner.+ if (discountCode) {+ console.log(`\n=== Fixing discount code "${discountCode}" link ===`);+ const code = await prisma.discountCode.findFirst({+ where: { programId: PROGRAM_ID, code: discountCode },+ select: { id: true },+ });++ if (code) {+ console.log(` ${JSON.stringify(await fixDiscountCodeLink(code.id))}`);+ } else {+ console.log(` Discount code "${discountCode}" not found.`);+ }+ }++ console.log("\n=== Resyncing link stats ===");+ await resyncTouchedLinkStats();++ console.log("\n=== Resyncing partner stats ===");+ await resyncTouchedPartnerStats();++ console.log("\n=== Retallying affected payouts ===");+ await retallyPayouts();++ if (tbFailures.length > 0) {+ console.log(+ `\nβ οΈ Tinybird migration failed for ${tbFailures.length} customer(s) ` ++ `(DB is correct β redo their events): ${tbFailures.join(", ")}`,+ );+ }++ console.log(+ `\n${DRY_RUN ? "π‘ DRY RUN complete β no changes written. Re-run with --apply to execute." : "π΄ Done."}`,+ );+}++async function migrateEvents(result: ReassignResult, tbFailures: string[]) {+ if (!result.customerId || !result.fromLinkId || !result.toLinkId) return;++ try {+ await moveCustomerEvents({+ customerId: result.customerId,+ oldLinkId: result.fromLinkId,+ newLinkId: result.toLinkId,+ });+ } catch (error) {+ console.error(+ ` β οΈ Tinybird migration failed for ${result.stripeCustomerId}:`,+ error,+ );+ tbFailures.push(result.stripeCustomerId);+ }+}++main()+ .then(async () => {+ // let bulkCreateLinks' background cache propagation flush before exiting+ if (!DRY_RUN) await new Promise((r) => setTimeout(r, 2000));+ process.exit(0);+ })+ .catch((error) => {+ console.error("\nβ Script failed:", error);+ process.exit(1);+ });diff --git a/apps/web/scripts/customers/beehiiv/reassign-tinybird.ts b/apps/web/scripts/customers/beehiiv/reassign-tinybird.tsnew file mode 100644index 0000000000..ce66362b1b--- /dev/null+++ b/apps/web/scripts/customers/beehiiv/reassign-tinybird.ts@@ -0,0 +1,135 @@+import { prisma } from "@/lib/prisma";+import { tb } from "@/lib/tinybird/client";+import { getClickEvent } from "@/lib/tinybird/get-click-event";+import { recordLeadWithTimestamp } from "@/lib/tinybird/record-lead";+import { recordSaleWithTimestamp } from "@/lib/tinybird/record-sale";+import * as z from "zod/v4";+import { DRY_RUN } from "./reassign-utils";++const TB_BASE =+ process.env.TINYBIRD_API_URL || "https://api.us-east.tinybird.co";++const getRawCustomerEvents = tb.buildPipe({+ pipe: "internal_get_events",+ parameters: z.object({ customerId: z.string() }),+ data: z.any(),+});++async function tbDelete(dataSource: string, condition: string) {+ if (DRY_RUN) {+ console.log(` [dry] DELETE ${dataSource} WHERE ${condition}`);+ return;+ }++ const res = await fetch(`${TB_BASE}/v0/datasources/${dataSource}/delete`, {+ method: "POST",+ headers: {+ Authorization: `Bearer ${process.env.TINYBIRD_API_KEY}`,+ "Content-Type": "application/x-www-form-urlencoded",+ },+ body: `delete_condition=${condition}`,+ }).then((r) => r.json());++ console.log(` deleted ${dataSource}: ${JSON.stringify(res)}`);+}++async function tbIngest(datasource: string, payload: unknown) {+ return fetch(`${TB_BASE}/v0/events?name=${datasource}&wait=true`, {+ method: "POST",+ headers: { Authorization: `Bearer ${process.env.TINYBIRD_API_KEY}` },+ body: JSON.stringify(payload),+ }).then((r) => r.json());+}++// Move a single customer's events from `oldLinkId` to `newLinkId`.+export async function moveCustomerEvents({+ customerId,+ oldLinkId,+ newLinkId,+}: {+ customerId: string;+ oldLinkId: string;+ newLinkId: string;+}) {+ if (!oldLinkId || !newLinkId || oldLinkId === newLinkId) return;++ const newLink = await prisma.link.findUnique({+ where: { id: newLinkId },+ select: { id: true, key: true },+ });++ if (!newLink) {+ console.log(+ ` β οΈ destination link ${newLinkId} not found, skipping events`,+ );+ return;+ }++ const { data: events } = await getRawCustomerEvents({ customerId });++ const sales = events.filter(+ (e: any) => "amount" in e && e.amount !== null && e.amount !== undefined,+ );+ const leads = events.filter(+ (e: any) => !("amount" in e) || e.amount === null || e.amount === undefined,+ );++ console.log(+ ` ${leads.length} lead event(s), ${sales.length} sale event(s)`,+ );++ if (leads.length > 0) {+ if (!DRY_RUN) {+ await recordLeadWithTimestamp(+ leads.map((e: any) => ({+ ...e,+ link_id: newLink.id,+ key: newLink.key,+ })),+ );+ }+ const condition = `customer_id='${customerId}' and link_id='${oldLinkId}'`;+ await tbDelete("dub_lead_events", condition);+ await tbDelete("dub_lead_events_mv", condition);+ }++ if (sales.length > 0) {+ if (!DRY_RUN) {+ await recordSaleWithTimestamp(+ sales.map((e: any) => ({+ ...e,+ link_id: newLink.id,+ key: newLink.key,+ })),+ );+ }+ const condition = `customer_id='${customerId}' and link_id='${oldLinkId}'`;+ await tbDelete("dub_sale_events", condition);+ await tbDelete("dub_sale_events_mv", condition);+ }++ const customer = await prisma.customer.findUnique({+ where: { id: customerId },+ select: { clickId: true },+ });++ if (customer?.clickId) {+ const click = await getClickEvent({ clickId: customer.clickId });++ if (click) {+ console.log(` 1 click event (${customer.clickId})`);++ if (!DRY_RUN) {+ await tbIngest("dub_click_events", {+ ...click,+ link_id: newLink.id,+ key: newLink.key,+ });+ }++ const condition = `click_id='${customer.clickId}' and link_id='${oldLinkId}'`;+ await tbDelete("dub_click_events_mv", condition);+ await tbDelete("dub_click_events_id", condition);+ }+ }+}diff --git a/apps/web/scripts/customers/beehiiv/reassign-utils.ts b/apps/web/scripts/customers/beehiiv/reassign-utils.tsnew file mode 100644index 0000000000..b43539f0da--- /dev/null+++ b/apps/web/scripts/customers/beehiiv/reassign-utils.ts@@ -0,0 +1,630 @@+import { bulkCreateLinks } from "@/lib/api/links";+import { prisma } from "@/lib/prisma";+import { ProcessedLinkProps } from "@/lib/types";+import { nanoid } from "@dub/utils";+import { Link, Prisma } from "@prisma/client";+import { readFileSync } from "fs";++export const PROGRAM_ID = "prog_xxx";+export const PROGRAM_DOMAIN = "xxx.com";++export const TARGET_LINK_ID = "link_xxx"; // the colliding link to clean up+export const TARGET_DISCOUNT_CODE = "xxx"; // the discount code to re-point ("" to skip)++export const DRY_RUN =+ !process.argv.includes("--apply") && process.env.APPLY !== "1";++// Reads a `--name=value` CLI argument.+export function getArg(name: string): string | undefined {+ const prefix = `--${name}=`;+ return process.argv+ .find((arg) => arg.startsWith(prefix))+ ?.slice(prefix.length);+}++export function getCsvPath(): string {+ return (+ getArg("csv") || process.env.CROSSREF_CSV || "/attribution-mismatches.csv"+ );+}++// ---------------------------------------------------------------------------+// CSV parsing+// ---------------------------------------------------------------------------++export interface CrossrefRow {+ stripeCustomerId: string;+ customerEmail: string;+ rewardfulAffiliateEmail: string;+ dubPartnerEmail: string;+}++export function parseCsv(content: string): string[][] {+ const rows: string[][] = [];+ let field = "";+ let row: string[] = [];+ let inQuotes = false;++ for (let i = 0; i < content.length; i++) {+ const char = content[i];++ if (inQuotes) {+ if (char === '"') {+ if (content[i + 1] === '"') {+ field += '"';+ i++;+ } else {+ inQuotes = false;+ }+ } else {+ field += char;+ }+ continue;+ }++ if (char === '"') {+ inQuotes = true;+ } else if (char === ",") {+ row.push(field);+ field = "";+ } else if (char === "\n") {+ row.push(field);+ rows.push(row);+ row = [];+ field = "";+ } else if (char !== "\r") {+ field += char;+ }+ }++ if (field.length > 0 || row.length > 0) {+ row.push(field);+ rows.push(row);+ }++ return rows;+}++export function loadCrossref(csvPath: string): CrossrefRow[] {+ const content = readFileSync(csvPath, "utf-8");+ const [, ...dataRows] = parseCsv(content);++ return dataRows+ .filter((r) => r.length >= 7 && r[0]?.startsWith("cus_"))+ .map((r) => ({+ stripeCustomerId: r[0].trim(),+ customerEmail: (r[2] || "").trim(),+ rewardfulAffiliateEmail: (r[4] || "").trim().toLowerCase(),+ dubPartnerEmail: (r[6] || "").trim().toLowerCase(),+ }));+}++export function buildOwnerMap(rows: CrossrefRow[]): Map<string, string> {+ const byCustomer = new Map<string, Map<string, number>>();++ for (const row of rows) {+ if (!row.stripeCustomerId || !row.rewardfulAffiliateEmail) continue;++ if (!byCustomer.has(row.stripeCustomerId)) {+ byCustomer.set(row.stripeCustomerId, new Map());+ }++ const counts = byCustomer.get(row.stripeCustomerId)!;+ counts.set(+ row.rewardfulAffiliateEmail,+ (counts.get(row.rewardfulAffiliateEmail) ?? 0) + 1,+ );+ }++ const ownerMap = new Map<string, string>();++ for (const [customerId, counts] of byCustomer) {+ const sorted = [...counts.entries()].sort((a, b) => b[1] - a[1]);++ if (sorted.length > 1) {+ console.warn(+ `β οΈ Customer ${customerId} maps to multiple affiliates: ${sorted+ .map(([email, count]) => `${email}(${count})`)+ .join(", ")} β using "${sorted[0][0]}".`,+ );+ }++ ownerMap.set(customerId, sorted[0][0]);+ }++ return ownerMap;+}++// ---------------------------------------------------------------------------+// Partner + link resolution+// ---------------------------------------------------------------------------++const partnerCache = new Map<string, string | null>();++export async function resolvePartnerId(email: string): Promise<string | null> {+ if (partnerCache.has(email)) return partnerCache.get(email)!;++ const enrollment = await prisma.programEnrollment.findFirst({+ where: {+ programId: PROGRAM_ID,+ partner: { email },+ },+ select: { partnerId: true },+ });++ const partnerId = enrollment?.partnerId ?? null;+ partnerCache.set(email, partnerId);+ return partnerId;+}++let programPromise: ReturnType<typeof loadProgram> | null = null;++function loadProgram() {+ return prisma.program.findUniqueOrThrow({+ where: { id: PROGRAM_ID },+ select: {+ url: true,+ domain: true,+ defaultFolderId: true,+ workspaceId: true,+ },+ });+}++// Creates a fresh program link owned by `partnerId`. Returns null if creation+// was skipped (e.g. an astronomically unlikely key collision).+export async function createRemediationLink(+ partnerId: string,+ purpose: string,+): Promise<Link | null> {+ programPromise = programPromise ?? loadProgram();+ const program = await programPromise;++ const created = await bulkCreateLinks({+ links: [+ {+ domain: program.domain!,+ key: nanoid(),+ url: program.url!,+ trackConversion: true,+ programId: PROGRAM_ID,+ partnerId,+ folderId: program.defaultFolderId,+ projectId: program.workspaceId,+ comments: purpose,+ },+ ] as ProcessedLinkProps[],+ });++ if (created.length === 0) {+ console.error(` β failed to create link for partner ${partnerId}`);+ return null;+ }++ const link = await prisma.link.findUnique({ where: { id: created[0].id } });+ console.log(+ ` created link ${link?.id} for partner ${partnerId} (${purpose})`,+ );+ return link;+}++const linkCache = new Map<string, Link | null>();++// Resolve the link a reassigned customer should point to: prefer the partner's+// group-default link, otherwise their oldest link in the program. If the partner+// has no link at all (e.g. a coupon-only affiliate), create one β but only when+// applying. In dry-run, returns null so the caller can report `needs_link`.+export async function getDestinationLink(+ partnerId: string,+): Promise<Link | null> {+ if (linkCache.has(partnerId)) return linkCache.get(partnerId)!;++ let link = await prisma.link.findFirst({+ where: { programId: PROGRAM_ID, partnerId },+ orderBy: [{ partnerGroupDefaultLinkId: "desc" }, { createdAt: "asc" }],+ });++ if (!link && !DRY_RUN) {+ link = await createRemediationLink(+ partnerId,+ "Link created during Rewardful attribution remediation",+ );+ }++ linkCache.set(partnerId, link);+ return link;+}++// ---------------------------------------------------------------------------+// Reassignment+// ---------------------------------------------------------------------------++export type ReassignStatus =+ | "reassigned"+ | "already_correct"+ | "no_customer"+ | "no_partner"+ | "no_destination_link"+ | "needs_link"; // dry-run only: target partner has no link yet (would be created on apply)++export interface ReassignResult {+ status: ReassignStatus;+ stripeCustomerId: string;+ customerId?: string;+ correctAffiliateEmail: string;+ fromPartnerId?: string | null;+ toPartnerId?: string;+ fromLinkId?: string | null;+ toLinkId?: string;+ movedCommissions?: number;+ processedReset?: number;+ paidWithPayoutSkipped?: number;+}++// Tracks links/partners whose denormalized counters need a resync afterwards.+export const touchedLinkIds = new Set<string>();+export const touchedPartnerIds = new Set<string>();+export const payoutIdsToRetally = new Set<string>();+// Commissions that were already PAID via a real Dub payout β moving these is a+// financial (clawback) decision, so we never touch them automatically.+export const paidWithPayoutCommissionIds: string[] = [];++export async function reassignCustomer(+ stripeCustomerId: string,+ correctAffiliateEmail: string,+): Promise<ReassignResult> {+ const base = { stripeCustomerId, correctAffiliateEmail };++ const customer = await prisma.customer.findUnique({+ where: { stripeCustomerId },+ select: { id: true, partnerId: true, linkId: true, programId: true },+ });++ if (!customer || customer.programId !== PROGRAM_ID) {+ return { ...base, status: "no_customer" };+ }++ const toPartnerId = await resolvePartnerId(correctAffiliateEmail);+ if (!toPartnerId) {+ return { ...base, status: "no_partner" };+ }++ if (customer.partnerId === toPartnerId) {+ return { ...base, status: "already_correct", customerId: customer.id };+ }++ const destinationLink = await getDestinationLink(toPartnerId);+ if (!destinationLink) {+ // In dry-run a link-less partner can't be resolved yet; on apply we'd create+ // one. Surface it distinctly so the dry-run summary is accurate.+ return {+ ...base,+ status: DRY_RUN ? "needs_link" : "no_destination_link",+ customerId: customer.id,+ };+ }++ if (customer.linkId) touchedLinkIds.add(customer.linkId);+ touchedLinkIds.add(destinationLink.id);+ if (customer.partnerId) touchedPartnerIds.add(customer.partnerId);+ touchedPartnerIds.add(toPartnerId);++ const result: ReassignResult = {+ ...base,+ status: "reassigned",+ customerId: customer.id,+ fromPartnerId: customer.partnerId,+ toPartnerId,+ fromLinkId: customer.linkId,+ toLinkId: destinationLink.id,+ };++ if (DRY_RUN) {+ const counts = await getCommissionCounts(customer.id);+ return { ...result, ...counts };+ }++ // Move the customer + its commissions atomically so a crash can't leave a+ // customer whose commissions point at a different partner than the customer.+ const commissionResult = await prisma.$transaction(async (tx) => {+ await tx.customer.update({+ where: { id: customer.id },+ data: { partnerId: toPartnerId, linkId: destinationLink.id },+ });++ return reassignCommissions({+ tx,+ customerId: customer.id,+ toPartnerId,+ toLinkId: destinationLink.id,+ });+ });++ return { ...result, ...commissionResult };+}++async function getCommissionCounts(customerId: string) {+ const commissions = await prisma.commission.findMany({+ where: { customerId },+ select: { id: true, status: true, payoutId: true },+ });++ let movedCommissions = 0;+ let processedReset = 0;+ let paidWithPayoutSkipped = 0;++ for (const c of commissions) {+ if (c.payoutId && c.status === "paid") paidWithPayoutSkipped++;+ else if (c.payoutId) processedReset++;+ else movedCommissions++;+ }++ return { movedCommissions, processedReset, paidWithPayoutSkipped };+}++async function reassignCommissions({+ tx,+ customerId,+ toPartnerId,+ toLinkId,+}: {+ tx: Prisma.TransactionClient;+ customerId: string;+ toPartnerId: string;+ toLinkId: string;+}) {+ const commissions = await tx.commission.findMany({+ where: { customerId },+ select: { id: true, status: true, payoutId: true },+ });++ // (a) Commissions NOT tied to a payout: safe to move as-is (preserves the+ // historical earnings/status, including imported "paid" records).+ const freeIds = commissions.filter((c) => !c.payoutId).map((c) => c.id);++ // (b) Commissions tied to an in-progress payout but not yet disbursed:+ // detach from the payout, reset to pending, move, then retally the payout.+ const detachIds = commissions+ .filter((c) => c.payoutId && c.status !== "paid")+ .map((c) => c.id);++ // (c) Commissions PAID via a real payout: never auto-move (clawback decision).+ const paidWithPayout = commissions.filter(+ (c) => c.payoutId && c.status === "paid",+ );+ paidWithPayout.forEach((c) => paidWithPayoutCommissionIds.push(c.id));++ commissions+ .filter((c) => c.payoutId && c.status !== "paid")+ .forEach((c) => payoutIdsToRetally.add(c.payoutId!));++ let movedCommissions = 0;+ let processedReset = 0;++ if (freeIds.length > 0) {+ const res = await tx.commission.updateMany({+ where: { id: { in: freeIds } },+ data: { partnerId: toPartnerId, linkId: toLinkId },+ });+ movedCommissions = res.count;+ }++ if (detachIds.length > 0) {+ const res = await tx.commission.updateMany({+ where: { id: { in: detachIds } },+ data: {+ partnerId: toPartnerId,+ linkId: toLinkId,+ payoutId: null,+ status: "pending",+ },+ });+ processedReset = res.count;+ }++ return {+ movedCommissions,+ processedReset,+ paidWithPayoutSkipped: paidWithPayout.length,+ };+}++// ---------------------------------------------------------------------------+// Discount code re-pointing+// ---------------------------------------------------------------------------++// Re-point a DiscountCode whose linkId belongs to a different partner to a+// brand-new link owned by the discount code's partner, so future coupon-based+// attribution (Stripe promo code β DiscountCode β link.partnerId) credits the+// right partner.+export async function fixDiscountCodeLink(discountCodeId: string) {+ const discountCode = await prisma.discountCode.findUnique({+ where: { id: discountCodeId },+ include: { link: { select: { partnerId: true } } },+ });++ if (!discountCode) return { status: "not_found" as const };+ if (discountCode.link?.partnerId === discountCode.partnerId) {+ return { status: "already_correct" as const };+ }++ if (DRY_RUN) {+ return {+ status: "would_fix" as const,+ code: discountCode.code,+ fromLinkId: discountCode.linkId,+ };+ }++ const newLink = await createRemediationLink(+ discountCode.partnerId,+ `Discount code ${discountCode.code} remediation link`,+ );++ if (!newLink) {+ return { status: "link_creation_failed" as const, code: discountCode.code };+ }++ await prisma.discountCode.update({+ where: { id: discountCode.id },+ data: { linkId: newLink.id },+ });++ return {+ status: "fixed" as const,+ code: discountCode.code,+ fromLinkId: discountCode.linkId,+ toLinkId: newLink.id,+ };+}++// ---------------------------------------------------------------------------+// Denormalized counter resync (run once at the end)+// ---------------------------------------------------------------------------++export async function resyncTouchedLinkStats() {+ const linkIds = [...touchedLinkIds];+ if (linkIds.length === 0) return;++ const stats = await prisma.customer.groupBy({+ by: ["linkId"],+ where: { linkId: { in: linkIds } },+ _count: { id: true },+ _sum: { sales: true, saleAmount: true },+ });++ const byLink = new Map(stats.map((s) => [s.linkId, s]));++ for (const linkId of linkIds) {+ const stat = byLink.get(linkId);+ const data = {+ leads: stat?._count.id ?? 0,+ sales: stat?._sum.sales ?? 0,+ saleAmount: BigInt(stat?._sum.saleAmount ?? 0), // BigInt column+ };++ console.log(+ ` link ${linkId} -> leads:${data.leads} sales:${data.sales} saleAmount:${data.saleAmount}`,+ );+ if (!DRY_RUN) {+ await prisma.link.update({ where: { id: linkId }, data });+ }+ }+}++export async function resyncTouchedPartnerStats() {+ for (const partnerId of touchedPartnerIds) {+ const [linkAgg, commissionAgg] = await Promise.all([+ prisma.link.aggregate({+ where: { programId: PROGRAM_ID, partnerId },+ _sum: {+ clicks: true,+ leads: true,+ conversions: true,+ sales: true,+ saleAmount: true,+ },+ }),+ prisma.commission.aggregate({+ where: {+ programId: PROGRAM_ID,+ partnerId,+ earnings: { not: 0 },+ status: { in: ["pending", "processed", "paid"] },+ },+ _sum: { earnings: true },+ }),+ ]);++ const data = {+ totalClicks: linkAgg._sum.clicks ?? 0,+ totalLeads: linkAgg._sum.leads ?? 0,+ totalConversions: linkAgg._sum.conversions ?? 0,+ totalSales: linkAgg._sum.sales ?? 0,+ totalSaleAmount: BigInt(linkAgg._sum.saleAmount ?? 0), // BigInt column+ totalCommissions: commissionAgg._sum.earnings ?? 0,+ };++ console.log(+ ` partner ${partnerId} -> clicks:${data.totalClicks} leads:${data.totalLeads} ` ++ `conversions:${data.totalConversions} sales:${data.totalSales} ` ++ `saleAmount:${data.totalSaleAmount} commissions:${data.totalCommissions}`,+ );+ if (!DRY_RUN) {+ await prisma.programEnrollment.update({+ where: { partnerId_programId: { partnerId, programId: PROGRAM_ID } },+ data,+ });+ }+ }+}++export async function retallyPayouts() {+ for (const payoutId of payoutIdsToRetally) {+ const sum = await prisma.commission.aggregate({+ where: { payoutId },+ _sum: { earnings: true },+ });+ const amount = sum._sum.earnings ?? 0;++ console.log(` payout ${payoutId} -> amount ${amount}`);+ if (DRY_RUN) continue;++ if (amount > 0) {+ await prisma.payout.update({ where: { id: payoutId }, data: { amount } });+ } else {+ await prisma.payout.delete({ where: { id: payoutId } });+ }+ }+}++export function printResultSummary(results: ReassignResult[]) {+ const byStatus = results.reduce(+ (acc, r) => {+ acc[r.status] = (acc[r.status] ?? 0) + 1;+ return acc;+ },+ {} as Record<ReassignStatus, number>,+ );++ console.log("\n=== Reassignment summary ===");+ console.table(byStatus);++ const reassigned = results.filter((r) => r.status === "reassigned");+ const totalMoved = reassigned.reduce(+ (sum, r) => sum + (r.movedCommissions ?? 0),+ 0,+ );+ const totalReset = reassigned.reduce(+ (sum, r) => sum + (r.processedReset ?? 0),+ 0,+ );+ const totalPaidSkipped = reassigned.reduce(+ (sum, r) => sum + (r.paidWithPayoutSkipped ?? 0),+ 0,+ );++ console.log(`Customers reassigned: ${reassigned.length}`);+ console.log(`Commissions moved: ${totalMoved}`);+ console.log(`Commissions detached/reset: ${totalReset}`);+ console.log(`Paid-w/payout (NOT touched): ${totalPaidSkipped}`);++ const noPartner = results.filter((r) => r.status === "no_partner");+ if (noPartner.length > 0) {+ console.log(+ `\n${noPartner.length} customers could not be reassigned because their Rewardful affiliate is not an enrolled partner:`,+ );+ console.table(+ noPartner.slice(0, 25).map((r) => ({+ stripeCustomerId: r.stripeCustomerId,+ affiliate: r.correctAffiliateEmail,+ })),+ );+ }++ if (paidWithPayoutCommissionIds.length > 0) {+ console.log(+ `\n${paidWithPayoutCommissionIds.length} commissions are PAID via a real payout and were left untouched (clawback decision required).`,+ );+ }+}