@hla4ts/fom-codegen 0.1.0

package/src/xsd-parser.ts

@@ -0,0 +1,404 @@
+/**
+ * XSD Parser
+ *
+ * Parses XML Schema Definition (XSD) files to extract type information
+ * for generating TypeScript types.
+ */
+
+interface XmlElement {
+  name: string;
+  attributes: Record<string, string>;
+  children: XmlElement[];
+  text?: string;
+}
+
+interface XsdType {
+  name: string;
+  kind: "complex" | "simple" | "enum";
+  baseType?: string;
+  elements: XsdElement[];
+  attributes: XsdAttribute[];
+  enumValues?: string[];
+  documentation?: string;
+}
+
+interface XsdElement {
+  name: string;
+  type: string;
+  minOccurs: number;
+  maxOccurs: number | "unbounded";
+  optional: boolean;
+  array: boolean;
+  documentation?: string;
+}
+
+interface XsdAttribute {
+  name: string;
+  type: string;
+  required: boolean;
+  defaultValue?: string;
+}
+
+interface XsdSchema {
+  targetNamespace: string;
+  types: Map<string, XsdType>;
+  elements: Map<string, XsdElement>;
+  rootElement?: string;
+}
+
+/**
+ * Parse an XSD file and extract type information.
+ */
+export function parseXsd(xsdContent: string): XsdSchema {
+  const root = parseXml(xsdContent);
+  const schema: XsdSchema = {
+    targetNamespace: root.attributes["targetNamespace"] || "",
+    types: new Map(),
+    elements: new Map(),
+  };
+
+  // Find the schema element
+  const schemaElement = root.name === "schema" ? root : findChild(root, "schema");
+  if (!schemaElement) {
+    throw new Error("No schema element found in XSD");
+  }
+
+  // Extract namespace
+  schema.targetNamespace = schemaElement.attributes["targetNamespace"] || "";
+
+  // Parse complex types
+  for (const complexType of getChildren(schemaElement, "complexType")) {
+    const typeName = complexType.attributes["name"];
+    if (!typeName) continue;
+
+    const type = parseComplexType(complexType, schema);
+    schema.types.set(typeName, type);
+  }
+
+  // Parse inline complex types in elements (for elements without explicit type attribute)
+  // This is handled in parseElement now, but we need to process top-level elements too
+  for (const element of getChildren(schemaElement, "element")) {
+    const elementName = element.attributes["name"];
+    const elementType = element.attributes["type"];
+    if (elementName && !elementType) {
+      const complexType = findChild(element, "complexType");
+      if (complexType) {
+        // Check if it's simpleContent - if so, extract the base type
+        const simpleContent = findChild(complexType, "simpleContent");
+        if (!simpleContent) {
+          // Only register non-simpleContent inline types
+          const typeName = `${capitalize(elementName)}Type`;
+          const type = parseComplexType(complexType, schema);
+          type.name = typeName;
+          schema.types.set(typeName, type);
+        }
+      }
+    }
+  }
+
+  // Parse simple types (including enumerations)
+  for (const simpleType of getChildren(schemaElement, "simpleType")) {
+    const typeName = simpleType.attributes["name"];
+    if (!typeName) continue;
+
+    const type = parseSimpleType(simpleType);
+    schema.types.set(typeName, type);
+  }
+
+  // Parse root element
+  for (const element of getChildren(schemaElement, "element")) {
+    const elementName = element.attributes["name"];
+    const elementType = element.attributes["type"];
+    if (elementName && elementType) {
+      schema.rootElement = elementName;
+      schema.elements.set(elementName, {
+        name: elementName,
+        type: elementType,
+        minOccurs: 1,
+        maxOccurs: 1,
+        optional: false,
+        array: false,
+      });
+    }
+  }
+
+  return schema;
+}
+
+function parseComplexType(node: XmlElement, schema: XsdSchema): XsdType {
+  const typeName = node.attributes["name"] || "";
+  const type: XsdType = {
+    name: typeName,
+    kind: "complex",
+    elements: [],
+    attributes: [],
+  };
+
+  // Extract documentation
+  const annotation = findChild(node, "annotation");
+  if (annotation) {
+    const doc = findChild(annotation, "documentation");
+    if (doc && doc.text) {
+      type.documentation = doc.text.trim();
+    }
+  }
+
+  // Parse sequence/all/choice
+  const sequence = findChild(node, "sequence") || findChild(node, "all") || findChild(node, "choice");
+  if (sequence) {
+    for (const element of getChildren(sequence, "element")) {
+      type.elements.push(parseElement(element, schema));
+    }
+  }
+
+  // Handle simpleContent (for types that extend simple types)
+  const simpleContent = findChild(node, "simpleContent");
+  if (simpleContent) {
+    const extension = findChild(simpleContent, "extension");
+    if (extension) {
+      type.baseType = extension.attributes["base"];
+    }
+  }
+
+  // Handle complexContent (for types that extend complex types)
+  const complexContent = findChild(node, "complexContent");
+  if (complexContent) {
+    const extension = findChild(complexContent, "extension");
+    if (extension) {
+      type.baseType = extension.attributes["base"];
+      const extensionSequence = findChild(extension, "sequence") || findChild(extension, "all");
+      if (extensionSequence) {
+        for (const element of getChildren(extensionSequence, "element")) {
+          type.elements.push(parseElement(element, schema));
+        }
+      }
+    }
+  }
+
+  // Parse attributes
+  for (const attr of getChildren(node, "attribute")) {
+    type.attributes.push(parseAttribute(attr));
+  }
+
+
+  return type;
+}
+
+function parseSimpleType(node: XmlElement): XsdType {
+  const typeName = node.attributes["name"] || "";
+  
+  // Check for union (e.g., SecurityClassificationUnion)
+  const union = findChild(node, "union");
+  if (union) {
+    const memberTypes = union.attributes["memberTypes"] || "";
+    // For unions, we'll treat them as the first member type if it's an enum
+    const members = memberTypes.split(/\s+/).filter(Boolean);
+    if (members.length > 0) {
+      // Check if first member is an enum - if so, use it
+      // Otherwise, treat as string (union of enum + string)
+      return {
+        name: typeName,
+        kind: "simple",
+        baseType: members[0], // Reference to the enum type
+        elements: [],
+        attributes: [],
+      };
+    }
+  }
+  
+  // Check for enumeration
+  const restriction = findChild(node, "restriction");
+  if (restriction) {
+    const base = restriction.attributes["base"];
+    const enumValues: string[] = [];
+    
+    for (const enumValue of getChildren(restriction, "enumeration")) {
+      const value = enumValue.attributes["value"];
+      if (value) {
+        enumValues.push(value);
+      }
+    }
+
+    if (enumValues.length > 0) {
+      return {
+        name: typeName,
+        kind: "enum",
+        baseType: base,
+        enumValues,
+        elements: [],
+        attributes: [],
+      };
+    }
+  }
+
+  return {
+    name: typeName,
+    kind: "simple",
+    elements: [],
+    attributes: [],
+  };
+}
+
+function parseElement(node: XmlElement, schema?: XsdSchema): XsdElement {
+  const name = node.attributes["name"] || "";
+  let type = node.attributes["type"] || "";
+  const minOccurs = parseInt(node.attributes["minOccurs"] || "1", 10);
+  const maxOccurs = node.attributes["maxOccurs"] || "1";
+  const maxOccursNum = maxOccurs === "unbounded" ? Infinity : parseInt(maxOccurs, 10);
+
+  // Handle inline complexType
+  if (!type) {
+    const complexType = findChild(node, "complexType");
+    if (complexType) {
+      // Check if it's simpleContent (extends a simple type)
+      const simpleContent = findChild(complexType, "simpleContent");
+      if (simpleContent) {
+        const extension = findChild(simpleContent, "extension");
+        if (extension) {
+          type = extension.attributes["base"] || "string";
+        } else {
+          type = `${capitalize(name)}Type`;
+        }
+      } else {
+        // Generate a type name from the element name
+        // If name already ends with "Type", don't add another one
+        const baseName = capitalize(name);
+        const typeName = baseName.endsWith("Type") ? baseName : `${baseName}Type`;
+        type = typeName;
+        
+        // Parse and register the inline type if schema is provided
+        if (schema) {
+          const inlineType = parseComplexType(complexType, schema);
+          inlineType.name = typeName;
+          schema.types.set(typeName, inlineType);
+        }
+      }
+    } else {
+      const simpleType = findChild(node, "simpleType");
+      if (simpleType) {
+        type = `${capitalize(name)}Type`;
+      }
+    }
+  }
+
+  // Extract documentation
+  let documentation: string | undefined;
+  const annotation = findChild(node, "annotation");
+  if (annotation) {
+    const doc = findChild(annotation, "documentation");
+    if (doc && doc.text) {
+      documentation = doc.text.trim();
+    }
+  }
+
+  return {
+    name,
+    type,
+    minOccurs,
+    maxOccurs: maxOccursNum === Infinity ? "unbounded" : maxOccursNum,
+    optional: minOccurs === 0,
+    array: maxOccursNum > 1 || maxOccurs === "unbounded",
+    documentation,
+  };
+}
+
+function capitalize(str: string): string {
+  return str[0].toUpperCase() + str.slice(1);
+}
+
+function parseAttribute(node: XmlElement): XsdAttribute {
+  const name = node.attributes["name"] || "";
+  let type = node.attributes["type"] || "";
+  const use = node.attributes["use"] || "optional";
+  const defaultValue = node.attributes["default"];
+  const fixed = node.attributes["fixed"];
+
+  // If no type is specified, default to string
+  // Attributes with fixed values are typically strings
+  if (!type) {
+    type = "xs:string";
+  }
+
+  return {
+    name,
+    type,
+    required: use === "required",
+    defaultValue: defaultValue || fixed,
+  };
+}
+
+// Simple XML parser (reusing approach from xml-parser.ts)
+function parseXml(xml: string): XmlElement {
+  const cleaned = xml
+    .replace(/<!--[\s\S]*?-->/g, "")
+    .replace(/<!\[CDATA\[[\s\S]*?\]\]>/g, (match) => match.slice(9, -3))
+    .trim();
+  const tokens = cleaned.match(/<[^>]+>|[^<]+/g) ?? [];
+  const stack: XmlElement[] = [];
+  let root: XmlElement | undefined;
+
+  for (const token of tokens) {
+    if (token.startsWith("<")) {
+      if (token.startsWith("</")) {
+        stack.pop();
+        continue;
+      }
+
+      const selfClosing = token.endsWith("/>");
+      const tagBody = token.slice(1, token.length - (selfClosing ? 2 : 1)).trim();
+      const [rawName, ...attrParts] = tagBody.split(/\s+/);
+      const name = stripNamespace(rawName);
+      const attributes = parseAttributes(attrParts.join(" "));
+      const element: XmlElement = { name, attributes, children: [], text: "" };
+
+      if (!root) {
+        root = element;
+      }
+      if (stack.length > 0) {
+        stack[stack.length - 1].children.push(element);
+      }
+      if (!selfClosing) {
+        stack.push(element);
+      }
+    } else if (stack.length > 0) {
+      const text = token.trim();
+      if (text) {
+        stack[stack.length - 1].text += text;
+      }
+    }
+  }
+
+  if (!root) {
+    throw new Error("Failed to parse XML: no root element found.");
+  }
+  return root;
+}
+
+function parseAttributes(text: string): Record<string, string> {
+  const attrs: Record<string, string> = {};
+  const regex = /([^\s=]+)\s*=\s*"(.*?)"|([^\s=]+)\s*=\s*'(.*?)'/g;
+  let match: RegExpExecArray | null;
+  while ((match = regex.exec(text)) !== null) {
+    const name = stripNamespace(match[1] ?? match[3] ?? "");
+    const value = match[2] ?? match[4] ?? "";
+    if (name) {
+      attrs[name] = value;
+    }
+  }
+  return attrs;
+}
+
+function stripNamespace(name: string): string {
+  const parts = name.split(":");
+  return parts[parts.length - 1];
+}
+
+function findChild(parent: XmlElement, name: string): XmlElement | undefined {
+  return parent.children.find((child) => child.name === name);
+}
+
+function getChildren(parent: XmlElement, name: string): XmlElement[] {
+  return parent.children.filter((child) => child.name === name);
+}
+
+export type { XsdSchema, XsdType, XsdElement, XsdAttribute };