fhirsmith 0.3.0

package/tx/xml/capabilitystatement-xml.js

@@ -0,0 +1,63 @@
+//
+// CapabilityStatement XML Serialization
+//
+
+const { FhirXmlBase } = require('./xml-base');
+
+/**
+ * XML support for FHIR CapabilityStatement resources
+ */
+class CapabilityStatementXML extends FhirXmlBase {
+
+  /**
+   * Element order for CapabilityStatement (FHIR requires specific order)
+   */
+  static _elementOrder = [
+    'id', 'meta', 'implicitRules', 'language', 'text', 'contained',
+    'extension', 'modifierExtension',
+    'url', 'identifier', 'version', 'versionAlgorithmString', 'versionAlgorithmCoding',
+    'name', 'title', 'status', 'experimental', 'date', 'publisher',
+    'contact', 'description', 'useContext', 'jurisdiction', 'purpose', 'copyright',
+    'copyrightLabel', 'kind', 'instantiates', 'imports',
+    'software', 'implementation', 'fhirVersion', 'format', 'patchFormat',
+    'acceptLanguage', 'implementationGuide', 'rest', 'messaging', 'document'
+  ];
+
+  /**
+   * Convert CapabilityStatement JSON to XML string
+   * @param {Object} json - CapabilityStatement as JSON
+   * @param {number} fhirVersion - FHIR version (3, 4, or 5)
+   * @returns {string} XML string
+   */
+  // eslint-disable-next-line no-unused-vars
+  static toXml(json, fhirVersion) {
+    const content = this.renderElementsInOrder(json, 1, this._elementOrder);
+    return this.wrapInRootElement('CapabilityStatement', content);
+  }
+
+  /**
+   * Convert XML string to CapabilityStatement JSON
+   * @param {string} xml - XML string
+   * @param {number} fhirVersion - FHIR version
+   * @returns {Object} JSON object
+   */
+  static fromXml(xml) {
+    const element = this.parseXmlString(xml);
+    if (element.name !== 'CapabilityStatement') {
+      throw new Error(`Expected CapabilityStatement root element, got ${element.name}`);
+    }
+    return this.convertElementToFhirJson(element, 'CapabilityStatement');
+  }
+
+  /**
+   * Parse from a pre-parsed XML element
+   * @param {Object} element - Parsed element with {name, attributes, children}
+   * @param {number} fhirVersion - FHIR version
+   * @returns {Object} JSON object
+   */
+  static fromXmlElement(element) {
+    return this.convertElementToFhirJson(element, 'CapabilityStatement');
+  }
+}
+
+module.exports = { CapabilityStatementXML };

package/tx/xml/codesystem-xml.js

@@ -0,0 +1,62 @@
+//
+// CodeSystem XML Serialization
+//
+
+const { FhirXmlBase } = require('./xml-base');
+
+/**
+ * XML support for FHIR CodeSystem resources
+ */
+class CodeSystemXML extends FhirXmlBase {
+
+  /**
+   * Element order for CodeSystem (FHIR requires specific order)
+   */
+  static _elementOrder = [
+    'id', 'meta', 'implicitRules', 'language', 'text', 'contained',
+    'extension', 'modifierExtension',
+    'url', 'identifier', 'version', 'versionAlgorithmString', 'versionAlgorithmCoding',
+    'name', 'title', 'status', 'experimental', 'date', 'publisher',
+    'contact', 'description', 'useContext', 'jurisdiction', 'purpose', 'copyright',
+    'copyrightLabel', 'approvalDate', 'lastReviewDate', 'effectivePeriod',
+    'caseSensitive', 'valueSet', 'hierarchyMeaning', 'compositional', 'versionNeeded',
+    'content', 'supplements', 'count', 'filter', 'property', 'concept'
+  ];
+
+  /**
+   * Convert CodeSystem JSON to XML string
+   * @param {Object} json - CodeSystem as JSON
+   * @param {number} fhirVersion - FHIR version (3, 4, or 5)
+   * @returns {string} XML string
+   */
+  static toXml(json) {
+    const content = this.renderElementsInOrder(json, 1, this._elementOrder);
+    return this.wrapInRootElement('CodeSystem', content);
+  }
+
+  /**
+   * Convert XML string to CodeSystem JSON
+   * @param {string} xml - XML string
+   * @param {number} fhirVersion - FHIR version
+   * @returns {Object} JSON object
+   */
+  static fromXml(xml) {
+    const element = this.parseXmlString(xml);
+    if (element.name !== 'CodeSystem') {
+      throw new Error(`Expected CodeSystem root element, got ${element.name}`);
+    }
+    return this.convertElementToFhirJson(element, 'CodeSystem');
+  }
+
+  /**
+   * Parse from a pre-parsed XML element
+   * @param {Object} element - Parsed element with {name, attributes, children}
+   * @param {number} fhirVersion - FHIR version
+   * @returns {Object} JSON object
+   */
+  static fromXmlElement(element) {
+    return this.convertElementToFhirJson(element, 'CodeSystem');
+  }
+}
+
+module.exports = { CodeSystemXML };

