apps/web/app/(ee)/partners.dub.co/(dashboard)/programs/[programSlug]/(enrolled)/page-client.tsx (1)

428-431: Match tooltip with header number formatting (strip .00 for integers).

Top “Earnings” uses NumberFlow with trailingZeroDisplay: "stripIfInteger"; align the tooltip for consistency.

-                  {currency
-                    ? currencyFormatter(d.values.main)
+                  {currency
+                    ? currencyFormatter(d.values.main, {
+                        trailingZeroDisplay: "stripIfInteger",
+                      })
                     : nFormatter(d.values.main)}

apps/web/ui/partners/overview/blocks/partners-block.tsx (1)

78-78: Optional: strip .00 in compact list rows.

Slightly tighter look for integer amounts:

-              <span>{currencyFormatter(partner.saleAmount / 100)}</span>
+              <span>
+                {currencyFormatter(partner.saleAmount / 100, {
+                  trailingZeroDisplay: "stripIfInteger",
+                })}
+              </span>

packages/email/src/templates/partner-payout-failed.tsx (1)

44-44: Confirm currency and format failureFee consistently

• This assumes USD defaults. If partner payouts can be non-USD, add currency to props and pass it to currencyFormatter.
• Also format the failure fee with currencyFormatter for consistency (Line 79 currently interpolates a raw number).

Example (outside this hunk):

<span className="font-semibold text-neutral-800">
  {currencyFormatter((payout.failureFee ?? 0) / 10 ** 2)}
</span>

packages/email/src/templates/partner-paypal-payout-failed.tsx (1)

43-43: Pass explicit currency if PayPal payouts aren’t always USD

If payouts may be non-USD, surface currency on the template props and pass it to currencyFormatter to avoid USD-only rendering.

apps/web/ui/partners/overview/blocks/countries-block.tsx (1)

83-83: Verify currency semantics for saleAmount

This assumes USD (defaults) and 2-decimal scaling. If analytics can be multi-currency, pass currency and convert from minor units by exponent.

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

256-269: Prefer raw numbers for accessorFn; format in cell (future-proof sorting/aggregation)

Returning formatted strings from accessorFn can hinder numeric ops later. Keep the accessor numeric and format in cell.

-        {
-          id: "saleAmount",
-          header: "Revenue",
-          accessorFn: (d) => currencyFormatter(d.saleAmount / 100),
-        },
+        {
+          id: "saleAmount",
+          header: "Revenue",
+          accessorFn: (d) => d.saleAmount,
+          cell: ({ row }) => currencyFormatter(row.original.saleAmount / 100),
+        },
         {
           id: "totalCommissions",
           header: "Commissions",
-          accessorFn: (d) => currencyFormatter(d.totalCommissions / 100),
+          accessorFn: (d) => d.totalCommissions,
+          cell: ({ row }) =>
+            currencyFormatter(row.original.totalCommissions / 100),
         },
         {
           id: "netRevenue",
           header: "Net Revenue",
-          accessorFn: (d) => currencyFormatter(d.netRevenue / 100),
+          accessorFn: (d) => d.netRevenue,
+          cell: ({ row }) => currencyFormatter(row.original.netRevenue / 100),
         },

---

301-310: Sortable column id mismatch: use "totalCommissions" not "commissions"

This prevents sorting that column.

       sortableColumns: [
         "createdAt",
         "clicks",
         "leads",
         "conversions",
         "sales",
         "saleAmount",
-        "commissions",
+        "totalCommissions",
         "netRevenue",
       ],

apps/web/app/(ee)/admin.dub.co/(dashboard)/commissions/client.tsx (1)

127-128: Prefer getValue over row.original in cells.

Keeps display concerns decoupled from row shape and leverages the column accessor.

-        cell: ({ row }) => currencyFormatter(row.original.commissions / 100),
+        cell: ({ getValue }) => currencyFormatter(Number(getValue()) / 100),

Note: If you want display parity with the NumberFlow total (which strips .00 for integers), consider passing { trailingZeroDisplay: "stripIfInteger" } to currencyFormatter in this view.

apps/web/app/(ee)/partners.dub.co/(dashboard)/payouts/payout-stats.tsx (2)

82-82: Avoid hard-coded "$0.00"; defer zero/negative handling to the formatter.

Using a literal breaks consistency if defaults change (currency, locale) and misreports negatives. Always call the formatter for 0/negatives.

-                  <>{amount > 0 ? currencyFormatter(amount / 100) : "$0.00"}</>
+                  {currencyFormatter(((amount ?? 0)) / 100)}

---

26-33: Loading vs. error UX is inconsistent.

isLoading collapses errors into the skeleton state, making the inner error ? "-" : ... branch effectively dead on error. Consider keeping error distinct.

-  const isLoading = amount === undefined || error;
+  const isLoading = amount === undefined;

This will render "-" on errors as intended.

Also applies to: 36-36, 79-86

apps/web/app/app.dub.co/(dashboard)/[slug]/(ee)/program/bounties/[bountyId]/bounty-submission-details-sheet.tsx (1)

143-147: Confirm zero-reward display semantics.

commission?.earnings ? ... : "-" hides a $0.00 reward with "-". If you want explicit zeros for clarity, format 0 instead.

-                  value: commission?.earnings
-                    ? currencyFormatter(commission.earnings / 100)
-                    : "-",
+                  value:
+                    commission?.earnings !== undefined
+                      ? currencyFormatter((commission?.earnings ?? 0) / 100)
+                      : "-",

apps/web/ui/links/link-analytics-badge.tsx (2)

107-111: Remove the ts-ignore by widening the formatter’s option type.

Avoid suppressing TS for trailingZeroDisplay. Update the shared CurrencyFormatterOptions to include it, then drop the ignore here.

Outside this file (in @dub/utils):

// packages/utils/src/functions/currency-formatter.ts
export type CurrencyFormatterOptions = Intl.NumberFormatOptions & {
  trailingZeroDisplay?: "auto" | "stripIfInteger";
};

After that, this call compiles without the ts-ignore.

---

171-176: Duplicate config — factor into a tiny helper.

You pass the same { trailingZeroDisplay: "stripIfInteger" } twice. A local formatSales helper improves readability and avoids drift.

+  const formatSales = (cents: number) =>
+    currencyFormatter(cents / 100, { trailingZeroDisplay: "stripIfInteger" });

...
-                    ? currencyFormatter(value / 100, {
-                        trailingZeroDisplay: "stripIfInteger",
-                      })
+                    ? formatSales(value)
...
-                      ? currencyFormatter(value / 100, {
-                          // @ts-ignore – trailingZeroDisplay is a valid option but TS is outdated
-                          trailingZeroDisplay: "stripIfInteger",
-                        })
+                      ? formatSales(value)

apps/web/app/(ee)/admin.dub.co/(dashboard)/payouts/client.tsx (1)

155-167: Optional: match NumberFlow’s no-decimal integers

Top totals use trailingZeroDisplay: "stripIfInteger" (Lines 219-223), but table cells always show two decimals via the default formatter. If you want visual consistency in this view, pass the same option here.

-        cell: ({ row }) => currencyFormatter(row.original.amount / 100),
+        cell: ({ row }) =>
+          currencyFormatter(row.original.amount / 100, {
+            trailingZeroDisplay: "stripIfInteger",
+          }),
...
-        cell: ({ row }) => currencyFormatter(row.original.fee / 100),
+        cell: ({ row }) =>
+          currencyFormatter(row.original.fee / 100, {
+            trailingZeroDisplay: "stripIfInteger",
+          }),
...
-        cell: ({ row }) => currencyFormatter(row.original.total / 100),
+        cell: ({ row }) =>
+          currencyFormatter(row.original.total / 100, {
+            trailingZeroDisplay: "stripIfInteger",
+          }),

Additionally (outside this hunk), consider applying the same option to tooltip and Y-axis values (Lines 272 and 283) to keep all numbers in this page consistent.

// Line 272
currencyFormatter(d.values.value / 100, { trailingZeroDisplay: "stripIfInteger" })
// Line 283
value => currencyFormatter(value / 100, { trailingZeroDisplay: "stripIfInteger" })

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

257-259: stripIfInteger likely ineffective with formatter’s fixed 2 fraction digits; pass digits here if you want $100 instead of $100.00.

currencyFormatter defaults to minimumFractionDigits: 2 and maximumFractionDigits: 2. Without overriding them, trailingZeroDisplay: "stripIfInteger" won’t hide .00. If the intent is to trim zeros in this badge, override digits locally:

-      : currencyFormatter(Number(value), {
-          trailingZeroDisplay: "stripIfInteger",
-        });
+      : currencyFormatter(Number(value), {
+          minimumFractionDigits: 0,
+          maximumFractionDigits: 2,
+          trailingZeroDisplay: "stripIfInteger",
+        });

apps/web/app/(ee)/partners.dub.co/(dashboard)/programs/[programSlug]/(enrolled)/earnings/earnings-composite-chart.tsx (1)

182-183: Optional: align tooltip formatting with header (no .00 for integers).

Header uses NumberFlow with trailingZeroDisplay: "stripIfInteger". Consider matching it in tooltip rows for consistency:

-                        {currencyFormatter((d.values.total || 0) / 100)}
+                        {currencyFormatter((d.values.total || 0) / 100, {
+                          trailingZeroDisplay: "stripIfInteger",
+                        })}

-                              {currencyFormatter(valueAccessor(d))}
+                              {currencyFormatter(valueAccessor(d), {
+                                trailingZeroDisplay: "stripIfInteger",
+                              })}

Also applies to: 204-205

packages/email/src/templates/new-sale-alert-partner.tsx (1)

58-60: Clarify preview copy: it shows commission, not sale amount.

Preview reads “You just made a {earningsInDollars} sale…”, but earningsInDollars is commission. Consider rewording to avoid confusion.

-        You just made a {earningsInDollars} sale via your referral link{" "}
+        You just earned {earningsInDollars} via your referral link{" "}

apps/web/ui/partners/bounties/bounty-performance.tsx (1)

32-39: Guard zero/invalid targets and show 0% progress.

If target is 0 or negative, value/target yields Infinity/NaN and the bar can incorrectly render as full width. Also, value && (...) hides a valid 0% bar.

-      <div className="h-1.5 w-full overflow-hidden rounded-full bg-neutral-200">
-        {value && (
+      <div className="h-1.5 w-full overflow-hidden rounded-full bg-neutral-200">
+        {typeof value === "number" && (
           <div
             style={{
-              width: Math.min(Math.max(value / target, 0), 1) * 100 + "%",
+              width:
+                (target > 0
+                  ? Math.min(Math.max(value / target, 0), 1)
+                  : 0) *
+                  100 + "%",
             }}
             className="h-full rounded-full bg-orange-600"
           />
         )}
       </div>

apps/web/app/app.dub.co/(dashboard)/[slug]/(ee)/program/payouts/payout-details-sheet.tsx (1)

86-86: Prefer a cents-to-currency helper to avoid repeated /100.

This math appears many times across the app. A tiny wrapper improves consistency and reduces chance of accidental double division.

Apply locally:

-      Total: currencyFormatter(payout.amount / 100),
+      Total: currencyFromCents(payout.amount),

Helper (outside this file):

// packages/utils/src/functions/currency-formatter.ts
export const currencyFromCents = (
  cents: number,
  options?: CurrencyFormatterOptions,
) => currencyFormatter(cents / 100, options);

apps/web/ui/partners/mark-commission-duplicate-modal.tsx (1)

82-86: Inline /100 reads well, but a shared helper is safer.

Minor DX/consistency win: reuse a currencyFromCents(...) wrapper.

-          ? currencyFormatter(commission.amount / 100)
+          ? currencyFromCents(commission.amount)
@@
-      Commission: currencyFormatter(commission.earnings / 100),
+      Commission: currencyFromCents(commission.earnings),

(See suggested helper in previous comment.)

apps/web/ui/links/link-builder/link-partner-details.tsx (1)

57-61: Nice simplification; consider a shared currencyFromCents helper.

Removes the bespoke helper and standardizes on the utils formatter. Small follow-up: use a cents wrapper to eliminate inline division and ensure consistency everywhere.

-            partner ? currencyFormatter(partner.saleAmount / 100) : undefined,
+            partner ? currencyFromCents(partner.saleAmount) : undefined,
@@
-              ? currencyFormatter(partner.totalCommissions / 100)
+              ? currencyFromCents(partner.totalCommissions)
@@
-            partner ? currencyFormatter(partner.netRevenue / 100) : undefined,
+            partner ? currencyFromCents(partner.netRevenue) : undefined,

Helper shown in the first file’s comment.

Also applies to: 64-66, 69-70

apps/web/app/(ee)/app.dub.co/invoices/[invoiceId]/domain-renewal-invoice.tsx (1)

74-86: Guard percentage calc against divide-by-zero

If invoice.amount can be 0, Math.round((invoice.fee / invoice.amount) * 100) will throw. Add a safe fallback.

-  {
-    label: `Platform fees (${Math.round((invoice.fee / invoice.amount) * 100)}%)`,
-    value: `${currencyFormatter(invoice.fee / 100)}`,
-  },
+  {
+    label: `Platform fees (${
+      invoice.amount ? Math.round((invoice.fee / invoice.amount) * 100) : 0
+    }%)`,
+    value: `${currencyFormatter(invoice.fee / 100)}`,
+  },

apps/web/ui/partners/partner-details-sheet.tsx (2)

151-157: stripIfInteger + minFractionDigits=2 still shows 1.50; set min to 0 for true “dynamic” decimals

With the utils default min/max = 2, trailingZeroDisplay: "stripIfInteger" only strips integer ".00". If you want 1.5 instead of 1.50, override minimumFractionDigits to 0.

-                : currencyFormatter(partner.saleAmount / 100, {
-                    trailingZeroDisplay: "stripIfInteger",
-                  }),
+                : currencyFormatter(partner.saleAmount / 100, {
+                    minimumFractionDigits: 0,
+                    maximumFractionDigits: 2,
+                    trailingZeroDisplay: "stripIfInteger",
+                  }),

---

388-403: Match “dynamic decimals” intent for link revenue

Same as above: override minimumFractionDigits for non-integers to avoid 1.50.

-        accessorFn: (d) =>
-          currencyFormatter(d.saleAmount / 100, {
-            trailingZeroDisplay: "stripIfInteger",
-          }),
+        accessorFn: (d) =>
+          currencyFormatter(d.saleAmount / 100, {
+            minimumFractionDigits: 0,
+            maximumFractionDigits: 2,
+            trailingZeroDisplay: "stripIfInteger",
+          }),
...
-            {currencyFormatter(row.original.saleAmount / 100, {
-              trailingZeroDisplay: "stripIfInteger",
-            })}
+            {currencyFormatter(row.original.saleAmount / 100, {
+              minimumFractionDigits: 0,
+              maximumFractionDigits: 2,
+              trailingZeroDisplay: "stripIfInteger",
+            })}

apps/web/lib/integrations/slack/transform.ts (1)

154-190: Optional: unify sale amount formatting and handle currency exponents

createSaleTemplate still hand-rolls toFixed(2) and appends the code. Consider using currencyFormatter with proper exponent handling for non-USD currencies, consistent with the invoice fix.

-  const amountInDollars = (sale.amount / 100).toFixed(2);
+  const digits = new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency: sale.currency.toUpperCase(),
+  }).resolvedOptions().maximumFractionDigits;
+  const amountInMajor = sale.amount / Math.pow(10, digits);
...
-            text: `*Amount*\n${amountInDollars} ${sale.currency.toUpperCase()}`,
+            text: `*Amount*\n${currencyFormatter(amountInMajor, {
+              currency: sale.currency.toUpperCase(),
+            })}`,

packages/utils/src/functions/currency-formatter.ts (2)

11-16: Non-USD overrides will still force 2 decimals. Prefer currency-native minor units when options.currency is provided.

Today JPY/EUR overrides would render with 2 decimals unless callers remember to set digits. Make the default smarter.

-  Intl.NumberFormat("en-US", {
-    style: "currency",
-    currency: "USD",
-    minimumFractionDigits: 2,
-    maximumFractionDigits: 2,
-    trailingZeroDisplay: "auto",
-    ...options,
-  } as CurrencyFormatterOptions).format(value);
+  {
+    const defaults: CurrencyFormatterOptions = {
+      style: "currency",
+      currency: "USD",
+      minimumFractionDigits: 2,
+      maximumFractionDigits: 2,
+      trailingZeroDisplay: "auto",
+    };
+    const merged: CurrencyFormatterOptions = { ...defaults, ...options };
+    // If caller overrides currency and didn't explicitly set fraction digits,
+    // use that currency's native minor units (defer to Intl defaults).
+    if (options?.currency &&
+        options.minimumFractionDigits === undefined &&
+        options.maximumFractionDigits === undefined) {
+      delete (merged as any).minimumFractionDigits;
+      delete (merged as any).maximumFractionDigits;
+    }
+    return new Intl.NumberFormat("en-US", merged).format(value);
+  }

---

11-16: Micro-perf: cache the default formatter.

Most calls appear to use defaults; reuse a single Intl.NumberFormat instance.

+const defaultCurrencyFormatter = new Intl.NumberFormat("en-US", {
+  style: "currency",
+  currency: "USD",
+  minimumFractionDigits: 2,
+  maximumFractionDigits: 2,
+  trailingZeroDisplay: "auto",
+} as CurrencyFormatterOptions);
+
 export const currencyFormatter = (
   value: number,
   options?: CurrencyFormatterOptions,
 ) =>
-  Intl.NumberFormat("en-US", {
-    style: "currency",
-    currency: "USD",
-    minimumFractionDigits: 2,
-    maximumFractionDigits: 2,
-    trailingZeroDisplay: "auto",
-    ...options,
-  } as CurrencyFormatterOptions).format(value);
+  (options
+    ? new Intl.NumberFormat("en-US", {
+        style: "currency",
+        currency: "USD",
+        minimumFractionDigits: 2,
+        maximumFractionDigits: 2,
+        trailingZeroDisplay: "auto",
+        ...options,
+      } as CurrencyFormatterOptions)
+    : defaultCurrencyFormatter
+  ).format(value);

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: devkiran
PR: dubinc/dub#2448
File: packages/email/src/templates/partner-program-summary.tsx:0-0
Timestamp: 2025-05-29T04:45:18.504Z
Learning: In the PartnerProgramSummary email template (packages/email/src/templates/partner-program-summary.tsx), the stat titles are hardcoded constants ("Clicks", "Leads", "Sales", "Earnings") that will always match the ICONS object keys after toLowerCase() conversion, so icon lookup failures are not possible.

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.

Learnt from: devkiran
PR: dubinc/dub#2635
File: packages/prisma/schema/payout.prisma:24-25
Timestamp: 2025-07-11T16:28:55.693Z
Learning: In the Dub codebase, multiple payout records can now share the same stripeTransferId because payouts are grouped by partner and processed as single Stripe transfers. This is why the unique constraint was removed from the stripeTransferId field in the Payout model - a single transfer can include multiple payouts for the same partner.