cleanup code

Author: icecrasher321

apps/sim/app/api/organizations/[id]/seats/route.ts

@@ -13,6 +13,8 @@ import {
   hasUsableSubscriptionStatus,
   USABLE_SUBSCRIPTION_STATUSES,
 } from '@/lib/billing/subscriptions/utils'
+import { toDecimal, toNumber } from '@/lib/billing/utils/decimal'
+import { syncSeatsFromStripeQuantity } from '@/lib/billing/validation/seat-management'
 import { isBillingEnabled } from '@/lib/core/config/feature-flags'
 
 const logger = createLogger('OrganizationSeatsAPI')
@@ -164,8 +166,6 @@ export async function PUT(request: NextRequest, { params }: { params: Promise<{
       userId: session.user.id,
     })
 
-    // Update the subscription item quantity using Stripe's recommended approach
-    // This will automatically prorate the billing
     const updatedSubscription = await stripe.subscriptions.update(
       orgSubscription.stripeSubscriptionId,
       {
@@ -176,19 +176,16 @@ export async function PUT(request: NextRequest, { params }: { params: Promise<{
           },
         ],
         proration_behavior: 'always_invoice',
-      }
+      },
+      { idempotencyKey: `seats-update:${orgSubscription.stripeSubscriptionId}:${newSeatCount}` }
     )
 
-    // Update our local database to reflect the change
-    // Note: This will also be updated via webhook, but we update immediately for UX
-    await db
-      .update(subscription)
-      .set({
-        seats: newSeatCount,
-      })
-      .where(eq(subscription.id, orgSubscription.id))
+    await syncSeatsFromStripeQuantity(
+      orgSubscription.id,
+      orgSubscription.seats,
+      updatedSubscription.items.data[0]?.quantity ?? newSeatCount
+    )
 
-    // Update orgUsageLimit to reflect new seat count (seats × basePrice as minimum)
     const { basePrice } = getPlanPricing(orgSubscription.plan)
     const newMinimumLimit = newSeatCount * basePrice
 
@@ -200,7 +197,7 @@ export async function PUT(request: NextRequest, { params }: { params: Promise<{
 
     const currentOrgLimit =
       orgData.length > 0 && orgData[0].orgUsageLimit
-        ? Number.parseFloat(orgData[0].orgUsageLimit)
+        ? toNumber(toDecimal(orgData[0].orgUsageLimit))
         : 0
 
     // Update if new minimum is higher than current limit

apps/sim/app/api/v1/admin/subscriptions/[id]/route.ts

@@ -134,10 +134,11 @@ export const DELETE = withAdminAuthParams<RouteParams>(async (request, context)
     // (overage bill, usage reset, Pro restore, org delete) via
     // `handleSubscriptionDeleted`, so no outbox needed here.
     const stripe = requireStripeClient()
-    await stripe.subscriptions.cancel(existing.stripeSubscriptionId, {
-      prorate: true,
-      invoice_now: true,
-    })
+    await stripe.subscriptions.cancel(
+      existing.stripeSubscriptionId,
+      { prorate: true, invoice_now: true },
+      { idempotencyKey: `admin-cancel:${existing.stripeSubscriptionId}` }
+    )
 
     logger.info('Admin API: Triggered immediate subscription cancellation on Stripe', {
       subscriptionId,

apps/sim/lib/billing/authorization.ts

@@ -1,8 +1,6 @@
-import { db } from '@sim/db'
-import * as schema from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
-import { and, eq } from 'drizzle-orm'
 import { hasPaidSubscription } from '@/lib/billing'
+import { isOrganizationOwnerOrAdmin } from '@/lib/billing/core/organization'
 import { isOrgScopedSubscription } from '@/lib/billing/subscriptions/utils'
 
 const logger = createLogger('BillingAuthorization')
@@ -24,14 +22,10 @@ export async function authorizeSubscriptionReference(
   referenceId: string,
   action?: string
 ): Promise<boolean> {
-  // `isOrgScopedSubscription` returns `false` when referenceId === userId,
-  // which is exactly the "personal subscription" case we want to allow
-  // without further checks.
   if (!isOrgScopedSubscription({ referenceId }, userId)) {
     return true
   }
 
-  // Only block duplicate subscriptions during upgrade/checkout, not cancel/restore/list
   if (action === 'upgrade-subscription' && (await hasPaidSubscription(referenceId))) {
     logger.warn('Blocking checkout - active subscription already exists for organization', {
       userId,
@@ -40,12 +34,5 @@ export async function authorizeSubscriptionReference(
     return false
   }
 
-  const members = await db
-    .select()
-    .from(schema.member)
-    .where(and(eq(schema.member.userId, userId), eq(schema.member.organizationId, referenceId)))
-
-  const member = members[0]
-
-  return member?.role === 'owner' || member?.role === 'admin'
+  return isOrganizationOwnerOrAdmin(userId, referenceId)
 }

apps/sim/lib/billing/calculations/usage-monitor.ts

@@ -1,18 +1,19 @@
 import { db } from '@sim/db'
 import { member, userStats } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
-import { and, eq, inArray } from 'drizzle-orm'
+import { and, eq } from 'drizzle-orm'
 import {
   getHighestPrioritySubscription,
   type HighestPrioritySubscription,
 } from '@/lib/billing/core/plan'
-import { getUserUsageLimit } from '@/lib/billing/core/usage'
+import { getPooledOrgCurrentPeriodCost, getUserUsageLimit } from '@/lib/billing/core/usage'
 import {
   computeDailyRefreshConsumed,
   getOrgMemberRefreshBounds,
 } from '@/lib/billing/credits/daily-refresh'
 import { getPlanTierDollars, isPaid } from '@/lib/billing/plan-helpers'
 import { isOrgScopedSubscription } from '@/lib/billing/subscriptions/utils'
+import { toDecimal, toNumber } from '@/lib/billing/utils/decimal'
 import { isBillingEnabled } from '@/lib/core/config/feature-flags'
 import { toError } from '@/lib/core/utils/helpers'
 
@@ -50,23 +51,10 @@ async function computePooledOrgUsage(
     periodEnd: Date | null
   }
 ): Promise<number> {
-  const teamMembers = await db
-    .select({ userId: member.userId })
-    .from(member)
-    .where(eq(member.organizationId, organizationId))
-
-  if (teamMembers.length === 0) return 0
-
-  const memberIds = teamMembers.map((tm) => tm.userId)
-  const memberStatsRows = await db
-    .select({ current: userStats.currentPeriodCost, total: userStats.totalCost })
-    .from(userStats)
-    .where(inArray(userStats.userId, memberIds))
-
-  let pooled = 0
-  for (const stats of memberStatsRows) {
-    pooled += Number.parseFloat(stats.current?.toString() || stats.total.toString())
-  }
+  const { memberIds, currentPeriodCost } = await getPooledOrgCurrentPeriodCost(organizationId)
+  if (memberIds.length === 0) return 0
+
+  let pooled = currentPeriodCost
 
   if (isPaid(sub.plan) && sub.periodStart) {
     const planDollars = getPlanTierDollars(sub.plan)
@@ -99,9 +87,7 @@ export async function checkUsageStatus(
     if (!isBillingEnabled) {
       const statsRecords = await db.select().from(userStats).where(eq(userStats.userId, userId))
       const currentUsage =
-        statsRecords.length > 0
-          ? Number.parseFloat(statsRecords[0].currentPeriodCost?.toString())
-          : 0
+        statsRecords.length > 0 ? toNumber(toDecimal(statsRecords[0].currentPeriodCost)) : 0
 
       return {
         percentUsed: Math.min((currentUsage / 1000) * 100, 100),
@@ -150,9 +136,7 @@ export async function checkUsageStatus(
         }
       }
 
-      const rawUsage = Number.parseFloat(
-        statsRecords[0].currentPeriodCost?.toString() || statsRecords[0].totalCost.toString()
-      )
+      const rawUsage = toNumber(toDecimal(statsRecords[0].currentPeriodCost))
 
       let refresh = 0
       if (sub && isPaid(sub.plan) && sub.periodStart) {
@@ -296,16 +280,12 @@ export async function checkServerSideUsageLimits(
         blocked: userStats.billingBlocked,
         blockedReason: userStats.billingBlockedReason,
         current: userStats.currentPeriodCost,
-        total: userStats.totalCost,
       })
       .from(userStats)
       .where(eq(userStats.userId, userId))
       .limit(1)
 
-    const currentUsage =
-      stats.length > 0
-        ? Number.parseFloat(stats[0].current?.toString() || stats[0].total.toString())
-        : 0
+    const currentUsage = stats.length > 0 ? toNumber(toDecimal(stats[0].current)) : 0
 
     if (stats.length > 0 && stats[0].blocked) {
       const message =

apps/sim/lib/billing/core/billing.ts

@@ -29,7 +29,13 @@ import { createLogger } from '@sim/logger'
 const logger = createLogger('Billing')
 
 /**
- * Get organization subscription directly by organization ID
+ * Get the organization's subscription row when its status is one of
+ * `ENTITLED_SUBSCRIPTION_STATUSES` (includes `past_due`). Use this
+ * when making billing-side decisions (overage math, limit reads,
+ * webhooks) where `past_due` still counts as an active paid tenant.
+ * For product-access gating use `getOrganizationSubscriptionUsable`
+ * (from `core/subscription.ts`), which excludes `past_due`.
+ * Returns `null` when there is no entitled sub.
  */
 export async function getOrganizationSubscription(organizationId: string) {
   try {
@@ -83,6 +89,13 @@ export async function isSubscriptionOrgScoped(sub: { referenceId: string }): Pro
  * query. Used by org-scoped summary and overage calculations so we don't
  * call `getUserUsageData` per-member — that helper now returns the entire
  * pool for org-scoped subs, which would N-times-count the usage.
+ *
+ * The `currentPeriodCost` sum here is semantically identical to
+ * `getPooledOrgCurrentPeriodCost` (same `LEFT JOIN` + `toDecimal`
+ * null handling); this helper bundles the copilot fields in the same
+ * round-trip. Never fall back to lifetime `totalCost` on nulls — the
+ * column is `NOT NULL DEFAULT '0'` and mixing scopes would break
+ * current-period billing math.
  */
 async function aggregateOrgMemberStats(organizationId: string): Promise<{
   memberIds: string[]
@@ -123,6 +136,54 @@ async function aggregateOrgMemberStats(organizationId: string): Promise<{
   }
 }
 
+/**
+ * Compute an org's overage amount from already-fetched pool/departed
+ * inputs. Internally performs one daily-refresh DB read to subtract
+ * refresh credits; callers are expected to have already loaded the
+ * pooled `currentPeriodCost` and `departedMemberUsage` (threshold
+ * billing passes lock-held values; `calculateSubscriptionOverage`
+ * passes lockless values from `aggregateOrgMemberStats`). Both
+ * callers route through this to keep the overage math in one place.
+ */
+export async function computeOrgOverageAmount(params: {
+  plan: string | null
+  seats: number | null
+  periodStart: Date | null
+  periodEnd: Date | null
+  organizationId: string
+  pooledCurrentPeriodCost: number
+  departedMemberUsage: number
+  memberIds: string[]
+}): Promise<{
+  effectiveUsage: number
+  baseSubscriptionAmount: number
+  dailyRefreshDeduction: number
+  totalOverage: number
+}> {
+  const totalUsage = params.pooledCurrentPeriodCost + params.departedMemberUsage
+
+  let dailyRefreshDeduction = 0
+  const planDollars = getPlanTierDollars(params.plan)
+  if (planDollars > 0 && params.periodStart && params.memberIds.length > 0) {
+    const userBounds = await getOrgMemberRefreshBounds(params.organizationId, params.periodStart)
+    dailyRefreshDeduction = await computeDailyRefreshConsumed({
+      userIds: params.memberIds,
+      periodStart: params.periodStart,
+      periodEnd: params.periodEnd ?? null,
+      planDollars,
+      seats: params.seats || 1,
+      userBounds: Object.keys(userBounds).length > 0 ? userBounds : undefined,
+    })
+  }
+
+  const effectiveUsage = Math.max(0, totalUsage - dailyRefreshDeduction)
+  const { basePrice } = getPlanPricing(params.plan ?? '')
+  const baseSubscriptionAmount = (params.seats || 1) * basePrice
+  const totalOverage = Math.max(0, effectiveUsage - baseSubscriptionAmount)
+
+  return { effectiveUsage, baseSubscriptionAmount, dailyRefreshDeduction, totalOverage }
+}
+
 /**
  * Calculate overage amount for a subscription
  * Shared logic between invoice.finalized and customer.subscription.deleted handlers
@@ -150,49 +211,38 @@ export async function calculateSubscriptionOverage(sub: {
 
   if (isOrgScoped) {
     const pooled = await aggregateOrgMemberStats(sub.referenceId)
-    const totalTeamUsageDecimal = toDecimal(pooled.currentPeriodCost)
 
     const orgData = await db
       .select({ departedMemberUsage: organization.departedMemberUsage })
       .from(organization)
       .where(eq(organization.id, sub.referenceId))
       .limit(1)
 
-    const departedUsageDecimal =
-      orgData.length > 0 ? toDecimal(orgData[0].departedMemberUsage) : new Decimal(0)
-
-    const totalUsageWithDepartedDecimal = totalTeamUsageDecimal.plus(departedUsageDecimal)
+    const departedMemberUsage =
+      orgData.length > 0 ? toNumber(toDecimal(orgData[0].departedMemberUsage)) : 0
 
-    let dailyRefreshDeduction = 0
-    const planDollars = getPlanTierDollars(sub.plan)
-    if (planDollars > 0 && sub.periodStart) {
-      const userBounds = await getOrgMemberRefreshBounds(sub.referenceId, sub.periodStart)
-      dailyRefreshDeduction = await computeDailyRefreshConsumed({
-        userIds: pooled.memberIds,
-        periodStart: sub.periodStart,
-        periodEnd: sub.periodEnd ?? null,
-        planDollars,
-        seats: sub.seats || 1,
-        userBounds: Object.keys(userBounds).length > 0 ? userBounds : undefined,
-      })
-    }
+    const { totalOverage, effectiveUsage, baseSubscriptionAmount } = await computeOrgOverageAmount({
+      plan: sub.plan,
+      seats: sub.seats ?? null,
+      periodStart: sub.periodStart ?? null,
+      periodEnd: sub.periodEnd ?? null,
+      organizationId: sub.referenceId,
+      pooledCurrentPeriodCost: pooled.currentPeriodCost,
+      departedMemberUsage,
+      memberIds: pooled.memberIds,
+    })
 
-    const effectiveUsageDecimal = Decimal.max(
-      0,
-      totalUsageWithDepartedDecimal.minus(toDecimal(dailyRefreshDeduction))
-    )
-    const { basePrice } = getPlanPricing(sub.plan ?? '')
-    const baseSubscriptionAmount = (sub.seats || 1) * basePrice
-    totalOverageDecimal = Decimal.max(0, effectiveUsageDecimal.minus(baseSubscriptionAmount))
+    totalOverageDecimal = toDecimal(totalOverage)
 
     logger.info('Calculated org-scoped overage', {
       subscriptionId: sub.id,
       plan: sub.plan,
-      currentMemberUsage: toNumber(totalTeamUsageDecimal),
-      departedMemberUsage: toNumber(departedUsageDecimal),
-      totalUsage: toNumber(totalUsageWithDepartedDecimal),
+      currentMemberUsage: pooled.currentPeriodCost,
+      departedMemberUsage,
+      totalUsage: pooled.currentPeriodCost + departedMemberUsage,
+      effectiveUsage,
       baseSubscriptionAmount,
-      totalOverage: toNumber(totalOverageDecimal),
+      totalOverage,
     })
   } else if (isPro(sub.plan)) {
     // Read user_stats directly (not via `getUserUsageData`). Priority