fix(enrichment): rearm waiting cells on input changes

Author: TheodoreSpeaks

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/data-row.tsx

@@ -199,7 +199,9 @@ export const DataRow = React.memo(function DataRow({
         for (const id of unmet.columns) labels.add(nameByColumnId.get(id) ?? id)
       }
 
-      if (group.type === 'enrichment') {
+      const hasAttemptedManualRun =
+        group.autoRun === false && row.executions?.[group.id] !== undefined
+      if (group.type === 'enrichment' && (group.autoRun !== false || hasAttemptedManualRun)) {
         const enrichment = getEnrichment(group.enrichmentId)
         if (enrichment) {
           const inputColumnById = new Map<string, string>()

apps/sim/background/workflow-column-execution.ts

@@ -435,9 +435,6 @@ async function runWorkflowAndWriteTerminal(
         )
         return true
       }
-        )
-        return true
-      }
 
       // Enrichment groups call a registry function directly instead of running a
       // workflow, reusing the same pickup → run → terminal-write status flow. The

apps/sim/enrichments/readiness.test.ts

@@ -2,6 +2,7 @@
  * @vitest-environment node
  */
 import { describe, expect, it } from 'vitest'
+import { companyInfoEnrichment } from '@/enrichments/company-info/company-info'
 import { getEnrichmentReadiness } from '@/enrichments/readiness'
 import { workEmailEnrichment } from '@/enrichments/work-email/work-email'
 
@@ -39,4 +40,13 @@ describe('getEnrichmentReadiness', () => {
     expect(readiness.ready).toBe(false)
     expect(readiness.missingInputs.map((input) => input.id)).toEqual(['fullName'])
   })
+
+  it('reports actionable inputs when present values are rejected by every provider', () => {
+    const readiness = getEnrichmentReadiness(companyInfoEnrichment, {
+      domain: 'https://',
+    })
+
+    expect(readiness.ready).toBe(false)
+    expect(readiness.missingInputs.map((input) => input.id)).toEqual(['domain'])
+  })
 })

apps/sim/enrichments/readiness.ts

@@ -25,8 +25,11 @@ export function getEnrichmentReadiness(
   const ready = enrichment.providers.some((provider) => provider.buildParams(inputs) !== null)
   if (ready) return { ready: true, missingInputs: [] }
 
+  const missingInputs = enrichment.inputs.filter((input) => isEmpty(inputs[input.id]))
   return {
     ready: false,
-    missingInputs: enrichment.inputs.filter((input) => isEmpty(inputs[input.id])),
+    /** If every input is present but every provider rejects the values, surface
+     * all fields as actionable rather than rendering a reasonless wait state. */
+    missingInputs: missingInputs.length > 0 ? missingInputs : enrichment.inputs,
   }
 }

apps/sim/lib/table/deps.test.ts

@@ -74,6 +74,28 @@ describe('optimisticallyScheduleNewlyEligibleGroups — checkbox toggle', () =>
   })
 })
 
+describe('optimisticallyScheduleNewlyEligibleGroups — enrichment inputs', () => {
+  const group = makeGroup({
+    id: 'g1',
+    type: 'enrichment',
+    autoRun: true,
+    inputMappings: [{ inputName: 'companyDomain', columnName: 'domain' }],
+  })
+
+  it('flips a completed enrichment to pending when a mapped input changes', () => {
+    const before = makeRow(
+      { domain: 'old.example', g1_out: 'person@old.example' },
+      { g1: completedExec('wf-g1') }
+    )
+
+    const next = optimisticallyScheduleNewlyEligibleGroups([group], before, {
+      domain: 'new.example',
+    })
+
+    expect(next?.g1?.status).toBe('pending')
+  })
+})
+
 function completedExec(workflowId: string): RowExecutionMetadata {
   return { status: 'completed', executionId: 'e1', jobId: null, workflowId, error: null }
 }

apps/sim/lib/table/deps.ts

@@ -118,6 +118,19 @@ export function getUnmetGroupDeps(group: WorkflowGroup, row: TableRow): UnmetDep
   return { columns }
 }
 
