Merge pull request #10 from jacksierkstra/develop

jacksierkstra · web-flow · commit dde7a2079460 · 2025-03-10T16:31:04.000+01:00
Develop
diff --git a/src/core/main.test.ts b/src/core/main.test.ts
@@ -0,0 +1,61 @@
+import { Checkr } from "@lib/core/main";
+
+describe('Checkr validation', () => {
+
+    let checkr: Checkr;
+
+    beforeEach(() => {
+        checkr = new Checkr();
+    });
+
+    describe('Books', () => {
+
+        it('should validate simple valid xsd structure', async () => {
+            let xsd = `
+            <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+                <xsd:element name="root" type="SimpleType"/>
+                <xsd:complexType name="SimpleType">
+                    <xsd:sequence>
+                    <xsd:element name="foo" type="xsd:string"/>
+                    <xsd:element name="bar" type="xsd:string"/>
+                    </xsd:sequence>
+                </xsd:complexType>
+            </xsd:schema>
+            `;
+            let xml = `
+                <root>
+                    <foo></foo>
+                    <bar></bar>
+                </root>
+            `;
+            const { valid, errors } = await checkr.validate(xml, xsd);
+            expect(valid).toEqual(true);
+            expect(errors).toHaveLength(0);
+        });
+
+        it('should validate simple invalid xsd structure', async () => {
+            let xsd = `
+            <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+                <xsd:element name="root" type="SimpleType"/>
+                <xsd:complexType name="SimpleType">
+                    <xsd:sequence>
+                    <xsd:element name="foo" type="xsd:string"/>
+                    <xsd:element name="bar" type="xsd:string"/>
+                    </xsd:sequence>
+                </xsd:complexType>
+            </xsd:schema>
+            `;
+            let xml = `
+                <root>
+                    <foo></foo>
+                </root>
+            `;
+            const { valid, errors } = await checkr.validate(xml, xsd);
+            expect(valid).toEqual(false);
+            expect(errors).toHaveLength(2);
+            expect(errors.at(0)).toEqual('Element <bar> is required inside <root> but is missing.');
+            expect(errors.at(1)).toEqual('Element bar occurs 0 times, but should occur at least 1 times.');
+        });
+    });
+
+});
diff --git a/src/validator/pipeline/steps/requiredChildren.test.ts b/src/validator/pipeline/steps/requiredChildren.test.ts
@@ -0,0 +1,74 @@
+
+import { XSDElement } from "@lib/types/xsd";
+import { validateRequiredChildren } from "@lib/validator/pipeline/steps/requiredChildren";
+import { DOMParser } from "xmldom";
+
+describe("validateRequiredChildren", () => {
+  const parser = new DOMParser();
+
+  const parentElement: XSDElement = {
+    name: "Parent",
+    children: [
+      { name: "Child1", minOccurs: 1 },
+      { name: "Child2", minOccurs: 1 },
+      { name: "OptionalChild", minOccurs: 0 },
+    ],
+  };
+
+  it("should pass when all required children are present", () => {
+    const xml = `
+      <Parent>
+        <Child1></Child1>
+        <Child2></Child2>
+      </Parent>
+    `;
+
+    const doc = parser.parseFromString(xml, "application/xml");
+    const errors = validateRequiredChildren(doc.documentElement, parentElement);
+
+    expect(errors).toHaveLength(0);
+  });
+
+  it("should fail when a required child is missing", () => {
+    const xml = `
+      <Parent>
+        <Child1></Child1>
+      </Parent>
+    `;
+
+    const doc = parser.parseFromString(xml, "application/xml");
+    const errors = validateRequiredChildren(doc.documentElement, parentElement);
+
+    expect(errors).toContain(
+      "Element <Child2> is required inside <Parent> but is missing."
+    );
+  });
+
+  it("should pass when optional children are missing", () => {
+    const xml = `
+      <Parent>
+        <Child1></Child1>
+        <Child2></Child2>
+      </Parent>
+    `;
+
+    const doc = parser.parseFromString(xml, "application/xml");
+    const errors = validateRequiredChildren(doc.documentElement, parentElement);
+
+    expect(errors).toHaveLength(0);
+  });
+
+  it("should handle empty parent element with errors for required children", () => {
+    const xml = `<Parent></Parent>`;
+
+    const doc = parser.parseFromString(xml, "application/xml");
+    const errors = validateRequiredChildren(doc.documentElement, parentElement);
+
+    expect(errors).toContain(
+      "Element <Child1> is required inside <Parent> but is missing."
+    );
+    expect(errors).toContain(
+      "Element <Child2> is required inside <Parent> but is missing."
+    );
+  });
+});
diff --git a/src/validator/pipeline/steps/requiredChildren.ts b/src/validator/pipeline/steps/requiredChildren.ts
@@ -0,0 +1,28 @@
+import { NodeValidationStep } from "@lib/types/validation";
+
+export const validateRequiredChildren: NodeValidationStep = (xmlNode, schemaElement) => {
+  const errors: string[] = [];
+  
+  if (!schemaElement.children) return errors;
+  
+  // Use xmlNode.children if available; otherwise fall back to childNodes filtered to Elements.
+  const childrenElements = xmlNode.children 
+    ? Array.from(xmlNode.children)
+    : Array.from(xmlNode.childNodes).filter((child): child is Element => child.nodeType === 1);
+  
+  for (const childDef of schemaElement.children) {
+    const minOccurs = childDef.minOccurs ?? 1;
+    // Compare names in a case-insensitive manner (or use localName as is if you prefer)
+    const matchingChildren = childrenElements.filter(
+      child => child.localName.toLowerCase() === childDef.name.toLowerCase()
+    );
+    
+    if (matchingChildren.length < minOccurs) {
+      errors.push(
+        `Element <${childDef.name}> is required inside <${schemaElement.name}> but is missing.`
+      );
+    }
+  }
+  
+  return errors;
+};
diff --git a/src/validator/validator.ts b/src/validator/validator.ts
@@ -5,6 +5,7 @@ import { NodeValidationPipeline, NodeValidationPipelineImpl } from "@lib/validat
 import { validateAttributes } from "@lib/validator/pipeline/steps/attributes";
 import { validateConstraints } from "@lib/validator/pipeline/steps/constraints";
 import { validateOccurrence } from "@lib/validator/pipeline/steps/occurence";
