packages/prisma/client.ts (1)

1-20: 💡 Verification agent

❓ Verification inconclusive

CommissionType is still implicitly re-exported via export *

Although CommissionType was removed from the explicit list (👍), the wildcard export on line 1 still exposes every enum from @prisma/client, so downstream code can continue to import CommissionType and bypass the refactor.

-export * from "@prisma/client";
+// Re-export selected members to avoid leaking deprecated enums.
+export {
+  CommissionStatus,
+  EventType,
+  FolderType,
+  FolderUserRole,
+  InvoiceStatus,
+  LinkStructure,
+  PartnerBannedReason,
+  PartnerProfileType,
+  PartnerRole,
+  PartnerStatus,
+  PayoutStatus,
+  Prisma,
+  ProgramEnrollmentStatus,
+  RewardStructure,
+  Role,
+  WebhookReceiver,
+} from "@prisma/client";

Alternatively, keep the wildcard and add an explicit export type CommissionType = never to cause compile-time failures wherever the old enum is referenced.

---

Avoid wildcard re-export to prevent leaking deprecated enums

The top-level export * from "@prisma/client" still exposes every enum—including the deprecated CommissionType—so downstream code can continue to import it. To fully remove CommissionType, either:

• Replace the wildcard export with an explicit list of allowed exports:

  - export * from "@prisma/client";
  + // Re-export only supported members to avoid leaking deprecated enums
  + export {
  +   CommissionStatus,
  +   EventType,
  +   FolderType,
  +   FolderUserRole,
  +   InvoiceStatus,
  +   LinkStructure,
  +   PartnerBannedReason,
  +   PartnerProfileType,
  +   PartnerRole,
  +   PartnerStatus,
  +   PayoutStatus,
  +   Prisma,
  +   ProgramEnrollmentStatus,
  +   RewardStructure,
  +   Role,
  +   WebhookReceiver,
  + } from "@prisma/client";

• Or keep the wildcard but explicitly block CommissionType:

  export * from "@prisma/client";
  export type CommissionType = never;

File: packages/prisma/client.ts
Lines: 1–20

apps/web/scripts/tella/update-commissions.ts (1)

20-38: Concurrent DB calls: throttle to avoid connection exhaustion

Promise.all fires 50 commission.update queries in parallel.
If this script is ever pointed at a larger batch (or the default take is removed), it can easily exceed the pool size. Consider p-map with a concurrency limit or a simple for … of loop with await.

apps/web/lib/rewardful/import-campaign.ts (1)

36-40: Handle unexpected reward_type values explicitly

reward_type === "amount" ? … : … silently treats every non-amount value as percentage.
A defensive switch improves clarity and surfaces API drifts:

-let newType =
-  reward_type === "amount"
-    ? RewardStructure.flat
-    : RewardStructure.percentage;
+let newType: RewardStructure;
+switch (reward_type) {
+  case "amount":
+    newType = RewardStructure.flat;
+    break;
+  case "percentage":
+    newType = RewardStructure.percentage;
+    break;
+  default:
+    throw new Error(`Unsupported reward_type: ${reward_type}`);
+}

apps/web/ui/partners/commission-row-menu.tsx (1)

48-50: Good guard, but rely on enum constant not magic string

Prefer the generated enum to avoid typos and refactor churn:

-import { CommissionType } from "@dub/prisma/client";
-…
-if (row.original.type === "custom") {
+if (row.original.type === CommissionType.custom) {
   return null;
 }

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

79-83: Hard-coded filter list duplicated across files

The literal array ["click", "lead", "sale", "custom"] is now the third place this list appears. Consider extracting to a shared constant (e.g. COMMISSION_EVENT_TYPES) to avoid drift when another type is added.

- options: ["click", "lead", "sale", "custom"].map((slug) => ({
+ import { COMMISSION_EVENT_TYPES } from "@/lib/constants";
+ options: COMMISSION_EVENT_TYPES.map((slug) => ({

apps/web/lib/api/sales/construct-reward-amount.ts (1)

1-12: Compare against the enum value instead of string literal

RewardStructure is emitted by Prisma as both a value object and a type union.
Using the value object prevents silent breakage if the enum member is renamed:

-return type === "percentage"
+return type === RewardStructure.percentage

This keeps the comparison type-safe and discoverable by IDE refactors.

packages/prisma/schema/commission.prisma (1)

11-16: Consider documenting / constraining the new custom type

custom commissions don’t clearly map to either amount (sale) or quantity (click/lead).
Without nullable fields or a check constraint, consumers may have to populate both columns with sentinel values to satisfy NOT NULL.

Options:

• Make amount & quantity nullable and add a @@check ensuring exactly one is non-null per type.
• Keep them required but add a migration script & code-level guard that enforces one or the other.

This avoids bad data and simplifies downstream logic.

apps/web/ui/partners/comission-type-icon.tsx (2)

11-16: Mark the icon map as immutable for safer typings

Add as const to preserve literal types and prevent accidental mutation:

-const ICONS_MAP = {
+const ICONS_MAP = {
   click: { icon: CursorRays, className: "text-blue-500" },
   lead: { icon: UserCheck, className: "text-purple-500" },
   sale: { icon: InvoiceDollar, className: "text-teal-500" },
   custom: { icon: MoneyBills2, className: "text-gray-500" },
-};
+} as const;

---

25-27: Graceful fallback for unexpected types

ICONS_MAP[type] will throw if an unknown type is passed.
Provide a default icon to avoid runtime errors:

-const { icon: Icon, className: iconClassName } = ICONS_MAP[type];
+const { icon: Icon, className: iconClassName } =
+  ICONS_MAP[type] ?? ICONS_MAP.sale; // fallback

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

apps/web/scripts/convert-manual-commissions.ts (1)

74-75: 🛠️ Refactor suggestion

Exit with proper error code on failure

Unhandled promise rejections will be swallowed under some Node versions. Attach a catcher so CI/cron jobs fail loudly.

-main();
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

apps/web/scripts/convert-manual-commissions.ts (1)

9-19: Limit the SELECT list for better IO and privacy

include: { partner: true } fetches the entire partner record, but the script only needs partner.name. Use select to reduce payload and avoid unintentionally loading PII.

-    include: {
-      partner: true,
-    },
+    select: {
+      id: true,
+      amount: true,
+      partnerId: true,
+      programId: true,
+      partner: { select: { name: true } },
+    },

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

apps/web/app/(ee)/api/partner-profile/programs/[programId]/earnings/count/route.ts (2)

69-71: Deduplicate IDs before querying Prisma

Filtering out null IDs is a solid fix.
However, the resulting array can still include duplicates, creating unnecessary work for the database and transferring redundant data over the wire. De-dupe cheaply with Set:

-              in: counts
-                .map(({ linkId }) => linkId)
-                .filter((id): id is string => id !== null),
+              in: Array.from(
+                new Set(
+                  counts
+                    .map(({ linkId }) => linkId)
+                    .filter((id): id is string => id !== null)
+                )
+              ),

This keeps the query lean without changing behaviour.

---

75-85: Drop the any escape hatch and keep type safety

as any[] sacrifices compile-time guarantees and can hide future regressions.
Define an explicit result shape and rely on inference:

interface LinkCount {
  id: string | null;
  domain?: string | null;
  key?: string | null;
  url?: string | null;
  _count: number;
}

counts = counts.map(({ linkId, _count }): LinkCount => {
  const link = links.find((l) => l.id === linkId);
  return {
    id: linkId,
    domain: link?.domain,
    key: link?.key,
    url: link?.url,
    _count,
  };
});

You retain type safety with minimal extra code.

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