fhirsmith 0.7.6 → 0.8.2

package/tx/workers/translate.js

@@ -113,10 +113,15 @@ class TranslateWorker extends TerminologyWorker {
     let targetScope = null;
     let sourceScope = null;
     let targetSystem = null;
+    let reverse = false;
 
     // Get the source coding
+    // Accept both R5 names (sourceCoding, sourceCodeableConcept, sourceCode/sourceSystem)
+    // and R4 names (coding, codeableConcept, code/system) as aliases
     if (params.has('sourceCoding')) {
       coding = params.get('sourceCoding');
+    } else if (params.has('coding')) {
+      coding = params.get('coding');
     } else if (params.has('sourceCodeableConcept')) {
       const cc = params.get('sourceCodeableConcept');
       if (cc.coding && cc.coding.length > 0) {
@@ -125,19 +130,48 @@ class TranslateWorker extends TerminologyWorker {
         throw new Issue('error', 'invalid', null, null,
           'sourceCodeableConcept must contain at least one coding', null, 400);
       }
-    } else if (params.has('sourceCode')) {
-      if (!params.has('sourceSystem')) {
+    } else if (params.has('codeableConcept')) {
+      const cc = params.get('codeableConcept');
+      if (cc.coding && cc.coding.length > 0) {
+        coding = cc.coding[0];
+      } else {
         throw new Issue('error', 'invalid', null, null,
-          'sourceSystem parameter is required when using sourceCode', null, 400);
+          'codeableConcept must contain at least one coding', null, 400);
       }
-      coding = {
-        system: params.get('sourceSystem'),
-        version: params.get('sourceVersion'),
-        code: params.get('sourceCode')
-      };
+    } else if (params.has('sourceCode') || params.has('code')) {
+      const code = params.has('sourceCode') ? params.get('sourceCode') : params.get('code');
+      const system = params.has('sourceSystem') ? params.get('sourceSystem') : params.get('system');
+      if (!system) {
+        throw new Issue('error', 'invalid', null, null,
+          'system parameter is required when using code/sourceCode', null, 400);
+      }
+      const version = params.has('sourceVersion') ? params.get('sourceVersion') : params.get('version');
+      coding = {system, version, code};
+    } else if (params.has('targetCoding')) {
+      reverse = true;
+      coding = params.get('targetCoding');
+    } else if (params.has('targetCodeableConcept')) {
+      reverse = true;
+      const cc = params.get('targetCodeableConcept');
+      if (cc.coding && cc.coding.length > 0) {
+        coding = cc.coding[0]; // Use first coding
+      } else {
+        throw new Issue('error', 'invalid', null, null,
+          'sourceCodeableConcept must contain at least one coding', null, 400);
+      }
+    } else if (params.has('targetCode')) {
+      reverse = true;
+      const code = params.get('targetCode');
+      const system = params.get('targetSystem');
+      if (!system) {
+        throw new Issue('error', 'invalid', null, null,
+          'targetSystem parameter is required when using targetCode', null, 400);
+      }
+      const version = params.get('targetVersion');
+      coding = { system, version, code };
     } else {
       throw new Issue('error', 'invalid', null, null,
-        'Must provide sourceCode (with system), sourceCoding, or sourceCodeableConcept', null, 400);
+        'Must provide sourceCode+(source)system, sourceCoding, or sourceCodeableConcept, or targetCode+targetSystem), targetCoding, or targetCodeableConcept', null, 400);
     }
 
     // Get the concept map
@@ -162,21 +196,33 @@ class TranslateWorker extends TerminologyWorker {
     if (params.has('targetScope')) {
       targetScope = params.get('targetScope');
     }
-    if (params.has('targetSystem')) {
-      targetSystem = params.get('targetSystem');
+    if (reverse) {
+      if (params.has('sourceSystem')) {
+        targetSystem = params.get('sourceSystem');
+      }
+    } else {
+      if (params.has('targetSystem')) {
+        targetSystem = params.get('targetSystem');
+      }
     }
-
+    let explicit = true;
     // If no explicit concept map, we need to find one based on source/target
     if (conceptMaps.length == 0) {
-      await this.findConceptMapsInAdditionalResources(conceptMaps, coding.system, sourceScope, targetScope, targetSystem);
-      await this.provider.findConceptMapForTranslation(this.opContext, conceptMaps, coding.system, sourceScope, targetScope, targetSystem);
+      explicit = false;
+      if (reverse) {
+        await this.findConceptMapsInAdditionalResources(conceptMaps,targetSystem, targetScope, sourceScope, coding.system);
+        await this.provider.findConceptMapForTranslation(this.opContext, conceptMaps, targetSystem, targetScope, sourceScope, coding.system, coding.code);
+      } else {
+        await this.findConceptMapsInAdditionalResources(conceptMaps, coding.system, sourceScope, targetScope, targetSystem);
+        await this.provider.findConceptMapForTranslation(this.opContext, conceptMaps, coding.system, sourceScope, targetScope, targetSystem, coding.code);
+      }
       if (conceptMaps.length == 0) {
         throw new Issue('error', 'not-found', null, null, 'No suitable ConceptMaps found for the specified source and target', null, 404);
       }
     }
 
     // Perform the translation
-    const result = await this.doTranslate(conceptMaps, coding, targetScope, targetSystem, txp);
+    const result = await this.doTranslate(conceptMaps, coding, targetScope, targetSystem, txp, reverse, explicit);
     return res.status(200).json(result);
   }
 
@@ -208,10 +254,14 @@ class TranslateWorker extends TerminologyWorker {
     txp.readParams(params.jsonObj);
 
     // Get the source coding
+    // Accept both R5 names (sourceCoding, sourceCodeableConcept, sourceCode)
+    // and R4 names (coding, codeableConcept, code) as aliases
     let coding = null;
 
     if (params.has('sourceCoding')) {
       coding = params.get('sourceCoding');
+    } else if (params.has('coding')) {
+      coding = params.get('coding');
     } else if (params.has('sourceCodeableConcept')) {
       const cc = params.get('sourceCodeableConcept');
       if (cc.coding && cc.coding.length > 0) {
@@ -220,15 +270,25 @@ class TranslateWorker extends TerminologyWorker {
         throw new Issue('error', 'invalid', null, null,
           'sourceCodeableConcept must contain at least one coding', null, 400);
       }
-    } else if (params.has('sourceCode')) {
-      if (!params.has('system')) {
+    } else if (params.has('codeableConcept')) {
+      const cc = params.get('codeableConcept');
+      if (cc.coding && cc.coding.length > 0) {
+        coding = cc.coding[0];
+      } else {
         throw new Issue('error', 'invalid', null, null,
-          'system parameter is required when using sourceCode', null, 400);
+          'codeableConcept must contain at least one coding', null, 400);
+      }
+    } else if (params.has('sourceCode') || params.has('code')) {
+      const code = params.has('sourceCode') ? params.get('sourceCode') : params.get('code');
+      const system = params.has('system') ? params.get('system') : null;
+      if (!system) {
+        throw new Issue('error', 'invalid', null, null,
+          'system parameter is required when using code/sourceCode', null, 400);
       }
       coding = {
-        system: params.get('system'),
+        system,
         version: params.get('version'),
-        code: params.get('sourceCode')
+        code
       };
     } else {
       throw new Issue('error', 'invalid', null, null,
@@ -262,7 +322,7 @@ class TranslateWorker extends TerminologyWorker {
     return result;
   }
 
-  translateUsingGroups(cm, coding, targetScope, targetSystem, params, output) {
+  translateUsingGroupsForwards(cm, coding, targetScope, targetSystem, params, output, explicit) {
     let result = false;
     const matches = cm.listTranslations(coding, targetScope, targetSystem);
     if (matches.length > 0) {
@@ -270,7 +330,13 @@ class TranslateWorker extends TerminologyWorker {
         const g = match.group;
         const em = match.match;
         for (const map of em.target || []) {
-          if (['null', 'equivalent', 'equal', 'wider', 'subsumes', 'narrower', 'specializes', 'inexact'].includes(map.relationship)) {
+          let ok = false;
+          if (map.equivalence) { // R4 mode
+            ok = ['null', 'relatedto', 'equivalent', 'equal', 'wider', 'subsumes', 'narrower', 'specializes', 'inexact'].includes(map.equivalence);
+          } else {
+            ok = ['null', 'related-to', 'equivalent',  'source-is-narrower-than-target', 'source-is-broader-than-target'].includes(map.relationship);
+          }
+          if (ok) {
             result = true;
 
             const outcome = {
@@ -278,22 +344,119 @@ class TranslateWorker extends TerminologyWorker {
               code: map.code
             };
 
+            if (!this.hasMatch(output, outcome)) {
+              const matchParts = [];
+              matchParts.push({
+                name: 'concept',
+                valueCoding: outcome
+              });
+              matchParts.push({
+                name: 'relationship',
+                valueCode: map.relationship
+              });
+              // equivalence vs relationship will be sorted out in the version transform for parameters
+              if (map.equivalence) {
+                matchParts.push({
+                  name: 'equivalence',
+                  valueCode: map.equivalence
+                });
+              }
+              if (map.comment) {
+                matchParts.push({
+                  name: 'message',
+                  valueString: map.comment
+                });
+              }
+              for (const prod of map.product || []) {
+                const productParts = [];
+                productParts.push({
+                  name: 'element',
+                  valueString: prod.property
+                });
+                productParts.push({
+                  name: 'concept',
+                  valueCoding: {
+                    system: prod.system,
+                    code: prod.value
+                  }
+                });
+                matchParts.push({
+                  name: 'product',
+                  part: productParts
+                });
+              }
+              if (!explicit) {
+                matchParts.push({
+                  name: 'sourceMap',
+                  valueCanonical: cm.vurl
+                });
+              }
+              output.push({
+                name: 'match',
+                part: matchParts
+              });
+            }
+          }
+        }
+      }
+    }
+    return result;
+  }
+
+  translateUsingGroupsReverse(cm, coding, targetScope, targetSystem, params, output, explicit) {
+    let result = false;
+    const matches = cm.listTranslationsReverse(coding, targetScope, targetSystem);
+    if (matches.length > 0) {
+      for (let match of matches) {
+        const g = match.group;
+        const em = match.match;
+        const map = match.target;
+        let ok = false;
+        if (map.equivalence) { // R4 mode
+          ok = ['null', 'relatedto', 'equivalent', 'equal', 'wider', 'subsumes', 'narrower', 'specializes', 'inexact'].includes(map.equivalence);
+        } else {
+          ok = ['null', 'related-to', 'equivalent',  'source-is-narrower-than-target', 'source-is-broader-than-target'].includes(map.relationship);
+        }
+        if (ok) {
+          result = true;
+
+          const outcome = {
+            system: g.source,
+            code: em.code
+          };
+          const t = {
+            system: g.target,
+            code: coding.code
+          };
+
+          if (!this.hasMatch(output, outcome)) {
             const matchParts = [];
             matchParts.push({
-              name: 'concept',
+              name: 'source',
               valueCoding: outcome
             });
+            matchParts.push({
+              name: 'concept',
+              valueCoding: t
+            });
             matchParts.push({
               name: 'relationship',
               valueCode: map.relationship
             });
-            if (map.comments) {
+            // equivalence vs relationship will be sorted out in the version transform for parameters
+            if (map.equivalence) {
+              matchParts.push({
+                name: 'equivalence',
+                valueCode: map.equivalence
+              });
+            }
+            if (map.comment) {
               matchParts.push({
                 name: 'message',
-                valueString: map.comments
+                valueString: map.comment
               });
             }
-            for (const prod of map.products || []) {
+            for (const prod of map.product || []) {
               const productParts = [];
               productParts.push({
                 name: 'element',
@@ -311,6 +474,12 @@ class TranslateWorker extends TerminologyWorker {
                 part: productParts
               });
             }
+            if (!explicit) {
+              matchParts.push({
+                name: 'sourceMap',
+                valueCanonical: cm.vurl
+              });
+            }
             output.push({
               name: 'match',
               part: matchParts
@@ -322,7 +491,7 @@ class TranslateWorker extends TerminologyWorker {
     return result;
   }
 
-  async translateUsingCodeSystem(cm, coding, target, params, output) {
+  async translateUsingCodeSystem(cm, coding, target, params, output, reverse, explicit) {
     let result = false;
     const factory = cm.jsonObj.internalSource;
     let prov = await factory.build(this.opContext, []);
@@ -332,7 +501,7 @@ class TranslateWorker extends TerminologyWorker {
       valueUri: prov.system() + '|' + prov.version()
     });
 
-    let translations = await prov.getTranslations(coding, target);
+    let translations = await prov.getTranslations(cm, coding, target, reverse);
 
     if (translations.length > 0) {
       result = true;
@@ -346,7 +515,7 @@ class TranslateWorker extends TerminologyWorker {
         }
 
         const outcome = {
-          system: t.uri,
+          system: t.system,
           code: t.code,
           version: t.version,
           display: t.display
@@ -367,6 +536,12 @@ class TranslateWorker extends TerminologyWorker {
             valueString: t.message
           });
         }
+        if (!explicit) {
+          matchParts.push({
+            name: 'sourceMap',
+            valueCanonical: cm.vurl
+          });
+        }
         output.push({
           name: 'match',
           part: matchParts
@@ -383,9 +558,11 @@ class TranslateWorker extends TerminologyWorker {
    * @param {string} targetScope - Target value set scope (optional)
    * @param {string} targetSystem - Target code system (optional)
    * @param {Parameters} params - Full parameters object
+   * @param {boolean} reverse - Full parameters object*
+   * @param {boolean} explicit - If the concept map was named explicitly
    * @returns {Object} Parameters resource with translate result
    */
-  async doTranslate(conceptMaps, coding, targetScope, targetSystem, params) {
+  async doTranslate(conceptMaps, coding, targetScope, targetSystem, params, reverse, explicit) {
     this.deadCheck('doTranslate');
 
     const result = [];
@@ -394,9 +571,11 @@ class TranslateWorker extends TerminologyWorker {
       let added = false;
       for (const cm of conceptMaps) {
         if (cm.jsonObj.internalSource) {
-          added = await this.translateUsingCodeSystem(cm, coding, targetSystem, params, result) || added;
-        } else {
-          added = this.translateUsingGroups(cm, coding, targetScope, targetSystem, params, result) || added;
+          added = await this.translateUsingCodeSystem(cm, coding, targetSystem, params, result, reverse, explicit) || added;
+        } else if (reverse) {
+          added = this.translateUsingGroupsReverse(cm, coding, targetScope, targetSystem, params, result, reverse, explicit) || added;
+        } else{
+          added = this.translateUsingGroupsForwards(cm, coding, targetScope, targetSystem, params, result, reverse, explicit) || added;
         }
       }
       result.push({
@@ -492,6 +671,16 @@ class TranslateWorker extends TerminologyWorker {
       }
     }
   }
+
+  hasMatch(output, outcome) {
+    for (let o of output) {
+      let c = o.part.find(x => x.name === 'concept');
+      if (c.valueCoding.code === outcome.code && c.valueCoding.system === outcome.system) {
+        return true;
+      }
+    }
+    return false;
+  }
 }
 
 module.exports = TranslateWorker;

package/tx/workers/validate.js

@@ -316,21 +316,21 @@ class ValueSetChecker {
       }
 
       Extensions.checkNoImplicitRules(this.valueSet, 'ValueSetChecker.prepare', 'ValueSet');
-      Extensions.checkNoModifiers(this.valueSet, 'ValueSetChecker.prepare', 'ValueSet');
+      Extensions.checkNoModifiers(this.valueSet, 'ValueSetChecker.prepare', 'ValueSet', this.valueSet.vurl);
 
       this.allValueSet = this.valueSet.url === 'http://hl7.org/fhir/ValueSet/@all';
 
       if (this.valueSet.jsonObj.compose) {
-        Extensions.checkNoModifiers(this.valueSet.jsonObj.compose, 'ValueSetChecker.prepare', 'ValueSet.compose');
-        this.worker.checkNoLockedDate(this.valueSet.url, this.valueSet.jsonObj.compose)
+        Extensions.checkNoModifiers(this.valueSet.jsonObj.compose, 'ValueSetChecker.prepare', 'ValueSet.compose', this.valueSet.vurl);
+        this.worker.checkNoLockedDate(this.valueSet.vurl, this.valueSet.jsonObj.compose)
         let i = 0;
         for (let cc of this.valueSet.jsonObj.compose.include || []) {
-          await this.prepareConceptSet('include['+i+']', cc);
+          await this.prepareConceptSet('include['+i+']', cc, this.valueSet);
           i++;
         }
         i = 0;
         for (let cc of this.valueSet.jsonObj.compose.exclude || []) {
-          await this.prepareConceptSet('exclude['+i+']', cc);
+          await this.prepareConceptSet('exclude['+i+']', cc, this.valueSet);
           i++;
         }
       }
@@ -342,9 +342,9 @@ class ValueSetChecker {
     }
   }
 
-  async prepareConceptSet(desc, cc) {
+  async prepareConceptSet(desc, cc, vs) {
     this.worker.deadCheck('prepareConceptSet');
-    Extensions.checkNoModifiers(cc, 'ValueSetChecker.prepare', desc);
+    Extensions.checkNoModifiers(cc, 'ValueSetChecker.prepare', desc, vs.vurl);
     this.worker.opContext.addNote(this.valueSet, 'Prepare ' + desc + ': "' + this.worker.renderer.displayValueSetInclude(cc) + '"', this.indentCount);
     if (cc.valueSet) {
       for (let u of cc.valueSet) {
@@ -374,7 +374,7 @@ class ValueSetChecker {
       let i = 0;
       for (let ccf of cc.filter || []) {
         this.worker.deadCheck('prepareConceptSet#2');
-        Extensions.checkNoModifiers(ccf, 'ValueSetChecker.prepare', desc + '.filter');
+        Extensions.checkNoModifiers(ccf, 'ValueSetChecker.prepare', desc + '.filter', this.valueSet.vurl);
         if (!ccf.value) {
           throw new Issue('error', 'invalid', "ValueSet.compose."+desc+".filter["+i+"]", 'UNABLE_TO_HANDLE_SYSTEM_FILTER_WITH_NO_VALUE',
             this.worker.i18n.translate('UNABLE_TO_HANDLE_SYSTEM_FILTER_WITH_NO_VALUE', this.params.HTTPLanguages, [cs.system(), ccf.property, ccf.op]), "vs-invalid").handleAsOO(400);
@@ -677,7 +677,7 @@ class ValueSetChecker {
         throw new Issue('error', 'not-found', null, 'VALUESET_SUPPLEMENT_MISSING', this.worker.i18n.translatePlural(unused.size, 'VALUESET_SUPPLEMENT_MISSING', this.params.HTTPLanguages, [[...unused].join(',')]), 'not-found').handleAsOO(422);
       }
 
-      if (Extensions.checkNoModifiers(this.valueSet.jsonObj.compose, 'ValueSetChecker.prepare', 'ValueSet.compose')) {
+      if (Extensions.checkNoModifiers(this.valueSet.jsonObj.compose, 'ValueSetChecker.prepare', 'ValueSet.compose', this.valueSet.vurl)) {
         result = false;
         let determinedVersion = undefined;
         if (!version) {
@@ -807,7 +807,7 @@ class ValueSetChecker {
             }
           }
         }
-      } else if (Extensions.checkNoModifiers(this.valueSet.jsonObj.expansion, 'ValueSetChecker.prepare', 'ValueSet.expansion')) {
+      } else if (Extensions.checkNoModifiers(this.valueSet.jsonObj.expansion, 'ValueSetChecker.prepare', 'ValueSet.expansion', this.valueSet.vurl)) {
         let ccc = this.valueSet.findContains(system, version, code);
         if (ccc === null) {
           result = false;
@@ -1107,7 +1107,7 @@ class ValueSetChecker {
       codelist = !codelist ? '\'' + cc + '\'' : codelist + ', \'' + cc + '\'';
 
       if (v === false && !this.valueSet.jsonObj.internallyDefined && mode === 'codeableConcept') {
-        let m = this.worker.i18n.translate('None_of_the_provided_codes_are_in_the_value_set_one', this.params.HTTPLanguages, ['', this.valueSet.vurl, '\'' + cc + '\'']);
+        let m = this.worker.i18n.translate('None_of_the_provided_codes_are_in_the_value_set_one', this.params.HTTPLanguages, ['', this.valueSet.vurlOrMsg, '\'' + cc + '\'']);
         let p = issuePath + '.coding[' + i + '].code';
         op.addIssue(new Issue('information', 'code-invalid', p, 'None_of_the_provided_codes_are_in_the_value_set_one', m, 'this-code-not-in-vs'));
         if (cause.value === 'null') {
@@ -1284,10 +1284,10 @@ class ValueSetChecker {
       let mid, m, p;
       if (mode === 'codeableConcept') {
         mid = 'TX_GENERAL_CC_ERROR_MESSAGE';
-        m = this.worker.i18n.translate('TX_GENERAL_CC_ERROR_MESSAGE', this.params.HTTPLanguages, [this.valueSet.vurl]);
+        m = this.worker.i18n.translate('TX_GENERAL_CC_ERROR_MESSAGE', this.params.HTTPLanguages, [this.valueSet.vurlOrMsg]);
       } else {
         mid = 'None_of_the_provided_codes_are_in_the_value_set_one';
-        m = this.worker.i18n.translate('None_of_the_provided_codes_are_in_the_value_set_one', this.params.HTTPLanguages, ['', this.valueSet.vurl, codelist]);
+        m = this.worker.i18n.translate('None_of_the_provided_codes_are_in_the_value_set_one', this.params.HTTPLanguages, ['', this.valueSet.vurlOrMsg, codelist]);
       }
 
       if (mode === 'codeableConcept') {

package/tx/xversion/xv-parameters.js

@@ -10,7 +10,11 @@ const {VersionUtilities} = require("../../library/version-utilities");
 
 function parametersToR5(jsonObj, sourceVersion) {
   if (VersionUtilities.isR5Ver(sourceVersion)) {
-    return jsonObj; // No conversion needed
+    if (jsonObj.parameter && jsonObj.parameter.find(p => p.name == 'match')) {
+      return convertResourceWithinR5(JSON.parse(JSON.stringify(jsonObj)));
+    } else {
+      return jsonObj; // No conversion needed
+    }
   }
 
   const {convertResourceFromR5} = require("./xv-resource");
@@ -59,8 +63,57 @@ function parametersR5ToR4(r5Obj) {
     if (p.resource) {
       p.resource = convertResourceFromR5(p.resource, "R4");
     }
+    if (p.name == 'match') {
+      fixMatchParameterfor4(p);
+    }
+  }
+  return r5Obj;
+}
+
+function convertResourceWithinR5(r5Obj) {
+  for (let p of r5Obj.parameter) {
+    if (p.name == 'match') {
+      fixMatchParameterfor5(p);
+    }
   }
   return r5Obj;
+
+}
+
+function fixMatchParameterfor5(p) {
+  if (p.part) {
+    p.part = p.part.filter(pp => pp.name !== 'equivalence');
+  }
+}
+
+function fixMatchParameterfor4(p) {
+  if (p.part) {
+    if (!p.part.find(pp => pp.name === 'equivalence')) {
+      let rel = p.part.find(pp => pp.name === 'relationship');
+      if (rel && rel.valueCode) {
+        let pp = {name: "equivalence"};
+        switch (rel.valueCode) {
+          case 'related-to':
+            pp.valueCode = 'relatedto';
+            break;
+          case 'equivalent':
+            pp.valueCode = 'equivalent';
+            break;
+          case 'source-is-narrower-than-target':
+            pp.valueCode = 'wider';
+            break;
+          case 'source-is-broader-than-target':
+            pp.valueCode = 'narrower';
+            break;
+          case 'not-related-to':
+            pp.valueCode = 'unmatched';
+            break;
+        }
+        p.part.push(pp);
+      }
+    }
+    p.part = p.part.filter(pp => pp.name !== 'relationship');
+  }
 }
 
 function convertParameterR5ToR3(p) {