Payout Settlement

Copy// This cron job aggregates due commissions (pending commissions that are past the partner group's holding period) into payouts.
// Runs once every hour (0 * * * *) + calls itself recursively to look through all pending commissions available.
// GET /api/cron/payouts/aggregate-due-commissions
export const GET = withCron(async () => {
  const programsWithPendingCommissions = await prisma.program.findMany({
    where: {
      commissions: {
        some: {
          status: CommissionStatus.pending,
        },
      },
    },
    select: {
      id: true,
    },
  });
 
  const programIds = programsWithPendingCommissions.map((p) => p.id);
 
  if (programIds.length === 0) {
    return logAndRespond("No programs with due commissions found. Skipping...");
  }
 
  console.log(`Found ${programIds.length} programs with pending commissions.`);
 
  // process 50 programs at a time to avoid overwhelming the database
  const programIdChunks = chunk(programIds, 50);
 
  for (const [index, programIdChunk] of programIdChunks.entries()) {
    const delaySeconds = index * 10; // delay by 10s between program chunks
 
    const jobs: PublishBatchRequest<{ programId: string }>[] =
      programIdChunk.map((programId) => ({
        url: `${APP_DOMAIN_WITH_NGROK}/api/cron/payouts/aggregate-due-commissions/process`,
        body: {
          programId,
        },
        deduplicationId: `aggregate-due-commissions-${programId}`,
        label: "aggregate-due-commissions",
        flowControl: {
          key: `aggregate-due-commissions-${programId}`,
          parallelism: 1,
        },
        delay: delaySeconds,
      }));

Copyconst BATCH_SIZE = 100;
 
const inputSchema = z.object({
  programId: z.string(),
});
 
// POST /api/cron/payouts/aggregate-due-commissions/process
export const POST = withCron(async ({ rawBody }) => {
  const { programId } = inputSchema.parse(JSON.parse(rawBody));
 
  const program = await prisma.program.findUnique({
    where: {
      id: programId,
    },
    select: {
      id: true,
      name: true,
      workspaceId: true,
    },
  });
 
  if (!program) {
    return logAndRespond(`Program ${programId} not found. Skipping...`);
  }
 
  const partnerGroupsByHoldingPeriod = await prisma.partnerGroup.groupBy({
    by: ["holdingPeriodDays"],
    where: {
      programId,
    },
    _count: {
      id: true,
    },
    orderBy: {
      _count: {
        id: "desc",
      },
    },
  });
 
  for (const { holdingPeriodDays } of partnerGroupsByHoldingPeriod) {
    const partnerGroups = await prisma.partnerGroup.findMany({
      where: {
        holdingPeriodDays,
        programId,
      },
      select: {
        id: true,
      },
    });
 
    console.log(
      `Found ${partnerGroups.length} partner groups with holding period days: ${holdingPeriodDays}`,
    );
 
    while (true) {
      const dueCommissions = await prisma.commission.findMany({
        where: {
          programId,
          status: CommissionStatus.pending,
          programEnrollment: {
            groupId: {
              in: partnerGroups.map((p) => p.id),
            },
          },
          // If holding period days is greater than 0:
          // we only process commissions that were created before the holding period
          // but custom commissions are always included
          ...(holdingPeriodDays > 0
            ? {
                OR: [
                  {
                    type: {
                      // includes manual + referral commissions + clawbacks
                      in: ["custom", "referral"],
                    },
                  },
                  {
                    createdAt: {
                      lt: new Date(

Copyexport async function getEligiblePayouts({
  program,
  cutoffPeriod,
  selectedPayoutIds,
  excludedPayoutIds,
  pageSize,
  page = 1,
}: GetEligiblePayoutsProps) {
  const cutoffPeriodValue = CUTOFF_PERIOD.find(
    (c) => c.id === cutoffPeriod,
  )?.value;
 
  let payouts = await prisma.payout.findMany({
    where: {
      ...payoutIdSelectionWhere({ selectedPayoutIds, excludedPayoutIds }),
      ...getPayoutEligibilityFilter({ program }),
    },
    include: {
      partner: true,
      programEnrollment: {
        select: {
          groupId: true,
          tenantId: true,
        },
      },
      ...(cutoffPeriodValue && {
        commissions: {
          where: {
            createdAt: {
              lt: cutoffPeriodValue,
            },
          },
        },
      }),
    },
    orderBy: {
      amount: "desc",
    },
    ...(isFinite(pageSize) && {
      skip: (page - 1) * pageSize,
      take: pageSize,
    }),
  });
 
  if (cutoffPeriodValue) {
    payouts = payouts
      .map((payout) => {
        const newPayoutAmount = payout.commissions.reduce((acc, commission) => {
          return acc + commission.earnings;
        }, 0);
 
        return {
          ...payout,
          amount: newPayoutAmount,
        };
      })
      .filter((payout) => {
        if (payout.amount >= program.minPayoutAmount) {
          if (payout.partner.defaultPayoutMethod === "tremendous") {
            return (
              payout.amount >= TREMENDOUS_MIN_PAYOUT_AMOUNT_CENTS &&
              payout.amount <= TREMENDOUS_MAX_PAYOUT_AMOUNT_CENTS
            );
          }
          return true;
        }
        return false;
      });
  }

Copyexport const dynamic = "force-dynamic";
export const maxDuration = 600; // This function can run for a maximum of 10 minutes
 
const processPayoutsCronSchema = z.object({
  workspaceId: z.string(),
  userId: z.string(),
  invoiceId: z.string(),
  paymentMethodId: z.string(),
  cutoffPeriod: CUTOFF_PERIOD_ENUM,
  selectedPayoutIds: z.array(z.string()).optional(),
  excludedPayoutIds: z.array(z.string()).optional(),
});
 
// POST /api/cron/payouts/process
// This route is used to process payouts for a given invoice
// we're intentionally offloading this to a cron job to avoid blocking the main thread
export const POST = withCron(async ({ rawBody }) => {
  try {
    const {
      workspaceId,
      userId,
      invoiceId,
      paymentMethodId,
      cutoffPeriod,
      selectedPayoutIds,
      excludedPayoutIds,
    } = processPayoutsCronSchema.parse(JSON.parse(rawBody));

Copyconst workspace = await prisma.project.findUniqueOrThrow({
  where: {
    id: workspaceId,
  },
  include: {
    programs: true,
    invoices: {
      where: {
        id: invoiceId,
      },
    },
  },
});
 
// should never happen, but just in case
if (workspace.programs.length === 0) {
  return logAndRespond(
    `Workspace ${workspaceId} has no programs. Skipping...`,
  );
}
 
const program = workspace.programs[0];
 
// should never happen, but just in case
if (workspace.invoices.length === 0) {
  return logAndRespond(
    `Invoice ${invoiceId} not found for workspace ${workspaceId}. Skipping...`,
  );
}
 
const invoice = workspace.invoices[0];
 
// avoid race condition where Stripe's charge.failed webhook is processed before this cron job
if (invoice.status === "failed") {
  return logAndRespond(
    `Invoice ${invoiceId} has already been marked as failed. Skipping...`,
  );
}
 
if (cutoffPeriod) {
  await splitPayouts({
    program,
    cutoffPeriod,
    selectedPayoutIds,
    excludedPayoutIds,
  });
}

Copyexport async function processPayouts({
  workspace,
  program,
  invoice,
  userId,
  paymentMethodId,
  cutoffPeriod,
  selectedPayoutIds,
  excludedPayoutIds,
}: ProcessPayoutsProps) {
  const cutoffPeriodValue = CUTOFF_PERIOD.find(
    (c) => c.id === cutoffPeriod,
  )?.value;
 
  const res = await prisma.payout.updateMany({
    where: {
      ...payoutIdSelectionWhere({ selectedPayoutIds, excludedPayoutIds }),
      ...getPayoutEligibilityFilter({ program }),
      ...(cutoffPeriodValue && {
        periodEnd: {
          lte: cutoffPeriodValue,
        },
      }),
    },
    data: {
      invoiceId: invoice.id,
      status: "processing",
      userId,
      initiatedAt: new Date(),
      // if the program is in external mode, set the mode to external
      // otherwise set it to internal (we'll update specific payouts to "external" later if it's hybrid mode)
      mode: program.payoutMode === "external" ? "external" : "internal",
    },
  });
 
  if (res.count === 0) {
    console.log(
      `No payouts updated/found for invoice ${invoice.id}. Skipping...`,
    );
    return;
  }
 
  console.log(
    `Updated ${res.count} payouts to invoice ${invoice.id} and "processing" status`,
  );
 
  // if hybrid mode, we need to update payouts for partners with payoutsEnabledAt = null to external mode
  // here we don't need to filter if they have tenantId cause getPayoutEligibilityFilter above already takes care of that
  if (program.payoutMode === "hybrid") {
    await prisma.payout.updateMany({
      where: {
        invoiceId: invoice.id,
        partner: {
          payoutsEnabledAt: null,
        },
      },
      data: {
        mode: "external",
      },
    });
  }

Copyconst payoutsByMode = await prisma.payout.groupBy({
  by: ["mode"],
  where: {
    invoiceId: invoice.id,
  },
  _sum: {
    amount: true,
  },
});
 
const totalInternalPayoutAmount =
  payoutsByMode.find((p) => p.mode === "internal")?._sum.amount ?? 0;
const totalExternalPayoutAmount =
  payoutsByMode.find((p) => p.mode === "external")?._sum.amount ?? 0;
const totalPayoutAmount =
  totalInternalPayoutAmount + totalExternalPayoutAmount;
 
const paymentMethod = await stripe.paymentMethods.retrieve(paymentMethodId);
 
const payoutFee = calculatePayoutFeeForMethod({
  paymentMethod: paymentMethod.type,
  payoutFee: workspace.payoutFee,
});
 
if (!payoutFee) {
  throw new Error("Failed to calculate payout fee.");
}
 
console.info(
  `Using payout fee of ${payoutFee} for payment method ${paymentMethod.type}`,
);
 
const {
  fee: invoiceFee,
  feeFreeAmount,
  feeChargedAmount,
  feeWaiverRemaining,
} = calculatePayoutFeeWithWaiver({
  payoutAmount: totalPayoutAmount,
  payoutFee,
  payoutFeeWaiverLimit: workspace.payoutFeeWaiverLimit,
  payoutFeeWaiverUsage: workspace.payoutFeeWaiverUsage,
  paymentMethod: invoice.paymentMethod!,
});
 
const invoiceTotal = totalPayoutAmount + invoiceFee;
 
console.log({
  totalInternalPayoutAmount,
  totalExternalPayoutAmount,
  totalPayoutAmount,
  invoiceFee,
  invoiceTotal,
  feeFreeAmount,
  feeChargedAmount,
  feeWaiverRemaining,
});
 
await prisma.invoice.update({
  where: {
    id: invoice.id,
  },
  data: {
    amount: totalPayoutAmount,
    externalAmount: totalExternalPayoutAmount,
    fee: invoiceFee,
    total: invoiceTotal,
  },
});
 
let totalToCharge = invoiceTotal - totalExternalPayoutAmount;
const currency = nonUsdPaymentMethodTypes[paymentMethod.type] || "usd";
 
// convert the amount to EUR/CAD if the payment method is sepa_debit or acss_debit
if (Object.keys(nonUsdPaymentMethodTypes).includes(paymentMethod.type)) {
  const fxQuote = await createFxQuote({
    fromCurrency: currency,
    toCurrency: "usd",
  });
 

Copyconst confirmPayoutsSchema = z
  .object({
    workspaceId: z.string(),
    paymentMethodId: z.string(),
    cutoffPeriod: CUTOFF_PERIOD_ENUM,
    selectedPayoutIds: z.array(z.string()).optional(),
    excludedPayoutIds: z.array(z.string()).optional(),
    fastSettlement: z.boolean().optional().default(false),
    amount: z.number(),
    fee: z.number(),
    total: z.number(),
  })
  .superRefine((data, ctx) => {
    if (data.selectedPayoutIds?.length && data.excludedPayoutIds?.length) {
      ctx.addIssue({
        code: "custom",
        message:
          "Cannot combine selectedPayoutIds with excludedPayoutIds in the same request.",
      });
    }
  });

CopythrowIfNoPermission({
  role: workspace.role,
  requiredPermissions: ["payouts.write"],
});
 
if (!workspace.stripeId) {
  throw new Error("Workspace does not have a valid Stripe ID.");
}
 
if (fastSettlement && !workspace.fastDirectDebitPayouts) {
  throw new Error(
    "Fast settlement is not enabled for this program. Contact sales to enable it.",
  );
}
 
// if workspace's payouts usage + the current invoice amount
// is greater than the workspace's payouts limit, throw an error
if (workspace.payoutsUsage + amount > workspace.payoutsLimit) {
  throw new Error(
    exceededLimitError({
      plan: workspace.plan,
      planPeriod: workspace.planPeriod,
      limit: workspace.payoutsLimit,
      type: "payouts",
    }),
  );
}
 
if (amount < INVOICE_MIN_PAYOUT_AMOUNT_CENTS) {
  throw new Error(
    "Your payout total is less than the minimum invoice amount of $10.",
  );
}

Copyconst paymentMethod = await stripe.paymentMethods.retrieve(paymentMethodId);
 
if (paymentMethod.customer !== workspace.stripeId) {
  throw new Error("Invalid payout method.");
}
 
if (!PAYMENT_METHOD_TYPES.includes(paymentMethod.type)) {
  throw new Error(
    `We only support ${PAYMENT_METHOD_TYPES.join(
      ", ",
    )} for now. Please update your payout method to one of these.`,
  );
}
 
if (fastSettlement && paymentMethod.type !== "us_bank_account") {
  throw new Error("Fast settlement is only supported for ACH payment.");
}
 
// if it's a direct debit payment method, we need to check to make sure mandate is valid
if (DIRECT_DEBIT_PAYMENT_METHOD_TYPES.includes(paymentMethod.type)) {
  const mandate = await checkPaymentMethodMandate({
    paymentMethodId,
  });
 
  if (!mandate) {
    // if mandate is not valid, remove the payment method
    await stripe.paymentMethods.detach(paymentMethodId);
    throw new Error(
      "No active mandate found for this bank account. Please set up a new bank account for payouts under your billing settings page.",
    );
  }
}

Copyif (program.payoutMode !== "internal") {
  const [eligiblePayouts, payoutWebhooks] = await Promise.all([
    getEligiblePayouts({
      program,
      cutoffPeriod,
      selectedPayoutIds,
      excludedPayoutIds,
      page: 1,
      pageSize: Infinity,
    }),
 
    getWebhooks({
      workspaceId: workspace.id,
      triggers: ["payout.confirmed"],
      disabled: false,
      installationId: null,
    }),
  ]);
 
  // Check if the invoice includes any external payouts
  const hasExternalPayouts = eligiblePayouts.find(
    (payout) => payout.mode === "external",
  );
 
  if (hasExternalPayouts && payoutWebhooks.length === 0) {
    throw new Error(
      `EXTERNAL_WEBHOOK_REQUIRED: This invoice includes at least one external payout, which requires an active webhook subscribed to the "payout.confirmed" event. Please set one up before proceeding.`,
    );
  }
}

Copyconst invoice = await prisma.$transaction(async (tx) => {
  // Generate the next invoice number by counting the number of invoices for the workspace
  const totalInvoices = await tx.invoice.count({
    where: {
      workspaceId: workspace.id,
    },
  });
 
  const paddedNumber = String(totalInvoices + 1).padStart(4, "0");
  const invoiceNumber = `${workspace.invoicePrefix}-${paddedNumber}`;
 
  // Create the invoice and return it
  return await tx.invoice.create({
    data: {
      id: createId({ prefix: "inv_" }),
      number: invoiceNumber,
      programId,
      workspaceId: workspace.id,
      // these numbers will be updated later in the payouts/process cron job
      // but we're adding them now for the program/payouts/success screen
      amount,
      fee,
      total,
      paymentMethod: fastSettlement
        ? "ach_fast"
        : STRIPE_PAYMENT_METHOD_NORMALIZATION[paymentMethod.type],

Copyconst payloadSchema = z.object({
  invoiceId: z.string(),
});
 
// POST /api/cron/payouts/charge-succeeded
// This route is used to process the charge-succeeded event from Stripe.
// We're intentionally offloading this to a cron job so we can return a 200 to Stripe immediately.
export const POST = withCron(async ({ rawBody }) => {
  try {
    const { invoiceId } = payloadSchema.parse(JSON.parse(rawBody));
 
    const invoice = await prisma.invoice.findUnique({
      where: {
        id: invoiceId,
      },
      include: {
        _count: {
          select: {
            payouts: {
              where: {
                status: "processing",
              },
            },
          },
        },
      },
    });
 
    if (!invoice) {
      return logAndRespond(`Invoice ${invoiceId} not found.`);
    }
 
    if (invoice._count.payouts === 0) {
      return logAndRespond(
        `No payouts found with status 'processing' for invoice ${invoiceId}, skipping...`,
      );
    }

Copy// Set the method for each payout in the invoice to the corresponding partner's default payout method
await prisma.$executeRaw`
  UPDATE Payout p
  INNER JOIN Partner pn ON p.partnerId = pn.id
  SET p.method = pn.defaultPayoutMethod
  WHERE p.invoiceId = ${invoice.id}
  AND pn.defaultPayoutMethod IS NOT NULL
  AND p.status = 'processing'
`;

Copylet fundsAvailable = true;
 
// if invoice payment method is card, we need to check if the funds have settled yet
if (invoice.paymentMethod === "card") {
  const fundSettlementTiming = await getFundSettlementTiming(invoice);
  if (!fundSettlementTiming.fundsAvailable) {
    // set fundsAvailable to false so we don't queue any payouts that require funds to be available
    fundsAvailable = false;
 
    const postSettlementPayoutMethods = [
      PartnerPayoutMethod.stablecoin,
      PartnerPayoutMethod.paypal,
      PartnerPayoutMethod.tremendous,
    ];
 
    const postSettlementPayoutsCount = await prisma.payout.count({
      where: {
        invoiceId: invoice.id,
        status: "processing",
        method: {
          in: postSettlementPayoutMethods,
        },
      },
    });
 
    if (postSettlementPayoutsCount > 0) {
      await scheduleDelayedPayouts({
        invoice,
        executeAt: fundSettlementTiming.scheduledAt,
      });
    }
  }
}

Copyexport async function scheduleDelayedPayouts({
  invoice,
  executeAt,
}: {
  invoice: Pick<Invoice, "id">;
  executeAt: Date;
}) {
  const scheduleTimeMs = executeAt.getTime();
 
  const delaySeconds = Math.max(
    0,
    Math.floor((scheduleTimeMs - Date.now()) / 1000),
  );
 
  const qstashResponse = await qstash.publishJSON({
    url: `${APP_DOMAIN_WITH_NGROK}/api/cron/payouts/charge-succeeded`,
    delay: delaySeconds + 5 * 60, // 5 minutes delay to give some buffer for the card charge to settle fully
    deduplicationId: `retry-delayed-payouts-${invoice.id}`, // The deduplication window is 10 minutes
    label: invoice.id,
    flowControl: {
      key: invoice.id,
      parallelism: 1,
    },
    body: {
      invoiceId: invoice.id,
    },
  });
 
  if (qstashResponse.messageId) {
    const scheduledAt = new Date(scheduleTimeMs);
 
    console.log(
      `Scheduled delayed payouts for invoice ${invoice.id} at ${scheduledAt.toISOString()}.`,
      {
        qstashResponse,
      },
    );
  } else {
    throw new Error(
      `Failed to schedule delayed payouts for invoice ${invoice.id}`,
    );
  }
}

Copyawait Promise.allSettled([
  // Queue Stripe payouts (need to pass along fundsAvailable to handle stablecoin payouts)
  queueStripePayouts({
    invoice,
    fundsAvailable,
  }),
 
  // only send PayPal and Tremendous payouts if funds are available
  ...(fundsAvailable
    ? [
        sendPaypalPayouts({
          invoice,
        }),
        queueTremendousPayouts({
          invoice,
        }),
      ]
    : []),
 
  // Queue external payouts (doesn't rely on fundsAvailable)
  queueExternalPayouts(invoice),
]);
 

Copyexport async function queueStripePayouts({
  invoice,
  fundsAvailable,
}: {
  invoice: Pick<
    Invoice,
    "id" | "paymentMethod" | "stripeChargeMetadata" | "payoutMode"
  >;
  fundsAvailable: boolean;
}) {
  if (invoice.payoutMode === "external") {
    console.log(
      `Invoice ${invoice.id} is paid externally, skipping Stripe payouts...`,
    );
    return;
  }
 
  const { id: invoiceId, paymentMethod, stripeChargeMetadata } = invoice;
 
  if (fundsAvailable) {
    // Fund the total Stablecoin payout amount for this invoice
    const { _sum, _count } = await prisma.payout.aggregate({
      _sum: {
        amount: true,
      },
      _count: {
        id: true,
      },
      where: {
        invoiceId: invoice.id,
        method: "stablecoin",
        status: "processing",
        // only transfer funds for stablecoin payouts >= minimum withdrawal amount
        // for payouts below the minimum withdrawal amount, we will just mark them as processed
        // and users can force withdraw them manually later (which triggers another fundFinancialAccount call)
        amount: {
          gte: MIN_WITHDRAWAL_AMOUNT_CENTS,
        },
      },
    });
 
    // We need to add the STABLECOIN_PAYOUT_FIXED_FEE_CENTS for each payout to the total funding amount
    // to make sure that `createStablecoinPayout` later has enough funds to cover Stripe's fees
    const stablecoinFundingAmount =
      (_sum.amount ?? 0) + _count.id * STABLECOIN_PAYOUT_FIXED_FEE_CENTS;
 
    // Send money to Financial Account to handle Stablecoin payouts
    if (stablecoinFundingAmount > 0) {
      try {
        await fundFinancialAccount({
          amount: stablecoinFundingAmount,
          idempotencyKey: invoiceId,
        });
      } catch (error) {
        await log({
          message: `Failed to fund Dub's financial account for stablecoin payouts: ${error.message}`,
          type: "errors",
        });
 
        throw error;
      }
    }
  }
 
  // Find the id of the charge that was used to fund the transfer
  const parsedChargeMetadata =
    stripeChargeMetadataSchema.safeParse(stripeChargeMetadata);
  const chargeId = parsedChargeMetadata?.success
    ? parsedChargeMetadata?.data.id
    : undefined;
 
  // this should never happen since all completed invoices should have a charge id, but just in case
  if (!chargeId) {
    await log({
      message:
        "No charge id found in stripeChargeMetadata for invoice " +
        invoiceId +
        ", continuing without source_transaction.",
      type: "errors",
    });

Copyexport async function queueTremendousPayouts({
  invoice,
}: {
  invoice: Pick<Invoice, "id" | "payoutMode" | "programId">;
}) {
  if (invoice.payoutMode === "external") {
    console.log(
      `Invoice ${invoice.id} is paid externally, skipping Tremendous payouts...`,
    );
    return;
  }
 
  // should never happen, but just in case
  if (!invoice.programId) {
    console.log(
      `Invoice ${invoice.id} has no program ID, skipping Tremendous payouts...`,
    );
    return;
  }
 
  const partnersInCurrentInvoice = await prisma.payout.groupBy({
    by: ["partnerId"],
    where: {
      invoiceId: invoice.id,
      status: PayoutStatus.processing,
      mode: PayoutMode.internal,
      method: PartnerPayoutMethod.tremendous,
      amount: {
        gte: TREMENDOUS_MIN_PAYOUT_AMOUNT_CENTS,
        lte: TREMENDOUS_MAX_PAYOUT_AMOUNT_CENTS,
      },
      partner: {
        tremendousEmail: {
          not: null,
        },
        payoutsEnabledAt: {
          not: null,
        },
      },
    },
  });
 
  if (partnersInCurrentInvoice.length === 0) {
    console.log("No partners for sending via Tremendous, skipping...");
    return;
  }
 
  const program = await prisma.program.findUniqueOrThrow({
    where: {
      id: invoice.programId,
    },
    select: {
      tremendousCampaignId: true,
    },
  });
 
  // Log and skip if the program has no Tremendous campaign.
  if (!program.tremendousCampaignId) {
    logger.error("missing_campaign", {
      service: "tremendous",
      operation: "queue_tremendous_payouts",
      correlation: {
        invoiceId: invoice.id,
        programId: invoice.programId,
      },
    });
 
    await logger.flush();
    return;
  }
 
  const chunkedPartners = chunk(partnersInCurrentInvoice, 100);
 
  for (let i = 0; i < chunkedPartners.length; i++) {
    const partnersInChunk = chunkedPartners[i];
 
    await Promise.all(
      partnersInChunk.map(({ partnerId }) =>
        queue.enqueueJSON({
          url: `${APP_DOMAIN_WITH_NGROK}/api/cron/payouts/send-tremendous-payout`,

Copy// only send PayPal and Tremendous payouts if funds are available
...(fundsAvailable
  ? [
      sendPaypalPayouts({
        invoice,
      }),
      queueTremendousPayouts({
        invoice,
      }),
    ]
  : []),
 
// Queue external payouts (doesn't rely on fundsAvailable)
queueExternalPayouts(invoice),

Copyconst payloadSchema = z.object({
  partnerId: z.string(),
  invoiceId: z.string().optional(),
  chargeId: z.string().optional(),
});

Copyconst partner = await prisma.partner.findUniqueOrThrow({
  where: {
    id: partnerId,
  },
  select: {
    id: true,
    email: true,
    stripeConnectId: true,
    payoutsEnabledAt: true,
  },
});
 
// should never happen, but just in case
if (!partner.stripeConnectId || !partner.payoutsEnabledAt) {
  console.warn(
    `Partner ${partner.email} does not have an active payout account.`,
  );
  return;
}
 
const commonInclude: Prisma.PayoutInclude = {
  program: {
    select: {
      id: true,
      name: true,
      logo: true,
      workspaceId: true,
    },
  },
};
 
const [previouslyProcessedPayouts, currentInvoicePayouts] = await Promise.all(
  [
    prisma.payout.findMany({
      where: {
        partnerId: partner.id,
        status: "processed",
        stripeTransferId: null,
        method: "connect",
      },
      orderBy: {
        id: "asc",
      },
      include: commonInclude,
    }),
 
    invoiceId
      ? prisma.payout.findMany({
          where: {
            partnerId: partner.id,
            invoiceId,
            status: "processing",
            method: "connect",
          },
          orderBy: {
            id: "asc",
          },
          include: commonInclude,
        })
      : Promise.resolve([]),
  ],
);

Copyconst idempotencyKey = createPayoutsIdempotencyKey({
  partnerId: partner.id,
  invoiceId,
  payoutIds: allPayouts.map((p) => p.id),
});
 
// Create a transfer for the partner combined payouts and update it as sent
const transfer = await stripe.transfers.create(
  {
    amount: finalTransferableAmount,
    currency: "usd",
    // here, `transfer_group` technically only used to associate the transfer with the invoice
    // (even though the transfer could technically include payouts from multiple invoices)
    transfer_group: finalPayoutInvoiceId!,
    destination: partner.stripeConnectId,
    description: `Dub Partners payout transfer (${allPayoutsProgramNames.join(", ")})`,
    // Omit `source_transaction` if prior processed payouts exist to ensure this transfer
    // never exceeds the original charge amount.
    ...(previouslyProcessedPayouts.length === 0 &&
      chargeId && {
        source_transaction: chargeId,
      }),
  },
  {
    idempotencyKey,
  },
);

Copyconst stripeRecipientAccount = await getStripeRecipientAccount(
  partner.stripeRecipientId,
);
 
// Stripe recipient account is closed
if (stripeRecipientAccount.closed) {
  await prisma.partner.update({
    where: {
      id: partner.id,
    },
    data: {
      stripeRecipientId: null,
      payoutsEnabledAt: null,
      defaultPayoutMethod: null,
    },
  });
 
  await markPayoutsAsProcessed(currentInvoicePayouts);
 
  console.warn(
    `Stripe recipient account for partner ${partner.email} is closed.`,
  );
  return;
}
 
// Stripe recipient account does not have crypto wallet capabilities
if (
  stripeRecipientAccount.configuration?.recipient?.capabilities
    ?.crypto_wallets?.status !== "active"
) {
  await prisma.partner.update({
    where: {
      id: partner.id,
    },
    data: {
      payoutsEnabledAt: null,
    },
  });
 
  await markPayoutsAsProcessed(currentInvoicePayouts);
 
  const message = `Stripe recipient account for partner ${partner.email} does not have crypto wallet capabilities.`;
 
  if (forceWithdrawal) {
    throw new Error(message);
  } else {
    console.warn(message);
    return;
  }
}