apps/web/app/app.dub.co/(dashboard)/[slug]/(ee)/program/partners/use-partner-filters.tsx (1)

144-155: Fix stale searchQuery when only “search” changes

searchQuery depends on searchParamsObj.search but it’s not in the deps array, causing stale URLs when users change only the search term.

-    [activeFilters, workspaceId, extraSearchParams],
+    [activeFilters, workspaceId, searchParamsObj.search, extraSearchParams],

apps/web/app/app.dub.co/(dashboard)/[slug]/(ee)/program/partners/use-partner-filters.tsx (1)

93-111: Bug: Group filter options should default to [] (not null) + avoid O(n*m) lookup; also guard permalink when slug is undefined

Returning null can break consumers expecting an array (other filters return []). Also, the count lookup does a linear search per group. Use a precomputed Map for O(1). Lastly, permalink should be conditional on slug to avoid "/undefined/..." during initial load.

Apply this diff:

       {
         key: "groupId",
         icon: Users6,
         label: "Group",
         options:
-          groups?.map((group) => {
-            const count = groupCount?.find(
-              ({ groupId }) => groupId === group.id,
-            )?._count;
-
-            return {
-              value: group.id,
-              label: group.name,
-              icon: <GroupColorCircle group={group} />,
-              right: nFormatter(count || 0, { full: true }),
-              permalink: `/${slug}/program/groups/${group.slug}/rewards`,
-            };
-          }) ?? null,
+          groups?.map((group) => {
+            const count = groupCountMap.get(group.id) || 0;
+            return {
+              value: group.id,
+              label: group.name,
+              icon: <GroupColorCircle group={group} />,
+              right: nFormatter(count, { full: true }),
+              permalink: slug
+                ? `/${slug}/program/groups/${group.slug}/rewards`
+                : undefined,
+            };
+          }) ?? [],
       },

Place this near other useMemo hooks (after fetching groupCount, before const filters = useMemo(...)):

const groupCountMap = useMemo(
  () =>
    new Map<string, number>(
      (groupCount ?? []).map(({ groupId, _count }) => [groupId, _count]),
    ),
  [groupCount],
);

apps/web/app/app.dub.co/(dashboard)/[slug]/(ee)/program/partners/use-partner-filters.tsx (1)

113-114: Include slug in filters useMemo deps

slug is used in the permalink; add it to the dependency array to prevent stale permalinks after workspace changes.

-    [countriesCount, statusCount, groupCount, groups],
+    [countriesCount, statusCount, groupCount, groups, slug],

apps/web/app/app.dub.co/(dashboard)/[slug]/(ee)/program/groups/groups-table.tsx (3)

30-168: Consider memoizing table data transformation for better performance.

The table data transformation on lines 54-60 includes router prefetching for each group. This operation runs on every render when groups change. Consider memoizing this transformation to avoid unnecessary prefetch calls and improve performance.