package/tx/xml/conceptmap-xml.js

@@ -0,0 +1,65 @@
+//
+// ConceptMap XML Serialization
+//
+
+const { FhirXmlBase } = require('./xml-base');
+
+/**
+ * XML support for FHIR ConceptMap resources
+ */
+class ConceptMapXML extends FhirXmlBase {
+
+  /**
+   * Element order for ConceptMap (FHIR requires specific order)
+   */
+  static _elementOrder = [
+    'id', 'meta', 'implicitRules', 'language', 'text', 'contained',
+    'extension', 'modifierExtension',
+    'url', 'identifier', 'version', 'versionAlgorithmString', 'versionAlgorithmCoding',
+    'name', 'title', 'status', 'experimental', 'date', 'publisher',
+    'contact', 'description', 'useContext', 'jurisdiction', 'purpose', 'copyright',
+    'copyrightLabel', 'approvalDate', 'lastReviewDate', 'effectivePeriod',
+    'sourceScopeUri', 'sourceScopeCanonical', 'targetScopeUri', 'targetScopeCanonical',
+    'group'
+  ];
+
+  /**
+   * Convert ConceptMap JSON to XML string
+   * @param {Object} json - ConceptMap as JSON
+   * @param {number} fhirVersion - FHIR version (3, 4, or 5)
+   * @returns {string} XML string
+   */
+  // eslint-disable-next-line no-unused-vars
+  static toXml(json, fhirVersion) {
+    const content = this.renderElementsInOrder(json, 1, this._elementOrder);
+    return this.wrapInRootElement('ConceptMap', content);
+  }
+
+  /**
+   * Convert XML string to ConceptMap JSON
+   * @param {string} xml - XML string
+   * @param {number} fhirVersion - FHIR version
+   * @returns {Object} JSON object
+   */
+  // eslint-disable-next-line no-unused-vars
+  static fromXml(xml, fhirVersion) {
+    const element = this.parseXmlString(xml);
+    if (element.name !== 'ConceptMap') {
+      throw new Error(`Expected ConceptMap root element, got ${element.name}`);
+    }
+    return this.convertElementToFhirJson(element, 'ConceptMap');
+  }
+
+  /**
+   * Parse from a pre-parsed XML element
+   * @param {Object} element - Parsed element with {name, attributes, children}
+   * @param {number} fhirVersion - FHIR version
+   * @returns {Object} JSON object
+   */
+  // eslint-disable-next-line no-unused-vars
+  static fromXmlElement(element, fhirVersion) {
+    return this.convertElementToFhirJson(element, 'ConceptMap');
+  }
+}
+
+module.exports = { ConceptMapXML };

package/tx/xml/namingsystem-xml.js

