apps/web/app/app.dub.co/(dashboard)/[slug]/(ee)/program/partners/applications/rejected/page-client.tsx (1)

127-140: Consider extracting avatar rendering to a shared component.

The inline avatar rendering duplicates logic from PartnerRowItem (lines 80-85 in partner-row-item.tsx). While this implementation is correct and the decision to remove the tooltip for rejected applicants is intentional, extracting the avatar rendering (image source selection, fallback, and styles) into a reusable component would improve maintainability and reduce duplication.

Example shared component:

export function PartnerAvatar({ 
  image, 
  name 
}: { 
  image?: string | null; 
  name: string 
}) {
  return (
    <img
      src={image || `${OG_AVATAR_URL}${name}`}
      alt={name}
      className="size-5 shrink-0 rounded-full"
    />
  );
}

apps/web/ui/partners/partner-rewards-tooltip.tsx (1)

46-49: Add type safety for iconMap access.

The code assumes reward.iconType exists in iconMap, but there's no runtime check. While the TypeScript types constrain this, a malformed API response could cause a runtime error.

Apply this diff for defensive coding:

   // Convert API rewards to component rewards
   const convertedRewards: RewardItem[] = rewards.map((reward) => ({
-    icon: iconMap[reward.iconType],
+    icon: iconMap[reward.iconType] ?? InvoiceDollar,
     text: reward.text,
   }));

Alternatively, add a runtime check:

   const convertedRewards: RewardItem[] = rewards
+    .filter(reward => reward.iconType in iconMap)
     .map((reward) => ({
       icon: iconMap[reward.iconType],
       text: reward.text,
     }));

apps/web/ui/partners/partner-row-item.tsx (1)

29-32: Pass null instead of empty string to skip data fetching.

The code passes an empty string to usePartnerRewardsAndDiscounts when showRewardsTooltip is false. While this works (the hook checks partnerId truthiness), passing null or undefined would be more idiomatic and explicit.

Apply this diff:

   // Fetch real reward data when showing rewards tooltip
   const { rewardsAndDiscounts } = usePartnerRewardsAndDiscounts(
-    showRewardsTooltip ? partner.id : "",
+    showRewardsTooltip ? partner.id : null,
   );

Then update the hook signature in use-partner-rewards-and-discounts.ts:

-export function usePartnerRewardsAndDiscounts(partnerId: string) {
+export function usePartnerRewardsAndDiscounts(partnerId: string | null) {

apps/web/lib/swr/use-partner-rewards-and-discounts.ts (1)

5-16: Consider tightening the any types.

The reward and discount fields use any, which reduces type safety. If these types are defined elsewhere in the codebase (e.g., in Prisma schema), consider importing and using them.

For example, if reward types are defined:

import type { ClickReward, LeadReward, SaleReward, Discount } from "@/lib/types";

type RewardsAndDiscounts = {
  rewards: Array<{
    type: "click" | "lead" | "sale";
    iconType: "CursorRays" | "UserPlus" | "InvoiceDollar";
    text: string;
    reward: ClickReward | LeadReward | SaleReward;
  }>;
  discount: {
    text: string;
    discount: Discount;
  } | null;
} | null;

If the types aren't available, consider adding a comment explaining why any is necessary.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

apps/web/lib/api/groups/get-groups.ts (1)

98-127: Consider performance optimization for reward data fetching.

The additional database query to fetch rewards runs after the main query completes. For large result sets, this could add latency. Consider:

1. Using Prisma.sql joins in the main query to fetch reward data alongside group metrics in a single round-trip
2. Conditionally fetching rewards only when includeExpandedFields is true (if rewards are only needed with expanded data)

Additionally, when groupIdsFromQuery is empty, the query still executes with an empty IN clause. While not incorrect, you could short-circuit and return the groups directly to avoid the extra query.

Example optimization:

  const groupIdsFromQuery = groups.map((group) => group.id);

+ // Skip rewards fetch if no groups
+ if (groupIdsFromQuery.length === 0) {
+   return groups.map((group) => ({
+     ...group,
+     partners: Number(group.partners),
+     totalClicks: Number(group.totalClicks),
+     totalLeads: Number(group.totalLeads),
+     totalSales: Number(group.totalSales),
+     totalSaleAmount: Number(group.totalSaleAmount),
+     totalConversions: Number(group.totalConversions),
+     totalCommissions: Number(group.totalCommissions),
+     netRevenue: Number(group.netRevenue),
+   }));
+ }
+
  // Fetch rewards for these groups
  const groupsWithRewards = await prisma.partnerGroup.findMany({

apps/web/ui/partners/partner-rewards-tooltip.tsx (2)

69-80: Handle the edge case for maxDuration === 1.

The duration logic skips maxDuration === 1 in both sale rewards (lines 75-80) and discounts (lines 102-107). When maxDuration is exactly 1, no duration text is appended, resulting in text like "10% per sale" instead of "10% per sale for 1 month".

Verify if this is intentional. If single-month durations should be displayed, update the condition:

- } else if (maxDuration && maxDuration > 1) {
+ } else if (maxDuration && maxDuration >= 1) {
    durationText =
      maxDuration % 12 === 0
        ? ` for ${maxDuration / 12} year${maxDuration / 12 > 1 ? "s" : ""}`
-       : ` for ${maxDuration} month${maxDuration > 1 ? "s" : ""}`;
+       : ` for ${maxDuration} month${maxDuration !== 1 ? "s" : ""}`;
  }

Also applies to: 96-107

---

115-132: Comment inconsistency: "always have rewards".

The comment states "partners will always have rewards through their group," but the component returns null when group is falsy (line 30). This suggests partners might not have a group or rewards.

Consider updating the comment to reflect the actual behavior:

- // Always show rewards - partners will always have rewards through their group
+ // Show rewards if group exists - partners without a group won't display tooltip
  return (

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Learnt from: devkiran
PR: dubinc/dub#2735
File: apps/web/lib/actions/partners/delete-reward.ts:33-41
Timestamp: 2025-08-14T05:17:51.825Z
Learning: In the partner groups system, a rewardId can only belong to one group, establishing a one-to-one relationship between rewards and groups. This means using Prisma's `update` method (rather than `updateMany`) is appropriate when updating groups by rewardId.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro