fix(billing): make storage-decrement notification re-arm only (never send on a shrink)

Author: waleedlatif1

apps/sim/lib/billing/core/limit-notifications.test.ts

@@ -99,6 +99,19 @@ describe('maybeSendLimitThresholdEmail', () => {
     expect(subjectMock).toHaveBeenCalledWith('storage', 'reached')
   })
 
+  it('never sends in rearmOnly mode, even when usage is above a threshold', async () => {
+    // A storage shrink that still leaves usage at 90% must only re-arm, not send,
+    // even if the stored threshold is 0 (claim would otherwise win).
+    await maybeSendLimitThresholdEmail({
+      ...baseUserParams,
+      currentUsage: 4.5,
+      limit: 5,
+      rearmOnly: true,
+    })
+    expect(mockClaim).not.toHaveBeenCalled()
+    expect(sendEmailSpy).not.toHaveBeenCalled()
+  })
+
   it('does not send when the atomic claim is lost (already notified)', async () => {
     mockClaim.mockReturnValue([]) // someone else already advanced the threshold
     await maybeSendLimitThresholdEmail({ ...baseUserParams, currentUsage: 4.5, limit: 5 })

apps/sim/lib/billing/core/limit-notifications.ts

@@ -122,6 +122,12 @@ export async function maybeSendLimitThresholdEmail(params: {
    * suppressed. Omit when only the post-mutation usage is observable.
    */
   priorUsage?: number
+  /**
+   * When true, only the re-arm is evaluated and no email is ever sent. Used by
+   * usage-decrease paths (e.g. a storage shrink) where usage can still be above
+   * a threshold but the change is a drop, not a fresh crossing.
+   */
+  rearmOnly?: boolean
   userId?: string
   userEmail?: string
   userName?: string
@@ -149,7 +155,8 @@ export async function maybeSendLimitThresholdEmail(params: {
       await rearmThreshold(scope, stateId, category)
     }
 
-    if (desired === 0) return
+    // Usage-decrease callers re-arm only — a drop is never a fresh crossing to email.
+    if (params.rearmOnly || desired === 0) return
 
     if (!(await claimThreshold(scope, stateId, category, desired))) return
 
@@ -253,6 +260,8 @@ export async function maybeNotifyLimit(params: {
   limitLabel: string
   /** Usage before the mutation, when known — see {@link maybeSendLimitThresholdEmail}. */
   priorUsage?: number
+  /** Re-arm only, never send — for usage-decrease callers. See {@link maybeSendLimitThresholdEmail}. */
+  rearmOnly?: boolean
 }): Promise<void> {
   try {
     const sub = await getHighestPrioritySubscription(params.billedUserId)
@@ -279,6 +288,7 @@ export async function maybeNotifyLimit(params: {
       usageLabel: params.usageLabel,
       limitLabel: params.limitLabel,
       priorUsage: params.priorUsage,
+      rearmOnly: params.rearmOnly,
       userId: params.billedUserId,
       userEmail,
       userName,

apps/sim/lib/billing/storage/tracking.ts

@@ -21,11 +21,18 @@ function formatGb(bytes: number, decimals: number): string {
 }
 
 /**
- * Best-effort storage threshold email after an increment. Re-reads the (now
- * updated) usage and plan limit, then delegates scope resolution + dedup + send
- * to {@link maybeNotifyLimit}. Never throws.
+ * Best-effort storage threshold evaluation after a usage change. Re-reads the
+ * (now updated) usage and plan limit, then delegates scope resolution + dedup +
+ * send to {@link maybeNotifyLimit}. Never throws.
+ *
+ * @param rearmOnly - True on decrements, so a shrink that leaves usage above a
+ *   threshold re-arms but never sends (a drop is not a fresh crossing).
  */
-async function maybeNotifyStorageLimit(userId: string, workspaceId: string): Promise<void> {
+async function maybeNotifyStorageLimit(
+  userId: string,
+  workspaceId: string,
+  rearmOnly = false
+): Promise<void> {
   try {
     const [usage, limit] = await Promise.all([
       getUserStorageUsage(userId),
@@ -40,6 +47,7 @@ async function maybeNotifyStorageLimit(userId: string, workspaceId: string): Pro
       limit,
       usageLabel: formatGb(usage, 2),
       limitLabel: formatGb(limit, 0),
+      rearmOnly,
     })
   } catch (error) {
     logger.error('Error evaluating storage limit notification:', error)
@@ -145,7 +153,8 @@ export async function decrementStorageUsage(
     throw error
   }
 
+  // Re-arm only: usage dropped, so this never sends.
   if (workspaceId) {
-    void maybeNotifyStorageLimit(userId, workspaceId)
+    void maybeNotifyStorageLimit(userId, workspaceId, true)
   }
 }