fix(forking): preserve dependent-chain semantics

Author: icecrasher321

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

@@ -5,15 +5,13 @@ import { describe, expect, it } from 'vitest'
 import type { ForkDependentReconfig } from '@/lib/api/contracts/workspace-fork'
 import {
   applyDependentRepick,
-  DEPENDENT_CLEARED_BY_PARENT,
   dependentKey,
   effectiveCopyDependentValue,
   effectiveDependentValue,
   getActionableDependentFields,
   getDisplayedDependentFields,
-  isDependentClearedByParent,
   isDependentConfigurationActionable,
-  submittedDependentValue,
+  isDependentInvalidated,
 } from '@/ee/workspace-forking/components/fork-sync/dependent-value'
 
 const field = (overrides: Partial<ForkDependentReconfig> = {}): ForkDependentReconfig => ({
@@ -34,6 +32,11 @@ const field = (overrides: Partial<ForkDependentReconfig> = {}): ForkDependentRec
   ...overrides,
 })
 
+const mappedRepickContext = (previousValue: string) => ({
+  previousValue,
+  baselineValueFor: (dependent: ForkDependentReconfig) => dependent.currentValue,
+})
+
 describe('dependentKey', () => {
   it('keys by target workflow + block + subblock', () => {
     expect(
@@ -141,14 +144,15 @@ describe('applyDependentRepick', () => {
       previous,
       site,
       [site, drive, spreadsheet, sheet, unrelated],
-      'site-new'
+      'site-new',
+      mappedRepickContext('site-old')
     )
 
     expect(next).toEqual({
       [dependentKey(site)]: 'site-new',
-      [dependentKey(drive)]: DEPENDENT_CLEARED_BY_PARENT,
-      [dependentKey(spreadsheet)]: DEPENDENT_CLEARED_BY_PARENT,
-      [dependentKey(sheet)]: DEPENDENT_CLEARED_BY_PARENT,
+      [dependentKey(drive)]: null,
+      [dependentKey(spreadsheet)]: null,
+      [dependentKey(sheet)]: null,
       [dependentKey(unrelated)]: 'still-keep-me',
     })
     expect(effectiveDependentValue(drive, next, false)).toBe('')
@@ -172,10 +176,10 @@ describe('applyDependentRepick', () => {
       spreadsheet,
       [spreadsheet, range],
       'sheet-doc',
-      effectiveDependentValue(spreadsheet, {}, false)
+      mappedRepickContext(effectiveDependentValue(spreadsheet, {}, false))
     )
 
-    expect(next).toEqual({ [dependentKey(spreadsheet)]: 'sheet-doc' })
+    expect(next).toEqual({})
     expect(effectiveDependentValue(range, next, false)).toBe('Sheet1!A1:D')
   })
 
@@ -188,7 +192,8 @@ describe('applyDependentRepick', () => {
         { [dependentKey(unrelated)]: 'still-keep-me' },
         leaf,
         [leaf, unrelated],
-        'ISSUE-2'
+        'ISSUE-2',
+        mappedRepickContext('ISSUE-1')
       )
     ).toEqual({
       [dependentKey(leaf)]: 'ISSUE-2',
@@ -227,97 +232,105 @@ describe('applyDependentRepick', () => {
         previous,
         projectOne,
         [projectOne, issueOne, projectTwo, issueTwo],
-        'P1-NEW'
+        'P1-NEW',
+        mappedRepickContext('INBOX')
       )
     ).toEqual({
       [dependentKey(projectOne)]: 'P1-NEW',
-      [dependentKey(issueOne)]: DEPENDENT_CLEARED_BY_PARENT,
+      [dependentKey(issueOne)]: null,
       [dependentKey(issueTwo)]: 'P2-1',
     })
   })
-})
 
-describe('submittedDependentValue', () => {
-  const mappedParent = { copying: false, parentChanged: false }
-
-  it('omits an optional descendant a parent re-pick blanked, so the target keeps its value', () => {
+  it('restores the stored chain when a provider is changed and then returned to baseline', () => {
     const spreadsheet = field({
       subBlockKey: 'spreadsheetId',
       currentValue: 'doc-old',
       providesContextKey: 'spreadsheetId',
     })
-    const sheet = field({
-      subBlockKey: 'sheetName',
-      currentValue: 'Sheet1',
-      required: true,
-      consumesContextKeys: ['spreadsheetId'],
-    })
     const range = field({
       subBlockKey: 'range',
       currentValue: 'A1:D50',
-      required: false,
       consumesContextKeys: ['spreadsheetId'],
     })
 
-    const next = applyDependentRepick(
+    const changed = applyDependentRepick(
       {},
       spreadsheet,
-      [spreadsheet, sheet, range],
+      [spreadsheet, range],
       'doc-new',
-      effectiveDependentValue(spreadsheet, {}, false)
+      mappedRepickContext('doc-old')
+    )
+    const restored = applyDependentRepick(
+      changed,
+      spreadsheet,
+      [spreadsheet, range],
+      'doc-old',
+      mappedRepickContext('doc-new')
     )
 
-    expect(isDependentClearedByParent(range, next)).toBe(true)
-    expect(submittedDependentValue(range, next, mappedParent)).toBeUndefined()
-    expect(submittedDependentValue(sheet, next, mappedParent)).toBeUndefined()
-    expect(submittedDependentValue(spreadsheet, next, mappedParent)).toBe('doc-new')
+    expect(changed).toEqual({
+      [dependentKey(spreadsheet)]: 'doc-new',
+      [dependentKey(range)]: null,
+    })
+    expect(restored).toEqual({})
+    expect(effectiveDependentValue(range, restored, false)).toBe('A1:D50')
   })
 
-  it('submits an empty value the user picked themselves, so an explicit clear still clears', () => {
+  it('keeps an intentional empty pick distinct from automatic invalidation', () => {
     const label = field({ subBlockKey: 'label', currentValue: 'INBOX' })
 
-    const next = applyDependentRepick({}, label, [label], '', 'INBOX')
+    const next = applyDependentRepick({}, label, [label], '', mappedRepickContext('INBOX'))
 
-    expect(isDependentClearedByParent(label, next)).toBe(false)
-    expect(submittedDependentValue(label, next, mappedParent)).toBe('')
+    expect(isDependentInvalidated(label, next)).toBe(false)
+    expect(next[dependentKey(label)]).toBe('')
+    expect(effectiveDependentValue(label, next, false)).toBe('')
   })
 
-  it('submits a re-picked descendant once the user chooses a replacement', () => {
+  it('does not restore an Excel sheet while its drive still differs from baseline', () => {
+    const drive = field({
+      subBlockKey: 'driveId',
+      currentValue: 'drive-old',
+      providesContextKey: 'driveId',
+    })
     const spreadsheet = field({
       subBlockKey: 'spreadsheetId',
-      currentValue: 'doc-old',
+      currentValue: 'workbook-old',
+      consumesContextKeys: ['driveId'],
       providesContextKey: 'spreadsheetId',
     })
-    const range = field({
-      subBlockKey: 'range',
-      currentValue: 'A1:D50',
-      consumesContextKeys: ['spreadsheetId'],
+    const sheet = field({
+      subBlockKey: 'sheetName',
+      currentValue: 'Sheet1',
+      consumesContextKeys: ['driveId', 'spreadsheetId'],
     })
 
-    const cleared = applyDependentRepick(
+    const driveChanged = applyDependentRepick(
       {},
+      drive,
+      [drive, spreadsheet, sheet],
+      'drive-new',
+      mappedRepickContext('drive-old')
+    )
+    const spreadsheetRepicked = applyDependentRepick(
+      driveChanged,
       spreadsheet,
-      [spreadsheet, range],
-      'doc-new',
-      effectiveDependentValue(spreadsheet, {}, false)
+      [drive, spreadsheet, sheet],
+      'workbook-new',
+      mappedRepickContext('')
     )
-    const repicked = applyDependentRepick(
-      cleared,
-      range,
-      [spreadsheet, range],
-      'A1:Z',
-      effectiveDependentValue(range, cleared, false)
+    const spreadsheetRestored = applyDependentRepick(
+      spreadsheetRepicked,
+      spreadsheet,
+      [drive, spreadsheet, sheet],
+      'workbook-old',
+      mappedRepickContext('workbook-new')
     )
 
-    expect(submittedDependentValue(range, repicked, mappedParent)).toBe('A1:Z')
-  })
-
-  it('falls back to the stored value under an unchanged parent and to the source when copying', () => {
-    const untouched = field({ subBlockKey: 'label', currentValue: 'INBOX' })
-    const copied = field({ subBlockKey: 'documentSelector', currentValue: '', sourceValue: 'doc' })
-
-    expect(submittedDependentValue(untouched, {}, mappedParent)).toBe('INBOX')
-    expect(submittedDependentValue(copied, {}, { copying: true, parentChanged: false })).toBe('doc')
+    expect(spreadsheetRestored).toEqual({
+      [dependentKey(drive)]: 'drive-new',
+      [dependentKey(sheet)]: null,
+    })
   })
 })
 
@@ -409,7 +422,7 @@ describe('isDependentConfigurationActionable', () => {
       spreadsheet,
       [spreadsheet, sheet],
       'doc-new',
-      effectiveDependentValue(spreadsheet, {}, false)
+      mappedRepickContext(effectiveDependentValue(spreadsheet, {}, false))
     )
 
     // The sync gate reads the same blank the selector shows, so the field gates and is visible.
@@ -425,7 +438,7 @@ describe('isDependentConfigurationActionable', () => {
 
   it('shows a required field the user emptied themselves (it blocks Sync)', () => {
     const sheet = field({ subBlockKey: 'sheetName', required: true, currentValue: 'Sheet1' })
-    const next = applyDependentRepick({}, sheet, [sheet], '', 'Sheet1')
+    const next = applyDependentRepick({}, sheet, [sheet], '', mappedRepickContext('Sheet1'))
 
     expect(effectiveDependentValue(sheet, next, false)).toBe('')
     expect(