fix(forking): keep dependent chains configurable

Author: icecrasher321

apps/sim/ee/workspace-forking/components/fork-sync/dependent-value.test.ts

@@ -7,6 +7,7 @@ import {
   dependentKey,
   effectiveCopyDependentValue,
   effectiveDependentValue,
+  getActionableDependentFields,
   isDependentConfigurationActionable,
 } from '@/ee/workspace-forking/components/fork-sync/dependent-value'
 
@@ -184,3 +185,91 @@ describe('isDependentConfigurationActionable', () => {
     ).toBe(false)
   })
 })
+
+describe('getActionableDependentFields', () => {
+  const unchangedMappedParent = {
+    parentResolved: true,
+    parentChanged: false,
+    copying: false,
+  }
+
+  it('includes the context provider for a required missing child', () => {
+    const spreadsheet = field({
+      subBlockKey: 'spreadsheetId',
+      title: 'Spreadsheet',
+      currentValue: '',
+      providesContextKey: 'spreadsheetId',
+    })
+    const sheet = field({
+      subBlockKey: 'sheetName',
+      title: 'Sheet',
+      currentValue: '',
+      required: true,
+      consumesContextKeys: ['spreadsheetId'],
+    })
+
+    expect(
+      getActionableDependentFields([spreadsheet, sheet], {}, unchangedMappedParent).map(
+        (dependent) => dependent.subBlockKey
+      )
+    ).toEqual(['spreadsheetId', 'sheetName'])
+  })
+
+  it('keeps a saved context provider visible while its child needs configuration', () => {
+    const spreadsheet = field({
+      subBlockKey: 'spreadsheetId',
+      title: 'Spreadsheet',
+      currentValue: 'spreadsheet-target',
+      providesContextKey: 'spreadsheetId',
+    })
+    const sheet = field({
+      subBlockKey: 'sheetName',
+      title: 'Sheet',
+      currentValue: '',
+      required: true,
+      consumesContextKeys: ['spreadsheetId'],
+    })
+
+    expect(
+      getActionableDependentFields([spreadsheet, sheet], {}, unchangedMappedParent).map(
+        (dependent) => dependent.subBlockKey
+      )
+    ).toEqual(['spreadsheetId', 'sheetName'])
+  })
+
+  it('walks transitive providers and leaves unrelated optional fields hidden', () => {
+    const unrelated = field({
+      subBlockKey: 'optionalLabel',
+      title: 'Optional label',
+      currentValue: '',
+    })
+    const site = field({
+      subBlockKey: 'siteId',
+      title: 'Site',
+      currentValue: '',
+      providesContextKey: 'siteId',
+    })
+    const drive = field({
+      subBlockKey: 'driveId',
+      title: 'Drive',
+      currentValue: '',
+      providesContextKey: 'driveId',
+      consumesContextKeys: ['siteId'],
+    })
+    const spreadsheet = field({
+      subBlockKey: 'spreadsheetId',
+      title: 'Spreadsheet',
+      currentValue: '',
+      required: true,
+      consumesContextKeys: ['driveId'],
+    })
+
+    expect(
+      getActionableDependentFields(
+        [unrelated, site, drive, spreadsheet],
+        {},
+        unchangedMappedParent
+      ).map((dependent) => dependent.subBlockKey)
+    ).toEqual(['siteId', 'driveId', 'spreadsheetId'])
+  })
+})

apps/sim/ee/workspace-forking/components/fork-sync/dependent-value.ts

@@ -38,7 +38,7 @@ export function effectiveCopyDependentValue(
   return field.currentValue || field.sourceValue
 }
 
