fix(datamapper): scope schema elements to root include chain (#3462)

Problem
When multiple XSD files are loaded into the DataMapper, unrelated schemas can shadow elements/types if they have the same name as the ones in the root element's include chain. This happens because populateNamedTypeFragments and populateGlobalElementFragmentsForSchema iterated through all loaded schemas.

Solution
- Performed a BFS traversal from the root element's parent schema using getExternals() to find only reachable schemas.
- Scoped the schema loop in populateNamedTypeFragments to just these reachable schemas.
- If unreachable schemas define elements/types with the same name as the reachable ones, we now generate a warning.
- Added a test case that ensures shadowing is avoided and reachable schemas' types are used.

Fixes #3462

Author: QuantumBreakz

packages/ui/src/services/document/xml-schema/xml-schema-document.service.test.ts

@@ -1117,6 +1117,85 @@ describe('XmlSchemaDocumentService', () => {
       expect(rootElement.fields[0].name).toBe('partA');
       expect(rootElement.fields[1].name).toBe('partB');
     });
+
+    it('should detect shadowed elements and only use reachable schema definitions', () => {
+      const mainXsd = `<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+           elementFormDefault="qualified">
+  <xs:include schemaLocation="MainTypes.xsd"/>
+  <xs:element name="Root">
+    <xs:complexType>
+      <xs:sequence>
+        <xs:element ref="Order" minOccurs="0" maxOccurs="unbounded"/>
+      </xs:sequence>
+    </xs:complexType>
+  </xs:element>
+</xs:schema>`;
+      const mainTypesXsd = `<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+           elementFormDefault="qualified">
+  <xs:complexType name="BaseObject" abstract="true">
+    <xs:sequence>
+      <xs:element name="ObjectId" type="xs:string" minOccurs="0"/>
+    </xs:sequence>
+  </xs:complexType>
+  <xs:element name="Order">
+    <xs:complexType>
+      <xs:complexContent>
+        <xs:extension base="BaseObject">
+          <xs:sequence>
+            <xs:element name="OrderItem" type="xs:string"/>
+            <xs:element name="Quantity" type="xs:int"/>
+            <xs:element name="Price" type="xs:double"/>
+          </xs:sequence>
+        </xs:extension>
+      </xs:complexContent>
+    </xs:complexType>
+  </xs:element>
+</xs:schema>`;
+      const unrelatedXsd = `<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+           elementFormDefault="qualified">
+  <xs:element name="Order">
+    <xs:complexType>
+      <xs:sequence>
+        <xs:element name="Status" type="xs:string"/>
+        <xs:element name="Action" type="xs:string"/>
+      </xs:sequence>
+    </xs:complexType>
+  </xs:element>
+</xs:schema>`;
+
+      const definition = new DocumentDefinition(
+        DocumentType.SOURCE_BODY,
+        DocumentDefinitionType.XML_SCHEMA,
+        'test-doc',
+        {
+          'Main.xsd': mainXsd,
+          'MainTypes.xsd': mainTypesXsd,
+          'Unrelated.xsd': unrelatedXsd,
+        },
+      );
+      definition.rootElementChoice = { name: 'Root', namespaceUri: '' };
+
+      const result = XmlSchemaDocumentService.createXmlSchemaDocument(definition);
+      expect(result.validationStatus).toBe('warning');
+      expect(result.warnings).toHaveLength(1);
+      expect(result.warnings![0].message).toContain("Element 'Order'");
+      expect(result.warnings![0].filePath).toBe('Unrelated.xsd');
+
+      const document = result.document as XmlSchemaDocument;
+      expect(document).toBeDefined();
+
+      const rootElement = document.fields[0];
+      expect(rootElement.name).toBe('Root');
+      
+      const orderElement = rootElement.fields.find(f => f.name === 'Order');
+      expect(orderElement).toBeDefined();
+
+      const orderFields = orderElement!.fields.map(f => f.name);
+      expect(orderFields).toEqual(['ObjectId', 'OrderItem', 'Quantity', 'Price']);
+    });
   });
 
   describe('with xs:import', () => {

packages/ui/src/services/document/xml-schema/xml-schema-document.service.ts

@@ -99,7 +99,7 @@ export class XmlSchemaDocumentService {
 
     const document = new XmlSchemaDocument(definition, collection, rootElement);
 
-    XmlSchemaDocumentService.populateNamedTypeFragments(document);
+    XmlSchemaDocumentService.populateNamedTypeFragments(document, analysis.warnings);
     XmlSchemaDocumentService.populateElement(document, document.fields, document.rootElement!);
 
     DocumentUtilService.processOverrides(
@@ -276,7 +276,7 @@ export class XmlSchemaDocumentService {
     const collection = document.xmlSchemaCollection;
     collection.getSchemaResolver().addFiles(additionalFiles);
     XmlSchemaDocumentUtilService.loadXmlSchemaFiles(collection, additionalFiles);
-    XmlSchemaDocumentService.populateNamedTypeFragments(document);
+    XmlSchemaDocumentService.populateNamedTypeFragments(document, undefined, false);
     XmlSchemaDocumentService.rebuildAbstractWrapperChildren(document);
   }
 
@@ -504,8 +504,74 @@ export class XmlSchemaDocumentService {
    * Must be called before processing elements to ensure base types are available for extensions and restrictions.
    * @param document - The document whose schema collection will be traversed and whose namedTypeFragments will be populated
    */
-  static populateNamedTypeFragments(document: XmlSchemaDocument) {
-    const schemas = document.xmlSchemaCollection.getUserSchemas();
+  static populateNamedTypeFragments(
+    document: XmlSchemaDocument,
+    warnings?: Array<{ message: string; filePath?: string }>,
+    filterUnreachable: boolean = true,
+  ) {
+    let schemas = document.xmlSchemaCollection.getUserSchemas();
+
+    if (filterUnreachable && document.rootElement) {
+      const parentSchema = document.rootElement.getParent();
+      const reachableSchemas = new Set<XmlSchema>();
+      const queue: XmlSchema[] = [parentSchema];
+
+      while (queue.length > 0) {
+        const current = queue.shift()!;
+        if (!reachableSchemas.has(current)) {
+          reachableSchemas.add(current);
+          const externals = current.getExternals();
+          for (const ext of externals) {
+            const schema = ext.getSchema();
+            if (schema) {
+              queue.push(schema);
+            }
+          }
+        }
+      }
+
+      const reachableArray = schemas.filter((s) => reachableSchemas.has(s));
+      const nonReachableArray = schemas.filter((s) => !reachableSchemas.has(s));
+
+      if (warnings) {
+        const reachableElements = new Set<string>();
+        const reachableTypes = new Set<string>();
+
+        for (const rs of reachableArray) {
+          for (const elemQName of rs.getElements().keys()) {
+            reachableElements.add(elemQName.toString());
+          }
+          for (const typeQName of rs.getSchemaTypes().keys()) {
+            reachableTypes.add(typeQName.toString());
+          }
+        }
+
+        for (const nrs of nonReachableArray) {
+          const conflicts = [];
+          for (const elemQName of nrs.getElements().keys()) {
+            if (reachableElements.has(elemQName.toString())) {
+              conflicts.push(`Element '${elemQName.getLocalPart()}'`);
+            }
+          }
+          for (const typeQName of nrs.getSchemaTypes().keys()) {
+            if (reachableTypes.has(typeQName.toString())) {
+              conflicts.push(`Type '${typeQName.getLocalPart()}'`);
+            }
+          }
+
+          if (conflicts.length > 0) {
+            const filePath = nrs.getSourceURI() ?? undefined;
+            warnings.push({
+              message: `Unrelated schema shadows reachable schema definitions. ${conflicts.join(', ')} will be ignored.`,
+              filePath,
+            });
+          }
+        }
+      }
+
+      schemas = reachableArray;
+    }
+
     for (const schema of schemas) {
       XmlSchemaDocumentService.populateNamedTypeFragmentsForSchema(document, schema);
     }