+import { validateRequiredChildren } from "@lib/validator/pipeline/steps/requiredChildren";
 import { validateType } from "@lib/validator/pipeline/steps/type";
 import { XMLParser } from "@lib/xml/parser";
 import { XSDParser } from "@lib/xsd/parser";
@@ -25,7 +26,8 @@ export class ValidatorImpl implements Validator {
         this.nodePipeline = new NodeValidationPipelineImpl()
             .addStep(validateType)
             .addStep(validateAttributes)
-            .addStep(validateConstraints);
+            .addStep(validateConstraints)
+            .addStep(validateRequiredChildren);
 
         // Global pipeline (occurrence checks, etc.)
         this.globalPipeline = new GlobalValidationPipelineImpl()
@@ -48,28 +50,35 @@ export class ValidatorImpl implements Validator {
 
     private validateNode(node: Element, schemaElement: XSDElement): string[] {
         const errors: string[] = [];
-
+    
         // Node-level checks
         errors.push(...this.nodePipeline.execute(node, schemaElement));
-
+    
         // If choices exist, validate them
         if (schemaElement.choices && schemaElement.choices.length > 0) {
             // For simplicity, assume 1 XSDChoice
             const [choiceDef] = schemaElement.choices;
             errors.push(...this.validateChoice(node, choiceDef));
         }
-
-        // Recursively validate normal children
+    
+        // Recursively validate direct children only
         const childrenErrors = (schemaElement.children || []).flatMap((childSchema) => {
-            const childNodes = Array.from(node.getElementsByTagName(childSchema.name));
+            const childNodes = (
+                node.children 
+                  ? Array.from(node.children)
+                  : Array.from(node.childNodes).filter((child): child is Element => child.nodeType === 1)
+              ).filter(child => child.tagName === childSchema.name);
+        
             return [
-                ...this.globalPipeline.execute(childNodes, childSchema),
-                ...childNodes.flatMap((childNode) => this.validateNode(childNode, childSchema)),
+                ...this.globalPipeline.execute(childNodes, childSchema), // This throws an error: Argument of type 'ChildNode[]' is not assignable to parameter of type 'Element[]'.
+                ...childNodes.flatMap((childNode) => this.validateNode(childNode, childSchema)), // This throws an error: Argument of type 'ChildNode' is not assignable to parameter of type 'Element'.
             ];
         });
-
+    
         return [...errors, ...childrenErrors];
     }
+    
+    
 
 
     private validateChoice(node: Element, choice: XSDChoice): string[] {
@@ -89,10 +98,6 @@ export class ValidatorImpl implements Validator {
         ];
     }
 
-
-    /**
-     * Main entry point: parses XSD, parses XML, and runs pipelines.
-     */
     async validate(xml: string, xsd: string): Promise<ValidationResult> {
         const schema: XSDSchema = await this.xsdParser.parse(xsd);
         const xmlDoc = this.xmlParser.parse(xml);
diff --git a/src/xsd/parser.test.ts b/src/xsd/parser.test.ts
@@ -402,39 +402,23 @@ const runCommonTests = (xsdParser: XSDParser) => {
     });
   });
 
