fix(billing): count only an earlier account as the Gmail inbox holder

Author: waleedlatif1

apps/sim/lib/users/gmail-alias.integration.ts

@@ -22,18 +22,20 @@ vi.mock('@/lib/auth', () => authMock)
 
 const userIds: string[] = []
 
-async function insertUser(email: string, { banned = false } = {}): Promise<string> {
+async function insertUser(
+  email: string,
+  { banned = false, createdAt = new Date() } = {}
+): Promise<string> {
   const id = generateId()
   userIds.push(id)
-  const now = new Date()
   await db.insert(user).values({
     id,
     name: 'Gmail alias fixture',
     email,
     emailVerified: true,
     banned,
-    createdAt: now,
-    updatedAt: now,
+    createdAt,
+    updatedAt: createdAt,
   })
   return id
 }
@@ -113,6 +115,36 @@ describe('Gmail inboxes and the free allowance', () => {
     expect(await statsOf(alias)).toEqual({ freeTierEligible: false, limit: 0 })
   })
 
+  it('keeps the allowance with the inbox’s first account when its stats row comes after an alias’s', async () => {
+    const local = uniqueLocalPart()
+    const original = await insertUser(`${local}@gmail.com`, {
+      createdAt: new Date(Date.now() - 60_000),
+    })
+    const alias = await signUp(`${local}+later@gmail.com`)
+
+    await ensureUserStatsExists(original)
+
+    expect(await statsOf(original)).toEqual({ freeTierEligible: true, limit: getFreeTierLimit() })
+    expect(await statsOf(alias)).toEqual({ freeTierEligible: false, limit: 0 })
+  })
+
+  it('withholds from exactly one of two accounts created at the same instant', async () => {
+    const local = uniqueLocalPart()
+    const createdAt = new Date()
+    const first = await insertUser(`${local}@gmail.com`, { createdAt })
+    const second = await insertUser(`${local.slice(0, 2)}.${local.slice(2)}@gmail.com`, {
+      createdAt,
+    })
+
+    await ensureUserStatsExists(first)
+    await ensureUserStatsExists(second)
+
+    const eligible = [await statsOf(first), await statsOf(second)].map(
+      (stats) => stats.freeTierEligible
+    )
+    expect(eligible.sort()).toEqual([false, true])
+  })
+
   it('finds the inbox through user_gmail_mailbox_idx rather than a scan of user', async () => {
     const plan = await db.transaction(async (tx) => {
       await tx.execute(sql`SET LOCAL enable_seqscan = off`)

apps/sim/lib/users/gmail-alias.ts

@@ -1,7 +1,7 @@
 import { db } from '@sim/db'
 import { gmailMailbox, user } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
-import { and, eq, ne, sql } from 'drizzle-orm'
+import { and, eq, lt, or, sql } from 'drizzle-orm'
 import { isBillingEnabled } from '@/lib/core/config/env-flags'
 import type { DbOrTx } from '@/lib/db/types'
 
@@ -18,12 +18,14 @@ import type { DbOrTx } from '@/lib/db/types'
 const logger = createLogger('GmailAlias')
 
 /**
- * Whether another account, banned or not, already holds the Gmail inbox this
- * user's address delivers to. Pass the caller's transaction as `executor` to
- * read on it; the read then runs in a savepoint, so a failed lookup never
- * aborts that transaction. Fails open: a lookup error returns `false` and is
- * logged, because refusing a legitimate person's allowance is worse than one
- * missed match.
+ * Whether an earlier account, banned or not, already holds the Gmail inbox this
+ * user's address delivers to. Only an account created before this one counts
+ * (the id breaks a creation-time tie), so the inbox's first account keeps the
+ * allowance however late its own stats row is created. Pass the caller's
+ * transaction as `executor` to read on it; the read then runs in a savepoint,
+ * so a failed lookup never aborts that transaction. Fails open: a lookup error
+ * returns `false` and is logged, because refusing a legitimate person's
+ * allowance is worse than one missed match.
  */
 export async function userHasGmailAliasAccount(
   userId: string,
@@ -32,15 +34,23 @@ export async function userHasGmailAliasAccount(
   if (!isBillingEnabled) return false
   const read = async (reader: DbOrTx) => {
     const [self] = await reader
-      .select({ mailbox: gmailMailbox(user.email) })
+      .select({ mailbox: gmailMailbox(user.email), createdAt: user.createdAt })
       .from(user)
       .where(eq(user.id, userId))
       .limit(1)
     if (!self?.mailbox) return false
     const [other] = await reader
       .select({ id: user.id })
       .from(user)
-      .where(and(sql`${gmailMailbox(user.email)} = ${self.mailbox}`, ne(user.id, userId)))
+      .where(
+        and(
+          sql`${gmailMailbox(user.email)} = ${self.mailbox}`,
+          or(
+            lt(user.createdAt, self.createdAt),
+            and(eq(user.createdAt, self.createdAt), lt(user.id, userId))
+          )
+        )
+      )
       .limit(1)
     return Boolean(other)
   }