refactor(table): consolidate exec-status helpers + fix N-running counter

TheodoreSpeaks · TheodoreSpeaks · commit 01deeab6851b · 2026-05-07T02:09:25.000-07:00
Cleanup pass on the recent table changes — pulls duplicated predicates and
SQL snippets into shared helpers and fixes one drift bug along the way.

- isExecInFlight: now single export from lib/table/deps.ts. Removed the
  duplicate in components/table-grid/utils.ts. Used by isGroupEligible
  (server eligibility) and runningByRowId (client counter).
- isOptimisticInFlight: kept local to hooks/queries/tables.ts — renamed from
  isInFlight to disambiguate from the stricter isExecInFlight. The two
  predicates differ on `pending` without a jobId: optimistic patches and
  poll-trigger want the broader version, eligibility wants the strict one.
- areOutputsFilled: single export from lib/table/deps.ts, dropped duplicate
  from workflow-columns.ts.
- classifyExecStatusMix: shared row × group walker in table-grid/utils.ts.
  Replaces two copies of the same loop in table-grid.tsx (selectionStats +
  contextMenuStats). Both surfaces now have the same short-circuit
  semantics, including the seen-all-selected-rows early break that
  contextMenuStats was missing.
- stripGroupExecutions: SQL helper in service.ts. Replaces three copies of
  the `UPDATE user_table_rows SET executions = executions - $gid::text`
  pattern across deleteColumn / deleteColumns / deleteWorkflowGroup.

Drift bug:
- runningByRowId / totalRunning counted only `running` and `queued`. Every
  other in-flight check in the codebase treats post-stamp `pending` as
  in-flight too, so the page-header "N running" badge briefly dropped to 0
  between scheduler stamp and worker pickup. Now uses isExecInFlight.
diff --git a/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/table-grid.tsx b/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/table-grid.tsx
@@ -10,7 +10,7 @@ import type { RunMode } from '@/lib/api/contracts/tables'
 import { cn } from '@/lib/core/utils/cn'
 import { captureEvent } from '@/lib/posthog/client'
 import type { ColumnDefinition, TableRow as TableRowType, WorkflowGroup } from '@/lib/table'