-interface DependentConfigurationState {
+export interface DependentConfigurationState {
   parentResolved: boolean
   parentChanged: boolean
   copying: boolean
@@ -58,3 +58,36 @@ export function isDependentConfigurationActionable(
   if (state.parentChanged || state.copying) return true
   return field.required && effectiveDependentValue(field, reconfig, false) === ''
 }
+
+/**
+ * Actionable fields plus the transitive in-block providers that scope them. A provider belongs
+ * in the configuration UI whenever one of its descendants needs action, even if its saved value
+ * is present, so the user can see and change the context in which the child is selected.
+ */
+export function getActionableDependentFields(
+  fields: ForkDependentReconfig[],
+  reconfig: Record<string, string>,
+  state: DependentConfigurationState
+): ForkDependentReconfig[] {
+  const actionable = new Set(
+    fields.filter((field) => isDependentConfigurationActionable(field, reconfig, state))
+  )
+  const providersByContextKey = new Map<string, ForkDependentReconfig>()
+  for (const field of fields) {
+    if (field.providesContextKey) providersByContextKey.set(field.providesContextKey, field)
+  }
+
+  const pending = Array.from(actionable)
+  for (let index = 0; index < pending.length; index += 1) {
+    const field = pending[index]
+    if (!field) continue
+    for (const contextKey of field.consumesContextKeys) {
+      const provider = providersByContextKey.get(contextKey)
+      if (!provider || actionable.has(provider)) continue
+      actionable.add(provider)
+      pending.push(provider)
+    }
+  }
+
+  return fields.filter((field) => actionable.has(field))
+}

apps/sim/ee/workspace-forking/components/fork-sync/fork-sync-view.tsx

@@ -34,10 +34,11 @@ import {
 import { forkRefKey } from '@/ee/workspace-forking/components/fork-sync/copy-reconciliation'
 import { DependentFieldSelector } from '@/ee/workspace-forking/components/fork-sync/dependent-field-selector'
 import {
+  type DependentConfigurationState,
   dependentKey,
   effectiveCopyDependentValue,
   effectiveDependentValue,
-  isDependentConfigurationActionable,
+  getActionableDependentFields,
 } from '@/ee/workspace-forking/components/fork-sync/dependent-value'
 import type {
   ForkKindSummary,
@@ -106,7 +107,8 @@ interface WorkflowDependents {
 function groupDependentsByWorkflow(
   workflows: ForkResourceUsage['workflows'],
   dependents: ForkDependentReconfig[],
-  configurableDependents: ReadonlySet<ForkDependentReconfig>
+  reconfig: Record<string, string>,
+  state: DependentConfigurationState
 ): WorkflowDependents[] {
   const byWorkflow = new Map<string, ForkDependentReconfig[]>()
   for (const dependent of dependents) {
@@ -128,12 +130,15 @@ function groupDependentsByWorkflow(
         byBlock.set(field.targetBlockId, block)
       }
       block.fields.push(field)
-      if (configurableDependents.has(field)) block.configurableFields.push(field)
     }
     return {
       workflowId: workflow.workflowId,
       workflowName: workflow.workflowName,
       blocks: Array.from(byBlock.values())
+        .map((block) => ({
+          ...block,
+          configurableFields: getActionableDependentFields(block.fields, reconfig, state),
+        }))
         .filter((block) => block.configurableFields.length > 0)
         .sort((a, b) => a.blockName.localeCompare(b.blockName)),
     }
@@ -368,18 +373,15 @@ function MappingEntry({ controller, group, entry }: MappingEntryProps) {
 
   const usages = controller.usagesForEntry(entry)
   const dependents = controller.dependentsForEntry(entry)
-  const workflows = useMemo(() => {
-    const configurableDependents = new Set(
-      dependents.filter((field) =>
-        isDependentConfigurationActionable(field, controller.reconfig, {
-          parentResolved: target !== '' || copying,
-          parentChanged,
-          copying,
-        })
-      )
-    )
-    return groupDependentsByWorkflow(usages, dependents, configurableDependents)
-  }, [usages, dependents, controller.reconfig, target, parentChanged, copying])
+  const workflows = useMemo(
+    () =>
+      groupDependentsByWorkflow(usages, dependents, controller.reconfig, {
+        parentResolved: target !== '' || copying,
+        parentChanged,
+        copying,
+      }),
+    [usages, dependents, controller.reconfig, target, parentChanged, copying]
+  )
   const configurable = workflows.filter((workflow) => workflow.blocks.length > 0)
   const usedOnly = workflows.filter((workflow) => workflow.blocks.length === 0)