fhirsmith 0.4.2 → 0.5.1

package/tx/workers/worker.js

@@ -1,4 +1,4 @@
-const { TerminologyError } = require('../operation-context');
+const { TerminologyError, isDebugging} = require('../operation-context');
 const { CodeSystem } = require('../library/codesystem');
 const ValueSet = require('../library/valueset');
 const {VersionUtilities} = require("../../library/version-utilities");
@@ -133,9 +133,10 @@ class TerminologyWorker {
    * @param {Array<string>} kinds - Allowed content modes
    * @param {OperationOutcome} op - Op for errors
    * * @param {boolean} nullOk - Whether null result is acceptable
+   * @param {Set<string>} statedSupplements - Supplements invoked in context
    * @returns {CodeSystemProvider|null} Code system provider or null
    */
-  async findCodeSystem(url, version = '', params, kinds = ['complete'], op, nullOk = false, checkVer = false, noVParams = false) {
+  async findCodeSystem(url, version = '', params, kinds = ['complete'], op, nullOk = false, checkVer = false, noVParams = false, statedSupplements = null) {
     if (!url) {
       return null;
     }
@@ -145,7 +146,7 @@ class TerminologyWorker {
     }
     let codeSystemResource = null;
     let provider = null;
-    const supplements = this.loadSupplements(url, version);
+    const supplements = this.loadSupplements(url, version, statedSupplements);
 
     // First check additional resources
     codeSystemResource = this.findInAdditionalResources(url, version, 'CodeSystem', !nullOk);
@@ -169,13 +170,13 @@ class TerminologyWorker {
 
     if (!provider && !nullOk) {
       if (!version) {
-        throw new Issue("error", "not-found", null, "UNKNOWN_CODESYSTEM_EXP", this.i18n.translate("UNKNOWN_CODESYSTEM_EXP", params.FHTTPLanguages, [url]), "not-found", 404);
+        throw new Issue("error", "not-found", null, "UNKNOWN_CODESYSTEM_EXP", this.i18n.translate("UNKNOWN_CODESYSTEM_EXP", params.FHTTPLanguages, [url]), "not-found", 422);
       } else {
         const versions = await this.listVersions(url);
         if (versions.length === 0) {
-          throw new Issue("error", "not-found", null, "UNKNOWN_CODESYSTEM_VERSION_EXP_NONE", this.i18n.translate("UNKNOWN_CODESYSTEM_VERSION_EXP_NONE", params.FHTTPLanguages, [url, version]), "not-found", 404);
+          throw new Issue("error", "not-found", null, "UNKNOWN_CODESYSTEM_VERSION_EXP_NONE", this.i18n.translate("UNKNOWN_CODESYSTEM_VERSION_EXP_NONE", params.FHTTPLanguages, [url, version]), "not-found", 422);
         } else {
-          throw new Issue("error", "not-found", null, "UNKNOWN_CODESYSTEM_VERSION_EXP", this.i18n.translate("UNKNOWN_CODESYSTEM_VERSION_EXP", params.FHTTPLanguages, [url, version, this.presentVersionList(versions)]), "not-found", 404);
+          throw new Issue("error", "not-found", null, "UNKNOWN_CODESYSTEM_VERSION_EXP", this.i18n.translate("UNKNOWN_CODESYSTEM_VERSION_EXP", params.FHTTPLanguages, [url, version, this.presentVersionList(versions)]), "not-found", 422);
         }
       }
     }
@@ -245,9 +246,10 @@ class TerminologyWorker {
    * Load supplements for a code system
    * @param {string} url - Code system URL
    * @param {string} version - Code system version
+   * @param {Set<string>} statedSupplements - Supplements invoked in context
    * @returns {Array<CodeSystem>} Supplement code systems
    */
-  loadSupplements(url, version = '') {
+  loadSupplements(url, version = '', statedSupplements) {
     const supplements = [];
 
     if (!this.additionalResources) {
@@ -265,6 +267,10 @@ class TerminologyWorker {
           continue;
         }
 
+        // we consider either language packs or specified supplements
+        if (!(cs.isLangPack() || (statedSupplements && (statedSupplements.has(cs.url) || statedSupplements.has(cs.vurl))))) {
+          continue;
+        }
         // Handle exact URL match (no version specified in supplements)
         if (supplementsUrl === url) {
           // If we're looking for a specific version, only include if no version in supplements URL
@@ -298,10 +304,10 @@ class TerminologyWorker {
    * @param {CodeSystemProvider} cs - Code system provider
    * @param {Object} src - Source element (for extensions)
    */
-  checkSupplements(cs, src, requiredSupplements) {
+  checkSupplements(cs, src, requiredSupplements, usedSupplements = null) {
     // Check for required supplements in extensions
-    if (src && src.getExtensions) {
-      const supplementExtensions = src.getExtensions('http://hl7.org/fhir/StructureDefinition/valueset-supplement');
+    if (src && src.extension) {
+      const supplementExtensions = src.extension.filter(x => x.url == 'http://hl7.org/fhir/StructureDefinition/valueset-supplement');
       for (const ext of supplementExtensions) {
         const supplementUrl = ext.valueString || ext.valueUri;
         if (supplementUrl && !cs.hasSupplement(this.opContext, supplementUrl)) {
@@ -310,10 +316,12 @@ class TerminologyWorker {
       }
     }
 
-    // Remove required supplements that are satisfied
-    for (let i = requiredSupplements.length - 1; i >= 0; i--) {
-      if (cs.hasSupplement(requiredSupplements[i])) {
-        requiredSupplements.splice(i, 1);
+    // Note required supplements that are satisfied
+    if (usedSupplements) {
+      for (const s of requiredSupplements) {
+        if (cs.hasSupplement(s)) {
+          usedSupplements.add(s);
+        }
       }
     }
   }
@@ -456,6 +464,10 @@ class TerminologyWorker {
     if (req.method === 'POST' && req.body && req.body.resourceType === 'Parameters') {
       return req.body;
     }
+    if (req.method === 'POST' && req.body && req.body.resourceType) {
+      let langs = this.languages.parse(req.headers['accept-language']);
+      throw new Issue('error', 'invalid', null, 'Wrong_type_for_resource_expected', this.i18n.translate('Wrong_type_for_resource_expected', langs, ["Parameters", req.body.resourceType])).handleAsOO(400);
+    }
 
     // Convert query params or form body to Parameters
     const source = req.method === 'POST' ? {...req.query, ...req.body} : req.query;
@@ -480,6 +492,10 @@ class TerminologyWorker {
           // Assume it's a complex type like Coding or CodeableConcept
           params.parameter.push(this.buildComplexParameter(name, value));
         }
+      } else if (value == 'true') {
+        params.parameter.push({name, valueBoolean: true});
+      } else if (value == 'false') {
+        params.parameter.push({name, valueBoolean: false});
       } else {
         params.parameter.push({name, valueString: String(value)});
       }
@@ -837,31 +853,6 @@ class TerminologyWorker {
     return result;
   }
 
-  // Note: findParameter, getStringParam, getResourceParam, getCodingParam,
-  // and getCodeableConceptParam are inherited from TerminologyWorker base class
-
-  fixForVersion(resource) {
-    if (this.provider.fhirVersion >= 5) {
-      return resource;
-    }
-    let rt = resource.resourceType;
-    switch (rt) {
-      case "ValueSet": {
-        let vs = new ValueSet(resource);
-        if (this.provider.fhirVersion == 4) {
-          return vs.convertFromR5(resource, "R4");
-        } else if (this.provider.fhirVersion == 3) {
-          return vs.convertFromR5(resource, "R3");
-        } else {
-          return resource;
-        }
-      }
-      default:
-        return resource;
-    }
-  }
-
-
   seeSourceVS(vs, url) {
     let s = url;
     if (vs) {
@@ -896,6 +887,19 @@ class TerminologyWorker {
     const lastItem = items.pop();
     return `${items.join(', ')} and ${lastItem}`;
   }
+
+  checkNoLockedDate(url, compose) {
+    if (compose.lockedDate) {
+      throw new Issue("error", "business-rule", null, null, `Cannot process ValueSet ${url} due to the presence of a lockedDate on the compose`);
+    }
+    return true;
+  }
+
+  debugLog(error) {
+    if (isDebugging()) {
+      console.log(error);
+    }
+  }
 }
 
 module.exports = {

package/tx/xml/bundle-xml.js

@@ -0,0 +1,237 @@
+//
+// Bundle XML Serialization
+//
+
+const { FhirXmlBase } = require('./xml-base');
+
+/**
+ * XML support for FHIR Bundle resources
+ */
+class BundleXML extends FhirXmlBase {
+
+  /**
+   * Element order for Bundle (FHIR requires specific order)
+   */
+  static _elementOrder = [
+    'id', 'meta', 'implicitRules', 'language',
+    'identifier', 'type', 'timestamp', 'total',
+    'link', 'entry', 'signature', 'issues'
+  ];
+
+  /**
+   * Element order for Bundle.entry
+   */
+  static _entryElementOrder = [
+    'link', 'fullUrl', 'resource', 'search', 'request', 'response'
+  ];
+
+  /**
+   * Element order for Bundle.link
+   */
+  static _linkElementOrder = [
+    'relation', 'url'
+  ];
+
+  /**
+   * Element order for Bundle.entry.search
+   */
+  static _searchElementOrder = [
+    'mode', 'score'
+  ];
+
+  /**
+   * Convert Bundle JSON to XML string
+   * @param {Object} json - Bundle as JSON
+   * @param {number} fhirVersion - FHIR version (3, 4, or 5)
+   * @returns {string} XML string
+   */
+  static toXml(json, fhirVersion) {
+    let content = '';
+    const indent = '  ';
+
+    // Render simple elements first
+    for (const key of this._elementOrder) {
+      if (json[key] === undefined) continue;
+
+      if (key === 'link') {
+        // Handle link array
+        for (const link of json.link || []) {
+          content += `${indent}<link>\n`;
+          content += this.renderElementsInOrder(link, 2, this._linkElementOrder);
+          content += `${indent}</link>\n`;
+        }
+      } else if (key === 'entry') {
+        // Handle entry array with nested resources
+        for (const entry of json.entry || []) {
+          content += `${indent}<entry>\n`;
+
+          // fullUrl
+          if (entry.fullUrl) {
+            content += `${indent}${indent}<fullUrl value="${this.escapeXml(entry.fullUrl)}"/>\n`;
+          }
+
+          // resource - needs special handling to embed full resource
+          if (entry.resource) {
+            content += `${indent}${indent}<resource>\n`;
+            content += this.renderResource(entry.resource, 3, fhirVersion);
+            content += `${indent}${indent}</resource>\n`;
+          }
+
+          // search
+          if (entry.search) {
+            content += `${indent}${indent}<search>\n`;
+            if (entry.search.mode) {
+              content += `${indent}${indent}${indent}<mode value="${this.escapeXml(entry.search.mode)}"/>\n`;
+            }
+            if (entry.search.score !== undefined) {
+              content += `${indent}${indent}${indent}<score value="${entry.search.score}"/>\n`;
+            }
+            content += `${indent}${indent}</search>\n`;
+          }
+
+          content += `${indent}</entry>\n`;
+        }
+      } else if (key === 'total') {
+        content += `${indent}<total value="${json.total}"/>\n`;
+      } else if (key === 'type') {
+        content += `${indent}<type value="${this.escapeXml(json.type)}"/>\n`;
+      } else if (key === 'timestamp') {
+        content += `${indent}<timestamp value="${this.escapeXml(json.timestamp)}"/>\n`;
+      } else if (key === 'id') {
+        content += `${indent}<id value="${this.escapeXml(json.id)}"/>\n`;
+      } else if (key === 'meta') {
+        content += this.renderMeta(json.meta, 1);
+      } else {
+        // Generic element handling
+        content += this.renderElement(key, json[key], 1);
+      }
+    }
+
+    return this.wrapInRootElement('Bundle', content);
+  }
+
+  /**
+   * Render a nested resource as XML
+   */
+  static renderResource(resource, indentLevel, _fhirVersion) {
+    void _fhirVersion; // reserved for future version-specific rendering
+
+    const indent = '  '.repeat(indentLevel);
+    const resourceType = resource.resourceType;
+
+    // For known resource types, delegate to their specific converters
+    // For unknown types, render generically
+    let innerContent = '';
+
+    // Get element order based on resource type
+    const elementOrder = this.getElementOrderForResource(resourceType);
+
+    innerContent = this.renderElementsInOrder(resource, indentLevel + 1, elementOrder);
+
+    return `${indent}<${resourceType} xmlns="http://hl7.org/fhir">\n${innerContent}${indent}</${resourceType}>\n`;
+  }
+
+  /**
+   * Get element order for a resource type
+   */
+  static getElementOrderForResource(resourceType) {
+    // Common elements that most resources have
+    const commonElements = [
+      'id', 'meta', 'implicitRules', 'language', 'text', 'contained',
+      'extension', 'modifierExtension'
+    ];
+
+    switch (resourceType) {
+      case 'CodeSystem':
+        return [
+          ...commonElements,
+          'url', 'identifier', 'version', 'versionAlgorithmString', 'versionAlgorithmCoding',
+          'name', 'title', 'status', 'experimental', 'date', 'publisher',
+          'contact', 'description', 'useContext', 'jurisdiction', 'purpose', 'copyright',
+          'copyrightLabel', 'approvalDate', 'lastReviewDate',
+          'caseSensitive', 'valueSet', 'hierarchyMeaning', 'compositional',
+          'versionNeeded', 'content', 'supplements', 'count', 'filter', 'property', 'concept'
+        ];
+      case 'ValueSet':
+        return [
+          ...commonElements,
+          'url', 'identifier', 'version', 'versionAlgorithmString', 'versionAlgorithmCoding',
+          'name', 'title', 'status', 'experimental', 'date', 'publisher',
+          'contact', 'description', 'useContext', 'jurisdiction', 'purpose', 'copyright',
+          'copyrightLabel', 'approvalDate', 'lastReviewDate', 'effectivePeriod',
+          'immutable', 'compose', 'expansion'
+        ];
+      case 'ConceptMap':
+        return [
+          ...commonElements,
+          'url', 'identifier', 'version', 'name', 'title', 'status', 'experimental',
+          'date', 'publisher', 'contact', 'description', 'useContext', 'jurisdiction',
+          'purpose', 'copyright', 'sourceUri', 'sourceCanonical', 'targetUri', 'targetCanonical',
+          'group'
+        ];
+      default:
+        // Return common elements plus all other keys from the resource
+        return commonElements;
+    }
+  }
+
+  /**
+   * Render meta element
+   */
+  static renderMeta(meta, indentLevel) {
+    if (!meta) return '';
+    const indent = '  '.repeat(indentLevel);
+    let content = `${indent}<meta>\n`;
+
+    if (meta.versionId) {
+      content += `${indent}  <versionId value="${this.escapeXml(meta.versionId)}"/>\n`;
+    }
+    if (meta.lastUpdated) {
+      content += `${indent}  <lastUpdated value="${this.escapeXml(meta.lastUpdated)}"/>\n`;
+    }
+    if (meta.source) {
+      content += `${indent}  <source value="${this.escapeXml(meta.source)}"/>\n`;
+    }
+    for (const profile of meta.profile || []) {
+      content += `${indent}  <profile value="${this.escapeXml(profile)}"/>\n`;
+    }
+    for (const security of meta.security || []) {
+      content += this.renderCoding(security, indentLevel + 1, 'security');
+    }
+    for (const tag of meta.tag || []) {
+      content += this.renderCoding(tag, indentLevel + 1, 'tag');
+    }
+
+    content += `${indent}</meta>\n`;
+    return content;
+  }
+
+  /**
+   * Render a Coding element
+   */
+  static renderCoding(coding, indentLevel, elementName) {
+    const indent = '  '.repeat(indentLevel);
+    let content = `${indent}<${elementName}>\n`;
+
+    if (coding.system) {
+      content += `${indent}  <system value="${this.escapeXml(coding.system)}"/>\n`;
+    }
+    if (coding.version) {
+      content += `${indent}  <version value="${this.escapeXml(coding.version)}"/>\n`;
+    }
+    if (coding.code) {
+      content += `${indent}  <code value="${this.escapeXml(coding.code)}"/>\n`;
+    }
+    if (coding.display) {
+      content += `${indent}  <display value="${this.escapeXml(coding.display)}"/>\n`;
+    }
+    if (coding.userSelected !== undefined) {
+      content += `${indent}  <userSelected value="${coding.userSelected}"/>\n`;
+    }
+
+    content += `${indent}</${elementName}>\n`;
+    return content;
+  }
+}
+
+module.exports = { BundleXML };