Simplify stripping column names

Author: TheodoreSpeaks

apps/sim/hooks/queries/tables.ts

@@ -84,6 +84,16 @@ function hasRunningGroupExecution(rows: TableRow[] | undefined): boolean {
   return false
 }
 
+function hasRunningGroupExecutionInPages(
+  pages: TableRowsResponse[] | undefined
+): boolean {
+  if (!pages) return false
+  for (const page of pages) {
+    if (hasRunningGroupExecution(page.rows)) return true
+  }
+  return false
+}
+
 const logger = createLogger('TableQueries')
 
 type TableQueryScope = 'active' | 'archived' | 'all'
@@ -317,8 +327,9 @@ export function useInfiniteTableRows({
      */
     refetchInterval: (query) => {
       if (queryClient.isMutating() > 0) return false
-      const rows = query.state.data?.pages.flatMap((p) => p.rows)
-      return hasRunningGroupExecution(rows) ? ROWS_POLL_INTERVAL_WHILE_RUNNING_MS : false
+      return hasRunningGroupExecutionInPages(query.state.data?.pages)
+        ? ROWS_POLL_INTERVAL_WHILE_RUNNING_MS
+        : false
     },
     refetchIntervalInBackground: false,
   })

apps/sim/lib/table/deps.ts

@@ -95,24 +95,25 @@ export function optimisticallyScheduleNewlyEligibleGroups(
   }
 
   let next: RowExecutions | null = null
+  let flipped = 0
+  let skipped = 0
   for (const group of groups) {
-    const tag = `[OptimisticCascade] row=${beforeRow.id} group=${group.id}`
     if (group.autoRun === false) {
-      logger.debug(`${tag} → skip: autoRun=false`)
+      skipped++
       continue
     }
     if (!areGroupDepsSatisfied(group, afterRow)) {
-      logger.debug(`${tag} → skip: deps unmet on afterRow`)
+      skipped++
       continue
     }
 
     const exec = beforeRow.executions?.[group.id]
     if (exec?.status === 'queued' || exec?.status === 'running') {
-      logger.debug(`${tag} → skip: already ${exec.status}`)
+      skipped++
       continue
     }
     if (exec?.status === 'pending' && exec.jobId) {
-      logger.debug(`${tag} → skip: pending+jobId (worker reserved)`)
+      skipped++
       continue
     }
 
@@ -121,13 +122,11 @@ export function optimisticallyScheduleNewlyEligibleGroups(
     const becameSatisfied = !wasSatisfied
     const isRetryable = exec?.status === 'cancelled' || exec?.status === 'error'
     if (!becameSatisfied && !isStaleCompleted && !isRetryable && exec) {
-      logger.debug(`${tag} → skip: no fire reason (status=${exec?.status})`)
+      skipped++
       continue
     }
 
-    logger.debug(
-      `${tag} → flip to pending (becameSatisfied=${becameSatisfied} stale=${isStaleCompleted} retry=${isRetryable})`
-    )
+    flipped++
     if (next === null) next = { ...(beforeRow.executions ?? {}) }
     const pending: RowExecutionMetadata = {
       status: 'pending',
@@ -138,5 +137,10 @@ export function optimisticallyScheduleNewlyEligibleGroups(
     }
     next[group.id] = pending
   }
+  if (flipped > 0) {
+    logger.debug(
+      `[OptimisticCascade] row=${beforeRow.id} flipped=${flipped} skipped=${skipped}`
+    )
+  }
   return next
 }

apps/sim/lib/table/service.ts

@@ -61,7 +61,12 @@ import {
   validateTableName,
   validateTableSchema,
 } from './validation'
-import { assertValidSchema, scheduleRunsForRows, scheduleRunsForTable } from './workflow-columns'
+import {
+  assertValidSchema,
+  scheduleRunsForRows,
+  scheduleRunsForTable,
+  stripGroupDeps,
+} from './workflow-columns'
 
 const logger = createLogger('TableService')
 
@@ -2400,16 +2405,7 @@ export async function deleteColumn(
         }
         next = { ...next, outputs: remaining }
       }
