fhirsmith 0.6.0 → 0.7.0

package/tx/workers/search.js

@@ -7,6 +7,7 @@
 
 const { TerminologyWorker } = require('./worker');
 const {Utilities} = require("../../library/utilities");
+const {debugLog} = require("../operation-context");
 
 class SearchWorker extends TerminologyWorker {
   /**
@@ -114,7 +115,7 @@ class SearchWorker extends TerminologyWorker {
 
     } catch (error) {
       this.log.error(error);
-      this.debugLog(error);
+      debugLog(error);
       req.logInfo = "error "+(error.msgId || error.className);
       return res.status(500).json({
         resourceType: 'OperationOutcome',
@@ -146,9 +147,7 @@ class SearchWorker extends TerminologyWorker {
 
     for (const [key, cs] of this.provider.codeSystems) {
       this.deadCheck('searchCodeSystems');
-      if (cs.url == 'http://www.cms.gov/Medicare/Coding/HCPCSReleaseCodeSets') {
-        console.log("debug");
-      }
+
       if (key == cs.vurl) {
         const json = cs.jsonObj;
 
@@ -160,10 +159,6 @@ class SearchWorker extends TerminologyWorker {
         // Check each search parameter for partial match
         let isMatch = true;
         for (const [param, searchValue] of Object.entries(searchParams)) {
-          // 'system' doesn't do anything for CodeSystem search
-          if (param === 'system') {
-            continue;
-          }
 
           // Map content-mode to content property
           const jsonProp = param === 'content-mode' ? 'content' : param;
@@ -180,7 +175,7 @@ class SearchWorker extends TerminologyWorker {
               isMatch = false;
               break;
             }
-          } else if (param === 'url') { // exact match
+          } else if (param === 'url' || param === 'system') { // exact match
             const propValue = json.url;
             if (propValue !== searchValue) {
               isMatch = false;

package/tx/workers/subsumes.js

@@ -12,6 +12,7 @@ const { FhirCodeSystemProvider } = require('../cs/cs-cs');
 const {TxParameters} = require("../params");
 const {Parameters} = require("../library/parameters");
 const {Issue, OperationOutcome} = require("../library/operation-outcome");
+const {debugLog} = require("../operation-context");
 class SubsumesWorker extends TerminologyWorker {
   /**
    * @param {OperationContext} opContext - Operation context
@@ -43,7 +44,7 @@ class SubsumesWorker extends TerminologyWorker {
       await this.handleTypeLevelSubsumes(req, res);
     } catch (error) {
       this.log.error(error);
-      this.debugLog(error);
+      debugLog(error);
       req.logInfo = "error "+(error.msgId || error.className);
       if (error instanceof Issue) {
         let oo = new OperationOutcome();
@@ -67,7 +68,7 @@ class SubsumesWorker extends TerminologyWorker {
       await this.handleInstanceLevelSubsumes(req, res);
     } catch (error) {
       this.log.error(error);
-      this.debugLog(error);
+      debugLog(error);
       if (error instanceof Issue) {
         let oo = new OperationOutcome();
         oo.addIssue(error);

package/tx/workers/translate.js

@@ -12,6 +12,7 @@ const { TxParameters } = require('../params');
 const { Parameters } = require('../library/parameters');
 const { Issue, OperationOutcome } = require('../library/operation-outcome');
 const {ConceptMap} = require("../library/conceptmap");
+const {debugLog} = require("../operation-context");
 
 class TranslateWorker extends TerminologyWorker {
   /**
@@ -44,7 +45,7 @@ class TranslateWorker extends TerminologyWorker {
       await this.handleTypeLevelTranslate(req, res);
     } catch (error) {
       this.log.error(error);
-      this.debugLog(error);
+      debugLog(error);
       if (error instanceof Issue) {
         const oo = new OperationOutcome();
         oo.addIssue(error);
@@ -67,7 +68,7 @@ class TranslateWorker extends TerminologyWorker {
       await this.handleInstanceLevelTranslate(req, res);
     } catch (error) {
       this.log.error(error);
-      this.debugLog(error);
+      debugLog(error);
       if (error instanceof Issue) {
         const oo = new OperationOutcome();
         oo.addIssue(error);
@@ -410,7 +411,7 @@ class TranslateWorker extends TerminologyWorker {
       }
     } catch (error) {
       this.log.error(error);
-      this.debugLog(error);
+      debugLog(error);
       result.push({
         name: 'result',
         valueBoolean: false

package/tx/workers/validate.js

@@ -23,6 +23,8 @@ const ValueSet = require("../library/valueset");
 const {ValueSetExpander} = require("./expand");
 const {FhirCodeSystemProvider} = require("../cs/cs-cs");
 const {CodeSystem} = require("../library/codesystem");
+const {VersionUtilities} = require("../../library/version-utilities");
+const {debugLog} = require("../operation-context");
 
 const DEV_IGNORE_VALUESET = false; // todo: what's going on with this (ported from pascal)
 
@@ -123,7 +125,7 @@ class ValueSetChecker {
       }
     } catch (error) {
       this.log.error(error);
-      this.debugLog(error);
+      debugLog(error);
       throw new Error('Exception expanding value set in order to infer system: ' + error.message);
     }
     return result;
@@ -444,7 +446,7 @@ class ValueSetChecker {
     return await this.check(issuePath, system, version, code, null, unknownSystems, ver, inactive, normalForm, vstatus, it, op, null, null, contentMode, impliedSystem, ts, msgs, defLang);
   }
 
-  async check(path, system, version, code, displays, unknownSystems, ver, inactive, normalForm, vstatus, cause, op, vcc, params, contentMode, impliedSystem, unkCodes, messages, defLang) {
+  async check(path, system, version, code, displays, unknownSystems, ver, inactive, normalForm, vstatus, cause, op, vcc, params, contentMode, impliedSystem, unkCodes, messages, defLang, display) {
     defLang.value = new Language('en');
     this.worker.opContext.addNote(this.valueSet, 'Check "' + this.worker.renderer.displayCoded(system, version, code) + '"', this.indentCount);
 
@@ -677,11 +679,28 @@ class ValueSetChecker {
 
       if (Extensions.checkNoModifiers(this.valueSet.jsonObj.compose, 'ValueSetChecker.prepare', 'ValueSet.compose')) {
         result = false;
-        for (let cc of this.valueSet.jsonObj.compose.include || []) {
+        let determinedVersion = undefined;
+        if (!version) {
+          // if we don't have a fixed version, and we have more than one possible version, we have to pick the version
+          // now, by looking to see which version we can find the value in, starting from the most revent.
+          let includes = (this.valueSet.jsonObj.compose.include || []).filter(inc => inc.system == system);
+          let vset = new Set(includes.map(inc => inc.version).filter(Boolean));
+          if (vset.size > 1) {
+            determinedVersion = await this.pickApplicableVersion(vset, system, code, display);
+          }
+        }
+        const includes = [...(this.valueSet.jsonObj.compose.include || [])];
+        includes.sort((a, b) => {
+          if (a.system === b.system && a.version && b.version) {
+            return -VersionUtilities.compareVersionsGeneral(a.version, b.version);
+          }
+          return 0;
+        });
+        for (let cc of includes) {
           this.worker.deadCheck('check#2');
           if (!cc.system) {
             result = true;
-          } else if (cc.system === system || system === '%%null%%') {
+          } else if ((cc.system === system || system === '%%null%%') && (!determinedVersion || cc.version == determinedVersion) && this.useThisVersion(cc, version)) {
             let v = await this.determineVersion(path, cc.system, cc.version, version, op, unknownSystems, messages);
             let cs = await this.worker.findCodeSystem(system, v, this.params, ["complete", "fragment"], op,true, true, false, this.worker.requiredSupplements);
             if (cs === null) {
@@ -720,12 +739,12 @@ class ValueSetChecker {
             defLang.value = new Language(cs.defLang());
             this.worker.opContext.addNote(this.valueSet, 'CodeSystem found: ' + this.worker.renderer.displayCoded(cs) + ' for ' + this.worker.renderer.displayCoded(cc.system, v), this.indentCount);
             await this.checkCanonicalStatusCS(path, op, cs, this.valueSet);
-            ver.value = cs.version();
             this.worker.checkSupplements(cs, cc, this.worker.requiredSupplements, this.worker.usedSupplements);
             contentMode.value = cs.contentMode();
 
             let msg = '';
             if ((system === '%%null%%' || cs.system() === system) && await this.checkConceptSet(path, 'in', cs, cc, code, displays, this.valueSet, msg, inactive, normalForm, vstatus, op, vcc, messages)) {
+              ver.value = cs.version();
               result = true;
             } else {
               result = false;
@@ -766,7 +785,6 @@ class ValueSetChecker {
               }
               await this.checkCanonicalStatus(path, op, cs, this.valueSet);
               this.worker.checkSupplements(cs, cc, this.worker.requiredSupplements, this.worker.usedSupplements);
-              ver.value = cs.version();
               contentMode.value = cs.contentMode();
               let msg = '';
               excluded = (system === '%%null%%' || cs.system() === system) && await this.checkConceptSet(path, 'not in', cs, cc, code, displays, this.valueSet, msg, inactive, normalForm, vstatus, op, vcc);
@@ -1037,7 +1055,8 @@ class ValueSetChecker {
       if (this.worker.opContext.usageTracker) {
         this.worker.opContext.usageTracker.seeConcept(c.system, c.code);
       }
-      const csd = await this.worker.findCodeSystem(c.system, null, this.params, ['complete', 'fragment'], false, true, false, false, this.worker.requiredSupplements);
+      let vsImpliedVersion = this.findVSVersionForSystem(c.system);
+      const csd = await this.worker.findCodeSystem(c.system, vsImpliedVersion, this.params, ['complete', 'fragment'], false, true, false, false, this.worker.requiredSupplements);
       this.worker.seeSourceProvider(csd, c.system);
       this.worker.deadCheck('check-b#1');
       let path;
@@ -1055,7 +1074,7 @@ class ValueSetChecker {
       let ver = { value: '' };
       let contentMode = { value: null };
       let defLang = { value: null };
-      let v = await this.check(path, c.system, c.version, c.code, list, unknownSystems, ver, inactive, normalForm, vstatus, cause, op, vcc, result, contentMode, impliedSystem, ts, mt, defLang);
+      let v = await this.check(path, c.system, c.version, c.code, list, unknownSystems, ver, inactive, normalForm, vstatus, cause, op, vcc, result, contentMode, impliedSystem, ts, mt, defLang, c.display);
       if (v === false) {
         cause.value = 'code-invalid';
       }
@@ -1509,14 +1528,16 @@ class ValueSetChecker {
 
   async checkConceptSet(path, role, cs, cset, code, displays, vs, message, inactive, normalForm, vstatus, op, vcc, messages) {
     this.worker.opContext.addNote(vs, 'check code ' + role + ' ' + this.worker.renderer.displayValueSetInclude(cset) + ' at ' + path, this.indentCount);
-    inactive.value = false;
+    if (role !== 'not in') {
+      inactive.value = false;
+    }
     let result = false;
     if (!cset.concept && !cset.filter) {
       let loc = await cs.locate(code);
       result = false;
       if (loc.context == null) {
         this.worker.opContext.addNote(this.valueSet, 'Code "' + code + '" not found in ' + this.worker.renderer.displayCoded(cs)+": "+loc.mesage, this.indentCount);
-        if (!this.params.membershipOnly) {
+        if (!this.params.membershipOnly && role !== 'not in') {
           if (cs.contentMode() !== 'complete') {
             op.addIssue(new Issue('warning', 'code-invalid', addToPath(path, 'code'), 'UNKNOWN_CODE_IN_FRAGMENT', this.worker.i18n.translate('UNKNOWN_CODE_IN_FRAGMENT', this.params.HTTPLanguages, [code, cs.system(), cs.version()]), 'invalid-code'));
             result = true;
@@ -1548,16 +1569,18 @@ class ValueSetChecker {
 
         if (!(this.params.abstractOk || !(await cs.isAbstract(loc.context)))) {
           this.worker.opContext.addNote(this.valueSet, 'Code "' + code + '" found in ' + this.worker.renderer.displayCoded(cs) + ' but is abstract', this.indentCount);
-          if (!this.params.membershipOnly) {
+          if (!this.params.membershipOnly && role !== 'not in') {
             op.addIssue(new Issue('error', 'business-rule', addToPath(path, 'code'), 'ABSTRACT_CODE_NOT_ALLOWED', this.worker.i18n.translate('ABSTRACT_CODE_NOT_ALLOWED', this.params.HTTPLanguages, [cs.system(), code]), 'code-rule'));
           }
         } else if (this.excludeInactives() && await cs.isInactive(loc.context)) {
           this.worker.opContext.addNote(this.valueSet, 'Code "' + code + '" found in ' + this.worker.renderer.displayCoded(cs) + ' but is inactive', this.indentCount);
-          let msg = this.worker.i18n.translate('STATUS_CODE_WARNING_CODE', this.params.HTTPLanguages, ['not active', code]);
-          op.addIssue(new Issue('error', 'business-rule', addToPath(path, 'code'), 'STATUS_CODE_WARNING_CODE', msg, 'code-rule'));
+          if (role !== 'not in') {
+            let msg = this.worker.i18n.translate('STATUS_CODE_WARNING_CODE', this.params.HTTPLanguages, ['not active', code]);
+            op.addIssue(new Issue('error', 'business-rule', addToPath(path, 'code'), 'STATUS_CODE_WARNING_CODE', msg, 'code-rule'));
+            messages.push(msg);
+          }
           result = false;
-          messages.push(msg);
-          if (!this.params.membershipOnly) {
+          if (!this.params.membershipOnly && role !== 'not in') {
             inactive.value = true;
             inactive.path = path;
             if (inactive.value) {
@@ -1567,28 +1590,31 @@ class ValueSetChecker {
         } else if (this.params.activeOnly && await cs.isInactive(loc.context)) {
           this.worker.opContext.addNote(this.valueSet, 'Code "' + code + '" found in ' + this.worker.renderer.displayCoded(cs) + ' but is inactive', this.indentCount);
           result = false;
-          inactive.value = true;
-          inactive.path = path;
-          vstatus.value = await cs.getStatus(loc.context);
-          let msg = this.worker.i18n.translate('STATUS_CODE_WARNING_CODE', this.params.HTTPLanguages, ['not active', code]);
-          messages.push(msg);
-          op.addIssue(new Issue('error', 'business-rule', addToPath(path, 'code'), 'STATUS_CODE_WARNING_CODE', msg, 'code-rule'));
+          if (role !== 'not in') {
+            inactive.value = true;
+            inactive.path = path;
+            vstatus.value = await cs.getStatus(loc.context);
+            let msg = this.worker.i18n.translate('STATUS_CODE_WARNING_CODE', this.params.HTTPLanguages, ['not active', code]);
+            messages.push(msg);
+            op.addIssue(new Issue('error', 'business-rule', addToPath(path, 'code'), 'STATUS_CODE_WARNING_CODE', msg, 'code-rule'));
+          }
         } else {
           result = true;
-          inactive.value = await cs.isInactive(loc.context);
-          inactive.path = path;
-          vstatus.value = await cs.getStatus(loc.context);
-
-          if (vcc !== null) {
-            if (!vcc.coding) {
-              vcc.coding = [];
+          if (role !== 'not in') {
+            inactive.value = await cs.isInactive(loc.context);
+            inactive.path = path;
+            vstatus.value = await cs.getStatus(loc.context);
+            if (vcc !== null) {
+              if (!vcc.coding) {
+                vcc.coding = [];
+              }
+              vcc.coding.push({
+                system: cs.system(),
+                version: cs.version(),
+                code: await cs.code(loc.context),
+                display: displays.preferredDisplay(this.params.workingLanguages())
+              });
             }
-            vcc.coding.push({
-              system: cs.system(),
-              version: cs.version(),
-              code: await cs.code(loc.context),
-              display: displays.preferredDisplay(this.params.workingLanguages())
-            });
           }
           return result;
         }
@@ -1739,6 +1765,72 @@ class ValueSetChecker {
     return list.join(",");
   }
 
+  findVSVersionForSystem(system) {
+    let set = new Set();
+    for (let inc of this.valueSet.jsonObj.compose?.include || []) {
+      if (inc.system == system && inc.version) {
+        set.add(inc.version);
+      }
+    }
+    let v = null;
+    for (let t of set) {
+      if (!v || VersionUtilities.compareVersionsGeneral(t, v) > 0) {
+        v = t;
+      }
+    }
+    return v;
+  }
+
+  async pickApplicableVersion(vset, system, code, display) {
+    let found = [];
+    for (let v of vset) {
+      let cs = await this.worker.findCodeSystem(system, v, this.params, ["complete", "fragment"], null, true, true, false, this.worker.requiredSupplements);
+      if (cs != null) {
+        let loc = await cs.locate(code);
+        if (loc.context) {
+          if (!display || await this.displayIsOk(cs, loc.context, display)) {
+            found.push(v);
+          }
+        }
+      }
+    }
+    // if it was found in none or all of them, we don't do anything
+    if (found.length == vset.size) {
+      return undefined;
+    }
+    if (found.length > 0) {
+      let sorted = found.sort((a, b) => -VersionUtilities.compareVersionsGeneral(a, b));
+      return sorted[0];
+    } else { // well, none of them, we'll go with the latest
+      let sorted = [...vset].sort((a, b) => -VersionUtilities.compareVersionsGeneral(a, b));
+      return sorted[0];
+    }
+  }
+
+  async displayIsOk(cs, context, display) {
+    if (display == await cs.display(context)) {
+      return true;
+    }
+    const cds = new Designations(this.worker.i18n.languageDefinitions);
+    await cs.designations(context, cds);
+    return cds.designations.find(cd => cd.value == display);
+  }
+
+  hasMatchForVersion(includes, version) {
+    for (let inc of includes) {
+      if (inc.version == version) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  useThisVersion(cc, version) {
+    if (!version || cc.version == version) {
+      return true;
+    }
+    return !this.hasMatchForVersion(this.valueSet.jsonObj.compose.include || [], version);
+  }
 }
 
 function addToPath(path, name) {
@@ -1855,7 +1947,7 @@ class ValidateWorker extends TerminologyWorker {
 
     } catch (error) {
       this.log.error(error);
-      this.debugLog(error);
+      debugLog(error);
       if (error instanceof Issue) {
         if (error.isHandleAsOO()) {
           let oo = new OperationOutcome();
@@ -1914,7 +2006,7 @@ class ValidateWorker extends TerminologyWorker {
       return result;
     } catch (error) {
       this.log.error(error);
-      this.debugLog(error);
+      debugLog(error);
       if (error instanceof Issue && !error.isHandleAsOO()) {
         return await this.handlePrepareError(error, coded, mode.mode, txp);
       } else {
@@ -1973,7 +2065,7 @@ class ValidateWorker extends TerminologyWorker {
 
     } catch (error) {
       this.log.error(error);
-      this.debugLog(error);
+      debugLog(error);
       return res.status(error.statusCode || 500).json(this.operationOutcome(
         'error', error.issueCode || 'exception', error.message));
     }
@@ -1994,7 +2086,7 @@ class ValidateWorker extends TerminologyWorker {
 
     } catch (error) {
       this.log.error(error);
-      this.debugLog(error);
+      debugLog(error);
       if (error instanceof Issue) {
         let op = new OperationOutcome();
         op.addIssue(error);
@@ -2074,7 +2166,7 @@ class ValidateWorker extends TerminologyWorker {
 
     } catch (error) {
       this.log.error(error);
-      this.debugLog(error);
+      debugLog(error);
       return res.status(error.statusCode || 500).json(this.operationOutcome(
         'error', error.issueCode || 'exception', error.message));
     }
@@ -2314,7 +2406,7 @@ class ValidateWorker extends TerminologyWorker {
       await checker.prepare();
     } catch (error) {
       this.log.error(error);
-      this.debugLog(error);
+      debugLog(error);
       if (!(error instanceof Issue) || error.isHandleAsOO()) {
         throw error;
       } else {

package/tx/workers/worker.js

@@ -1,4 +1,4 @@
-const { TerminologyError, isDebugging} = require('../operation-context');
+const { TerminologyError} = require('../operation-context');
 const { CodeSystem } = require('../library/codesystem');
 const ValueSet = require('../library/valueset');
 const {VersionUtilities} = require("../../library/version-utilities");
@@ -900,12 +900,6 @@ class TerminologyWorker {
     return true;
   }
 
-  debugLog(error) {
-    if (isDebugging()) {
-      console.log(error);
-    }
-  }
-
   hasSupplement(cs, supplements) {
     for (let t of supplements) {
       if (t.vurl == cs.vurl) {