+/**
+ * Columns whose edits invalidate a group's execution. Enrichments consume
+ * their input mappings directly, so those mappings re-arm the cell even when
+ * they are not also configured as automatic-run dependencies.
+ */
+export function getGroupInvalidationColumns(group: WorkflowGroup): string[] {
+  const columns = new Set(group.dependencies?.columns ?? [])
+  if (group.type === 'enrichment') {
+    for (const mapping of group.inputMappings ?? []) columns.add(mapping.columnName)
+  }
+  return [...columns]
+}
+
 /**
  * Optimistic mirror of the server's row-update→scheduler cascade: for every
  * workflow group whose deps were unmet *before* the patch and are satisfied
@@ -168,7 +181,9 @@ export function optimisticallyScheduleNewlyEligibleGroups(
     // flight downstream groups, so optimistically flip to `pending`
     // regardless of current exec status (queued/running included — they're
     // about to be cancelled and re-run).
-    const depTouched = (group.dependencies?.columns ?? []).some((d) => patchedColumns.has(d))
+    const depTouched = getGroupInvalidationColumns(group).some((columnId) =>
+      patchedColumns.has(columnId)
+    )
 
     if (!depTouched && (exec?.status === 'queued' || exec?.status === 'running')) {
       skipped++

apps/sim/lib/table/rows/executions.test.ts

@@ -3,8 +3,8 @@
  */
 import { dbChainMock, dbChainMockFns, resetDbChainMock } from '@sim/testing'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { writeExecutionsPatch } from '@/lib/table/rows/executions'
-import type { RowExecutionMetadata } from '@/lib/table/types'
+import { deriveExecClearsForDataPatch, writeExecutionsPatch } from '@/lib/table/rows/executions'
+import type { RowExecutionMetadata, TableSchema, WorkflowGroup } from '@/lib/table/types'
 
 const EXECUTION_STATE: RowExecutionMetadata = {
   status: 'running',
@@ -14,6 +14,16 @@ const EXECUTION_STATE: RowExecutionMetadata = {
   error: null,
 }
 
+const MANUAL_ENRICHMENT_GROUP: WorkflowGroup = {
+  id: 'enrichment-group',
+  workflowId: '',
+  enrichmentId: 'work-email',
+  type: 'enrichment',
+  autoRun: false,
+  inputMappings: [{ inputName: 'companyDomain', columnName: 'domain' }],
+  outputs: [{ blockId: '', path: '', outputId: 'email', columnName: 'email' }],
+}
+
 function renderCondition(value: unknown): string {
   if (!value || typeof value !== 'object') return ''
   const record = value as Record<string, unknown>
@@ -110,3 +120,31 @@ describe('writeExecutionsPatch guards', () => {
     ).resolves.toBe('wrote')
   })
 })
+
+describe('deriveExecClearsForDataPatch enrichment inputs', () => {
+  it('re-arms a completed manual enrichment when a mapped input changes', () => {
+    const schema: TableSchema = {
+      columns: [
+        { id: 'domain', name: 'Domain', type: 'string' },
+        {
+          id: 'email',
+          name: 'Email',
+          type: 'string',
+          workflowGroupId: MANUAL_ENRICHMENT_GROUP.id,
+        },
+      ],
+      workflowGroups: [MANUAL_ENRICHMENT_GROUP],
+    }
+    const completed = { ...EXECUTION_STATE, status: 'completed' as const }
+
+    const result = deriveExecClearsForDataPatch(
+      { domain: 'new.example' },
+      schema,
+      { [MANUAL_ENRICHMENT_GROUP.id]: completed },
+      undefined,
+      { domain: 'new.example', email: '' }
+    )
+
+    expect(result.executionsPatch).toEqual({ [MANUAL_ENRICHMENT_GROUP.id]: null })
+  })
+})

apps/sim/lib/table/rows/executions.ts

@@ -9,7 +9,7 @@ import { tableRowExecutions } from '@sim/db/schema'
 import { and, eq, inArray, type SQL, sql } from 'drizzle-orm'
 import type { DbOrTx } from '@/lib/db/types'
 import { getColumnId } from '@/lib/table/column-keys'
-import { areGroupDepsSatisfied } from '@/lib/table/deps'
+import { areGroupDepsSatisfied, getGroupInvalidationColumns } from '@/lib/table/deps'
 import type {
   EnrichmentRunDetail,
   RowData,
@@ -152,8 +152,8 @@ export function deriveExecClearsForDataPatch(
   const groups = schema.workflowGroups ?? []
   const afterRow = { data: mergedData } as TableRow
   for (const group of groups) {
-    const deps = group.dependencies?.columns ?? []
-    const depMatched = deps.some((d) => dirtied.has(d))
+    const invalidationColumns = getGroupInvalidationColumns(group)
+    const depMatched = invalidationColumns.some((columnId) => dirtied.has(columnId))
     if (!depMatched) continue
 
     // A dep column changed, but if the group's deps are no longer satisfied