perf(table): start the workspace load with the table load when a workspace is asserted

resolveActiveTableContext ran two sequential round trips: load the table,
then load the workspace it turned out to live in. When the caller asserts a
workspace the second input is already in hand, so both can start together.

What makes that safe is unchanged: requireTable still compares the table's
canonical workspaceId against the assertion and reports a mismatch as
not_found. The table outcome is inspected first and unconditionally, so any
path that returns has proven the assertion equal to the canonical id, and a
failing workspace load can never replace the concealing not_found. A final
identity check on the loaded context restates the invariant at the point of
return, so even with the first check removed the function cannot hand back a
foreign workspace. Promise.allSettled keeps the discarded branch from
surfacing as an unhandled rejection.

With no asserted workspace the path stays sequential — the table load is what
reveals which workspace to load, so there is nothing to start early.

One existing assertion changed: it required the workspace load not to have
been issued yet on a mismatched assertion, which is internal sequencing rather
than caller-observable behaviour and is definitionally untrue once the loads
overlap. The observable half is kept, and two timing tests now cover the
sequencing directly.

Verified to fail: removing either mismatch check, reading the workspace
outcome first, and swapping allSettled for bare awaits each turn the
corresponding tests red.

Author: waleedlatif1

apps/sim/lib/table/application/context.test.ts

@@ -2,7 +2,7 @@
  * @vitest-environment node
  */
 