@@ -0,0 +1,65 @@
+//
+// NamingSystem XML Serialization
+//
+
+const { FhirXmlBase } = require('./xml-base');
+
+/**
+ * XML support for FHIR NamingSystem resources
+ */
+class NamingSystemXML extends FhirXmlBase {
+
+  /**
+   * Element order for NamingSystem (FHIR requires specific order)
+   */
+  static _elementOrder = [
+    'id', 'meta', 'implicitRules', 'language', 'text', 'contained',
+    'extension', 'modifierExtension',
+    'url', 'identifier', 'version', 'versionAlgorithmString', 'versionAlgorithmCoding',
+    'name', 'title', 'status', 'kind', 'experimental', 'date', 'publisher',
+    'contact', 'responsible', 'type', 'description', 'useContext', 'jurisdiction',
+    'purpose', 'copyright', 'copyrightLabel', 'approvalDate', 'lastReviewDate',
+    'effectivePeriod', 'topic', 'author', 'editor', 'reviewer', 'endorser',
+    'relatedArtifact', 'usage', 'uniqueId'
+  ];
+
+  /**
+   * Convert NamingSystem JSON to XML string
+   * @param {Object} json - NamingSystem as JSON
+   * @param {number} fhirVersion - FHIR version (3, 4, or 5)
+   * @returns {string} XML string
+   */
+  // eslint-disable-next-line no-unused-vars
+  static toXml(json, fhirVersion) {
+    const content = this.renderElementsInOrder(json, 1, this._elementOrder);
+    return this.wrapInRootElement('NamingSystem', content);
+  }
+
+  /**
+   * Convert XML string to NamingSystem JSON
+   * @param {string} xml - XML string
+   * @param {number} fhirVersion - FHIR version
+   * @returns {Object} JSON object
+   */
+  // eslint-disable-next-line no-unused-vars
+  static fromXml(xml, fhirVersion) {
+    const element = this.parseXmlString(xml);
+    if (element.name !== 'NamingSystem') {
+      throw new Error(`Expected NamingSystem root element, got ${element.name}`);
+    }
+    return this.convertElementToFhirJson(element, 'NamingSystem');
+  }
+
+  /**
+   * Parse from a pre-parsed XML element
+   * @param {Object} element - Parsed element with {name, attributes, children}
+   * @param {number} fhirVersion - FHIR version
+   * @returns {Object} JSON object
+   */
+  // eslint-disable-next-line no-unused-vars
+  static fromXmlElement(element, fhirVersion) {
+    return this.convertElementToFhirJson(element, 'NamingSystem');
+  }
+}
+
+module.exports = { NamingSystemXML };

package/tx/xml/operationoutcome-xml.js

