fix(billing): make usage-limit self-heal best-effort and respect concurrent writes

Author: waleedlatif1

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

@@ -102,6 +102,7 @@ describe('getUserUsageLimit', () => {
 
   it('heals a null limit to the free-tier default for free users', async () => {
     dbChainMockFns.limit.mockResolvedValueOnce([{ currentUsageLimit: null }])
+    dbChainMockFns.returning.mockResolvedValueOnce([{ currentUsageLimit: '10' }])
     mockGetFreeTierLimit.mockReturnValue(10)
 
     const limit = await getUserUsageLimit('user-1', null)
@@ -121,6 +122,7 @@ describe('getUserUsageLimit', () => {
 
   it('heals a null limit to the plan minimum for paid personal subscriptions', async () => {
     dbChainMockFns.limit.mockResolvedValueOnce([{ currentUsageLimit: null }])
+    dbChainMockFns.returning.mockResolvedValueOnce([{ currentUsageLimit: '40' }])
     mockHasPaidSubscriptionStatus.mockReturnValue(true)
     mockGetPerUserMinimumLimit.mockReturnValue(40)
 
@@ -133,4 +135,23 @@ describe('getUserUsageLimit', () => {
       usageLimitUpdatedAt: expect.any(Date),
     })
   })
+
+  it('returns a concurrently written limit when the guarded heal matches no rows', async () => {
+    dbChainMockFns.limit.mockResolvedValueOnce([{ currentUsageLimit: null }])
+    dbChainMockFns.returning.mockResolvedValueOnce([])
+    dbChainMockFns.limit.mockResolvedValueOnce([{ currentUsageLimit: '30' }])
+    mockGetFreeTierLimit.mockReturnValue(10)
+
+    const limit = await getUserUsageLimit('user-1', null)
+
+    expect(limit).toBe(30)
+  })
+
+  it('still returns the fallback when the heal write fails', async () => {
+    dbChainMockFns.limit.mockResolvedValueOnce([{ currentUsageLimit: null }])
+    dbChainMockFns.returning.mockRejectedValueOnce(new Error('connection lost'))
+    mockGetFreeTierLimit.mockReturnValue(10)
+
+    await expect(getUserUsageLimit('user-1', null)).resolves.toBe(10)
+  })
 })

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

@@ -499,7 +499,9 @@ export async function updateUserUsageLimit(
  * Org-scoped members carry a null `currentUsageLimit` by design (see
  * `syncUsageLimitsFromSubscription`). A user whose subscription stops being
  * org-scoped without a resync would otherwise stay null and fail closed on
- * every execution, so a null limit self-heals to the plan default here.
+ * every execution, so a null limit self-heals to the plan default here. The
+ * write-back is best-effort: a limit written concurrently wins, and a failed
+ * write still resolves to the fallback instead of blocking execution.
  */
 export async function getUserUsageLimit(
   userId: string,
@@ -547,19 +549,36 @@ export async function getUserUsageLimit(
         ? getPerUserMinimumLimit(subscription)
         : getFreeTierLimit()
 
-    await db
-      .update(userStats)
-      .set({
-        currentUsageLimit: fallbackLimit.toString(),
-        usageLimitUpdatedAt: new Date(),
-      })
-      .where(and(eq(userStats.userId, userId), isNull(userStats.currentUsageLimit)))
+    try {
+      const healed = await db
+        .update(userStats)
+        .set({
+          currentUsageLimit: fallbackLimit.toString(),
+          usageLimitUpdatedAt: new Date(),
+        })
+        .where(and(eq(userStats.userId, userId), isNull(userStats.currentUsageLimit)))
+        .returning({ currentUsageLimit: userStats.currentUsageLimit })
+
+      if (healed.length === 0) {
+        const concurrent = await db
+          .select({ currentUsageLimit: userStats.currentUsageLimit })
+          .from(userStats)
+          .where(eq(userStats.userId, userId))
+          .limit(1)
 
-    logger.warn('Healed null usage limit to plan default', {
-      userId,
-      plan: subscription?.plan || 'free',
-      fallbackLimit,
-    })
+        if (concurrent[0]?.currentUsageLimit) {
+          return toNumber(toDecimal(concurrent[0].currentUsageLimit))
+        }
+      }
+
+      logger.warn('Healed null usage limit to plan default', {
+        userId,
+        plan: subscription?.plan || 'free',
+        fallbackLimit,
+      })
+    } catch (error) {
+      logger.error('Failed to heal null usage limit', { userId, fallbackLimit, error })
+    }
 
     return fallbackLimit
   }