-import { getUnmetGroupDeps } from '@/lib/table/deps'
+import { getUnmetGroupDeps, isExecInFlight } from '@/lib/table/deps'
 import { useUserPermissionsContext } from '@/app/workspace/[workspaceId]/providers/workspace-permissions-provider'
 import {
   useAddTableColumn,
@@ -46,8 +46,10 @@ import type { DisplayColumn } from './types'
 import {
   buildHeaderGroups,
   type CellCoord,
+  classifyExecStatusMix,
   collectRowSnapshots,
   computeNormalizedSelection,
+  type ExecStatusMix,
   expandToDisplayColumns,
   moveCell,
   type NormalizedSelection,
@@ -116,11 +118,7 @@ export interface SelectionSnapshot {
   selectedRunScope: { groupIds: string[]; rowIds: string[] } | null
   /** Drives Play (`hasIncompleteOrFailed`) / Refresh (`hasCompleted`) /
    *  Stop (`hasInFlight`) visibility on the action bar. */
-  selectionStats: {
-    hasIncompleteOrFailed: boolean
-    hasCompleted: boolean
-    hasInFlight: boolean
-  }
+  selectionStats: ExecStatusMix
   /**
    * When the highlight resolves to exactly one workflow-group execution —
    * same row, every highlighted column in the same workflow group — describe
@@ -2569,8 +2567,7 @@ export function TableGrid({
       let count = 0
       const executions = row.executions ?? {}
       for (const gid in executions) {
-        const status = executions[gid]?.status
-        if (status === 'running' || status === 'queued') count++
+        if (isExecInFlight(executions[gid])) count++
       }
       if (count > 0) {
         byRow.set(row.id, count)
@@ -2671,30 +2668,12 @@ export function TableGrid({
     [tableWorkflowGroups]
   )
 
-  // Status mix across the (row, group) cells the context menu is acting on.
-  // Drives Run vs Refresh visibility in the dropdown — same shape the action
-  // bar uses for its selectionStats so both surfaces stay in sync.
-  const contextMenuStats = useMemo(() => {
-    let hasIncompleteOrFailed = false
-    let hasCompleted = false
-    if (contextMenuRowIds.length === 0 || tableWorkflowGroupIds.length === 0) {
-      return { hasIncompleteOrFailed, hasCompleted }
-    }
-    const rowIdSet = new Set(contextMenuRowIds)
-    for (const row of rows) {
-      if (!rowIdSet.has(row.id)) continue
-      for (const groupId of tableWorkflowGroupIds) {
-        const status = readExecution(row, groupId)?.status
-        if (status === 'queued' || status === 'running' || status === 'pending') continue
-        if (status === 'completed') hasCompleted = true
-        else hasIncompleteOrFailed = true
-        if (hasIncompleteOrFailed && hasCompleted) {
-          return { hasIncompleteOrFailed, hasCompleted }
-        }
-      }
-    }
-    return { hasIncompleteOrFailed, hasCompleted }
-  }, [contextMenuRowIds, rows, tableWorkflowGroupIds])
+  // Drives Run vs Refresh visibility on the context menu — same classifier
+  // the action bar uses, so both surfaces stay in sync.
+  const contextMenuStats = useMemo(
+    () => classifyExecStatusMix(rows, new Set(contextMenuRowIds), tableWorkflowGroupIds),
+    [contextMenuRowIds, rows, tableWorkflowGroupIds]
+  )
 
   // Run scope is derived from one of two selection sources:
   //   - checkedRows (whole-row selection) → those rows × every workflow group
@@ -2730,36 +2709,13 @@ export function TableGrid({
   }, [checkedRows, normalizedSelection, rows, displayColumns, tableWorkflowGroupIds])
 
   const selectionStats = useMemo<SelectionSnapshot['selectionStats']>(() => {
-    let hasIncompleteOrFailed = false
-    let hasCompleted = false
-    let hasInFlight = false
-    if (!selectedRunScope) return { hasIncompleteOrFailed, hasCompleted, hasInFlight }
-    // Walk only the selected rows (not every row in the table). When the
-    // selection comes from `checkedRows` we have a Set already; for the
-    // rectangle path we build one over the small rowIds list.
-    const rowIdSet = checkedRows.size > 0 ? checkedRows : new Set(selectedRunScope.rowIds)
-    const target = selectedRunScope.rowIds.length
-    let seen = 0
-    const groupIds = selectedRunScope.groupIds
-    for (const row of rows) {
-      if (!rowIdSet.has(row.id)) continue
-      seen++
-      for (const groupId of groupIds) {
-        const status = readExecution(row, groupId)?.status
-        if (status === 'queued' || status === 'running' || status === 'pending') {
-          hasInFlight = true
-        } else if (status === 'completed') {
-          hasCompleted = true
-        } else {
-          hasIncompleteOrFailed = true
-        }
-        if (hasInFlight && hasCompleted && hasIncompleteOrFailed) {
-          return { hasIncompleteOrFailed, hasCompleted, hasInFlight }
-        }
-      }
-      if (seen === target) break
+    if (!selectedRunScope) {
+      return { hasIncompleteOrFailed: false, hasCompleted: false, hasInFlight: false }
     }
-    return { hasIncompleteOrFailed, hasCompleted, hasInFlight }
+    // Reuse `checkedRows` as the rowIdSet when the selection comes from
+    // checkboxes — saves an O(n) Set construction for "select all 10k rows."
+    const rowIdSet = checkedRows.size > 0 ? checkedRows : new Set(selectedRunScope.rowIds)
+    return classifyExecStatusMix(rows, rowIdSet, selectedRunScope.groupIds)
   }, [selectedRunScope, rows, checkedRows])
 
   // Emit selection snapshots so the wrapper can render <TableActionBar>.
diff --git a/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/utils.ts b/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/utils.ts
@@ -123,15 +123,51 @@ export function readExecution(
   return row?.executions?.[groupId]
 }
 
-/** True when the cell has a worker actively reserved (queued / running, or
- *  pending after the scheduler stamped a jobId). Mirrors the eligibility
- *  predicate's in-flight check on the server. */
-export function isExecInFlight(exec: RowExecutionMetadata | undefined): boolean {
-  if (!exec) return false
-  const s = exec.status
-  if (s === 'queued' || s === 'running') return true
-  if (s === 'pending' && exec.jobId) return true
-  return false
+export interface ExecStatusMix {
+  hasIncompleteOrFailed: boolean
+  hasCompleted: boolean
+  hasInFlight: boolean
+}
+
+/**
+ * Walks `(rowIdSet × groupIds)` exec statuses on `rows` and reports which
+ * status buckets are present. Short-circuits once all three buckets are
+ * observed and once every selected row has been visited. Drives Play /
+ * Refresh / Stop visibility on the action bar and the context menu — both
+ * surfaces use the same shape so they stay in sync.
+ */
+export function classifyExecStatusMix(
+  rows: TableRowType[],
+  rowIdSet: ReadonlySet<string>,
+  groupIds: readonly string[]
+): ExecStatusMix {
+  const result: ExecStatusMix = {
+    hasIncompleteOrFailed: false,
+    hasCompleted: false,
+    hasInFlight: false,
+  }
+  if (rowIdSet.size === 0 || groupIds.length === 0) return result
+  const target = rowIdSet.size
+  let seen = 0
+  for (const row of rows) {
+    if (!rowIdSet.has(row.id)) continue
+    seen++
+    for (const groupId of groupIds) {
+      const status = readExecution(row, groupId)?.status
+      if (status === 'queued' || status === 'running' || status === 'pending') {
+        result.hasInFlight = true
+      } else if (status === 'completed') {
+        result.hasCompleted = true
+      } else {
+        result.hasIncompleteOrFailed = true
+      }
+      if (result.hasInFlight && result.hasCompleted && result.hasIncompleteOrFailed) {
+        return result
+      }
+    }
+    if (seen === target) break
+  }
+  return result
 }
 
 export function moveCell(
diff --git a/apps/sim/hooks/queries/tables.ts b/apps/sim/hooks/queries/tables.ts
@@ -78,9 +78,7 @@ function hasRunningGroupExecution(rows: TableRow[] | undefined): boolean {
   for (const row of rows) {
     const executions = row.executions ?? {}
     for (const key in executions) {
-      const exec = executions[key]
-      if (exec?.status === 'running' || exec?.status === 'queued' || exec?.status === 'pending')
-        return true
+      if (isOptimisticInFlight(executions[key])) return true
     }
   }
   return false
@@ -825,8 +823,7 @@ export function useCancelTableRuns({ workspaceId, tableId }: RowMutationContext)
         const nextExecutions: RowExecutions = { ...executions }
         for (const gid in executions) {
           const exec = executions[gid]
-          if (exec.status !== 'running' && exec.status !== 'queued' && exec.status !== 'pending')
-            continue
+          if (!isOptimisticInFlight(exec)) continue
           // Preserve blockErrors so cells that already errored keep their
           // Error rendering after the stop — only cells without a value or
           // error should flip to "Cancelled".
@@ -1138,7 +1135,11 @@ function buildPendingExec(
   }
 }
 
-function isInFlight(exec: RowExecutionMetadata | undefined): boolean {
+/** Broader sibling of `isExecInFlight` from `lib/table/deps`: treats any
+ *  `pending` (with or without a jobId) as in-flight. The optimistic-patch
+ *  context uses this to avoid re-marking a cell we just flipped optimistically.
+ *  The eligibility predicate uses the stricter version. */
+function isOptimisticInFlight(exec: RowExecutionMetadata | undefined): boolean {
   return exec?.status === 'running' || exec?.status === 'queued' || exec?.status === 'pending'
 }
 
@@ -1173,7 +1174,7 @@ export function useRunColumn({ workspaceId, tableId }: RowMutationContext) {
         const next: RowExecutions = { ...executions }
         for (const groupId of targetGroupIds) {
           const exec = executions[groupId] as RowExecutionMetadata | undefined
-          if (isInFlight(exec)) continue
+          if (isOptimisticInFlight(exec)) continue
           if (runMode === 'incomplete' && exec?.status === 'completed') continue
           next[groupId] = buildPendingExec(exec)
           changed = true
diff --git a/apps/sim/lib/table/deps.ts b/apps/sim/lib/table/deps.ts
@@ -6,6 +6,36 @@
 
 import type { RowData, RowExecutionMetadata, RowExecutions, TableRow, WorkflowGroup } from './types'
 
+/**
+ * True when the cell has a worker actively reserved — `queued` / `running`,
+ * or `pending` after the scheduler stamped a jobId. Single source of truth
+ * for the "is this exec in flight" classification across the eligibility
+ * predicate, optimistic patches, status counters, and renderer. `pending`
+ * without a jobId is the optimistic-flag-only state, not in-flight.
+ */
+export function isExecInFlight(exec: RowExecutionMetadata | undefined): boolean {
+  if (!exec) return false
+  const s = exec.status
+  if (s === 'queued' || s === 'running') return true
+  if (s === 'pending' && exec.jobId) return true
+  return false
+}
+
+/**
+ * True when every output column the group writes still has a non-empty value
+ * on this row. The "completed" exec status is metadata, but the cells are the
+ * source of truth — if the user cleared an output cell, the row is effectively
+ * incomplete and should be re-run on dep-fill / manual incomplete-mode runs.
+ */
+export function areOutputsFilled(group: WorkflowGroup, row: TableRow): boolean {
+  if (group.outputs.length === 0) return true
+  for (const o of group.outputs) {
+    const v = row.data[o.columnName]
+    if (v === null || v === undefined || v === '') return false
+  }
+  return true
+}
+
 /**
  * Returns true when every column this group depends on is non-empty on this
  * row. Workflow output columns count the same as plain columns — the model
@@ -97,12 +127,3 @@ export function optimisticallyScheduleNewlyEligibleGroups(
   }
   return next
 }
-
-function areOutputsFilled(group: WorkflowGroup, row: TableRow): boolean {
-  if (group.outputs.length === 0) return true
-  for (const o of group.outputs) {
-    const v = row.data[o.columnName]
-    if (v === null || v === undefined || v === '') return false
-  }
-  return true
-}
diff --git a/apps/sim/lib/table/service.ts b/apps/sim/lib/table/service.ts
@@ -1598,6 +1598,24 @@ function buildExecutionsSqlPatch(
   return expr
 }
 
+/**
+ * Strips the given workflow group ids from every row's `executions` jsonb on
+ * a table — used by the column / group delete paths so stale running/queued
+ * exec records don't linger and inflate counters after the group is gone.
+ * The caller wraps in their own transaction.
+ */
+async function stripGroupExecutions(
+  trx: Parameters<Parameters<typeof db.transaction>[0]>[0],
+  tableId: string,
+  groupIds: Iterable<string>
+): Promise<void> {
+  for (const gid of groupIds) {
+    await trx.execute(
+      sql`UPDATE user_table_rows SET executions = executions - ${gid}::text WHERE table_id = ${tableId} AND executions ? ${gid}::text`
+    )
+  }
+}
+
 /**
  * Updates a single row.
  *
@@ -2425,15 +2443,7 @@ export async function deleteColumn(
     await trx.execute(
       sql`UPDATE user_table_rows SET data = data - ${actualName}::text WHERE table_id = ${data.tableId} AND data ? ${actualName}::text`
     )
-    // If deleting this column orphaned its parent group (last output gone),
-    // strip the group's exec entries from every row. Otherwise stale
-    // running/queued exec records linger forever and inflate the
-    // "N running" counter.
-    if (groupRemovedId) {
-      await trx.execute(
-        sql`UPDATE user_table_rows SET executions = executions - ${groupRemovedId}::text WHERE table_id = ${data.tableId} AND executions ? ${groupRemovedId}::text`
-      )
-    }
+    if (groupRemovedId) await stripGroupExecutions(trx, data.tableId, [groupRemovedId])
   })
 
   logger.info(`[${requestId}] Deleted column "${actualName}" from table ${data.tableId}`)
@@ -2536,13 +2546,7 @@ export async function deleteColumns(
         sql`UPDATE user_table_rows SET data = data - ${name}::text WHERE table_id = ${data.tableId} AND data ? ${name}::text`
       )
     }
-    // Strip exec entries for any group orphaned by these column deletes —
-    // see `deleteColumn` for rationale.
-    for (const gid of removedGroupIds) {
-      await trx.execute(
-        sql`UPDATE user_table_rows SET executions = executions - ${gid}::text WHERE table_id = ${data.tableId} AND executions ? ${gid}::text`
-      )
-    }
+    await stripGroupExecutions(trx, data.tableId, removedGroupIds)
   })
 
   logger.info(
@@ -3443,9 +3447,7 @@ export async function deleteWorkflowGroup(
         sql`UPDATE user_table_rows SET data = data - ${name}::text WHERE table_id = ${data.tableId} AND data ? ${name}::text`
       )
     }
-    await trx.execute(
-      sql`UPDATE user_table_rows SET executions = executions - ${data.groupId}::text WHERE table_id = ${data.tableId} AND executions ? ${data.groupId}::text`
-    )
+    await stripGroupExecutions(trx, data.tableId, [data.groupId])
   })
 
   logger.info(`[${requestId}] Deleted workflow group "${data.groupId}" from table ${data.tableId}`)
diff --git a/apps/sim/lib/table/workflow-columns.ts b/apps/sim/lib/table/workflow-columns.ts
@@ -26,30 +26,17 @@ import type {
 
 const logger = createLogger('WorkflowGroupScheduler')
 
-import { areGroupDepsSatisfied } from './deps'
+import { areGroupDepsSatisfied, areOutputsFilled, isExecInFlight } from './deps'
 
 export {
   areGroupDepsSatisfied,
+  areOutputsFilled,
   getUnmetGroupDeps,
+  isExecInFlight,
   optimisticallyScheduleNewlyEligibleGroups,
   type UnmetDeps,
 } from './deps'
 
-/**
- * True when every output column the group writes still has a non-empty value
- * on this row. The "completed" exec status is metadata, but the cells are the
- * source of truth — if the user cleared an output cell, the row is effectively
- * incomplete and should be re-run on dep-fill / manual incomplete-mode runs.
- */
-function areOutputsFilled(group: WorkflowGroup, row: TableRow): boolean {
-  if (group.outputs.length === 0) return true
-  for (const o of group.outputs) {
-    const v = row.data[o.columnName]
-    if (v === null || v === undefined || v === '') return false
-  }
-  return true
-}
-
 /**
  * Per-(row, group) eligibility for both the auto-fire reactor and manual
  * runs. Manual runs bypass the `autoRun === false` skip, and additionally
@@ -70,9 +57,8 @@ export function isGroupEligible(
   if (group.autoRun === false && !isManualRun) return false
 
   const exec = row.executions?.[group.id]
+  if (isExecInFlight(exec)) return false
   const status = exec?.status
-  if (status === 'queued' || status === 'running') return false
-  if (status === 'pending' && exec?.jobId) return false
 
   const completedAndFilled = status === 'completed' && areOutputsFilled(group, row)
   if (!isManualRun && completedAndFilled) return false