@@ -0,0 +1,127 @@
+//
+// OperationOutcome XML Serialization
+//
+
+const { FhirXmlBase } = require('./xml-base');
+
+/**
+ * XML support for FHIR OperationOutcome resources
+ */
+class OperationOutcomeXML extends FhirXmlBase {
+
+  /**
+   * Element order for OperationOutcome (FHIR requires specific order)
+   */
+  static _elementOrder = [
+    'id', 'meta', 'implicitRules', 'language', 'text', 'contained',
+    'extension', 'modifierExtension', 'issue'
+  ];
+
+  /**
+   * Element order for issue elements
+   */
+  static _issueElementOrder = [
+    'severity', 'code', 'details', 'diagnostics', 'location', 'expression'
+  ];
+
+  /**
+   * Convert OperationOutcome JSON to XML string
+   * @param {Object} json - OperationOutcome as JSON
+   * @param {number} fhirVersion - FHIR version (3, 4, or 5)
+   * @returns {string} XML string
+   */
+  // eslint-disable-next-line no-unused-vars
+  static toXml(json, fhirVersion) {
+    const content = this._renderOperationOutcome(json, 1);
+    return this.wrapInRootElement('OperationOutcome', content);
+  }
+
+  /**
+   * Render OperationOutcome with special handling for issues
+   * @private
+   */
+  static _renderOperationOutcome(obj, level) {
+    let xml = '';
+
+    // Process elements in order
+    for (const key of this._elementOrder) {
+      if (Object.hasOwn(obj, key) && key !== 'resourceType') {
+        if (key === 'issue') {
+          xml += this._renderIssues(obj.issue, level);
+        } else {
+          xml += this.renderElement(key, obj[key], level);
+        }
+      }
+    }
+
+    // Process any remaining elements
+    for (const key of Object.keys(obj)) {
+      if (!this._elementOrder.includes(key) && key !== 'resourceType' && !key.startsWith('_')) {
+        xml += this.renderElement(key, obj[key], level);
+      }
+    }
+
+    return xml;
+  }
+
+  /**
+   * Render issue array with proper element ordering
+   * @private
+   */
+  static _renderIssues(issues, level) {
+    let xml = '';
+    if (!Array.isArray(issues)) {
+      issues = [issues];
+    }
+
+    for (const issue of issues) {
+      xml += `${this.indent(level)}<issue>\n`;
+
+      // Render issue elements in correct order
+      for (const key of this._issueElementOrder) {
+        if (Object.hasOwn(issue, key)) {
+          xml += this.renderElement(key, issue[key], level + 1);
+        }
+      }
+
+      // Render any remaining elements
+      for (const key of Object.keys(issue)) {
+        if (!this._issueElementOrder.includes(key) && !key.startsWith('_')) {
+          xml += this.renderElement(key, issue[key], level + 1);
+        }
+      }
+
+      xml += `${this.indent(level)}</issue>\n`;
+    }
+
+    return xml;
+  }
+
+  /**
+   * Convert XML string to OperationOutcome JSON
+   * @param {string} xml - XML string
+   * @param {number} fhirVersion - FHIR version
+   * @returns {Object} JSON object
+   */
+  // eslint-disable-next-line no-unused-vars
+  static fromXml(xml, fhirVersion) {
+    const element = this.parseXmlString(xml);
+    if (element.name !== 'OperationOutcome') {
+      throw new Error(`Expected OperationOutcome root element, got ${element.name}`);
+    }
+    return this.convertElementToFhirJson(element, 'OperationOutcome');
+  }
+
+  /**
+   * Parse from a pre-parsed XML element
+   * @param {Object} element - Parsed element with {name, attributes, children}
+   * @param {number} fhirVersion - FHIR version
+   * @returns {Object} JSON object
+   */
+  // eslint-disable-next-line no-unused-vars
+  static fromXmlElement(element, fhirVersion) {
+    return this.convertElementToFhirJson(element, 'OperationOutcome');
+  }
+}
+
+module.exports = { OperationOutcomeXML };

package/tx/xml/parameters-xml.js