-      const filtered = next.dependencies?.columns?.filter((d) => d !== actualName)
-      if (filtered && filtered.length !== (next.dependencies?.columns?.length ?? 0)) {
-        next = {
-          ...next,
-          ...(filtered.length > 0
-            ? { dependencies: { columns: filtered } }
-            : { dependencies: undefined }),
-        }
-      }
-      return next
+      return stripGroupDeps(next, new Set([actualName]))
     })
     .filter((g) => g.id !== groupRemovedId)
 
@@ -2502,17 +2498,7 @@ export async function deleteColumns(
   })
   updatedGroups = updatedGroups
     .filter((g) => !removedGroupIds.has(g.id))
-    .map((group) => {
-      const depCols = group.dependencies?.columns?.filter((d) => !namesToDelete.has(d))
-      const colsChanged = depCols && depCols.length !== (group.dependencies?.columns?.length ?? 0)
-      if (!colsChanged) return group
-      return {
-        ...group,
-        ...(depCols && depCols.length > 0
-          ? { dependencies: { columns: depCols } }
-          : { dependencies: undefined }),
-      }
-    })
+    .map((group) => stripGroupDeps(group, namesToDelete))
   const updatedSchema: TableSchema = {
     ...schema,
     columns: remaining,
@@ -2983,17 +2969,7 @@ export async function updateWorkflowGroup(
   // refs so we don't leave dangling-column deps that fail schema validation.
   const nextGroups = groups
     .map((g, i) => (i === groupIndex ? updatedGroup : g))
-    .map((g) => {
-      if (g.id === updatedGroup.id) return g
-      const filtered = g.dependencies?.columns?.filter((d) => !removedColumnNames.has(d))
-      if (!filtered || filtered.length === (g.dependencies?.columns?.length ?? 0)) return g
-      return {
-        ...g,
-        ...(filtered.length > 0
-          ? { dependencies: { columns: filtered } }
-          : { dependencies: undefined }),
-      }
-    })
+    .map((g) => (g.id === updatedGroup.id ? g : stripGroupDeps(g, removedColumnNames)))
   const updatedSchema: TableSchema = {
     ...schema,
     columns: nextColumns,
@@ -3424,16 +3400,7 @@ export async function deleteWorkflowGroup(
   // Strip those refs so we don't leave dangling-column deps behind.
   const nextGroups = groups
     .filter((g) => g.id !== data.groupId)
-    .map((g) => {
-      const filtered = g.dependencies?.columns?.filter((d) => !removedColumnNames.has(d))
-      if (!filtered || filtered.length === (g.dependencies?.columns?.length ?? 0)) return g
-      return {
-        ...g,
-        ...(filtered.length > 0
-          ? { dependencies: { columns: filtered } }
-          : { dependencies: undefined }),
-      }
-    })
+    .map((g) => stripGroupDeps(g, removedColumnNames))
   const updatedSchema: TableSchema = {
     ...schema,
     columns: schema.columns.filter((c) => !removedColumnNames.has(c.name)),

apps/sim/lib/table/workflow-columns.ts

@@ -47,52 +47,52 @@ export {
  * cells win over the exec metadata, so deleting an output value re-arms the
  * row for the cascade and for manual incomplete-mode runs.
  */
-export function isGroupEligible(
+/**
+ * Reason codes the eligibility predicate emits. Stable strings so the caller
+ * can aggregate skip reasons into one summary log per scheduler call instead
+ * of allocating a per-cell debug line.
+ */
+export type EligibilityReason =
+  | 'eligible'
+  | 'autoRun-off'
+  | 'in-flight'
+  | 'completed-on-auto'
+  | 'error-on-auto'
+  | 'completed-on-incomplete'
+  | 'manual-bypass'
+  | 'deps-unmet'
+
+export function classifyEligibility(
   group: WorkflowGroup,
   row: TableRow,
   opts?: { isManualRun?: boolean; mode?: 'all' | 'incomplete' }
-): boolean {
+): EligibilityReason {
   const isManualRun = opts?.isManualRun ?? false
   const mode = opts?.mode ?? 'all'
-  const tag = `[Eligibility] row=${row.id} group=${group.id} manual=${isManualRun} mode=${mode}`
 
-  if (group.autoRun === false && !isManualRun) {
-    logger.debug(`${tag} → skip: autoRun=false on auto-fire`)
-    return false
-  }
+  if (group.autoRun === false && !isManualRun) return 'autoRun-off'
 
   const exec = row.executions?.[group.id]
-  if (isExecInFlight(exec)) {
-    logger.debug(`${tag} → skip: in-flight (status=${exec?.status})`)
-    return false
-  }
+  if (isExecInFlight(exec)) return 'in-flight'
   const status = exec?.status
 
   const completedAndFilled = status === 'completed' && areOutputsFilled(group, row)
-  if (!isManualRun && completedAndFilled) {
-    logger.debug(`${tag} → skip: completed+filled on auto-fire`)
-    return false
-  }
+  if (!isManualRun && completedAndFilled) return 'completed-on-auto'
   // Auto-fire skips `error` to avoid infinite-retry loops on a deterministic
-  // failure. `cancelled` doesn't get the same treatment — cancellation is
-  // user-initiated, and once an upstream dep re-fires the cascade, the user
-  // almost certainly wants the chain to continue.
-  if (!isManualRun && status === 'error') {
-    logger.debug(`${tag} → skip: terminal status=error on auto-fire`)
-    return false
-  }
-  if (mode === 'incomplete' && completedAndFilled) {
-    logger.debug(`${tag} → skip: completed+filled on mode=incomplete`)
-    return false
-  }
+  // failure. `cancelled` is left runnable — cancellation is user-initiated.
+  if (!isManualRun && status === 'error') return 'error-on-auto'
+  if (mode === 'incomplete' && completedAndFilled) return 'completed-on-incomplete'
 
-  if (isManualRun && group.autoRun === false) {
-    logger.debug(`${tag} → eligible: manual on autoRun=false group (deps bypassed)`)
-    return true
-  }
-  const depsOk = areGroupDepsSatisfied(group, row)
-  logger.debug(`${tag} → ${depsOk ? 'eligible: deps satisfied' : 'skip: deps unmet'}`)
-  return depsOk
+  if (isManualRun && group.autoRun === false) return 'manual-bypass'
+  return areGroupDepsSatisfied(group, row) ? 'eligible' : 'deps-unmet'
+}
+
+export function isGroupEligible(
+  group: WorkflowGroup,
+  row: TableRow,
+  opts?: { isManualRun?: boolean; mode?: 'all' | 'incomplete' }
+): boolean {
+  return classifyEligibility(group, row, opts) === 'eligible'
 }
 
 /**
@@ -130,18 +130,19 @@ export async function scheduleRunsForRows(
     const groups = groupIdFilter ? allGroups.filter((g) => groupIdFilter.has(g.id)) : allGroups
     if (groups.length === 0) return { triggered: 0 }
 
-    logger.debug(
-      `[Cascade] scheduleRunsForRows table=${table.id} rows=${rows.length} groups=${groups.length} manual=${opts?.isManualRun ?? false} mode=${opts?.mode ?? 'all'} scoped=${groupIdFilter ? 'yes' : 'no'}`
-    )
-
     const orderedRows = rows.length <= 1 ? rows : [...rows].sort((a, b) => a.position - b.position)
 
     const pendingRuns: RunGroupCellOptions[] = []
+    const reasonCounts: Partial<Record<EligibilityReason, number>> = {}
 
     for (const row of orderedRows) {
       for (const group of groups) {
-        if (!isGroupEligible(group, row, { isManualRun: opts?.isManualRun, mode: opts?.mode }))
-          continue
+        const reason = classifyEligibility(group, row, {
+          isManualRun: opts?.isManualRun,
+          mode: opts?.mode,
+        })
+        reasonCounts[reason] = (reasonCounts[reason] ?? 0) + 1
+        if (reason !== 'eligible') continue
         pendingRuns.push({
           tableId: table.id,
           tableName: table.name,
@@ -154,6 +155,10 @@ export async function scheduleRunsForRows(
       }
     }
 
+    logger.debug(
+      `[Cascade] table=${table.id} rows=${rows.length} groups=${groups.length} manual=${opts?.isManualRun ?? false} mode=${opts?.mode ?? 'all'} reasons=${JSON.stringify(reasonCounts)}`
+    )
+
     if (pendingRuns.length === 0) return { triggered: 0 }
 
     logger.info(`Scheduling ${pendingRuns.length} workflow group cell run(s) for table=${table.id}`)
@@ -418,14 +423,13 @@ export async function cancelWorkflowGroupRuns(tableId: string, rowId?: string):
 }
 
 /**
- * Generalized run helper. Three public wrappers below pin specific
- * argument shapes; this is the shared inner primitive.
- *
- * `groupIds` omitted = every workflow group on the table.
- * `rowIds` omitted = every row (with `mode === 'incomplete'` filter applied
- * per group when targeting specific groups).
+ * Run a set of groups across the table or a row subset. Single canonical
+ * user-driven run op — every UI gesture (single cell, per-row Play, action-bar
+ * Play/Refresh, column-header menu) reduces to this. `mode: 'all'` re-runs
+ * completed cells; `mode: 'incomplete'` skips them. `groupIds` omitted = every
+ * workflow group on the table. `rowIds` omitted = every row.
  */
-async function runWorkflowGroupsInternal(opts: {
+export async function runWorkflowColumn(opts: {
   tableId: string
   workspaceId: string
   mode: 'all' | 'incomplete'
@@ -444,7 +448,7 @@ async function runWorkflowGroupsInternal(opts: {
   if (targetGroups.length === 0) return { triggered: 0 }
 
   logger.info(
-    `[Cascade] [${requestId}] runWorkflowColumn table=${tableId} groups=[${targetGroups.map((g) => g.id).join(',')}] rows=${rowIds ? `[${rowIds.join(',')}]` : 'all'} mode=${mode}`
+    `[Cascade] [${requestId}] manual run table=${tableId} groups=[${targetGroups.map((g) => g.id).join(',')}] rows=${rowIds ? `[${rowIds.join(',')}]` : 'all'} mode=${mode}`
   )
 
   const filters = [eq(userTableRows.tableId, tableId), eq(userTableRows.workspaceId, workspaceId)]
@@ -520,32 +524,28 @@ async function runWorkflowGroupsInternal(opts: {
   })
 }
 
+// ───────────────────────────── Validation ─────────────────────────────
+
 /**
- * Run a set of groups across the table or a row subset. Single canonical
- * user-driven run op — every UI gesture (single cell, per-row Play, action-bar
- * Play/Refresh, column-header menu) reduces to this. `mode: 'all'` re-runs
- * completed cells; `mode: 'incomplete'` skips them.
+/**
+ * Removes the given column names from a group's `dependencies.columns`. When
+ * the resulting list is empty, drops the `dependencies` field entirely so
+ * schema validation doesn't see an empty-deps object. Returns the same group
+ * reference when nothing changed.
  */
-export async function runWorkflowColumn(opts: {
-  tableId: string
-  workspaceId: string
-  groupIds: string[]
-  mode: 'all' | 'incomplete'
-  rowIds?: string[]
-  requestId: string
-}): Promise<{ triggered: number }> {
-  return runWorkflowGroupsInternal({
-    tableId: opts.tableId,
-    workspaceId: opts.workspaceId,
-    groupIds: opts.groupIds,
-    rowIds: opts.rowIds,
-    mode: opts.mode,
-    requestId: opts.requestId,
-  })
+export function stripGroupDeps(group: WorkflowGroup, removed: ReadonlySet<string>): WorkflowGroup {
+  const cols = group.dependencies?.columns
+  if (!cols || cols.length === 0) return group
+  const filtered = cols.filter((d) => !removed.has(d))
+  if (filtered.length === cols.length) return group
+  return {
+    ...group,
+    ...(filtered.length > 0
+      ? { dependencies: { columns: filtered } }
+      : { dependencies: undefined }),
+  }
 }
 
-// ───────────────────────────── Validation ─────────────────────────────
-
 /**
  * Validates schema-level invariants. Run on every `addTableColumn`,
  * `addWorkflowGroup`, `updateWorkflowGroup`, `renameColumn`, `reorderColumns`,