apps/web/app/(ee)/app.dub.co/invoices/[invoiceId]/route.tsx (2)

45-55: Add error handling for PDF generation

The PDF generation functions could throw errors that aren't currently handled. Consider wrapping these calls in try-catch blocks to provide better error reporting.

  let pdf: Buffer | null = null;

-  if (invoice.type === "partnerPayout") {
-    pdf = await PartnerPayoutInvoice({
-      invoice,
-      workspace: invoice.workspace,
-    });
-  } else if (invoice.type === "domainRenewal") {
-    pdf = await DomainRenewalInvoice({
-      invoice,
-      workspace: invoice.workspace,
-    });
-  }
+  try {
+    if (invoice.type === "partnerPayout") {
+      pdf = await PartnerPayoutInvoice({
+        invoice,
+        workspace: invoice.workspace,
+      });
+    } else if (invoice.type === "domainRenewal") {
+      pdf = await DomainRenewalInvoice({
+        invoice,
+        workspace: invoice.workspace,
+      });
+    }
+  } catch (error) {
+    throw new DubApiError({
+      code: "internal_server_error",
+      message: `Failed to generate PDF for invoice ${invoiceId}: ${error.message}`,
+    });
+  }

---

57-62: Improve error message accuracy

The error message "Invoice not found" is misleading since the invoice was successfully retrieved from the database. The actual issue is that the PDF generation failed or the invoice type is unsupported.

  if (!pdf) {
    throw new DubApiError({
      code: "bad_request",
-     message: `Invoice ${invoiceId} not found in workspace.`,
+     message: `Failed to generate PDF for invoice ${invoiceId}. Unsupported invoice type: ${invoice.type}`,
    });
  }

apps/web/lib/dynadot/set-renew-option.ts (1)

52-60: Document fire-and-forget error handling behavior

The function catches errors without re-throwing them, making this a fire-and-forget operation. Consider documenting this behavior or re-throwing critical errors after logging.

Add a comment explaining the fire-and-forget behavior:

  } catch (error) {
+    // Log error but don't throw - this is a fire-and-forget operation
+    // to avoid blocking the main workflow if Dynadot API is unavailable
    await log({
      message: `Failed to set renew option for ${domain}: ${error.message}`,
      type: "errors",
      mention: true,
    });

    console.error(error);
  }

apps/web/app/(ee)/api/stripe/webhook/charge-refunded.ts (1)

35-46: Consider type safety for registeredDomains field

The casting of invoice.registeredDomains as string[] could be unsafe if the database contains invalid data. Consider adding runtime validation.

async function processDomainRenewalInvoice({ invoice }: { invoice: Invoice }) {
- const domains = invoice.registeredDomains as string[];
+ const domains = Array.isArray(invoice.registeredDomains) 
+   ? invoice.registeredDomains.filter((domain): domain is string => typeof domain === 'string')
+   : [];

+ if (domains.length === 0) {
+   console.log(`No valid domains found in invoice ${invoice.id}`);
+   return;
+ }

  await Promise.allSettled(
    domains.map((domain) =>
      setRenewOption({
        domain,
        autoRenew: false,
      }),
    ),
  );
}

packages/email/src/templates/domain-renewal-failed.tsx (1)

80-85: Fix domain link URLs

The domain links only use the slug as the href, which won't form valid URLs. They should include the protocol.

                     <Link
-                      href={domain.slug}
+                      href={`https://${domain.slug}`}
                       className="font-semibold text-black underline"
                     >
                       {domain.slug}
                     </Link>

packages/email/src/templates/domain-renewed.tsx (1)

68-73: Fix domain link URLs

Similar to the renewal failed template, the domain links only use the slug without the protocol, which won't form valid URLs.

                      <Link
-                        href={domain.slug}
+                        href={`https://${domain.slug}`}
                        className="font-semibold text-black underline"
                      >
                        {domain.slug}
                      </Link>

apps/web/app/(ee)/api/cron/domains/renewal-reminders/route.ts (2)

38-46: Use addDays for clarity

Using subDays with a negative value is confusing. Use addDays for better readability.

    const targetDates = REMINDER_WINDOWS.map((days) => {
-      const date = subDays(now, -days);
+      const date = addDays(now, days);

      return {
        start: startOfDay(date),
        end: endOfDay(date),
        days,
      };
    });

---

111-125: Add error handling for batch email sending

