fix(tables): validate deployed workflow mappings

Author: TheodoreSpeaks

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/workflow-sidebar/workflow-sidebar.tsx

@@ -19,17 +19,11 @@ import {
 import { ArrowLeft, ChevronDown, SquareArrowUpRight, X } from '@sim/emcn/icons'
 import { toError } from '@sim/utils/errors'
 import { generateId } from '@sim/utils/id'
-import { useMutation, useQueryClient } from '@tanstack/react-query'
 import { findValidationIssue, isValidationError } from '@/lib/api/client/errors'
-import { requestJson } from '@/lib/api/client/request'
 import type {
   AddWorkflowGroupBodyInput,
   UpdateWorkflowGroupBodyInput,
 } from '@/lib/api/contracts/tables'
-import {
-  putWorkflowNormalizedStateContract,
-  type WorkflowStateContractInput,
-} from '@/lib/api/contracts/workflows'
 import type {
   ColumnDefinition,
   WorkflowGroup,
@@ -39,7 +33,6 @@ import type {
 } from '@/lib/table'
 import { getColumnId } from '@/lib/table/column-keys'
 import { columnTypeForLeaf, deriveOutputColumnName } from '@/lib/table/column-naming'
-import { columnTypeById } from '@/lib/table/column-types'
 import {
   type FlattenOutputsBlockInput,
   type FlattenOutputsEdgeInput,
@@ -55,12 +48,12 @@ import {
 } from '@/app/workspace/[workspaceId]/tables/[tableId]/components/sidebar-fields'
 import { PreviewWorkflow } from '@/app/workspace/[workspaceId]/w/components/preview'
 import { BlockTile } from '@/blocks/block-tile'
+import { useDeployedWorkflowState } from '@/hooks/queries/deployments'
 import {
   useAddWorkflowGroup,
   useUpdateColumn,
   useUpdateWorkflowGroup,
 } from '@/hooks/queries/tables'
-import { useWorkflowState, workflowKeys } from '@/hooks/queries/workflows'
 import type { WorkflowMetadata } from '@/stores/workflows/registry/types'
 import { InputMappingSection } from './input-mapping-section'
 import { RunSettingsSection } from './run-settings-section'
@@ -139,25 +132,6 @@ interface BlockOutputGroup {
   paths: string[]
 }
 
-interface WorkflowStatePayload {
-  blocks: Record<
-    string,
-    {
-      type: string
-      subBlocks?: Record<string, { id?: string; type?: string; value?: unknown }>
-    } & Record<string, unknown>
-  >
-  edges: unknown[]
-  loops: unknown
-  parallels: unknown
-  lastSaved?: number
-  isDeployed?: boolean
-}
-
-function tableColumnTypeToInputType(colType: ColumnDefinition['type'] | undefined): string {
-  return columnTypeById(colType).workflowInputType
-}
-
 /**
  * Right-edge sidebar for workflow group configuration. Three flows:
  * - create a new group (workflow + outputs + deps),
@@ -274,11 +248,6 @@ export function WorkflowSidebarBody({
    */
   const otherColumns = anchorIdx >= allColumns.length ? allColumns : allColumns.slice(0, anchorIdx)
 
-  // Used by the "missing workflow input" suggestion below — for edit-output
-  // we exclude the column being edited (you can't suggest it as its own
-  // input).
-  const anchorColumnName = config.mode === 'edit-output' ? config.columnName : null
-
   // Every left-of-current column is a valid dep — workflow output columns
   // included. Exclude this group's own outputs (you can't depend on yourself).
   const ownOutputIds = new Set(existingGroup?.outputs.map((o) => o.columnName) ?? [])
@@ -324,101 +293,21 @@ export function WorkflowSidebarBody({
   const [showValidation, setShowValidation] = useState(false)
   const [nameError, setNameError] = useState<string | null>(null)
 
-  const workflowState = useWorkflowState(selectedWorkflowId || undefined)
+  const workflowState = useDeployedWorkflowState(selectedWorkflowId || null)
 
-  /** Resolves the unified Start block id and its current `inputFormat` field
-   *  names. The "Add inputs" mutation only adds rows for table columns that
-   *  aren't already represented in the start block. */
-  const startBlockInputs = useMemo<{
-    blockId: string | null
-    existingNames: Set<string>
-    existing: InputFormatField[]
-  }>(() => {
+  /** Resolves Start-block inputs from the active deployment used by table runs. */
+  const startBlockInputs = useMemo<InputFormatField[]>(() => {
     const blocks = (workflowState.data as { blocks?: Record<string, { type: string }> } | null)
       ?.blocks
-    if (!blocks) return { blockId: null, existingNames: new Set(), existing: [] }
+    if (!blocks) return []
     const candidate = TriggerUtils.findStartBlock(blocks, 'manual')
-    if (!candidate) return { blockId: null, existingNames: new Set(), existing: [] }
+    if (!candidate) return []
     const block = blocks[candidate.blockId] as
       | { subBlocks?: Record<string, { value?: unknown }> }
       | undefined
-    const existing = normalizeInputFormatValue(block?.subBlocks?.inputFormat?.value)
-    return {
-      blockId: candidate.blockId,
-      existingNames: new Set(existing.map((f) => f.name).filter((n): n is string => !!n)),
-      existing,
-    }
+    return normalizeInputFormatValue(block?.subBlocks?.inputFormat?.value)
   }, [workflowState.data])
 
-  const missingInputColumnNames = useMemo<string[]>(() => {
-    if (!startBlockInputs.blockId) return []
-    const anchor = anchorColumnName
-    return allColumns
-      .filter(
-        (c) =>
-          getColumnId(c) !== anchor &&
-          !c.workflowGroupId &&
-          !startBlockInputs.existingNames.has(c.name)
-      )
-      .map((c) => c.name)
-  }, [allColumns, anchorColumnName, startBlockInputs])
-
-  const queryClient = useQueryClient()
-  const addInputsMutation = useMutation({
-    mutationFn: async () => {
-      const wfId = selectedWorkflowId
-      const startBlockId = startBlockInputs.blockId
-      const state = workflowState.data as WorkflowStatePayload | null | undefined
-      if (!wfId || !startBlockId || !state || missingInputColumnNames.length === 0) {
-        throw new Error('Nothing to add')
-      }
-      const startBlock = state.blocks[startBlockId]
-      if (!startBlock) throw new Error('Start block missing from workflow')
-
-      const newFields: InputFormatField[] = missingInputColumnNames.map((name) => {
-        const col = allColumns.find((c) => c.name === name)
-        return {
-          id: generateId(),
-          name,
-          type: tableColumnTypeToInputType(col?.type),
-          value: '',
-          collapsed: false,
-        } as InputFormatField & { id: string; collapsed: boolean }
-      })
-
-      const updatedSubBlock = {
-        ...(startBlock.subBlocks?.inputFormat ?? { id: 'inputFormat', type: 'input-format' }),
-        value: [...startBlockInputs.existing, ...newFields],
-      }
-      const updatedBlocks = {
-        ...state.blocks,
-        [startBlockId]: {
-          ...startBlock,
-          subBlocks: { ...startBlock.subBlocks, inputFormat: updatedSubBlock },
-        },
-      }
-
-      const rawBody = {
-        blocks: updatedBlocks,
-        edges: state.edges,
-        loops: state.loops,
-        parallels: state.parallels,
-        lastSaved: state.lastSaved ?? Date.now(),
-        isDeployed: state.isDeployed ?? false,
-      }
-      // double-cast-allowed: WorkflowStatePayload is the loose local view of
-      // useWorkflowState; round-trip back to the strict PUT body shape.
-      const body = rawBody as unknown as WorkflowStateContractInput
-      await requestJson(putWorkflowNormalizedStateContract, { params: { id: wfId }, body })
-    },
-    onError: (err) => {
-      toast.error(toError(err).message)
-    },
-    onSettled: () => {
-      return queryClient.invalidateQueries({ queryKey: workflowKeys.state(selectedWorkflowId) })
-    },
-  })
-
   const blockOutputGroups = useMemo<BlockOutputGroup[]>(() => {
     const state = workflowState.data as
       | {
@@ -509,13 +398,13 @@ export function WorkflowSidebarBody({
   // Once the Start block's input fields resolve, auto-fill any field that has no
   // persisted mapping yet but matches a table column by name. Runs once; never
   // overrides a persisted or user-picked mapping.
-  if (!inputMappingsHydrated && startBlockInputs.existing.length > 0) {
+  if (!inputMappingsHydrated && startBlockInputs.length > 0) {
     // Map a Start input field to the column sharing its name, storing the
     // column id (the value the dropdowns and persisted mappings key on).
     const idByColumnName = new Map(depOptions.map((c) => [c.name, getColumnId(c)]))
     const next = { ...inputMappings }
     let changed = false
-    for (const field of startBlockInputs.existing) {
+    for (const field of startBlockInputs) {
       if (!field.name || next[field.name]) continue
       const colId = idByColumnName.get(field.name)
       if (colId) {
@@ -805,29 +694,6 @@ export function WorkflowSidebarBody({
             <div className='flex flex-col gap-[9.5px]'>
               <div className='flex min-w-0 items-center justify-between gap-2 pl-0.5'>
                 <Label>Workflow preview</Label>
-                {!isEnrichment &&
-                  startBlockInputs.blockId &&
-                  missingInputColumnNames.length > 0 && (
-                    <Tooltip.Root>
-                      <Tooltip.Trigger asChild>
-                        <Button
-                          type='button'
-                          variant='default'
-                          size='sm'
-                          className='flex-none whitespace-nowrap'
-                          onClick={() => addInputsMutation.mutate()}
-                          disabled={addInputsMutation.isPending}
-                        >
-                          {addInputsMutation.isPending
-                            ? 'Adding…'
-                            : `Add column inputs (${missingInputColumnNames.length})`}
-                        </Button>
-                      </Tooltip.Trigger>
-                      <Tooltip.Content side='top'>
-                        Adds {missingInputColumnNames.join(', ')} to the workflow's Start block
-                      </Tooltip.Content>
-                    </Tooltip.Root>
-                  )}
               </div>
               <div className='relative h-[160px] overflow-hidden rounded-sm border border-[var(--border)]'>
                 {workflowState.isLoading ? (
@@ -886,12 +752,16 @@ export function WorkflowSidebarBody({
         <div className='flex flex-col gap-[9.5px]'>
           <RequiredLabel>Workflow</RequiredLabel>
           <ChipCombobox
-            options={workflows?.map((wf) => ({ label: wf.name, value: wf.id })) ?? []}
+            options={
+              workflows
+                ?.filter((workflow) => workflow.isDeployed)
+                .map((workflow) => ({ label: workflow.name, value: workflow.id })) ?? []
+            }
             value={selectedWorkflowId}
             onChange={(v) => setSelectedWorkflowId(v)}
             placeholder='Select a workflow'
             disabled={!workflows || workflows.length === 0 || isEditOutputMode || isEnrichment}
-            emptyMessage='No manual triggers configured'
+            emptyMessage='No deployed workflows available'
             maxHeight={260}
             searchable
             searchPlaceholder='Search workflows...'
@@ -984,7 +854,7 @@ export function WorkflowSidebarBody({
                 {showAdvanced && (
                   <>
                     <InputMappingSection
-                      inputFields={startBlockInputs.existing}
+                      inputFields={startBlockInputs}
                       columnOptions={depOptions}
                       value={inputMappings}
                       onChange={setInputMappings}

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

@@ -72,7 +72,7 @@ vi.mock('@/lib/workflows/application/context', () => ({
   resolveActiveWorkflowApplicationContext: mocks.resolveWorkflowContext,
 }))
 vi.mock('@/lib/workflows/application/resolve-workflow-outputs', () => ({
-  loadResolvedWorkflowOutputs: mocks.loadWorkflowOutputs,
+  loadResolvedDeployedWorkflowOutputs: mocks.loadWorkflowOutputs,
 }))
 
 import { v2WorkflowGroupSchema } from '@/lib/api/contracts/v2/tables'

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

@@ -35,7 +35,7 @@ import {
 } from '@/lib/table/workflow-groups/service'
 import { resolveActiveWorkflowApplicationContext } from '@/lib/workflows/application/context'
 import type { ResolveWorkflowOutputsResult } from '@/lib/workflows/application/resolve-workflow-outputs'
-import { loadResolvedWorkflowOutputs } from '@/lib/workflows/application/resolve-workflow-outputs'
+import { loadResolvedDeployedWorkflowOutputs } from '@/lib/workflows/application/resolve-workflow-outputs'
 import { getEnrichment } from '@/enrichments/registry'
 import type { EnrichmentConfig } from '@/enrichments/types'
 
@@ -64,7 +64,7 @@ async function resolveWorkflowForAuthorizedTableCommand(
     workflowId,
     assertedWorkspaceId: workspaceId,
   })
-  return loadResolvedWorkflowOutputs(workflowContext)
+  return loadResolvedDeployedWorkflowOutputs(workflowContext)
 }
 
 async function resolveRelatedWorkflowForTableRoute(

apps/sim/lib/workflows/application/resolve-workflow-outputs.test.ts

@@ -7,7 +7,9 @@ import { OrchestrationError } from '@/lib/core/orchestration/types'
 
 const mocks = vi.hoisted(() => ({
   flatten: vi.fn(),
+  loadDeployed: vi.fn(),
   load: vi.fn(),
+  NoActiveDeploymentError: class NoActiveDeploymentError extends Error {},
   order: vi.fn(),
   resolveContext: vi.fn(),
   resolvePermission: vi.fn(),
@@ -33,10 +35,15 @@ vi.mock('@/lib/workflows/blocks/flatten-outputs', () => ({
 }))
 
 vi.mock('@/lib/workflows/persistence/utils', () => ({
+  NoActiveDeploymentError: mocks.NoActiveDeploymentError,
+  loadDeployedWorkflowState: mocks.loadDeployed,
   loadWorkflowFromNormalizedTables: mocks.load,
 }))
 
-import { resolveWorkflowOutputs } from '@/lib/workflows/application/resolve-workflow-outputs'
+import {
+  loadResolvedDeployedWorkflowOutputs,
+  resolveWorkflowOutputs,
+} from '@/lib/workflows/application/resolve-workflow-outputs'
 
 const principal = {
   kind: 'delegated' as const,
@@ -59,12 +66,16 @@ describe('resolveWorkflowOutputs', () => {
       workspaceOrganizationId: null,
       allowPersonalApiKeys: true,
       billedAccountUserId: 'billing-owner-1',
-      workflow: { id: 'workflow-1' },
+      workflow: { id: 'workflow-1', isDeployed: true },
     })
     mocks.load.mockResolvedValue({
       blocks: { block1: { id: 'block-1', type: 'agent', name: 'Agent', subBlocks: {} } },
       edges: [],
     })
+    mocks.loadDeployed.mockResolvedValue({
+      blocks: { block1: { id: 'block-1', type: 'agent', name: 'Agent', subBlocks: {} } },
+      edges: [],
+    })
     mocks.flatten.mockReturnValue([
       {
         blockId: 'block-1',
@@ -110,6 +121,42 @@ describe('resolveWorkflowOutputs', () => {
     expect(mocks.load).not.toHaveBeenCalled()
   })
 
+  it('resolves table mappings from the active deployment state', async () => {
+    const context = await mocks.resolveContext()
+
+    await expect(loadResolvedDeployedWorkflowOutputs(context)).resolves.toMatchObject({
+      workflowId: 'workflow-1',
+      outputs: [{ blockId: 'block-1', path: 'content' }],
+    })
+
+    expect(mocks.loadDeployed).toHaveBeenCalledWith('workflow-1', 'workspace-1')
+    expect(mocks.load).not.toHaveBeenCalled()
+  })
+
+  it('rejects a workflow without an active deployment before resolving mappings', async () => {
+    const context = {
+      ...(await mocks.resolveContext()),
+      workflow: { id: 'workflow-1', isDeployed: false },
+    }
+
+    await expect(loadResolvedDeployedWorkflowOutputs(context)).rejects.toMatchObject({
+      code: 'validation',
+      message: 'Workflow must have an active deployment',
+    })
+    expect(mocks.loadDeployed).not.toHaveBeenCalled()
+  })
+
+  it('rejects inconsistent deployment metadata without returning draft mappings', async () => {
+    const context = await mocks.resolveContext()
+    mocks.loadDeployed.mockRejectedValueOnce(new mocks.NoActiveDeploymentError())
+
+    await expect(loadResolvedDeployedWorkflowOutputs(context)).rejects.toMatchObject({
+      code: 'validation',
+      message: 'Workflow must have an active deployment',
+    })
+    expect(mocks.load).not.toHaveBeenCalled()
+  })
+
   it('rejects expired delegated scope before loading workflow state', async () => {
     await expect(
       resolveWorkflowOutputs.execute({