fix(tables): compose copilot commands atomically

Author: TheodoreSpeaks

apps/sim/lib/copilot/application/execute-table-use-case.test.ts

@@ -0,0 +1,131 @@
+/**
+ * @vitest-environment node
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const mocks = vi.hoisted(() => ({
+  addOutput: vi.fn(),
+  createEnrichment: vi.fn(),
+  createFromFile: vi.fn(),
+  createWorkflowGroup: vi.fn(),
+  importFile: vi.fn(),
+  replaceProjectedRows: vi.fn(),
+  resolvePrincipal: vi.fn(),
+  updateWorkflowGroup: vi.fn(),
+}))
+
+vi.mock('@/lib/copilot/auth/table-delegation', () => ({
+  resolveCopilotTablePrincipal: mocks.resolvePrincipal,
+}))
+vi.mock('@/lib/table/application/groups', () => ({
+  addWorkflowTableGroupOutput: { execute: mocks.addOutput },
+  createTableEnrichmentGroup: { execute: mocks.createEnrichment },
+  createWorkflowTableGroup: { execute: mocks.createWorkflowGroup },
+  updateWorkflowTableGroup: { execute: mocks.updateWorkflowGroup },
+}))
+vi.mock('@/lib/table/application/rows', () => ({
+  replaceProjectedWireRows: { execute: mocks.replaceProjectedRows },
+}))
+vi.mock('@/lib/table/application/workspace-file-imports', () => ({
+  createTableFromWorkspaceFile: { execute: mocks.createFromFile },
+  importWorkspaceFileIntoTable: { execute: mocks.importFile },
+}))
+
+import {
+  copilotAddWorkflowTableGroupOutputPolicy,
+  copilotCreateTableEnrichmentGroupPolicy,
+  copilotCreateTableFromWorkspaceFilePolicy,
+  copilotCreateWorkflowTableGroupPolicy,
+  copilotImportWorkspaceFileIntoTablePolicy,
+  copilotReplaceProjectedWireRowsPolicy,
+  copilotUpdateWorkflowTableGroupPolicy,
+  executeCopilotAddWorkflowTableGroupOutput,
+  executeCopilotCreateTableEnrichmentGroup,
+  executeCopilotCreateTableFromWorkspaceFile,
+  executeCopilotCreateWorkflowTableGroup,
+  executeCopilotImportWorkspaceFileIntoTable,
+  executeCopilotReplaceProjectedWireRows,
+  executeCopilotUpdateWorkflowTableGroup,
+} from '@/lib/copilot/application/table-commands'
+
+const context = {
+  userId: 'user-1',
+  workspaceId: 'workspace-1',
+  toolCallId: 'tool-call-1',
+  copilotToolExecution: true,
+}
+const principal = { kind: 'delegated', audience: 'sim:tables' }
+
+describe('fixed Copilot Table application commands', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mocks.resolvePrincipal.mockReturnValue(principal)
+  })
+
+  it.each([
+    ['replace projected rows', executeCopilotReplaceProjectedWireRows, mocks.replaceProjectedRows],
+    ['create workflow group', executeCopilotCreateWorkflowTableGroup, mocks.createWorkflowGroup],
+    ['update workflow group', executeCopilotUpdateWorkflowTableGroup, mocks.updateWorkflowGroup],
+    ['add workflow output', executeCopilotAddWorkflowTableGroupOutput, mocks.addOutput],
+    ['create enrichment group', executeCopilotCreateTableEnrichmentGroup, mocks.createEnrichment],
+    ['import a workspace file', executeCopilotImportWorkspaceFileIntoTable, mocks.importFile],
+  ])(
+    'dispatches %s to exactly one code-defined Table command',
+    async (_label, execute, command) => {
+      command.mockResolvedValue({ ok: true })
+      const input = { tableId: 'table-1', workspaceId: 'workspace-1' }
+
+      await expect(execute(context, input as never)).resolves.toEqual({ ok: true })
+
+      expect(mocks.resolvePrincipal).toHaveBeenCalledWith(context, 'table-1')
+      expect(command).toHaveBeenCalledWith({ principal, input })
+      expect(command).toHaveBeenCalledTimes(1)
+    }
+  )
+
+  it('uses a workspace-scoped Table principal for create-from-file', async () => {
+    mocks.createFromFile.mockResolvedValue({ kind: 'empty' })
+    const input = { workspaceId: 'workspace-1', fileReference: 'files/people.csv' }
+
+    await executeCopilotCreateTableFromWorkspaceFile(context, input)
+
+    expect(mocks.resolvePrincipal).toHaveBeenCalledWith(context)
+    expect(mocks.createFromFile).toHaveBeenCalledWith({ principal, input })
+  })
+
+  it('declares inherited request-rate admission and no direct provider cost for every command', () => {
+    const policies = [
+      copilotReplaceProjectedWireRowsPolicy,
+      copilotCreateWorkflowTableGroupPolicy,
+      copilotUpdateWorkflowTableGroupPolicy,
+      copilotAddWorkflowTableGroupOutputPolicy,
+      copilotCreateTableEnrichmentGroupPolicy,
+      copilotCreateTableFromWorkspaceFilePolicy,
+      copilotImportWorkspaceFileIntoTablePolicy,
+    ]
+
+    for (const policy of policies) {
+      expect(policy.rate.kind).toBe('inherited_copilot_request')
+      expect(policy.rate.reason).toBeTruthy()
+      expect(policy.cost.kind).toBe('none')
+      expect(policy.cost.reason).toBeTruthy()
+    }
+  })
+
+  it('rejects an untrusted context before application execution', async () => {
+    const error = new Error('trusted Copilot execution context required')
+    mocks.resolvePrincipal.mockImplementationOnce(() => {
+      throw error
+    })
+
+    expect(() =>
+      executeCopilotReplaceProjectedWireRows(undefined, {
+        tableId: 'table-1',
+        sourceRows: [],
+        projectedRows: [],
+      })
+    ).toThrow(error)
+    expect(mocks.replaceProjectedRows).not.toHaveBeenCalled()
+  })
+})

apps/sim/lib/copilot/application/execute-table-use-case.ts

@@ -0,0 +1,137 @@
+import type { CopilotTableDelegationContext } from '@/lib/copilot/auth/table-delegation'
+import { resolveCopilotTablePrincipal } from '@/lib/copilot/auth/table-delegation'
+import {
+  type AddTableGroupOutputInput,
+  addWorkflowTableGroupOutput,
+  type CreateTableEnrichmentGroupInput,
+  type CreateWorkflowTableGroupInput,
+  createTableEnrichmentGroup,
+  createWorkflowTableGroup,
+  type UpdateWorkflowTableGroupInput,
+  updateWorkflowTableGroup,
+} from '@/lib/table/application/groups'
+import {
+  type ReplaceProjectedWireRowsInput,
+  replaceProjectedWireRows,
+} from '@/lib/table/application/rows'
+import {
+  type CreateTableFromWorkspaceFileInput,
+  createTableFromWorkspaceFile,
+  type ImportWorkspaceFileInput,
+  importWorkspaceFileIntoTable,
+} from '@/lib/table/application/workspace-file-imports'
+
+const INHERITED_COPILOT_RATE_POLICY = {
+  kind: 'inherited_copilot_request',
+  reason: 'The authenticated Copilot request owns request-rate admission.',
+} as const
+
+const NO_DIRECT_PROVIDER_COST_POLICY = {
+  kind: 'none',
+  reason: 'This command does not invoke a paid provider; table quota and storage limits apply.',
+} as const
+
+export const copilotReplaceProjectedWireRowsPolicy = {
+  rate: INHERITED_COPILOT_RATE_POLICY,
+  cost: NO_DIRECT_PROVIDER_COST_POLICY,
+} as const
+
+export function executeCopilotReplaceProjectedWireRows(
+  context: CopilotTableDelegationContext | undefined,
+  input: ReplaceProjectedWireRowsInput
+) {
+  return replaceProjectedWireRows.execute({
+    principal: resolveCopilotTablePrincipal(context, input.tableId),
+    input,
+  })
+}
+
+export const copilotCreateWorkflowTableGroupPolicy = {
+  rate: INHERITED_COPILOT_RATE_POLICY,
+  cost: NO_DIRECT_PROVIDER_COST_POLICY,
+} as const
+
+export function executeCopilotCreateWorkflowTableGroup(
+  context: CopilotTableDelegationContext | undefined,
+  input: CreateWorkflowTableGroupInput
+) {
+  return createWorkflowTableGroup.execute({
+    principal: resolveCopilotTablePrincipal(context, input.tableId),
+    input,
+  })
+}
+
+export const copilotUpdateWorkflowTableGroupPolicy = {
+  rate: INHERITED_COPILOT_RATE_POLICY,
+  cost: NO_DIRECT_PROVIDER_COST_POLICY,
+} as const
+
+export function executeCopilotUpdateWorkflowTableGroup(
+  context: CopilotTableDelegationContext | undefined,
+  input: UpdateWorkflowTableGroupInput
+) {
+  return updateWorkflowTableGroup.execute({
+    principal: resolveCopilotTablePrincipal(context, input.tableId),
+    input,
+  })
+}
+
+export const copilotAddWorkflowTableGroupOutputPolicy = {
+  rate: INHERITED_COPILOT_RATE_POLICY,
+  cost: NO_DIRECT_PROVIDER_COST_POLICY,
+} as const
+
+export function executeCopilotAddWorkflowTableGroupOutput(
+  context: CopilotTableDelegationContext | undefined,
+  input: AddTableGroupOutputInput
+) {
+  return addWorkflowTableGroupOutput.execute({
+    principal: resolveCopilotTablePrincipal(context, input.tableId),
+    input,
+  })
+}
+
+export const copilotCreateTableEnrichmentGroupPolicy = {
+  rate: INHERITED_COPILOT_RATE_POLICY,
+  cost: NO_DIRECT_PROVIDER_COST_POLICY,
+} as const
+
+export function executeCopilotCreateTableEnrichmentGroup(
+  context: CopilotTableDelegationContext | undefined,
+  input: CreateTableEnrichmentGroupInput
+) {
+  return createTableEnrichmentGroup.execute({
+    principal: resolveCopilotTablePrincipal(context, input.tableId),
+    input,
+  })
+}
+
+export const copilotCreateTableFromWorkspaceFilePolicy = {
+  rate: INHERITED_COPILOT_RATE_POLICY,
+  cost: NO_DIRECT_PROVIDER_COST_POLICY,
+} as const
+
+export function executeCopilotCreateTableFromWorkspaceFile(
+  context: CopilotTableDelegationContext | undefined,
+  input: CreateTableFromWorkspaceFileInput
+) {
+  return createTableFromWorkspaceFile.execute({
+    principal: resolveCopilotTablePrincipal(context),
+    input,
+  })
+}
+
+export const copilotImportWorkspaceFileIntoTablePolicy = {
+  rate: INHERITED_COPILOT_RATE_POLICY,
+  cost: NO_DIRECT_PROVIDER_COST_POLICY,
+} as const
+
+export function executeCopilotImportWorkspaceFileIntoTable(
+  context: CopilotTableDelegationContext | undefined,
+  input: ImportWorkspaceFileInput
+) {
+  return importWorkspaceFileIntoTable.execute({
+    principal: resolveCopilotTablePrincipal(context, input.tableId),
+    input,
+  })
+}