-import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
 const { getTableById, loadWorkspace } = vi.hoisted(() => ({
   getTableById: vi.fn(),
@@ -16,6 +16,37 @@ vi.mock('@/lib/workspaces/application/workspace-context', () => ({
 
 import { resolveActiveTableContext } from '@/lib/table/application/context'
 
+const WORKSPACE_ONE = {
+  workspaceId: 'workspace-1',
+  workspaceOrganizationId: 'organization-1',
+  allowPersonalApiKeys: true,
+  billedAccountUserId: 'billing-user-1',
+}
+
+const WORKSPACE_TWO = {
+  workspaceId: 'workspace-2',
+  workspaceOrganizationId: 'organization-2',
+  allowPersonalApiKeys: false,
+  billedAccountUserId: 'billing-user-2',
+}
+
+/** Runs `body` while capturing any unhandled promise rejection it provokes. */
+async function withUnhandledRejectionWatch(body: () => Promise<void>): Promise<unknown[]> {
+  const seen: unknown[] = []
+  const onUnhandled = (reason: unknown) => {
+    seen.push(reason)
+  }
+  process.on('unhandledRejection', onUnhandled)
+  try {
+    await body()
+    await new Promise((resolve) => setImmediate(resolve))
+    await new Promise((resolve) => setImmediate(resolve))
+  } finally {
+    process.off('unhandledRejection', onUnhandled)
+  }
+  return seen
+}
+
 describe('table application context', () => {
   beforeEach(() => {
     vi.clearAllMocks()
@@ -24,12 +55,13 @@ describe('table application context', () => {
       workspaceId: 'workspace-1',
       name: 'Contacts',
     })
-    loadWorkspace.mockResolvedValue({
-      workspaceId: 'workspace-1',
-      workspaceOrganizationId: 'organization-1',
-      allowPersonalApiKeys: true,
-      billedAccountUserId: 'billing-user-1',
-    })
+    loadWorkspace.mockImplementation(async (workspaceId: string) =>
+      workspaceId === 'workspace-1' ? WORKSPACE_ONE : WORKSPACE_TWO
+    )
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
   })
 
   it('derives workspace scope from the canonical active table', async () => {
@@ -44,13 +76,106 @@ describe('table application context', () => {
     expect(loadWorkspace).toHaveBeenCalledWith('workspace-1')
   })
 
-  it('conceals an asserted cross-workspace table before workspace resolution', async () => {
+  it('starts the workspace load without waiting for the table when a workspace is asserted', async () => {
+    let releaseTable: (table: unknown) => void = () => {}
+    getTableById.mockImplementationOnce(
+      () =>
+        new Promise((resolve) => {
+          releaseTable = resolve
+        })
+    )
+
+    const pending = resolveActiveTableContext({
+      tableId: 'table-1',
+      assertedWorkspaceId: 'workspace-1',
+    })
+    await Promise.resolve()
+    await Promise.resolve()
+
+    expect(loadWorkspace).toHaveBeenCalledWith('workspace-1')
+
+    releaseTable({ id: 'table-1', workspaceId: 'workspace-1', name: 'Contacts' })
+    await expect(pending).resolves.toMatchObject({ tableId: 'table-1', workspaceId: 'workspace-1' })
+  })
+
+  it('waits for the table before loading a workspace when none is asserted', async () => {
+    let releaseTable: (table: unknown) => void = () => {}
+    getTableById.mockImplementationOnce(
+      () =>
+        new Promise((resolve) => {
+          releaseTable = resolve
+        })
+    )
+
+    const pending = resolveActiveTableContext({ tableId: 'table-1' })
+    await Promise.resolve()
+    await Promise.resolve()
+
+    expect(loadWorkspace).not.toHaveBeenCalled()
+
+    releaseTable({ id: 'table-1', workspaceId: 'workspace-1', name: 'Contacts' })
+    await expect(pending).resolves.toMatchObject({ tableId: 'table-1', workspaceId: 'workspace-1' })
+    expect(loadWorkspace).toHaveBeenCalledWith('workspace-1')
+  })
+
+  it('conceals an asserted cross-workspace table as not found', async () => {
     await expect(
       resolveActiveTableContext({ tableId: 'table-1', assertedWorkspaceId: 'workspace-2' })
     ).rejects.toMatchObject({ code: 'not_found', message: 'Table not found' })
+  })
+
+  it('conceals a table that does not exist at all', async () => {
+    getTableById.mockResolvedValueOnce(null)
+
+    await expect(
+      resolveActiveTableContext({ tableId: 'missing', assertedWorkspaceId: 'workspace-1' })
+    ).rejects.toMatchObject({ code: 'not_found', message: 'Table not found' })
+  })
+
+  it('conceals a missing table with no asserted workspace', async () => {
+    getTableById.mockResolvedValueOnce(null)
+
+    await expect(resolveActiveTableContext({ tableId: 'missing' })).rejects.toMatchObject({
+      code: 'not_found',
+      message: 'Table not found',
+    })
     expect(loadWorkspace).not.toHaveBeenCalled()
   })
 
+  it('surfaces not_found rather than a failing workspace load on a mismatched assertion', async () => {
+    const failure = new Error('workspace database unavailable')
+    loadWorkspace.mockRejectedValueOnce(failure)
+
+    const unhandled = await withUnhandledRejectionWatch(async () => {
+      await expect(
+        resolveActiveTableContext({ tableId: 'table-1', assertedWorkspaceId: 'workspace-2' })
+      ).rejects.toMatchObject({ code: 'not_found', message: 'Table not found' })
+    })
+
+    expect(unhandled).toEqual([])
+  })
+
+  it('surfaces not_found rather than a failing table load on a matched assertion', async () => {
+    const failure = new Error('table database unavailable')
+    getTableById.mockRejectedValueOnce(failure)
+
+    const unhandled = await withUnhandledRejectionWatch(async () => {
+      await expect(
+        resolveActiveTableContext({ tableId: 'table-1', assertedWorkspaceId: 'workspace-1' })
+      ).rejects.toBe(failure)
+    })
+
+    expect(unhandled).toEqual([])
+  })
+
+  it('refuses a workspace context that is not the canonical workspace of the table', async () => {
+    loadWorkspace.mockResolvedValueOnce(WORKSPACE_TWO)
+
+    await expect(
+      resolveActiveTableContext({ tableId: 'table-1', assertedWorkspaceId: 'workspace-1' })
+    ).rejects.toMatchObject({ code: 'not_found', message: 'Table not found' })
+  })
+
   it('fails when the canonical workspace is unavailable', async () => {
     loadWorkspace.mockResolvedValueOnce(null)
 
@@ -60,10 +185,31 @@ describe('table application context', () => {
     })
   })
 
+  it('fails when the canonical workspace is unavailable on the asserted path', async () => {
+    loadWorkspace.mockResolvedValueOnce(null)
+
+    await expect(
+      resolveActiveTableContext({ tableId: 'table-1', assertedWorkspaceId: 'workspace-1' })
+    ).rejects.toMatchObject({ code: 'not_found', message: 'Workspace not found' })
+  })
+
   it('propagates canonical workspace database failures', async () => {
     const failure = new Error('workspace database unavailable')
     loadWorkspace.mockRejectedValueOnce(failure)
 
     await expect(resolveActiveTableContext({ tableId: 'table-1' })).rejects.toBe(failure)
   })
+
+  it('propagates canonical workspace database failures on the asserted path', async () => {
+    const failure = new Error('workspace database unavailable')
+    loadWorkspace.mockRejectedValueOnce(failure)
+
+    const unhandled = await withUnhandledRejectionWatch(async () => {
+      await expect(
+        resolveActiveTableContext({ tableId: 'table-1', assertedWorkspaceId: 'workspace-1' })
+      ).rejects.toBe(failure)
+    })
+
+    expect(unhandled).toEqual([])
+  })
 })

apps/sim/lib/table/application/context.ts

@@ -32,12 +32,49 @@ async function requireTable(tableId: string, workspaceId: string | undefined) {
   return table
 }
 
+/**
+ * Loads the canonical context a table use case authorizes against.
+ *
+ * When the caller asserts a workspace, the workspace load no longer has to wait for the table
+ * load: the asserted id is already in hand, so both round trips start together. What makes that
+ * safe is that {@link requireTable} still compares the table's canonical `workspaceId` against
+ * the assertion and reports any mismatch as `not_found`. The table outcome is inspected first and
+ * unconditionally, so on every path that returns, the assertion has been *proven* equal to the
+ * canonical workspace id — the context handed back is the table's own workspace, never a
+ * workspace the caller merely named. A mismatch throws before the workspace outcome is read, so a
+ * failing workspace load can never replace the concealing `not_found`. `Promise.allSettled` keeps
+ * the branch that is thrown away from surfacing as an unhandled rejection. A final identity check
+ * on the loaded context restates the invariant at the point of return, so the value handed back is
+ * only ever a context whose own `workspaceId` is the table's.
+ *
+ * Without an asserted id there is nothing to start early — the table load is what reveals which
+ * workspace to load — so that path stays sequential.
+ */
 export async function resolveActiveTableContext(input: {
   tableId: string
   assertedWorkspaceId?: string
 }): Promise<ActiveTableContext> {
-  const table = await requireTable(input.tableId, input.assertedWorkspaceId)
-  const workspaceContext = await resolveTableWorkspaceContext(table.workspaceId)
+  const { tableId, assertedWorkspaceId } = input
+
+  if (assertedWorkspaceId === undefined) {
+    const table = await requireTable(tableId, undefined)
+    const workspaceContext = await resolveTableWorkspaceContext(table.workspaceId)
+    return { ...workspaceContext, tableId: table.id, table }
+  }
+
+  const [tableOutcome, workspaceOutcome] = await Promise.allSettled([
+    requireTable(tableId, assertedWorkspaceId),
+    resolveTableWorkspaceContext(assertedWorkspaceId),
+  ])
+
+  if (tableOutcome.status === 'rejected') throw tableOutcome.reason
+  if (workspaceOutcome.status === 'rejected') throw workspaceOutcome.reason
+
+  const table = tableOutcome.value
+  const workspaceContext = workspaceOutcome.value
+  if (workspaceContext.workspaceId !== table.workspaceId) {
+    throw new OrchestrationError('not_found', 'Table not found')
+  }
   return { ...workspaceContext, tableId: table.id, table }
 }