fix(DataMapper): Preserve descendant overrides across choice selection changes

Fix #3234
Fix #3232

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: mmelko

packages/ui/src/services/document/choice-selection.service.test.ts

@@ -1,9 +1,13 @@
-import { DocumentDefinition, DocumentDefinitionType, DocumentType } from '../../models/datamapper';
+import { DocumentDefinition, DocumentDefinitionType, DocumentType, IField } from '../../models/datamapper';
 import { NS_XML_SCHEMA } from '../../models/datamapper/standard-namespaces';
+import { FieldOverrideVariant } from '../../models/datamapper/types';
+import { getChoiceWithAbstractXsd } from '../../stubs/datamapper/data-mapper';
 import { XmlSchemaCollection } from '../../xml-schema-ts';
 import { SchemaPathService } from '../schema-path.service';
 import { ChoiceSelectionService } from './choice-selection.service';
+import { FieldOverrideService } from './field-override.service';
 import { XmlSchemaDocument, XmlSchemaField } from './xml-schema/xml-schema-document.model';
+import { XmlSchemaDocumentService } from './xml-schema/xml-schema-document.service';
 
 describe('ChoiceSelectionService', () => {
   let document: XmlSchemaDocument;
@@ -145,7 +149,7 @@ describe('ChoiceSelectionService', () => {
       expect(document.definition.choiceSelections?.length).toBe(2);
     });
 
-    it('should cascade invalidate true descendant selections', () => {
+    it('should preserve descendant choice selections', () => {
       const parentChoice = document.fields[0].fields[0];
       const emailMember = parentChoice.fields[0];
       const nestedChoice = emailMember.fields[0];
@@ -155,9 +159,9 @@ describe('ChoiceSelectionService', () => {
 
       ChoiceSelectionService.setChoiceSelection(document, parentChoice, 1, namespaceMap);
 
-      expect(document.definition.choiceSelections?.length).toBe(1);
-      expect(document.definition.choiceSelections?.[0].schemaPath).not.toContain('email');
-      expect(nestedChoice.selectedMemberIndex).toBeUndefined();
+      // Both parent and nested selections preserved
+      expect(document.definition.choiceSelections?.length).toBe(2);
+      expect(nestedChoice.selectedMemberIndex).toBe(0);
     });
   });
 
@@ -214,7 +218,7 @@ describe('ChoiceSelectionService', () => {
       expect(document.definition.choiceSelections?.[0].schemaPath).toContain('Container');
     });
 
-    it('should cascade invalidate true descendant selections on clear', () => {
+    it('should preserve descendant choice selections on clear', () => {
       const parentChoice = document.fields[0].fields[0];
       const emailMember = parentChoice.fields[0];
       const nestedChoice = emailMember.fields[0];
@@ -225,8 +229,291 @@ describe('ChoiceSelectionService', () => {
 
       ChoiceSelectionService.clearChoiceSelection(document, parentChoice, namespaceMap);
 
-      expect(document.definition.choiceSelections?.length).toBe(0);
-      expect(nestedChoice.selectedMemberIndex).toBeUndefined();
+      // Nested selection preserved
+      expect(document.definition.choiceSelections?.length).toBe(1);
+      expect(nestedChoice.selectedMemberIndex).toBe(1);
+    });
+  });
+
+  describe('choice + descendant override interaction (issue #3234)', () => {
+    const NS_CHOICE_ABSTRACT = 'http://www.example.com/CHOICE_ABSTRACT';
+
+    function createChoiceWithAbstractDoc() {
+      const definition = new DocumentDefinition(
+        DocumentType.SOURCE_BODY,
+        DocumentDefinitionType.XML_SCHEMA,
+        'test-doc',
+        { 'ChoiceWithAbstract.xsd': getChoiceWithAbstractXsd() },
+      );
+      definition.rootElementChoice = { namespaceUri: NS_CHOICE_ABSTRACT, name: 'Notification' };
+      const result = XmlSchemaDocumentService.createXmlSchemaDocument(definition);
+      if (result.validationStatus !== 'success' || !result.document) {
+        throw new Error(
+          result.errors?.map((e) => e.message).join('; ') || 'Failed to create choice+abstract test document',
+        );
+      }
+      return result.document;
+    }
+
+    function findChoiceField(doc: XmlSchemaDocument): XmlSchemaField {
+      const root = doc.fields[0];
+      const choice = root.fields.find((f) => f.wrapperKind === 'choice');
+      if (!choice) throw new Error('Choice field not found in Notification');
+      return choice;
+    }
+
+    function findAbstractField(choiceField: IField): XmlSchemaField {
+      const abstract = choiceField.fields.find((f) => f.wrapperKind === 'abstract');
+      if (!abstract) throw new Error('Abstract field not found inside choice');
+      return abstract as XmlSchemaField;
+    }
+
+    describe('abstract substitution preserved across choice changes', () => {
+      it('should preserve descendant abstract substitution when setting choice selection', () => {
+        const doc = createChoiceWithAbstractDoc();
+        const nsMap = { ca: NS_CHOICE_ABSTRACT };
+        const choiceField = findChoiceField(doc);
+        const abstractField = findAbstractField(choiceField);
+
+        FieldOverrideService.applyFieldSubstitution(abstractField, 'ca:Email', nsMap);
+        const emailIndex = abstractField.selectedMemberIndex;
+        expect(emailIndex).toBeDefined();
+        expect(doc.definition.fieldSubstitutions).toHaveLength(1);
+
+        ChoiceSelectionService.setChoiceSelection(doc, choiceField, 0, nsMap);
+
+        // Substitution stays in both definition and live field — consistent state
+        expect(doc.definition.fieldSubstitutions).toHaveLength(1);
+        expect(abstractField.selectedMemberIndex).toBe(emailIndex);
+      });
+
+      it('should preserve descendant abstract substitution when clearing choice selection', () => {
+        const doc = createChoiceWithAbstractDoc();
+        const nsMap = { ca: NS_CHOICE_ABSTRACT };
+        const choiceField = findChoiceField(doc);
+        const abstractField = findAbstractField(choiceField);
+
+        ChoiceSelectionService.setChoiceSelection(doc, choiceField, 0, nsMap);
+        FieldOverrideService.applyFieldSubstitution(abstractField, 'ca:SMS', nsMap);
+        const smsIndex = abstractField.selectedMemberIndex;
+        expect(smsIndex).toBeDefined();
+        expect(doc.definition.fieldSubstitutions).toHaveLength(1);
+
+        ChoiceSelectionService.clearChoiceSelection(doc, choiceField, nsMap);
+
+        // Substitution preserved
+        expect(doc.definition.fieldSubstitutions).toHaveLength(1);
+        expect(abstractField.selectedMemberIndex).toBe(smsIndex);
+      });
+
+      it('should allow reverting abstract substitution after parent choice selection (issue #3234)', () => {
+        const doc = createChoiceWithAbstractDoc();
+        const nsMap = { ca: NS_CHOICE_ABSTRACT };
+        const choiceField = findChoiceField(doc);
+        const abstractField = findAbstractField(choiceField);
+
+        FieldOverrideService.applyFieldSubstitution(abstractField, 'ca:Email', nsMap);
+        expect(abstractField.selectedMemberIndex).toBeDefined();
+
+        ChoiceSelectionService.setChoiceSelection(doc, choiceField, 0, nsMap);
+
+        // Substitution is preserved, so revert should work
+        FieldOverrideService.revertFieldSubstitution(abstractField, nsMap);
+
+        expect(abstractField.selectedMemberIndex).toBeUndefined();
+        expect(doc.definition.fieldSubstitutions ?? []).toHaveLength(0);
+      });
+
+      it('should allow switching substitution after choice selection', () => {
+        const doc = createChoiceWithAbstractDoc();
+        const nsMap = { ca: NS_CHOICE_ABSTRACT };
+        const choiceField = findChoiceField(doc);
+        const abstractField = findAbstractField(choiceField);
+
+        FieldOverrideService.applyFieldSubstitution(abstractField, 'ca:Email', nsMap);
+        ChoiceSelectionService.setChoiceSelection(doc, choiceField, 0, nsMap);
+
+        // Switch from Email to SMS
+        FieldOverrideService.applyFieldSubstitution(abstractField, 'ca:SMS', nsMap);
+
+        expect(doc.definition.fieldSubstitutions).toHaveLength(1);
+        expect(doc.definition.fieldSubstitutions![0].name).toBe('ca:SMS');
+        const smsIndex = abstractField.fields.findIndex((f) => f.name === 'SMS');
+        expect(abstractField.selectedMemberIndex).toBe(smsIndex);
+      });
+
+      it('should allow revert after switching substitution across choice changes', () => {
+        const doc = createChoiceWithAbstractDoc();
+        const nsMap = { ca: NS_CHOICE_ABSTRACT };
+        const choiceField = findChoiceField(doc);
+        const abstractField = findAbstractField(choiceField);
+
+        FieldOverrideService.applyFieldSubstitution(abstractField, 'ca:Email', nsMap);
+        ChoiceSelectionService.setChoiceSelection(doc, choiceField, 0, nsMap);
+        FieldOverrideService.applyFieldSubstitution(abstractField, 'ca:SMS', nsMap);
+
+        FieldOverrideService.revertFieldSubstitution(abstractField, nsMap);
+
+        expect(abstractField.selectedMemberIndex).toBeUndefined();
+        expect(doc.definition.fieldSubstitutions).toHaveLength(0);
+      });
+    });
+
+    describe('type override preserved across choice changes', () => {
+      function findDescendantLeaf(field: IField): IField {
+        let current = field;
+        while (current.fields.length > 0) {
+          current = current.fields[0];
+        }
+        return current;
+      }
+
+      it('should preserve descendant type override when setting choice selection', () => {
+        const doc = createChoiceWithAbstractDoc();
+        const nsMap = { ca: NS_CHOICE_ABSTRACT };
+        const choiceField = findChoiceField(doc);
+
+        const firstMember = choiceField.fields[0];
+        const leafField = findDescendantLeaf(firstMember);
+
+        const leafPath = SchemaPathService.build(leafField, nsMap);
+        leafField.typeOverride = FieldOverrideVariant.SAFE;
+        leafField.originalField = { name: leafField.name, type: leafField.type };
+        doc.definition.fieldTypeOverrides = [{ schemaPath: leafPath, typeString: 'xs:int' }];
+
+        ChoiceSelectionService.setChoiceSelection(doc, choiceField, 0, nsMap);
+
+        expect(doc.definition.fieldTypeOverrides).toHaveLength(1);
+        expect(leafField.typeOverride).toBe(FieldOverrideVariant.SAFE);
+      });
+
+      it('should preserve descendant type override when clearing choice selection', () => {
+        const doc = createChoiceWithAbstractDoc();
+        const nsMap = { ca: NS_CHOICE_ABSTRACT };
+        const choiceField = findChoiceField(doc);
+
+        ChoiceSelectionService.setChoiceSelection(doc, choiceField, 0, nsMap);
+
+        const firstMember = choiceField.fields[0];
+        const leafField = findDescendantLeaf(firstMember);
+
+        const leafPath = SchemaPathService.build(leafField, nsMap);
+        leafField.typeOverride = FieldOverrideVariant.SAFE;
+        leafField.originalField = { name: leafField.name, type: leafField.type };
+        doc.definition.fieldTypeOverrides = [{ schemaPath: leafPath, typeString: 'xs:int' }];
+
+        ChoiceSelectionService.clearChoiceSelection(doc, choiceField, nsMap);
+
+        expect(doc.definition.fieldTypeOverrides).toHaveLength(1);
+        expect(leafField.typeOverride).toBe(FieldOverrideVariant.SAFE);
+      });
+    });
+
+    describe('round-trip — overrides survive choice switch and switch-back (issue #3232)', () => {
+      it('should preserve nested choice selection across parent choice round-trip', () => {
+        const doc = createTestDocumentWithChoices();
+        const nsMap = { xs: NS_XML_SCHEMA, ns0: 'io.kaoto.test' };
+        const parentChoice = doc.fields[0].fields[0]; // [email, phone, fax]
+        const emailMember = parentChoice.fields[0];
+        const nestedChoice = emailMember.fields[0]; // [work, personal]
+
+        // Select nested choice inside email
+        ChoiceSelectionService.setChoiceSelection(doc, parentChoice, 0, nsMap);
+        ChoiceSelectionService.setChoiceSelection(doc, nestedChoice, 1, nsMap);
+        expect(nestedChoice.selectedMemberIndex).toBe(1);
+
+        // Switch parent away from email
+        ChoiceSelectionService.setChoiceSelection(doc, parentChoice, 2, nsMap);
+
+        // Switch parent back to email
+        ChoiceSelectionService.setChoiceSelection(doc, parentChoice, 0, nsMap);
+
+        // Nested selection survived the round-trip
+        expect(nestedChoice.selectedMemberIndex).toBe(1);
+        expect(doc.definition.choiceSelections?.length).toBe(2);
+      });
+
+      it('should preserve substitution across parent choice round-trip', () => {
+        const doc = createChoiceWithAbstractDoc();
+        const nsMap = { ca: NS_CHOICE_ABSTRACT };
+        const choiceField = findChoiceField(doc);
+        const abstractField = findAbstractField(choiceField);
+
+        // Select substitution
+        FieldOverrideService.applyFieldSubstitution(abstractField, 'ca:Email', nsMap);
+        const emailIndex = abstractField.selectedMemberIndex;
+
+        // Switch choice away and back
+        ChoiceSelectionService.setChoiceSelection(doc, choiceField, 1, nsMap);
+        ChoiceSelectionService.setChoiceSelection(doc, choiceField, 0, nsMap);
+
+        // Substitution survived
+        expect(abstractField.selectedMemberIndex).toBe(emailIndex);
+        expect(doc.definition.fieldSubstitutions).toHaveLength(1);
+        expect(doc.definition.fieldSubstitutions![0].name).toBe('ca:Email');
+      });
+
+      it('should preserve substitution through multiple choice changes', () => {
+        const doc = createChoiceWithAbstractDoc();
+        const nsMap = { ca: NS_CHOICE_ABSTRACT };
+        const choiceField = findChoiceField(doc);
+        const abstractField = findAbstractField(choiceField);
+
+        FieldOverrideService.applyFieldSubstitution(abstractField, 'ca:SMS', nsMap);
+        const smsIndex = abstractField.selectedMemberIndex;
+
+        // Multiple choice changes
+        ChoiceSelectionService.setChoiceSelection(doc, choiceField, 0, nsMap);
+        ChoiceSelectionService.setChoiceSelection(doc, choiceField, 1, nsMap);
+        ChoiceSelectionService.clearChoiceSelection(doc, choiceField, nsMap);
+        ChoiceSelectionService.setChoiceSelection(doc, choiceField, 0, nsMap);
+
+        // Substitution survived all transitions
+        expect(abstractField.selectedMemberIndex).toBe(smsIndex);
+        expect(doc.definition.fieldSubstitutions).toHaveLength(1);
+      });
+    });
+
+    describe('negative cases — sibling overrides preserved', () => {
+      it('should preserve all substitutions — both descendant and sibling — on choice change', () => {
+        const doc = createChoiceWithAbstractDoc();
+        const nsMap = { ca: NS_CHOICE_ABSTRACT };
+        const choiceField = findChoiceField(doc);
+        const abstractField = findAbstractField(choiceField);
+
+        FieldOverrideService.applyFieldSubstitution(abstractField, 'ca:Email', nsMap);
+
+        // Manually add a sibling substitution entry (simulating another abstract field outside this choice)
+        const siblingPath = '/ca:Notification/ca:SiblingAbstract';
+        doc.definition.fieldSubstitutions!.push({ schemaPath: siblingPath, name: 'ca:SiblingType' });
+        expect(doc.definition.fieldSubstitutions).toHaveLength(2);
+
+        ChoiceSelectionService.setChoiceSelection(doc, choiceField, 0, nsMap);
+
+        // Both substitutions preserved
+        expect(doc.definition.fieldSubstitutions).toHaveLength(2);
+      });
+
+      it('should not affect sibling type override outside the choice subtree', () => {
+        const doc = createChoiceWithAbstractDoc();
+        const nsMap = { ca: NS_CHOICE_ABSTRACT };
+        const choiceField = findChoiceField(doc);
+
+        // Manually add a type override for a sibling field (id field, outside the choice)
+        const root = doc.fields[0];
+        const idField = root.fields.find((f) => f.name === 'id');
+        if (!idField) throw new Error('id field not found');
+        const idPath = SchemaPathService.build(idField, nsMap);
+        idField.typeOverride = FieldOverrideVariant.SAFE;
+        idField.originalField = { name: idField.name, type: idField.type };
+        doc.definition.fieldTypeOverrides = [{ schemaPath: idPath, typeString: 'xs:int' }];
+
+        ChoiceSelectionService.setChoiceSelection(doc, choiceField, 0, nsMap);
+
+        // Sibling type override should be preserved
+        expect(doc.definition.fieldTypeOverrides).toHaveLength(1);
+        expect(idField.typeOverride).toBe(FieldOverrideVariant.SAFE);
+      });
     });
   });
 });