apps/web/app/(ee)/api/stripe/webhook/customer-subscription-updated.ts (1)

65-69: LGTM, plus one defensive improvement suggestion.
The delegation is correct. Consider guarding priceId extraction to avoid undefined when subscription has multiple items/add-ons. Example (elsewhere in this file where priceId is read): prefer a recurring item and bail if none is found.

const priceId =
  subscriptionUpdated.items.data.find((i) => i.price?.type === "recurring")
    ?.price?.id;
if (!priceId) {
  console.log(`No recurring price on subscription ${subscriptionUpdated.id}`);
  return;
}

apps/web/app/(ee)/api/stripe/webhook/utils.ts (2)

80-116: Avoid allSettled for core DB mutations to prevent partial state.
project.update and restrictedToken.updateMany should succeed or fail together; cache expiry can remain best-effort.

-    await Promise.allSettled([
-      prisma.project.update({
+    await Promise.all([
+      prisma.project.update({
         where: {
           id: workspace.id,
         },
         data: {
           plan: newPlanName,
           usageLimit: plan.limits.clicks!,
           linksLimit: plan.limits.links!,
           payoutsLimit: plan.limits.payouts!,
           domainsLimit: plan.limits.domains!,
           aiLimit: plan.limits.ai!,
           tagsLimit: plan.limits.tags!,
           foldersLimit: plan.limits.folders!,
           groupsLimit: plan.limits.groups!,
           usersLimit: plan.limits.users!,
           paymentFailedAt: null,
           ...(shouldDeleteFolders && { foldersUsage: 0 }),
         },
       }),
-
-      prisma.restrictedToken.updateMany({
+      prisma.restrictedToken.updateMany({
         where: {
           projectId: workspace.id,
         },
         data: {
           rateLimit: plan.limits.api,
         },
       }),
-
-      // expire tokens cache
-      tokenCache.expireMany({
-        hashedKeys: workspace.restrictedTokens.map(
-          ({ hashedKey }) => hashedKey,
-        ),
-      }),
-    ]);
+    ]);
+    // expire tokens cache (best-effort)
+    await tokenCache.expireMany({
+      hashedKeys: workspace.restrictedTokens.map(({ hashedKey }) => hashedKey),
+    });

---

69-70: Derive webhook capability from plan metadata instead of name, if possible.
If available, prefer a plan capability flag (e.g., plan.features.webhooks) over string matching "free"/"pro" to future-proof.

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)/api/stripe/webhook/utils.ts (1)

68-71: Folder clean-up condition fixed — matches original intent.

Using workspace.foldersUsage > 0 for Free downgrades is correct and avoids unnecessary deletes when there are no folders.

apps/web/app/(ee)/api/stripe/webhook/utils.ts (3)

119-140: Reduce one DB write: include webhookEnabled in the primary project update.

You already know whether webhooks should be disabled. Fold this into the first update, then keep webhook.updateMany + cache refresh.

         data: {
           plan: newPlanName,
           usageLimit: plan.limits.clicks!,
           linksLimit: plan.limits.links!,
           payoutsLimit: plan.limits.payouts!,
           domainsLimit: plan.limits.domains!,
           aiLimit: plan.limits.ai!,
           tagsLimit: plan.limits.tags!,
           foldersLimit: plan.limits.folders!,
           groupsLimit: plan.limits.groups!,
           usersLimit: plan.limits.users!,
           paymentFailedAt: null,
+          ...(shouldDisableWebhooks && { webhookEnabled: false }),
         },

-    if (shouldDisableWebhooks) {
-      await Promise.all([
-        prisma.project.update({
-          where: {
-            id: workspace.id,
-          },
-          data: {
-            webhookEnabled: false,
-          },
-        }),
-
-        prisma.webhook.updateMany({
+    if (shouldDisableWebhooks) {
+      await prisma.webhook.updateMany({
         where: {
           projectId: workspace.id,
         },
         data: {
           disabledAt: new Date(),
         },
-        }),
-      ]);
+      });

Also applies to: 86-99

---

61-63: Use a type-only import for typing to avoid pulling code at runtime.

Minor build hygiene: import getPlanFromPriceId as a type.

-import { getPlanFromPriceId, LEGACY_PRICE_IDS } from "@dub/utils";
+import { LEGACY_PRICE_IDS } from "@dub/utils";
+import type { getPlanFromPriceId } from "@dub/utils";

Also applies to: 7-7

---

52-60: Clarify the workspace param type with a named alias.

Define a WorkspaceForPlanUpdate type for reuse and readability instead of an inline Pick & intersection.

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)/api/stripe/webhook/utils.ts (2)

81-118: Avoid masking failures; use a DB transaction and expire caches after.

Promise.allSettled can leave partial DB state. Make the two Prisma writes atomic and expire token cache only on success.

-    await Promise.allSettled([
-      prisma.project.update({
+    await prisma.$transaction([
+      prisma.project.update({
         where: {
           id: workspace.id,
         },
         data: {
           plan: newPlanName,
           usageLimit: plan.limits.clicks!,
           linksLimit: plan.limits.links!,
           payoutsLimit: plan.limits.payouts!,
           domainsLimit: plan.limits.domains!,
           aiLimit: plan.limits.ai!,
           tagsLimit: plan.limits.tags!,
           foldersLimit: plan.limits.folders!,
           groupsLimit: plan.limits.groups!,
           usersLimit: plan.limits.users!,
           paymentFailedAt: null,
-          ...(shouldDeleteFolders && { foldersUsage: 0 }),
         },
       }),
 
-      prisma.restrictedToken.updateMany({
+      prisma.restrictedToken.updateMany({
         where: {
           projectId: workspace.id,
         },
         data: {
           rateLimit: plan.limits.api,
         },
       }),
-
-      // expire tokens cache
-      tokenCache.expireMany({
-        hashedKeys: workspace.restrictedTokens.map(
-          ({ hashedKey }) => hashedKey,
-        ),
-      }),
     ]);
+
+    // expire tokens cache (non-DB)
+    await tokenCache.expireMany({
+      hashedKeys: workspace.restrictedTokens.map(({ hashedKey }) => hashedKey),
+    });

---

98-99: Don’t zero foldersUsage before deletion; update it after deletes succeed.

Zeroing early risks inconsistent stats if deletion fails.

@@
-          ...(shouldDeleteFolders && { foldersUsage: 0 }),
@@
-    if (shouldDeleteFolders) {
-      await deleteWorkspaceFolders({
-        workspaceId: workspace.id,
-      });
-    }
+    if (shouldDeleteFolders) {
+      await deleteWorkspaceFolders({ workspaceId: workspace.id });
+      await prisma.project.update({
+        where: { id: workspace.id },
+        data: { foldersUsage: 0 },
+      });
+    }

Also applies to: 160-164

apps/web/app/(ee)/api/stripe/webhook/customer-subscription-updated.ts (1)

65-69: Plan update centralization: looks good; consider retry-safety.

Delegation to updateWorkspacePlan is the right move. Minor: wrap in try/catch to log context (event.id, workspace.id) so Stripe retries are diagnosable.

Example:

-  await updateWorkspacePlan({
+  try {
+    await updateWorkspacePlan({
       workspace,
       plan,
       priceId,
-  });
+    });
+  } catch (err) {
+    console.error("customer.subscription.updated failed", {
+      eventId: event.id,
+      stripeId,
+      priceId,
+      err,
+    });
+    throw err; // let Stripe retry
+  }

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.