Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

apps/web/app/(ee)/api/cron/payouts/route.ts (2)

36-43: Fix partner aggregation map.

Current reducer overwrites acc[programId] with a single string, so programs with multiple partners either blow up (partnerId.in expects an array) or silently drop partners. Revert to collecting arrays of partnerIds (deduping as needed) before issuing the Prisma query.

---

70-83: Map banned partners by partnerId.

bannedPartners.map((partner) => partner.id) grabs the join row id, leaving the actual commissions for banned partners untouched. Use partner.partnerId so the update cancels the intended records.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

apps/web/app/(ee)/api/cron/payouts/route.ts (2)

221-237: Fix period boundary logic when reusing payouts.

When appending commissions to an existing payout, the code updates periodEnd to the new value but doesn't account for the existing period boundaries. This can cause reports to show incorrect date ranges:

1. periodStart is never updated, so if the new batch has earlier commissions, the payout won't reflect them
2. periodEnd should use MAX(existing, new) logic rather than blindly overwriting, otherwise a new batch from an earlier month could move it backwards

Update the payout logic to properly expand period boundaries:

         // if we're reusing a pending payout, we need to update the amount
         if (existingPendingPayouts.find((p) => p.id === payoutToUse.id)) {
           const updatedPayout = await prisma.payout.update({
             where: {
               id: payoutToUse.id,
             },
             data: {
               amount: {
                 increment: totalEarnings,
               },
-              periodEnd,
+              periodStart: {
+                set: periodStart < payoutToUse.periodStart ? periodStart : payoutToUse.periodStart,
+              },
+              periodEnd: {
+                set: periodEnd > payoutToUse.periodEnd ? periodEnd : payoutToUse.periodEnd,
+              },
             },
           });
           console.log(
             `Since we're reusing payout ${payoutToUse.id}, add the new earnings of ${totalEarnings} to the payout amount, making it ${updatedPayout.amount}`,
           );
         }

---

191-237: Wrap payout operations in a transaction.

The payout creation/update and commission updates are separate database calls without transaction protection. If any operation fails mid-sequence, you'll end up with orphaned payouts (no commissions assigned), commissions pointing to payouts with incorrect totals, or inconsistent state from concurrent cron runs.