+import { useState, useMemo } from "react";

 export function GroupsTable() {
   const router = useRouter();
   const { slug } = useWorkspace();
   const { pagination, setPagination } = usePagination();
   const { queryParams, searchParams } = useRouterStuff();

   const sortBy = searchParams.get("sortBy") || "saleAmount";
   const sortOrder = searchParams.get("sortOrder") === "asc" ? "asc" : "desc";

   const { groups, loading, error } = useGroups<GroupExtendedProps>({
     query: {
       includeExpandedFields: true,
     },
   });

   const {
     groupsCount,
     loading: countLoading,
     error: countError,
   } = useGroupsCount();

   const isFiltered = !!searchParams.get("search");

+  const tableData = useMemo(() => {
+    if (!groups) return [];
+    
+    return groups.map((group) => {
+      // prefetch the group page
+      router.prefetch(`/${slug}/program/groups/${group.slug}/rewards`);
+      return group;
+    });
+  }, [groups, router, slug]);

   const { table, ...tableProps } = useTable({
-    data: groups
-      ? groups.map((group) => {
-          // prefetch the group page
-          router.prefetch(`/${slug}/program/groups/${group.slug}/rewards`);
-          return group;
-        })
-      : [],
+    data: tableData,

---

200-262: Extract DeleteGroupModal to component root to avoid re-instantiation.

The DeleteGroupModal component is being instantiated inside the RowMenuButton component on every render. This could lead to unnecessary re-renders and potential state loss. Consider lifting it to a parent component or managing it with a single modal instance at the table level.

Additionally, there's an inconsistency in the slug parameter usage - line 202 uses useParams() while the parent component gets slug from useWorkspace(). This could lead to issues if these values differ.

 function RowMenuButton({ row }: { row: Row<GroupExtendedProps> }) {
   const router = useRouter();
-  const { slug } = useParams();
+  const { slug } = useWorkspace();
   const [isOpen, setIsOpen] = useState(false);

   const { DeleteGroupModal, setShowDeleteGroupModal } = useDeleteGroupModal(
     row.original,
   );

---

264-301: Consider using the existing MenuItem component from @dub/ui.

You're defining a custom MenuItem component here, but based on the relevant code snippets, there's already a MenuItem component available in the @dub/ui package that supports icons and variants. Consider using the existing component to maintain consistency across the codebase.

-function MenuItem({
-  icon: IconComp,
-  label,
-  onSelect,
-  variant = "default",
-}: {
-  icon: Icon;
-  label: string;
-  onSelect: () => void;
-  variant?: "default" | "danger";
-}) {
-  const variantStyles = {
-    default: {
-      text: "text-neutral-600",
-      icon: "text-neutral-500",
-    },
-    danger: {
-      text: "text-red-600",
-      icon: "text-red-600",
-    },
-  };
-
-  const { text, icon } = variantStyles[variant];
-
-  return (
-    <Command.Item
-      className={cn(
-        "flex cursor-pointer select-none items-center gap-2 whitespace-nowrap rounded-md p-2 text-sm",
-        "data-[selected=true]:bg-neutral-100",
-        text,
-      )}
-      onSelect={onSelect}
-    >
-      <IconComp className={cn("size-4 shrink-0", icon)} />
-      {label}
-    </Command.Item>
-  );
-}

Import and use the existing MenuItem from @dub/ui:

 import {
   Button,
   EditColumnsButton,
   Icon,
+  MenuItem,
   Popover,
   StatusBadge,
   Table,
   usePagination,
   useRouterStuff,
   useTable,
 } from "@dub/ui";

Then update the usage in RowMenuButton:

-              <MenuItem
-                icon={PenWriting}
-                label="Edit group"
-                variant="default"
-                onSelect={() =>
+              <Command.Item
+                onSelect={() =>
                   router.push(
                     `/${slug}/program/groups/${row.original.slug}/settings`,
                   )
                 }
-              />
+              >
+                <MenuItem icon={PenWriting} variant="default">
+                  Edit group
+                </MenuItem>
+              </Command.Item>

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

apps/web/lib/actions/partners/reject-partner.ts (1)

36-53: Prevent TOCTOU race: guard the update with a status predicate.

Between the pending-status check and the update, another process could transition the enrollment (e.g., approve). Updating by id alone could then clear fields for a non-pending enrollment. Guard the update itself with status: pending and handle the 0-count case.

Apply this diff:

-    await prisma.programEnrollment.update({
-      where: {
-        id: programEnrollment.id,
-      },
-      data: {
-        status: ProgramEnrollmentStatus.rejected,
-        groupId: null,
-        clickRewardId: null,
-        leadRewardId: null,
-        saleRewardId: null,
-        discountId: null,
-      },
-    });
+    const { count } = await prisma.programEnrollment.updateMany({
+      where: {
+        id: programEnrollment.id,
+        status: ProgramEnrollmentStatus.pending,
+      },
+      data: {
+        status: ProgramEnrollmentStatus.rejected,
+        groupId: null,
+        clickRewardId: null,
+        leadRewardId: null,
+        saleRewardId: null,
+        discountId: null,
+      },
+    });
+    if (count === 0) {
+      throw new Error("Program enrollment is not pending.");
+    }

apps/web/lib/actions/partners/bulk-reject-partners.ts (1)

38-52: Avoid race by restricting the bulk update to currently-pending rows.

Ids were fetched with status: pending earlier, but statuses can change between the read and write. Add a status predicate to the updateMany to avoid mutating non-pending enrollments.

Apply this diff:

     await prisma.programEnrollment.updateMany({
       where: {
-        id: {
-          in: programEnrollments.map(({ id }) => id),
-        },
+        status: ProgramEnrollmentStatus.pending,
+        id: { in: programEnrollments.map(({ id }) => id) },
       },
       data: {
         status: ProgramEnrollmentStatus.rejected,
         groupId: null,
         clickRewardId: null,
         leadRewardId: null,
         saleRewardId: null,
         discountId: null,
       },
     });

apps/web/app/app.dub.co/(dashboard)/[slug]/(ee)/program/partners/use-partner-filters.tsx (2)

36-44: Precompute group counts for O(1) lookups

Build a Map once so option rendering is O(n) instead of O(n·m).

Add this immediately after the usePartnersCount for groupId:

   >({
     groupBy: "groupId",
   });
+
+  const groupCountMap = useMemo(
+    () =>
+      new Map(
+        (groupCount ?? []).map(({ groupId, _count }) => [groupId, _count]),
+      ),
+    [groupCount],
+  );

---

49-66: Fix: options should default to [] (not null) and avoid O(n·m) count lookup

Returning null for options can break consumers that expect an array (other filters return []). Also, the per-option .find(...) is O(n·m). Prefer a precomputed map and return [].

Apply this diff:

-        options:
-          groups?.map((group) => {
-            const count = groupCount?.find(
-              ({ groupId }) => groupId === group.id,
-            )?._count;
-
-            return {
-              value: group.id,
-              label: group.name,
-              icon: <GroupColorCircle group={group} />,
-              right: nFormatter(count || 0, { full: true }),
-              permalink: `/${slug}/program/groups/${group.slug}/rewards`,
-            };
-          }) ?? null,
+        options:
+          groups?.map((group) => {
+            const count = groupCountMap.get(group.id) ?? 0;
+
+            return {
+              value: group.id,
+              label: group.name,
+              icon: <GroupColorCircle group={group} />,
+              right: nFormatter(count, { full: true }),
+              permalink: `/${slug}/program/groups/${group.slug}/rewards`,
+            };
+          }) ?? [],

apps/web/lib/actions/partners/reject-partner.ts (1)

32-33: Prefer enum constant over string literal for pending check.

For consistency with the update (and to reduce typo risk), compare against ProgramEnrollmentStatus.pending.

-    if (programEnrollment.status !== "pending") {
+    if (programEnrollment.status !== ProgramEnrollmentStatus.pending) {

apps/web/lib/actions/partners/bulk-reject-partners.ts (2)

20-27: Use enum for pending filter in the read as well.

Keeps consistency and leverages types.

-        status: "pending",
+        status: ProgramEnrollmentStatus.pending,

---

54-71: Audit log may over-report if some IDs were not updated due to concurrency.

After adding the status predicate to updateMany, a subset of the pre-fetched enrollments may be updated. Consider re-querying the successfully updated enrollments for logging (or log counts) to ensure logs reflect actual changes.

apps/web/app/app.dub.co/(dashboard)/[slug]/(ee)/program/partners/use-partner-filters.tsx (1)

113-113: Include slug (and groupCountMap, if used) in filters useMemo deps

The filters array derives permalink from slug. Without slug in deps, permalinks can go stale if the workspace slug changes. If you adopt groupCountMap, depend on it instead of groupCount.

Option A (if you add groupCountMap as suggested):

-    [groupCount, groups, statusCount, countriesCount],
+    [groupCountMap, groups, statusCount, countriesCount, slug],

Option B (minimal change):

-    [groupCount, groups, statusCount, countriesCount],
+    [groupCount, groups, statusCount, countriesCount, slug],

apps/web/lib/actions/partners/ban-partner.ts (1)

34-36: Use the enum for the status check to stay consistent

Minor consistency nit: compare against ProgramEnrollmentStatus.banned instead of the raw string.

-    if (programEnrollment.status === "banned") {
+    if (programEnrollment.status === ProgramEnrollmentStatus.banned) {

apps/web/lib/actions/partners/unban-partner.ts (3)

25-28: Minor clarity: add a quick comment explaining the shared filter.

This where object gets reused across multiple models. A short comment helps future readers avoid misinterpreting it as a model-specific filter.

Apply this diff to add context:

-    const where = {
+    // Shared filter for partner+program across queries
+    const where = {
       programId,
       partnerId,
     };

---

30-38: Reduce query payload: prefer select over include.

You only use program.defaultGroupId, partner metadata (for logs), and status. Selecting those fields trims the response and avoids loading the entire program record.

Apply this diff:

-    const programEnrollment = await prisma.programEnrollment.findUniqueOrThrow({
-      where: {
-        partnerId_programId: where,
-      },
-      include: {
-        program: true,
-        partner: true,
-      },
-    });
+    const programEnrollment = await prisma.programEnrollment.findUniqueOrThrow({
+      where: {
+        partnerId_programId: where,
+      },
+      select: {
+        status: true,
+        program: { select: { defaultGroupId: true } },
+        partner: true,
+      },
+    });

---

44-49: Use your standard error type for internal invariants.

Instead of a generic Error, consider throwing your canonical API error (e.g., DubApiError) to keep error handling consistent and typed across the stack.

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Learnt from: TWilson023
PR: dubinc/dub#2673
File: apps/web/ui/partners/rewards/rewards-logic.tsx:268-275
Timestamp: 2025-07-30T15:29:54.131Z
Learning: In apps/web/ui/partners/rewards/rewards-logic.tsx, when setting the entity field in a reward condition, dependent fields (attribute, operator, value) should be reset rather than preserved because different entities (customer vs sale) have different available attributes. Maintaining existing fields when the entity changes would create invalid state combinations and confusing UX.

apps/web/app/app.dub.co/(dashboard)/[slug]/(ee)/program/groups/groups-table.tsx (4)

12-27: Use type-only imports for Icon and Row to avoid accidental runtime imports

Both Icon and Row are types. Importing them as values risks runtime import errors and unnecessary bundle bloat. Switch to import type.

-import {
-  Button,
-  EditColumnsButton,
-  Icon,
-  Popover,
-  StatusBadge,
-  Table,
-  useCopyToClipboard,
-  usePagination,
-  useRouterStuff,
-  useTable,
-} from "@dub/ui";
+import {
+  Button,
+  EditColumnsButton,
+  Popover,
+  StatusBadge,
+  Table,
+  useCopyToClipboard,
+  usePagination,
+  useRouterStuff,
+  useTable,
+} from "@dub/ui";
+import type { Icon } from "@dub/ui";
@@
-import { Row } from "@tanstack/react-table";
+import type { Row } from "@tanstack/react-table";
@@
-import { useState } from "react";
+import { useEffect, useState } from "react";

Also applies to: 29-29

---

55-63: Avoid prefetching inside render; move to an effect and guard slug

Calling router.prefetch in the render path runs on every render and can spam the router, especially with many rows. Prefetch once when groups/slug change.

-    data: groups
-      ? groups.map((group) => {
-          // prefetch the group page
-          router.prefetch(`/${slug}/program/groups/${group.slug}/rewards`);
-          return group;
-        })
-      : [],
+    data: groups || [],

Add this effect after the useTable call (or anywhere inside the component):

useEffect(() => {
  if (!slug || !groups?.length) return;
  for (const group of groups) {
    router.prefetch(`/${slug}/program/groups/${group.slug}/rewards`);
  }
}, [router, slug, groups]);

---

138-141: Guard against undefined slug before navigating

On initial render slug can be undefined. A quick guard avoids pushing a malformed route.

-    onRowClick: (row) => {
-      router.push(`/${slug}/program/groups/${row.original.slug}/rewards`);
-    },
+    onRowClick: (row) => {
+      if (!slug) return;
+      router.push(`/${slug}/program/groups/${row.original.slug}/rewards`);
+    },

---

244-253: Ensure copyToClipboard returns a Promise when used with toast.promise

If useCopyToClipboard returns a synchronous value/boolean, toast.promise won’t behave as expected. If it doesn’t return a Promise, switch to a simple toast.

If needed:

-  toast.promise(copyToClipboard(row.original.id), {
-    success: "Group ID copied!",
-  });
+  const ok = await copyToClipboard(row.original.id);
+  if (ok) toast.success("Group ID copied!");

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

apps/web/app/(ee)/partners.dub.co/(apply)/[programSlug]/apply/page.tsx (2)

58-58: Passing optional group to ProgramApplicationForm — LGTM (non-null assertion removal addressed)

Previously flagged non-null assertion is gone; the component accepts an optional group id and handles it.

---

43-45: Improve heading: include human-readable group label

Consider surfacing the group in the hero to set user expectations, using the group name when available, otherwise title-casing the slug for readability.

Apply this diff:

-          <h1 className="text-4xl font-semibold">Apply to {program.name}</h1>
+          <h1 className="text-4xl font-semibold">
+            Apply to {program.name}{" "}
+            {program.group?.name ??
+              partnerGroupSlug
+                .split("-")
+                .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+                .join(" ")}
+          </h1>

apps/web/app/(ee)/partners.dub.co/(apply)/[programSlug]/layout.tsx (2)

17-22: Defaulting to the “default” group changes semantics and can 404 when the group doesn’t exist; add a safe fallback.

Previously, calling getProgram without a groupSlug returned the program with empty rewards. Now, forcing DEFAULT_PARTNER_GROUP.slug will cause a 404 for programs that don’t have a “default” group (e.g., during rollout/backfill gaps). Suggest a graceful fallback to the unscoped program when groupSlug wasn’t explicitly provided.

Apply this diff:

-  const partnerGroupSlug = groupSlug ?? DEFAULT_PARTNER_GROUP.slug;
-
-  const program = await getProgram({
-    slug: programSlug,
-    groupSlug: partnerGroupSlug,
-  });
+  const partnerGroupSlug = groupSlug ?? DEFAULT_PARTNER_GROUP.slug;
+
+  let program = await getProgram({
+    slug: programSlug,
+    groupSlug: partnerGroupSlug,
+  });
+  // If we defaulted to the "default" group and it doesn't exist, fall back to unscoped program.
+  if (!program && !groupSlug) {
+    program = await getProgram({ slug: programSlug });
+  }
 
   if (!program) {
     notFound();
   }

Also applies to: 24-26

---

31-33: Guard looks good; simplify with optional chaining.

Thanks for addressing the previous null/undefined guard. You can reduce verbosity with optional chaining.

-      program.rewards && program.rewards.length > 0
+      program.rewards?.length
         ? formatRewardDescription({ reward: program.rewards[0] }).toLowerCase()
         : "earn commissions"

apps/web/app/(ee)/partners.dub.co/(apply)/[programSlug]/apply/page.tsx (1)

10-16: Optional groupSlug plumbed correctly; remove unused isDefaultGroup

The optional param pattern works well for sharing this page between /:programSlug/apply and /:programSlug/:groupSlug/apply. The local isDefaultGroup is defined but unused, though—drop it to avoid lint noise.

Apply this diff:

-  const isDefaultGroup = partnerGroupSlug === DEFAULT_PARTNER_GROUP.slug;

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.