The batch send operation could partially fail. Consider adding error handling to track which emails failed.

    for (const reminderDomainsChunk of reminderDomainsChunks) {
-      await resend.batch.send(
-        reminderDomainsChunk.map(({ workspace, user, domain }) => ({
-          from: VARIANT_TO_FROM_MAP.notifications,
-          to: user.email!,
-          subject: "Your domain is expiring soon",
-          variant: "notifications",
-          react: DomainRenewalReminder({
-            email: user.email!,
-            workspace,
-            domain,
-          }),
-        })),
-      );
+      try {
+        await resend.batch.send(
+          reminderDomainsChunk.map(({ workspace, user, domain }) => ({
+            from: VARIANT_TO_FROM_MAP.notifications,
+            to: user.email!,
+            subject: "Your domain is expiring soon",
+            variant: "notifications",
+            react: DomainRenewalReminder({
+              email: user.email!,
+              workspace,
+              domain,
+            }),
+          })),
+        );
+      } catch (error) {
+        await log({
+          message: `Failed to send batch reminder emails: ${error.message}`,
+          type: "errors",
+        });
+        // Continue with next batch
+      }
    }

packages/email/src/templates/domain-expired.tsx (1)

83-83: Fix the domain link href to use absolute URL

The href attribute should use an absolute URL with protocol, not just the domain slug. This will create a relative link instead of linking to the actual domain.

-                        href={domain.slug}
+                        href={`https://${domain.slug}`}

packages/email/src/templates/domain-renewal-reminder.tsx (1)

62-62: Fix the domain link href to use absolute URL

The href attribute should use an absolute URL with protocol for proper linking to the domain.

-                href={domain.slug}
+                href={`https://${domain.slug}`}

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

37-47: Add type validation for registeredDomains

The code assumes invoice.registeredDomains is a string array, but the schema defines it as Json?. Consider adding runtime validation or type assertions.

+  // Validate registeredDomains is an array of strings
+  const domainSlugs = Array.isArray(invoice.registeredDomains) 
+    ? invoice.registeredDomains.filter((d): d is string => typeof d === 'string')
+    : [];
+
   const domains = await prisma.registeredDomain.findMany({
     where: {
       slug: {
-        in: invoice.registeredDomains as string[],
+        in: domainSlugs,
       },
     },
     select: {
       slug: true,
       renewalFee: true,
     },
   });

---

111-111: Prevent division by zero error

The platform fee percentage calculation could throw a division by zero error if invoice.amount is 0.

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

apps/web/ui/modals/domain-auto-renewal-modal.tsx (2)

66-68: Add runtime guard for optional registeredDomain before using expiresAt and renewalFee

The DomainProps definition marks registeredDomain as optional, so it's possible for domain.registeredDomain to be undefined. Your current code extracts properties without first checking that registeredDomain exists.

Add a guard before extracting properties:

+  if (!domain.registeredDomain) {
+    return (
+      <Modal
+        showModal={showDomainAutoRenewalModal}
+        setShowModal={setShowDomainAutoRenewalModal}
+      >
+        <div className="p-6 text-center">
+          <p className="text-sm text-neutral-600">
+            This domain is not registered and cannot be renewed.
+          </p>
+        </div>
+      </Modal>
+    );
+  }
+
   const isEnabling = enableAutoRenewal;
   const expiresAt = domain.registeredDomain?.expiresAt;
   const renewalFee = domain.registeredDomain?.renewalFee;

---

82-100: Remove non-null assertions after adding proper null checks

Lines 86-87 and 93 use non-null assertions (!) which could cause runtime errors if the values are undefined. After adding the null check for registeredDomain suggested above, these assertions become safe to use.