Wrap the per-partner block in prisma.$transaction:

       for (const { partnerId, commissions } of partnerIdsToCommissionsArray) {
-        // sort the commissions by createdAt
-        const sortedCommissions = commissions.sort(
-          (a, b) => a.createdAt.getTime() - b.createdAt.getTime(),
-        );
-
-        // sum the earnings of the commissions
-        const totalEarnings = sortedCommissions.reduce(
-          (total, commission) => total + commission.earnings,
-          0,
-        );
-
-        // earliest commission date
-        const periodStart = sortedCommissions[0].createdAt;
-
-        // end of the month of the latest commission date
-        // e.g. if the latest sale is 2024-12-16, the periodEnd should be 2024-12-31
-        const periodEnd = endOfMonth(
-          sortedCommissions[sortedCommissions.length - 1].createdAt,
-        );
-
-        let payoutToUse = existingPendingPayouts.find(
-          (p) => p.partnerId === partnerId,
-        );
-
-        if (!payoutToUse) {
-          payoutToUse = await prisma.payout.create({
-            data: {
-              id: createId({ prefix: "po_" }),
-              programId,
-              partnerId,
-              periodStart,
-              periodEnd,
-              amount: totalEarnings,
-              description: `Dub Partners payout (${program.name})`,
-            },
-          });
-          console.log(
-            `No existing payout found, created new one ${payoutToUse.id} for partner ${partnerId}`,
-          );
-        }
-
-        const updatedCommissions = await prisma.commission.updateMany({
-          where: {
-            id: { in: commissions.map((c) => c.id) },
-          },
-          data: {
-            status: "processed",
-            payoutId: payoutToUse.id,
-          },
-        });
-        console.log(
-          `Updated ${updatedCommissions.count} commissions to have payoutId ${payoutToUse.id}`,
-        );
-
-        // if we're reusing a pending payout, we need to update the amount
-        if (existingPendingPayouts.find((p) => p.id === payoutToUse.id)) {
-          const updatedPayout = await prisma.payout.update({
-            where: {
-              id: payoutToUse.id,
-            },
-            data: {
-              amount: {
-                increment: totalEarnings,
-              },
-              periodEnd,
-            },
-          });
-          console.log(
-            `Since we're reusing payout ${payoutToUse.id}, add the new earnings of ${totalEarnings} to the payout amount, making it ${updatedPayout.amount}`,
-          );
-        }
+        await prisma.$transaction(async (tx) => {
+          // sort the commissions by createdAt
+          const sortedCommissions = commissions.sort(
+            (a, b) => a.createdAt.getTime() - b.createdAt.getTime(),
+          );
+
+          // sum the earnings of the commissions
+          const totalEarnings = sortedCommissions.reduce(
+            (total, commission) => total + commission.earnings,
+            0,
+          );
+
+          // earliest commission date
+          const periodStart = sortedCommissions[0].createdAt;
+
+          // end of the month of the latest commission date
+          // e.g. if the latest sale is 2024-12-16, the periodEnd should be 2024-12-31
+          const periodEnd = endOfMonth(
+            sortedCommissions[sortedCommissions.length - 1].createdAt,
+          );
+
+          let payoutToUse = existingPendingPayouts.find(
+            (p) => p.partnerId === partnerId,
+          );
+
+          if (!payoutToUse) {
+            payoutToUse = await tx.payout.create({
+              data: {
+                id: createId({ prefix: "po_" }),
+                programId,
+                partnerId,
+                periodStart,
+                periodEnd,
+                amount: totalEarnings,
+                description: `Dub Partners payout (${program.name})`,
+              },
+            });
+            console.log(
+              `No existing payout found, created new one ${payoutToUse.id} for partner ${partnerId}`,
+            );
+          }
+
+          await tx.commission.updateMany({
+            where: {
+              id: { in: commissions.map((c) => c.id) },
+            },
+            data: {
+              status: "processed",
+              payoutId: payoutToUse.id,
+            },
+          });
+          console.log(
+            `Updated commissions to have payoutId ${payoutToUse.id}`,
+          );
+
+          // if we're reusing a pending payout, we need to update the amount
+          if (existingPendingPayouts.find((p) => p.id === payoutToUse.id)) {
+            const updatedPayout = await tx.payout.update({
+              where: {
+                id: payoutToUse.id,
+              },
+              data: {
+                amount: {
+                  increment: totalEarnings,
+                },
+                periodEnd,
+              },
+            });
+            console.log(
+              `Since we're reusing payout ${payoutToUse.id}, add the new earnings of ${totalEarnings} to the payout amount, making it ${updatedPayout.amount}`,
+            );
+          }
+        });
       }

apps/web/app/(ee)/api/cron/payouts/route.ts (1)

168-170: Remove redundant sorting.

The commissions are already ordered by createdAt ascending from the database query (lines 130-132), so sorting them again in memory is unnecessary.

-        // sort the commissions by createdAt
-        const sortedCommissions = commissions.sort(
-          (a, b) => a.createdAt.getTime() - b.createdAt.getTime(),
-        );
-
         // sum the earnings of the commissions
-        const totalEarnings = sortedCommissions.reduce(
+        const totalEarnings = commissions.reduce(
           (total, commission) => total + commission.earnings,
           0,
         );
 
         // earliest commission date
-        const periodStart = sortedCommissions[0].createdAt;
+        const periodStart = commissions[0].createdAt;
 
         // end of the month of the latest commission date
         // e.g. if the latest sale is 2024-12-16, the periodEnd should be 2024-12-31
         const periodEnd = endOfMonth(
-          sortedCommissions[sortedCommissions.length - 1].createdAt,
+          commissions[commissions.length - 1].createdAt,
         );

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro