fix(enrichment): wait for valid work email inputs

Author: TheodoreSpeaks

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

@@ -6,6 +6,8 @@ import { PlayOutline, Square } from '@sim/emcn/icons'
 import type { ActiveDispatch } from '@/lib/api/contracts/tables'
 import type { TableRow as TableRowType, WorkflowGroup } from '@/lib/table'
 import { getUnmetGroupDeps } from '@/lib/table/deps'
+import { getEnrichmentReadiness } from '@/enrichments/readiness'
+import { getEnrichment } from '@/enrichments/registry'
 import type { SaveReason } from '../../types'
 import { CellContent } from './cells'
 import {
@@ -180,27 +182,48 @@ export const DataRow = React.memo(function DataRow({
 }: DataRowProps) {
   const sel = normalizedSelection
   /**
-   * Per-row "Waiting on …" labels keyed by group id. A group has labels iff
-   * at least one of its dependencies is unmet for this row — drives the
-   * "Waiting" pill rendered by `CellContent` for empty workflow-output cells.
-   * Computed once per render rather than per cell so all cells in a group
-   * share the same array reference.
+   * Per-row "Waiting on …" labels keyed by group id. A group has labels when
+   * its dependencies are unmet or an enrichment has no provider that can build
+   * a valid request from the row. Computed once per render rather than per cell
+   * so all cells in a group share the same array reference.
    */
   const waitingByGroupId = React.useMemo(() => {
     if (workflowGroups.length === 0) return null
     // Deps are stored as column ids; the "Waiting on …" pill shows display names.
     const nameByColumnId = new Map(columns.map((c) => [c.key, c.name]))
     const map = new Map<string, string[]>()
     for (const group of workflowGroups) {
-      // autoRun=false groups never fire from the scheduler — there's nothing
-      // to wait on. The cell stays empty until the user clicks Run manually.
-      if (group.autoRun === false) continue
-      const unmet = getUnmetGroupDeps(group, row)
-      if (unmet.columns.length === 0) continue
-      map.set(
-        group.id,
-        unmet.columns.map((id) => nameByColumnId.get(id) ?? id)
-      )
+      const labels = new Set<string>()
+      if (group.autoRun !== false) {
+        const unmet = getUnmetGroupDeps(group, row)
+        for (const id of unmet.columns) labels.add(nameByColumnId.get(id) ?? id)
+      }
+
+      if (group.type === 'enrichment') {
+        const enrichment = getEnrichment(group.enrichmentId)
+        if (enrichment) {
+          const inputColumnById = new Map<string, string>()
+          const inputs: Record<string, unknown> = {}
+          for (const mapping of group.inputMappings ?? []) {
+            inputColumnById.set(mapping.inputName, mapping.columnName)
+            inputs[mapping.inputName] = row.data[mapping.columnName]
+          }
+          const readiness = getEnrichmentReadiness(enrichment, inputs)
+          if (!readiness.ready) {
+            const mappedLabels = readiness.missingInputs.flatMap((input) => {
+              const columnId = inputColumnById.get(input.id)
+              return columnId ? [nameByColumnId.get(columnId) ?? columnId] : []
+            })
+            const waitingLabels =
+              mappedLabels.length > 0
+                ? mappedLabels
+                : readiness.missingInputs.map((input) => input.name)
+            for (const label of waitingLabels) labels.add(label)
+          }
+        }
+      }
+
+      if (labels.size > 0) map.set(group.id, [...labels])
     }
     return map
   }, [workflowGroups, row, columns])

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

@@ -208,6 +208,7 @@ async function runWorkflowAndWriteTerminal(
     // workflow path rather than erroring.
     if (group.type === 'enrichment' && group.enrichmentId) {
       const { getEnrichment } = await import('@/enrichments/registry')
+      const { getEnrichmentReadiness } = await import('@/enrichments/readiness')
       const { runEnrichment, skippedEnrichmentDetail } = await import('@/enrichments/run')
       const enrichment = getEnrichment(group.enrichmentId)
       // `tableRowExecutions.workflowId` is an opaque id for status; use the
@@ -300,15 +301,16 @@ async function runWorkflowAndWriteTerminal(
         enrichInputs[m.inputName] = row.data[m.columnName]
       }
 
-      // Skip (don't error) rows missing a required input — common when a table
-      // is partially filled. Clear any prior output values so a stale result
-      // doesn't linger (and doesn't mark the group `completed`-and-filled, which
-      // would block the auto cascade from re-enriching once inputs return).
+      /**
+       * Skip (don't error) rows where no provider can build a valid request —
+       * common when a table is partially filled. Clear any prior output values
+       * so a stale result doesn't linger (and doesn't mark the group
+       * `completed`-and-filled, which would block the auto cascade from
+       * re-enriching once inputs return).
+       */
       const isEmpty = (v: unknown) => v === undefined || v === null || v === ''
-      const missingRequired = enrichment.inputs.some(
-        (i) => i.required && isEmpty(enrichInputs[i.id])
-      )
-      if (missingRequired) {
+      const readiness = getEnrichmentReadiness(enrichment, enrichInputs)
+      if (!readiness.ready) {
         const clearPatch: RowData = {}
         for (const out of group.outputs) {
           if (!isEmpty(row.data[out.columnName])) clearPatch[out.columnName] = ''

apps/sim/enrichments/readiness.test.ts

@@ -0,0 +1,42 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it } from 'vitest'
+import { getEnrichmentReadiness } from '@/enrichments/readiness'
+import { workEmailEnrichment } from '@/enrichments/work-email/work-email'
+
+describe('getEnrichmentReadiness', () => {
+  it('waits for an identifier when a work-email row only has a name', () => {
+    const readiness = getEnrichmentReadiness(workEmailEnrichment, { fullName: 'John Doe' })
+
+    expect(readiness.ready).toBe(false)
+    expect(readiness.missingInputs.map((input) => input.id)).toEqual([
+      'companyDomain',
+      'linkedinUrl',
+    ])
+  })
+
+  it('accepts either a company domain or LinkedIn URL', () => {
+    expect(
+      getEnrichmentReadiness(workEmailEnrichment, {
+        fullName: 'John Doe',
+        companyDomain: 'acme.com',
+      }).ready
+    ).toBe(true)
+    expect(
+      getEnrichmentReadiness(workEmailEnrichment, {
+        fullName: 'John Doe',
+        linkedinUrl: 'https://linkedin.com/in/johndoe',
+      }).ready
+    ).toBe(true)
+  })
+
+  it('reports missing required inputs before provider-specific inputs', () => {
+    const readiness = getEnrichmentReadiness(workEmailEnrichment, {
+      companyDomain: 'acme.com',
+    })
+
+    expect(readiness.ready).toBe(false)
+    expect(readiness.missingInputs.map((input) => input.id)).toEqual(['fullName'])
+  })
+})

apps/sim/enrichments/readiness.ts

@@ -0,0 +1,32 @@
+import type { EnrichmentConfig, EnrichmentInputField } from '@/enrichments/types'
+
+export interface EnrichmentReadiness {
+  ready: boolean
+  missingInputs: EnrichmentInputField[]
+}
+
+/**
+ * Checks whether an enrichment has its required inputs and at least one
+ * provider can build a valid request from the available values.
+ */
+export function getEnrichmentReadiness(
+  enrichment: EnrichmentConfig,
+  inputs: Record<string, unknown>
+): EnrichmentReadiness {
+  const isEmpty = (value: unknown) =>
+    value === undefined || value === null || (typeof value === 'string' && value.trim() === '')
+  const missingRequired = enrichment.inputs.filter(
+    (input) => input.required && isEmpty(inputs[input.id])
+  )
+  if (missingRequired.length > 0) {
+    return { ready: false, missingInputs: missingRequired }
+  }
+
+  const ready = enrichment.providers.some((provider) => provider.buildParams(inputs) !== null)
+  if (ready) return { ready: true, missingInputs: [] }
+
+  return {
+    ready: false,
+    missingInputs: enrichment.inputs.filter((input) => isEmpty(inputs[input.id])),
+  }
+}

apps/sim/enrichments/work-email/work-email.test.ts

@@ -89,6 +89,24 @@ describe('work-email enrichment cascade', () => {
     })
   })
 
+  describe('pdl', () => {
+    const p = provider('pdl')
+    it('uses a valid profile or name-and-company match and skips name alone', () => {
+      expect(p.buildParams(linkedinOnly)).toEqual({
+        profile: 'https://linkedin.com/in/johndoe',
+        min_likelihood: 6,
+        required: 'work_email',
+      })
+      expect(p.buildParams(nameDomain)).toEqual({
+        name: 'John Doe',
+        company: 'acme.com',
+        min_likelihood: 6,
+        required: 'work_email',
+      })
+      expect(p.buildParams({ fullName: 'John Doe' })).toBeNull()
+    })
+  })
+
   describe('datagma', () => {
     const p = provider('datagma')
     it('maps name + normalized company domain', () => {

apps/sim/enrichments/work-email/work-email.ts

@@ -120,16 +120,25 @@ export const workEmailEnrichment: EnrichmentConfig = {
       label: 'People Data Labs',
       toolId: 'pdl_person_enrich',
       buildParams: (inputs) => {
+        const profile = str(inputs.linkedinUrl)
+        if (profile) {
+          return {
+            profile,
+            min_likelihood: 6,
+            required: 'work_email',
+          }
+        }
         const name = str(inputs.fullName)
-        if (!name) return null
+        const company = normalizeDomain(inputs.companyDomain)
+        if (!name || !company) return null
         // `required` makes PDL 404 (free) when the profile has no work email,
         // instead of charging a credit for a match we'd discard as a no-match.
-        return filterUndefined({
+        return {
           name,
-          company: normalizeDomain(inputs.companyDomain) || undefined,
+          company,
           min_likelihood: 6,
           required: 'work_email',
-        })
+        }
       },
       mapOutput: (output) => {
         const person = output.person as Record<string, unknown> | undefined