@@ -0,0 +1,312 @@
+//
+// Parameters XML Serialization
+//
+
+const { FhirXmlBase } = require('./xml-base');
+
+// Forward declarations - will be loaded lazily to avoid circular dependencies
+let CodeSystemXML, ValueSetXML, ConceptMapXML, OperationOutcomeXML;
+
+/**
+ * XML support for FHIR Parameters resources
+ */
+class ParametersXML extends FhirXmlBase {
+
+  /**
+   * Element order for Parameters (FHIR requires specific order)
+   */
+  static _elementOrder = [
+    'id', 'meta', 'implicitRules', 'language', 'parameter'
+  ];
+
+  /**
+   * Lazily load resource XML classes to avoid circular dependencies
+   */
+  static _loadResourceClasses() {
+    if (!CodeSystemXML) {
+      CodeSystemXML = require('./codesystem-xml').CodeSystemXML;
+      ValueSetXML = require('./valueset-xml').ValueSetXML;
+      ConceptMapXML = require('./conceptmap-xml').ConceptMapXML;
+      OperationOutcomeXML = require('./operationoutcome-xml').OperationOutcomeXML;
+    }
+  }
+
+  /**
+   * Convert Parameters JSON to XML string
+   * @param {Object} json - Parameters as JSON
+   * @param {number} fhirVersion - FHIR version (3, 4, or 5)
+   * @returns {string} XML string
+   */
+  static toXml(json, fhirVersion) {
+    this._loadResourceClasses();
+    const content = this._renderParameters(json, 1, fhirVersion);
+    return this.wrapInRootElement('Parameters', content);
+  }
+
+  /**
+   * Render Parameters with special handling for parameter elements
+   * @private
+   */
+  static _renderParameters(obj, level, fhirVersion) {
+    let xml = '';
+
+    // Process elements in order
+    for (const key of this._elementOrder) {
+      if (Object.hasOwn(obj, key) && key !== 'resourceType') {
+        if (key === 'parameter') {
+          xml += this._renderParameterArray(obj.parameter, level, fhirVersion);
+        } else {
+          xml += this.renderElement(key, obj[key], level);
+        }
+      }
+    }
+
+    // Process any remaining elements
+    for (const key of Object.keys(obj)) {
+      if (!this._elementOrder.includes(key) && key !== 'resourceType' && !key.startsWith('_')) {
+        xml += this.renderElement(key, obj[key], level);
+      }
+    }
+
+    return xml;
+  }
+
+  /**
+   * Render parameter array
+   * @private
+   */
+  static _renderParameterArray(parameters, level, fhirVersion) {
+    let xml = '';
+    if (!Array.isArray(parameters)) {
+      parameters = [parameters];
+    }
+
+    for (const param of parameters) {
+      xml += `${this.indent(level)}<parameter>\n`;
+      xml += this._renderParameter(param, level + 1, fhirVersion);
+      xml += `${this.indent(level)}</parameter>\n`;
+    }
+
+    return xml;
+  }
+
+  /**
+   * Render a single parameter
+   * @private
+   */
+  static _renderParameter(param, level, fhirVersion) {
+    let xml = '';
+
+    // Parameter element order: name, value[x], resource, part
+    if (param.name !== undefined) {
+      xml += `${this.indent(level)}<name value="${this.escapeXml(param.name)}"/>\n`;
+    }
+
+    // Handle value[x] - find the value property
+    for (const [key, value] of Object.entries(param)) {
+      if (key.startsWith('value')) {
+        xml += this.renderElement(key, value, level);
+        break;
+      }
+    }
+
+    // Handle resource
+    if (param.resource) {
+      xml += `${this.indent(level)}<resource>\n`;
+      xml += this._renderResource(param.resource, level + 1, fhirVersion);
+      xml += `${this.indent(level)}</resource>\n`;
+    }
+
+    // Handle nested parts
+    if (param.part) {
+      for (const part of param.part) {
+        xml += `${this.indent(level)}<part>\n`;
+        xml += this._renderParameter(part, level + 1, fhirVersion);
+        xml += `${this.indent(level)}</part>\n`;
+      }
+    }
+
+    return xml;
+  }
+
+  /**
+   * Render an embedded resource
+   * @private
+   */
+  static _renderResource(resource, level, fhirVersion) {
+    const resourceType = resource.resourceType;
+    if (!resourceType) {
+      return '';
+    }
+
+    // Try to use dedicated XML converter
+    let fullXml;
+    try {
+      switch (resourceType) {
+        case 'CodeSystem':
+          fullXml = CodeSystemXML.toXml(resource, fhirVersion);
+          break;
+        case 'ValueSet':
+          fullXml = ValueSetXML.toXml(resource, fhirVersion);
+          break;
+        case 'ConceptMap':
+          fullXml = ConceptMapXML.toXml(resource, fhirVersion);
+          break;
+        case 'OperationOutcome':
+          fullXml = OperationOutcomeXML.toXml(resource, fhirVersion);
+          break;
+        case 'Parameters':
+          fullXml = ParametersXML.toXml(resource, fhirVersion);
+          break;
+        default:
+          // Fall back to generic rendering
+          return this._renderGenericResource(resource, level);
+      }
+
+      // Remove XML declaration and re-indent
+      let fragment = fullXml.replace(/^<\?xml[^?]*\?>\s*\n?/, '');
+
+      // Add indentation to each line
+      const indent = this.indent(level);
+      fragment = fragment.split('\n').map(line => line ? indent + line : line).join('\n');
+
+      return fragment;
+    } catch (e) {
+      return this._renderGenericResource(resource, level);
+    }
+  }
+
+  /**
+   * Generic resource rendering fallback
+   * @private
+   */
+  static _renderGenericResource(resource, level) {
+    let xml = '';
+    const resourceType = resource.resourceType;
+    if (resourceType) {
+      xml += `${this.indent(level)}<${resourceType} xmlns="${this.getNamespace()}">\n`;
+      for (const [key, value] of Object.entries(resource)) {
+        if (key !== 'resourceType') {
+          xml += this.renderElement(key, value, level + 1);
+        }
+      }
+      xml += `${this.indent(level)}</${resourceType}>\n`;
+    }
+    return xml;
+  }
+
+  /**
+   * Convert XML string to Parameters JSON
+   * @param {string} xml - XML string
+   * @param {number} fhirVersion - FHIR version
+   * @returns {Object} JSON object
+   */
+  static fromXml(xml, fhirVersion) {
+    this._loadResourceClasses();
+    const element = this.parseXmlString(xml);
+    if (element.name !== 'Parameters') {
+      throw new Error(`Expected Parameters root element, got ${element.name}`);
+    }
+    return this._parseParametersElement(element, fhirVersion);
+  }
+
+  /**
+   * Parse from a pre-parsed XML element
+   * @param {Object} element - Parsed element with {name, attributes, children}
+   * @param {number} fhirVersion - FHIR version
+   * @returns {Object} JSON object
+   */
+  static fromXmlElement(element, fhirVersion) {
+    this._loadResourceClasses();
+    return this._parseParametersElement(element, fhirVersion);
+  }
+
+  /**
+   * Parse Parameters element
+   * @private
+   */
+  static _parseParametersElement(element, fhirVersion) {
+    const json = { resourceType: 'Parameters' };
+
+    for (const child of element.children) {
+      if (child.name === 'id') {
+        json.id = child.attributes.value;
+      } else if (child.name === 'meta') {
+        json.meta = this.convertChildElement(child);
+      } else if (child.name === 'implicitRules') {
+        json.implicitRules = child.attributes.value;
+      } else if (child.name === 'language') {
+        json.language = child.attributes.value;
+      } else if (child.name === 'parameter') {
+        if (!json.parameter) {
+          json.parameter = [];
+        }
+        json.parameter.push(this._parseParameter(child, fhirVersion));
+      }
+    }
+
+    return json;
+  }
+
+  /**
+   * Parse a parameter element
+   * @private
+   */
+  static _parseParameter(element, fhirVersion) {
+    const param = {};
+
+    for (const child of element.children) {
+      if (child.name === 'name') {
+        param.name = child.attributes.value;
+      } else if (child.name.startsWith('value')) {
+        const { value, primitiveExt } = this._convertChildElementWithExt(child);
+        if (value !== null) {
+          param[child.name] = value;
+        }
+        if (primitiveExt !== null) {
+          param['_' + child.name] = primitiveExt;
+        }
+      } else if (child.name === 'resource') {
+        param.resource = this._parseResourceElement(child, fhirVersion);
+      } else if (child.name === 'part') {
+        if (!param.part) {
+          param.part = [];
+        }
+        param.part.push(this._parseParameter(child, fhirVersion));
+      }
+    }
+
+    return param;
+  }
+
+  /**
+   * Parse a resource element
+   * @private
+   */
+  static _parseResourceElement(element, fhirVersion) {
+    if (element.children.length > 0) {
+      const resourceElement = element.children[0];
+      const resourceType = resourceElement.name;
+
+      // Try to use dedicated parser
+      switch (resourceType) {
+        case 'CodeSystem':
+          return CodeSystemXML.fromXmlElement(resourceElement, fhirVersion);
+        case 'ValueSet':
+          return ValueSetXML.fromXmlElement(resourceElement, fhirVersion);
+        case 'ConceptMap':
+          return ConceptMapXML.fromXmlElement(resourceElement, fhirVersion);
+        case 'OperationOutcome':
+          return OperationOutcomeXML.fromXmlElement(resourceElement, fhirVersion);
+        case 'Parameters':
+          return ParametersXML.fromXmlElement(resourceElement, fhirVersion);
+        default:
+          // Generic parsing
+          return this.convertElementToFhirJson(resourceElement, resourceType);
+      }
+    }
+    return null;
+  }
+}
+
+module.exports = { ParametersXML };