perf(invitations): bound the join-preview fan-out off the render critical path

listPendingInvitationsForViewer computed join previews in a serial loop, which
was affordable when the switcher dropdown was the only caller. The sidebar
prefetch now calls it on every workspace page render, and each preview issues
up to three sequential queries — so a viewer with pending invitations paid
roughly three round-trips per invitation before the first byte of every route
under the workspace layout.

Bounds the fan-out with mapWithConcurrency instead. The preview already
degrades to null on failure, which is what makes it safe under a mapper that
fails all-or-nothing, and a bound keeps the pooled-connection ceiling the
serial loop was protecting.

Author: waleedlatif1

apps/sim/lib/invitations/pending.test.ts

@@ -0,0 +1,108 @@
+/**
+ * @vitest-environment node
+ */
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { mockGetInvitationJoinPreview, mockListPendingInvitationsForEmail } = vi.hoisted(() => ({
+  mockGetInvitationJoinPreview: vi.fn(),
+  mockListPendingInvitationsForEmail: vi.fn(),
+}))
+
+vi.mock('@/lib/invitations/core', () => ({
+  getInvitationJoinPreview: mockGetInvitationJoinPreview,
+  listPendingInvitationsForEmail: mockListPendingInvitationsForEmail,
+}))
+
+import { listPendingInvitationsForViewer } from '@/lib/invitations/pending'
+
+const USER_ID = 'user-1'
+const EMAIL = 'invitee@example.com'
+
+function invitation(id: string) {
+  return {
+    id,
+    kind: 'organization' as const,
+    email: EMAIL,
+    organizationId: 'org-1',
+    organizationName: 'Org',
+    membershipIntent: 'member',
+    role: 'member',
+    status: 'pending',
+    expiresAt: new Date('2026-02-01T00:00:00.000Z'),
+    createdAt: new Date('2026-01-01T00:00:00.000Z'),
+    inviterName: 'Ada',
+    inviterEmail: 'ada@example.com',
+    grants: [{ workspaceId: 'ws-1', workspaceName: 'WS', permission: 'read' }],
+  }
+}
+
+describe('listPendingInvitationsForViewer', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('pairs each row with its own preview, in order', async () => {
+    mockListPendingInvitationsForEmail.mockResolvedValue(['a', 'b', 'c'].map(invitation))
+    mockGetInvitationJoinPreview.mockImplementation(async (_userId, inv) => ({ for: inv.id }))
+
+    const rows = await listPendingInvitationsForViewer(USER_ID, EMAIL)
+
+    expect(rows.map((r) => r.id)).toEqual(['a', 'b', 'c'])
+    expect(rows.map((r) => r.joinPreview)).toEqual([{ for: 'a' }, { for: 'b' }, { for: 'c' }])
+  })
+
+  /**
+   * The preview is disclosure-only, so one failing row must degrade to `null` rather than
+   * hiding the invitation or failing the batch — which is what makes the bounded mapper
+   * safe, since it fails all-or-nothing on a throwing mapper.
+   */
+  it('degrades a failing preview to null without dropping the invitation', async () => {
+    mockListPendingInvitationsForEmail.mockResolvedValue(['a', 'b'].map(invitation))
+    mockGetInvitationJoinPreview.mockImplementation(async (_userId, inv) => {
+      if (inv.id === 'a') throw new Error('preview blew up')
+      return { for: inv.id }
+    })
+
+    const rows = await listPendingInvitationsForViewer(USER_ID, EMAIL)
+
+    expect(rows).toHaveLength(2)
+    expect(rows[0].joinPreview).toBeNull()
+    expect(rows[1].joinPreview).toEqual({ for: 'b' })
+  })
+
+  /**
+   * This runs inside the sidebar prefetch on every workspace page render, and each preview
+   * issues several queries — so the fan-out stays bounded rather than holding one pooled
+   * connection per pending invitation.
+   */
+  it('bounds how many previews run at once', async () => {
+    mockListPendingInvitationsForEmail.mockResolvedValue(
+      Array.from({ length: 12 }, (_, i) => invitation(`inv-${i}`))
+    )
+    let inFlight = 0
+    let peak = 0
+    mockGetInvitationJoinPreview.mockImplementation(async () => {
+      inFlight++
+      peak = Math.max(peak, inFlight)
+      await Promise.resolve()
+      inFlight--
+      return null
+    })
+
+    await listPendingInvitationsForViewer(USER_ID, EMAIL)
+
+    expect(mockGetInvitationJoinPreview).toHaveBeenCalledTimes(12)
+    expect(peak).toBeGreaterThan(1)
+    expect(peak).toBeLessThanOrEqual(4)
+  })
+
+  it('serializes dates to the wire shape', async () => {
+    mockListPendingInvitationsForEmail.mockResolvedValue([invitation('a')])
+    mockGetInvitationJoinPreview.mockResolvedValue(null)
+
+    const [row] = await listPendingInvitationsForViewer(USER_ID, EMAIL)
+
+    expect(row.expiresAt).toBe('2026-02-01T00:00:00.000Z')
+    expect(row.createdAt).toBe('2026-01-01T00:00:00.000Z')
+  })
+})