Once the guard is in place, update the code to remove the assertions:

           {isEnabling ? (
             <>
               By enabling auto-renewal, Dub will automatically renew your domain
-              on <strong>{formatDate(expiresAt!)}</strong> for{" "}
-              {currencyFormatter(renewalFee! / 100)}.
+              on <strong>{formatDate(expiresAt)}</strong> for{" "}
+              {currencyFormatter(renewalFee / 100)}.
             </>
           ) : (
             <>
               By disabling auto-renewal, your domain{" "}
               <strong>{domain.slug}</strong> will expire on{" "}
-              <strong>{formatDate(expiresAt!)}</strong>.
+              <strong>{formatDate(expiresAt)}</strong>.

apps/web/lib/stripe/create-payment-intent.ts (1)

31-41: Improve error handling consistency

The current implementation returns early without proper error responses, while the main try-catch block uses structured logging. This creates inconsistent error handling.

   if (cards.data.length === 0 && links.data.length === 0) {
-    console.error(`No valid payment methods found for customer ${stripeId}.`);
-    return;
+    const errorMsg = `No valid payment methods found for customer ${stripeId}.`;
+    console.error(errorMsg);
+    await log({
+      message: errorMsg,
+      type: "errors",
+      mention: true,
+    });
+    throw new Error(errorMsg);
   }

   const paymentMethod = cards.data[0] || links.data[0];

   if (!paymentMethod) {
-    console.error(`No valid payment method found for customer ${stripeId}.`);
-    return;
+    const errorMsg = `No valid payment method found for customer ${stripeId}.`;
+    console.error(errorMsg);
+    await log({
+      message: errorMsg,
+      type: "errors", 
+      mention: true,
+    });
+    throw new Error(errorMsg);
   }

apps/web/app/(ee)/api/cron/domains/renewal-payments/route.ts (1)

141-146: Ensure safe error message extraction

The error might not have a message property. Use a type guard or fallback.

   } catch (error) {
     await log({
-      message: "Domains renewal cron failed. Error: " + error.message,
+      message: "Domains renewal cron failed. Error: " + (error instanceof Error ? error.message : String(error)),
       type: "errors",
     });

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

151-151: Prevent potential division by zero

The platform fee percentage calculation could result in division by zero if invoice.amount is 0.

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

apps/web/app/(ee)/api/stripe/webhook/charge-failed.ts (1)

182-182: Use consistent amount source for payout emails

The email uses charge.amount instead of invoice.amount. This could lead to inconsistencies if there are currency conversions or processing fees.

apps/web/app/(ee)/api/stripe/webhook/charge-succeeded.ts (1)

155-169: Add error handling for email sending

The email sending operation lacks error handling, which could cause silent failures.

apps/web/lib/stripe/create-payment-intent.ts (1)

58-63: Simplify idempotency key handling

The conditional object spread can be simplified for better readability.

       },
-      {
-        ...(idempotencyKey
-          ? {
-              idempotencyKey,
-            }
-          : {}),
-      },
+      idempotencyKey ? { idempotencyKey } : undefined,

apps/web/app/(ee)/api/cron/domains/renewal-payments/route.ts (1)

129-131: Remove unnecessary non-null assertion.

The stripeId is already verified to exist before this point, so the non-null assertion is redundant.

       await createPaymentIntent({
-        stripeId: workspace.stripeId!,
+        stripeId: workspace.stripeId,
         amount: invoice.total,

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

34-34: Consider making the renewal fee configurable.

The renewal fee is hardcoded to 1200 ($12). This might need to be configurable in the future to support different pricing tiers or promotional rates.

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

77-93: Simplify period calculation logic.

The reduce operations for finding earliest and latest periods could be simplified for better readability.

-  const earliestPeriodStart = payouts.reduce(
-    (acc, payout) => {
-      if (!acc) return payout.periodStart;
-      if (!payout.periodStart) return acc;
-      return payout.periodStart < (acc as Date) ? payout.periodStart : acc;
-    },
-    null as Date | null,
-  );
+  const validPeriodStarts = payouts
+    .map(p => p.periodStart)
+    .filter((d): d is Date => d !== null);
+  const earliestPeriodStart = validPeriodStarts.length > 0
+    ? new Date(Math.min(...validPeriodStarts.map(d => d.getTime())))
+    : null;

-  const latestPeriodEnd = payouts.reduce(
-    (acc, payout) => {
-      if (!acc) return payout.periodEnd;
-      if (!payout.periodEnd) return acc;
-      return payout.periodEnd > (acc as Date) ? payout.periodEnd : acc;
-    },
-    null as Date | null,
-  );
+  const validPeriodEnds = payouts
+    .map(p => p.periodEnd)
+    .filter((d): d is Date => d !== null);
+  const latestPeriodEnd = validPeriodEnds.length > 0
+    ? new Date(Math.max(...validPeriodEnds.map(d => d.getTime())))
+    : null;

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

Learnt from: steven-tey
PR: dubinc/dub#0
File: :0-0
Timestamp: 2025-06-19T01:46:45.723Z
Learning: PayPal webhook verification in the Dub codebase is handled at the route level in `apps/web/app/(ee)/api/paypal/webhook/route.ts` using the `verifySignature` function. Individual webhook handlers like `payoutsItemFailed` don't need to re-verify signatures since they're only called after successful verification.

Learnt from: devkiran
PR: dubinc/dub#2637
File: apps/web/app/(ee)/api/singular/webhook/route.ts:0-0
Timestamp: 2025-07-17T06:41:45.620Z
Learning: In the Singular integration (apps/web/app/(ee)/api/singular/webhook/route.ts), the event names in the singularToDubEvent object have intentionally different casing: "Copy GAID" and "copy IDFA". This casing difference is valid and should not be changed, as these are the correct event names expected from Singular.

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#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: 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.

Learnt from: devkiran
PR: dubinc/dub#2433
File: apps/web/ui/modals/add-payment-method-modal.tsx:60-62
Timestamp: 2025-05-29T09:49:19.604Z
Learning: The `/api/workspaces/${slug}/billing/payment-methods` POST endpoint in the billing API returns either an error (handled by response.ok check) or a response object containing a `url` property for successful requests.

Learnt from: devkiran
PR: dubinc/dub#2433
File: apps/web/app/api/workspaces/[idOrSlug]/billing/payment-methods/route.ts:74-76
Timestamp: 2025-05-29T09:47:33.583Z
Learning: When Zod enum validation is used (e.g., `z.enum(PAYMENT_METHOD_TYPES)`), it ensures the validated value is one of the valid enum values, making subsequent type casts to the corresponding TypeScript types safe without additional validation.

Learnt from: TWilson023
PR: dubinc/dub#2673
File: apps/web/ui/partners/rewards/add-edit-reward-sheet.tsx:56-66
Timestamp: 2025-07-30T15:25:13.936Z
Learning: In apps/web/ui/partners/rewards/add-edit-reward-sheet.tsx, the form schema uses partial condition objects to allow users to add empty/unconfigured condition fields without type errors, while submission validation uses strict schemas to ensure data integrity. This two-stage validation pattern improves UX by allowing progressive completion of complex forms.

Learnt from: devkiran
PR: dubinc/dub#2177
File: apps/web/lib/api/links/bulk-create-links.ts:66-84
Timestamp: 2025-06-06T07:59:03.120Z
Learning: In apps/web/lib/api/links/bulk-create-links.ts, the team accepts the risk of potential undefined results from links.find() operations when building invalidLinks arrays, because existing links are fetched from the database based on the input links, so matches are expected to always exist.

Learnt from: TWilson023
PR: dubinc/dub#2614
File: apps/web/ui/partners/design/previews/lander-preview.tsx:181-181
Timestamp: 2025-07-09T20:52:56.592Z
Learning: In apps/web/ui/partners/design/previews/lander-preview.tsx, the ellipsis wave animation delay calculation `3 - i * -0.15` is intentionally designed to create negative delays that offset each dot's animation cycle. This pattern works correctly for the intended ellipsis effect and should not be changed to positive incremental delays.

Learnt from: TWilson023
PR: dubinc/dub#2538
File: apps/web/ui/partners/overview/blocks/commissions-block.tsx:16-27
Timestamp: 2025-06-18T20:26:25.177Z
Learning: In the Dub codebase, components that use workspace data (workspaceId, defaultProgramId) are wrapped in `WorkspaceAuth` which ensures these values are always available, making non-null assertions safe. This is acknowledged as a common pattern in their codebase, though not ideal.

Learnt from: devkiran
PR: dubinc/dub#2448
File: packages/email/src/templates/partner-program-summary.tsx:254-254
Timestamp: 2025-05-29T04:49:42.842Z
Learning: In the Dub codebase, it's acceptable to keep `partners.dub.co` hardcoded rather than making it configurable for different environments.

apps/web/app/(ee)/api/stripe/webhook/charge-failed.ts (1)

161-161: Use consistent amount source for payout emails

The email uses charge.amount instead of invoice.amount. This could lead to inconsistencies if there are currency conversions or processing fees.

-          amount: charge.amount,
+          amount: invoice.amount,

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

Learnt from: steven-tey
PR: dubinc/dub#0
File: :0-0
Timestamp: 2025-06-19T01:46:45.723Z
Learning: PayPal webhook verification in the Dub codebase is handled at the route level in `apps/web/app/(ee)/api/paypal/webhook/route.ts` using the `verifySignature` function. Individual webhook handlers like `payoutsItemFailed` don't need to re-verify signatures since they're only called after successful verification.

Learnt from: devkiran
PR: dubinc/dub#2433
File: apps/web/ui/modals/add-payment-method-modal.tsx:60-62
Timestamp: 2025-05-29T09:49:19.604Z
Learning: The `/api/workspaces/${slug}/billing/payment-methods` POST endpoint in the billing API returns either an error (handled by response.ok check) or a response object containing a `url` property for successful requests.