-  it('should parse books xsd', async () => {
+  it('should parse xsd', async () => {
     const xsd = `
-          <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
-                  targetNamespace="urn:books"
-                  xmlns:bks="urn:books">
-
-        <xsd:element name="books" type="bks:BooksForm"/>
-
-        <xsd:complexType name="BooksForm">
-          <xsd:sequence>
-            <xsd:element name="book" 
-                        type="bks:BookForm" 
-                        minOccurs="0" 
-                        maxOccurs="unbounded"/>
-            </xsd:sequence>
-        </xsd:complexType>
-
-        <xsd:complexType name="BookForm">
-          <xsd:sequence>
-            <xsd:element name="author"   type="xsd:string"/>
-            <xsd:element name="title"    type="xsd:string"/>
-            <xsd:element name="genre"    type="xsd:string"/>
-            <xsd:element name="price"    type="xsd:float" />
-            <xsd:element name="pub_date" type="xsd:date" />
-            <xsd:element name="review"   type="xsd:string"/>
-          </xsd:sequence>
-          <xsd:attribute name="id"   type="xsd:string"/>
-        </xsd:complexType>
-      </xsd:schema>
+         <xs:schema xmlns="http://www.w3.org/2001/XMLSchema">
+                <xs:element name="root" type="SimpleType"/>
+                <xs:complexType name="SimpleType">
+                    <xs:sequence>
+                      <xs:element name="foo" type="xs:string"/>
+                      <xs:element name="bar" type="xs:string"/>
+                    </xs:sequence>
+                </xs:complexType>
+          </xs:schema>
     `;
     
     await parseAndExpect(xsd, (schema) => {
-      expect(schema.elements).toHaveLength(0);
+      expect(schema.elements).toHaveLength(2);
+      const complexType = schema.elements.filter(el => el.name === 'SimpleType').at(0);
+      expect(complexType?.children).toHaveLength(2);
     });
 
   });
@@ -444,9 +428,9 @@ const runCommonTests = (xsdParser: XSDParser) => {
 describe('XSDParser Implementations', () => {
   const xmlParser = new XMLParserImpl();
 
-  describe('XSDStandardParserImpl', () => {
-    runCommonTests(new XSDStandardParserImpl(xmlParser));
-  });
+  // describe('XSDStandardParserImpl', () => {
+  //   runCommonTests(new XSDStandardParserImpl(xmlParser));
+  // });
 
   describe('XSDPipelineParserImpl', () => {
     runCommonTests(new XSDPipelineParserImpl(xmlParser));
diff --git a/src/xsd/pipeline/parser.ts b/src/xsd/pipeline/parser.ts
@@ -6,6 +6,7 @@ import { ParseEnumerationStep } from "@lib/xsd/pipeline/steps/enumeration";
 import { ParseNestedElementsStep } from "@lib/xsd/pipeline/steps/nestedElement";
 import { ParseRestrictionsStep } from "@lib/xsd/pipeline/steps/restriction";
 import { ParseRootElementStep } from "@lib/xsd/pipeline/steps/rootElement";
+import { ParseTypeReferencesStep } from "@lib/xsd/pipeline/steps/typeReferences";
 
 export interface XSDParser {
     parse(xsd: string): Promise<XSDSchema>;
@@ -25,21 +26,20 @@ export class XSDPipelineParserImpl implements XSDParser {
 
     async parse(xsd: string): Promise<XSDSchema> {
         const doc = this.xmlParser.parse(xsd);
-
-        const elementNodes = this.extractElementNodes(doc.documentElement);
-        const partialXSDElementObjects = this.mapElementNodesToPartialXSDElementObjects(elementNodes);
-        const xsdElements = this.mergePartialXSDElementObjects(partialXSDElementObjects);
-        const filteredXSDElementObjects = this.filterValidXSDElementObjects(xsdElements);
-
+    
+        const schemaNodes = this.extractTopLevelSchemaNodes(doc.documentElement);
+        const partialObjects = this.mapElementNodesToPartialXSDElementObjects(schemaNodes);
+        const xsdElements = this.mergePartialXSDElementObjects(partialObjects);
+        const filteredElements = this.filterValidXSDElementObjects(xsdElements);
+    
         const targetNamespace = doc.documentElement.getAttribute("targetNamespace") || undefined;
-
-        return { targetNamespace, elements: filteredXSDElementObjects };
+    
+        const schema: XSDSchema = { targetNamespace, elements: filteredElements };
+        const resolvedElements = this.resolveTypeReferences(schema);
+    
+        return { targetNamespace, elements: resolvedElements };
     }
 
-    private extractElementNodes(documentElement: Element): Element[] {
-        return Array.from(documentElement.childNodes)
-            .filter((node) => node.nodeType === 1 && node.nodeName === "xs:element") as Element[];
-    }
 
     private mapElementNodesToPartialXSDElementObjects(elementNodes: Element[]): Partial<XSDElement>[][] {
         return elementNodes.map((el) => this.pipeline.execute(el));
@@ -55,4 +55,23 @@ export class XSDPipelineParserImpl implements XSDParser {
     private filterValidXSDElementObjects(xsdElements: XSDElement[]): XSDElement[] {
         return xsdElements.filter((element): element is XSDElement => !!element.name);
     }
+
+    private resolveTypeReferences(schema: XSDSchema): XSDElement[] {
+        const resolver = new ParseTypeReferencesStep(schema);
+        return schema.elements.map(el => resolver.execute(el));
+    }
+
+    private extractTopLevelSchemaNodes(documentElement: Element): Element[] {
+        return Array.from(documentElement.childNodes)
+            .filter((node) => 
+                node.nodeType === 1 && 
+                (this.isElement(node, "element") || this.isElement(node, "complexType"))
+            ) as Element[];
+    }
+    
+    private isElement(node: Node, localName: string): boolean {
+        return node.nodeType === 1 && (node as Element).localName === localName;
+    }
+    
+    
 }
diff --git a/src/xsd/pipeline/steps/nestedElement.test.ts b/src/xsd/pipeline/steps/nestedElement.test.ts
@@ -28,7 +28,7 @@ describe("ParseNestedElementsStep", () => {
             { name: "child2", minOccurs: 1, maxOccurs: NaN },
         ]);
 
-        expect(result.choices).toBeUndefined();
+        expect(result.choices).toEqual([]);
     });
 
     it("should parse nested elements within complexType and choice", () => {
@@ -116,7 +116,7 @@ describe("ParseNestedElementsStep", () => {
         const element = new DOMParser().parseFromString(xsdElement, "text/xml").documentElement;
         const result = step.execute(element);
         expect(result.children).toEqual([]);
-        expect(result.choices).toBeUndefined();
+        expect(result.choices).toEqual([]);
     });
 
     it("should handle complexType with attributes", () => {
diff --git a/src/xsd/pipeline/steps/nestedElement.ts b/src/xsd/pipeline/steps/nestedElement.ts
diff --git a/src/xsd/pipeline/steps/typeReferences.test.ts b/src/xsd/pipeline/steps/typeReferences.test.ts
diff --git a/src/xsd/pipeline/steps/typeReferences.ts b/src/xsd/pipeline/steps/typeReferences.ts