apps/sim/lib/invitations/pending.ts

@@ -1,9 +1,17 @@
 import { createLogger } from '@sim/logger'
 import type { ViewerInvitation } from '@/lib/api/contracts/invitations'
+import { mapWithConcurrency } from '@/lib/core/utils/concurrency'
 import { getInvitationJoinPreview, listPendingInvitationsForEmail } from '@/lib/invitations/core'
 
 const logger = createLogger('PendingInvitations')
 
+/**
+ * Bounds the join-preview fan-out. A pending-invitation list is a handful of rows, so this
+ * resolves the common cases in one batch while still capping how many pooled connections a
+ * single page render can hold.
+ */
+const INVITATION_PREVIEW_CONCURRENCY = 4
+
 /**
  * The invitee-facing pending-invitation list behind the workspace switcher's
  * Invitations section, assembled once for both the `GET /api/invitations` route
@@ -22,26 +30,31 @@ export async function listPendingInvitationsForViewer(
    * Each row carries what accepting it will actually do, so the client can echo
    * `disclosedWorkspaceIds` on accept — the consent contract the emailed
    * `/invite` page honours. A preview failure degrades to `null` rather than
-   * hiding the invitation.
+   * hiding the invitation, which is what lets this run under a bounded mapper.
    *
-   * Sequential on purpose: each preview issues several queries, and the sidebar
-   * prefetch calls this on every workspace page load. Fanning them out with
-   * `Promise.all` would hold one pooled connection per pending invitation for
-   * the length of the slowest one. The list is a handful of rows, so the added
-   * latency is not worth the pool pressure.
+   * Bounded rather than unbounded: each preview issues up to three sequential
+   * queries, so `Promise.all` would hold one pooled connection per pending
+   * invitation for the length of the slowest one. It was previously a serial
+   * loop for that reason, which is no longer affordable now that the sidebar
+   * prefetch calls this on every workspace page render rather than only when
+   * the switcher opens — a serial loop puts every one of those queries on the
+   * critical path of the first byte.
    */
-  const previews: Array<Awaited<ReturnType<typeof getInvitationJoinPreview>> | null> = []
-  for (const inv of invitations) {
-    try {
-      previews.push(await getInvitationJoinPreview(userId, inv))
-    } catch (previewError) {
-      logger.warn('Failed to compute join preview for pending invitation', {
-        invitationId: inv.id,
-        error: previewError,
-      })
-      previews.push(null)
+  const previews = await mapWithConcurrency(
+    invitations,
+    INVITATION_PREVIEW_CONCURRENCY,
+    async (inv) => {
+      try {
+        return await getInvitationJoinPreview(userId, inv)
+      } catch (previewError) {
+        logger.warn('Failed to compute join preview for pending invitation', {
+          invitationId: inv.id,
+          error: previewError,
+        })
+        return null
+      }
     }
-  }
+  )
 
   return invitations.map(
     (inv, index) =>