fhirsmith 0.9.6 → 0.10.0

package/tx/workers/{related.js → compare.js}

@@ -1,11 +1,11 @@
 //
-// Related Worker - Handles ValueSet $related operation
+// Compare Worker - Handles ValueSet $compare operation
 //
-// GET /ValueSet/{id}/$related
-// GET /ValueSet/$related?url=...&version=...
-// POST /ValueSet/$related (form body or Parameters with url)
-// POST /ValueSet/$related (body is ValueSet resource)
-// POST /ValueSet/$related (body is Parameters with valueSet parameter)
+// GET /ValueSet/{id}/$compare
+// GET /ValueSet/$compare?url=...&version=...
+// POST /ValueSet/$compare (form body or Parameters with url)
+// POST /ValueSet/$compare (body is ValueSet resource)
+// POST /ValueSet/$compare (body is Parameters with valueSet parameter)
 //
 
 const { TerminologyWorker } = require('./worker');
@@ -18,7 +18,7 @@ const {SearchFilterText} = require("../library/designations");
 const {ArrayMatcher} = require("../../library/utilities");
 const {debugLog} = require("../operation-context");
 
-class RelatedWorker extends TerminologyWorker {
+class CompareWorker extends TerminologyWorker {
   showLogic = false;
 
   /**
@@ -37,18 +37,18 @@ class RelatedWorker extends TerminologyWorker {
    * @returns {string}
    */
   opName() {
-    return 'related';
+    return 'compare';
   }
 
   /**
-   * Handle a type-level $related request
-   * GET/POST /ValueSet/$related
+   * Handle a type-level $compare request
+   * GET/POST /ValueSet/$compare
    * @param {express.Request} req - Express request
    * @param {express.Response} res - Express response
    */
   async handle(req, res) {
     try {
-      await this.handleTypeLevelRelated(req, res);
+      await this.handleTypeLevelCompare(req, res);
     } catch (error) {
       this.log.error(error);
       debugLog(error);
@@ -76,14 +76,14 @@ class RelatedWorker extends TerminologyWorker {
   }
 
   /**
-   * Handle an instance-level $related request
-   * GET/POST /ValueSet/{id}/$related
+   * Handle an instance-level $compare request
+   * GET/POST /ValueSet/{id}/$compare
    * @param {express.Request} req - Express request
    * @param {express.Response} res - Express response
    */
   async handleInstance(req, res) {
     try {
-      await this.handleInstanceLevelRelated(req, res);
+      await this.handleInstanceLevelCompare(req, res);
     } catch (error) {
       this.log.error(error);
       debugLog(error);
@@ -105,11 +105,11 @@ class RelatedWorker extends TerminologyWorker {
   }
 
   /**
-   * Handle type-level $related: /ValueSet/$related
+   * Handle type-level $compare: /ValueSet/$compare
    * ValueSet identified by url, or provided directly in body
    */
-  async handleTypeLevelRelated(req, res) {
-    this.deadCheck('related-type-level');
+  async handleTypeLevelCompare(req, res) {
+    this.deadCheck('compare-type-level');
 
     let params = req.body;
     this.addHttpParams(req, params);
@@ -121,16 +121,16 @@ class RelatedWorker extends TerminologyWorker {
     let thisVS = await this.readValueSet(res, "this", params, txp);
     let otherVS = await this.readValueSet(res, "other", params, txp);
 
-    const result = await this.doRelated(txp, thisVS, otherVS);
+    const result = await this.doCompare(txp, thisVS, otherVS);
     return res.json(result);
   }
   
   /**
-   * Handle instance-level related: /ValueSet/{id}/$related
+   * Handle instance-level compare: /ValueSet/{id}/$compare
    * ValueSet identified by resource ID
    */
-  async handleInstanceLevelRelated(req, res) {
-    this.deadCheck('related-instance-level');
+  async handleInstanceLevelCompare(req, res) {
+    this.deadCheck('compare-instance-level');
 
     let params = req.body;
     this.addHttpParams(req, params);
@@ -147,7 +147,7 @@ class RelatedWorker extends TerminologyWorker {
     }
     let otherVS = await this.readValueSet(res, "other", params, txp);
 
-    const result = await this.doRelated(txp, thisVS, otherVS);
+    const result = await this.doCompare(txp, thisVS, otherVS);
     return res.json(result);
   }
   
@@ -198,7 +198,7 @@ class RelatedWorker extends TerminologyWorker {
     }
   }
 
-  async doRelated(txp, thisVS, otherVS) {
+  async doCompare(txp, thisVS, otherVS) {
 
     // ok, we have to compare the composes. we don't care about anything else
     const thisC = thisVS.jsonObj.compose;
@@ -206,12 +206,12 @@ class RelatedWorker extends TerminologyWorker {
     if (!thisC) {
       return this.makeOutcome("indeterminate", `The ValueSet ${thisVS.vurl} has no compose`);
     }
-    Extensions.checkNoModifiers(thisC, 'RelatedWorker.doRelated', 'compose', thisVS.vurl)
+    Extensions.checkNoModifiers(thisC, 'CompareWorker.doCompare', 'compose', thisVS.vurl)
     this.checkNoLockedDate(thisVS.vurl, thisC);
     if (!otherC) {
       return this.makeOutcome("indeterminate", `The ValueSet ${otherVS.vurl} has no compose`);
     }
-    Extensions.checkNoModifiers(otherC, 'RelatedWorker.doRelated', 'compose', otherVS.vurl)
+    Extensions.checkNoModifiers(otherC, 'CompareWorker.doCompare', 'compose', otherVS.vurl)
     this.checkNoLockedDate(otherVS.vurl, otherC);
 
     let systems = new Map(); // tracks whether the comparison is version dependent or not
@@ -268,7 +268,7 @@ class RelatedWorker extends TerminologyWorker {
     } else if (status.left) {
       outcome = this.makeOutcome("superset", `The valueSet ${thisVS.vurl} is a super-set of the valueSet ${otherVS.vurl}`);
     } else {
-      outcome = this.makeOutcome("subset", `The valueSet ${thisVS.vurl} is a seb-set of the valueSet ${otherVS.vurl}`);
+      outcome = this.makeOutcome("subset", `The valueSet ${thisVS.vurl} is a sub-set of the valueSet ${otherVS.vurl}`);
     }
     if (txp.diagnostics) {
       outcome.parameter.push({name: 'performed-expansion', valueBoolean: exp ? true : false})
@@ -712,5 +712,5 @@ class RelatedWorker extends TerminologyWorker {
 }
 
 module.exports = {
-  RelatedWorker
+  CompareWorker
 };

package/tx/workers/expand.js

@@ -647,11 +647,11 @@ class ValueSetExpander {
           } else if (cs.contentMode() === 'supplement') {
             throw new Issue('error', 'business-rule', null, null, 'The code system definition for ' + cset.system + ' defines a supplement, so this expansion cannot be performed', 'invalid');
           } else if (cs.contentMode() === 'fragment') {
-            this.addParamUri(exp, 'used-fragment', cs.system() + '|' + cs.version());
+            this.addParamUri(exp, 'used-fragment', cs.system()+ (cs.version() ?  '|' + cs.version(): ""));
             Extensions.addBoolean(exp, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed", true);
             Extensions.addString(exp, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed-reason","This extension is based on a fragment of the code system " + cset.system);
           } else {
-            this.addParamUri(exp, cs.contentMode(), cs.system() + '|' + cs.version());
+            this.addParamUri(exp, cs.contentMode(), cs.system() + cs.system()+ (cs.version() ?  '|' + cs.version(): ""));
             Extensions.addBoolean(exp, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed", true);
             Extensions.addString(exp, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed-reason","This extension is based on a fragment of the code system " + cset.system);
           }
@@ -948,7 +948,7 @@ class ValueSetExpander {
           let vs = await this.worker.findValueSet(s, '', vsSrc);
           const ivs = new ImportedValueSet(await this.expandValueSet(s, '',  vs, filter, notClosed));
           this.checkResourceCanonicalStatus(expansion, ivs.valueSet, this.valueSet);
-          if (!vs.isContained) {
+          if (!vs.isContained && ivs.valueSet.vurl) {
             this.addParamUri(expansion, 'used-valueset', ivs.valueSet.vurl);
           }
           valueSets.push(ivs);
@@ -961,124 +961,128 @@ class ValueSetExpander {
       const cs = await this.worker.findCodeSystem(cset.system, cset.version, this.params, ['complete', 'fragment'], false,
         true, true, null, this.requiredSupplements);
 
-      this.worker.checkSupplements(cs, cset, this.requiredSupplements, this.usedSupplements);
-      this.checkResourceCanonicalStatus(expansion, cs, this.valueSet);
-      const sv = this.canonical(await cs.system(), await cs.version());
-      this.addParamUri(expansion, 'used-codesystem', sv);
+      if (cs == null) {
+        // nothing?
+      } else {
+        this.worker.checkSupplements(cs, cset, this.requiredSupplements, this.usedSupplements);
+        this.checkResourceCanonicalStatus(expansion, cs, this.valueSet);
+        const sv = this.canonical(await cs.system(), await cs.version());
+        this.addParamUri(expansion, 'used-codesystem', sv);
 
-      for (const u of cset.valueSet || []) {
-        this.worker.deadCheck('processCodes#3');
-        const s = this.worker.pinValueSet(u);
-        this.worker.opContext.log('import value set ' + s);
-        let vs = await this.worker.findValueSet(s, '', vsSrc);
-        const ivs = new ImportedValueSet(await this.expandValueSet(s, '', vs, filter, notClosed));
-        this.checkResourceCanonicalStatus(expansion, ivs.valueSet, this.valueSet);
-        if (!vs.isContained) {
-          this.addParamUri(expansion, 'used-valueset', this.worker.makeVurl(ivs.valueSet));
+        for (const u of cset.valueSet || []) {
+          this.worker.deadCheck('processCodes#3');
+          const s = this.worker.pinValueSet(u);
+          this.worker.opContext.log('import value set ' + s);
+          let vs = await this.worker.findValueSet(s, '', vsSrc);
+          const ivs = new ImportedValueSet(await this.expandValueSet(s, '', vs, filter, notClosed));
+          this.checkResourceCanonicalStatus(expansion, ivs.valueSet, this.valueSet);
+          if (!vs.isContained) {
+            this.addParamUri(expansion, 'used-valueset', this.worker.makeVurl(ivs.valueSet));
+          }
+          valueSets.push(ivs);
         }
-        valueSets.push(ivs);
-      }
 
-      if (!cset.concept && !cset.filter) {
-        this.worker.opContext.log('handle system');
-        if (!cset.valueSet) {
-          if (!this.excludeSpecialCase) {
-            // excluding a whole system - we don't list the codes in this case
-            this.excludedSystems.add(cset.system + (this.doingVersion && cset.version ? '|' + cset.version : ''));
+        if (!cset.concept && !cset.filter) {
+          this.worker.opContext.log('handle system');
+          if (!cset.valueSet) {
+            if (!this.excludeSpecialCase) {
+              // excluding a whole system - we don't list the codes in this case
+              this.excludedSystems.add(cset.system + (this.doingVersion && cset.version ? '|' + cset.version : ''));
+            } else {
+              const iter = await cs.iteratorAll();
+              if (iter) {
+                let c = await cs.nextContext(iter);
+                while (c) {
+                  this.worker.deadCheck('processCodes#3aa');
+                  this.excludeCode(cs, cs.system(), cs.version(), await cs.code(c), expansion, valueSets, vsSrc.url);
+                  c = await cs.nextContext(iter);
+                }
+              }
+            }
           } else {
+            if (cs.isNotClosed(filter)) {
+              if (cs.specialEnumeration()) {
+                Extensions.addBoolean(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed", true);
+                Extensions.addString(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed-reason", 'The code System "' + cs.system() + " has a grammar and so has infinite members. This extension is based on " + cs.specialEnumeration());
+              } else {
+                throw new Issue("error", "too-costly", null, null, 'The code System "' + cs.system() + '" has a grammar, and cannot be enumerated directly', null, 422).withDiagnostics(this.worker.opContext.diagnostics());
+              }
+            }
+
             const iter = await cs.iteratorAll();
             if (iter) {
               let c = await cs.nextContext(iter);
               while (c) {
-                this.worker.deadCheck('processCodes#3aa');
-                this.excludeCode(cs, cs.system(), cs.version(), await cs.code(c), expansion, valueSets, vsSrc.url);
+                this.worker.deadCheck('processCodes#3a');
+                if (await this.passesFilters(cs, c, prep, filters, 0)) {
+                  this.excludeCode(cs, cs.system(), cs.version(), await cs.code(c), expansion, valueSets, vsSrc.url);
+                }
                 c = await cs.nextContext(iter);
               }
             }
           }
-        } else {
-          if (cs.isNotClosed(filter)) {
-            if (cs.specialEnumeration()) {
-              Extensions.addBoolean(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed", true);
-              Extensions.addString(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed-reason", 'The code System "' + cs.system() + " has a grammar and so has infinite members. This extension is based on " + cs.specialEnumeration());
-            } else {
-              throw new Issue("error", "too-costly", null, null, 'The code System "' + cs.system() + '" has a grammar, and cannot be enumerated directly', null, 422).withDiagnostics(this.worker.opContext.diagnostics());
-            }
-          }
-
-          const iter = await cs.iteratorAll();
-          if (iter) {
-            let c = await cs.nextContext(iter);
-            while (c) {
-              this.worker.deadCheck('processCodes#3a');
-              if (await this.passesFilters(cs, c, prep, filters, 0)) {
-                this.excludeCode(cs, cs.system(), cs.version(), await cs.code(c), expansion, valueSets, vsSrc.url);
-              }
-              c = await cs.nextContext(iter);
-            }
-          }
         }
-      }
 
-      if (cset.concept) {
-        this.worker.opContext.log('iterate concepts');
-        const cds = new Designations(this.worker.i18n.languageDefinitions);
-        for (const cc of cset.concept) {
-          this.worker.deadCheck('processCodes#3');
-          cds.clear();
-          Extensions.checkNoModifiers(cc, 'ValueSetExpander.processCodes', 'set concept reference', vsSrc.vurl);
-          const cctxt = await cs.locate(cc.code, this.allAltCodes);
-          if (cctxt && cctxt.context && (!this.params.activeOnly || !await cs.isInactive(cctxt.context)) && await this.passesFilters(cs, cctxt.context, prep, filters, 0)) {
-            if (filter.passesDesignations(cds) || filter.passes(cc.code)) {
-              let ov = Extensions.readString(cc, 'http://hl7.org/fhir/StructureDefinition/itemWeight');
-              if (!ov) {
-                ov = await cs.itemWeight(cctxt.context);
+        if (cset.concept) {
+          this.worker.opContext.log('iterate concepts');
+          const cds = new Designations(this.worker.i18n.languageDefinitions);
+          for (const cc of cset.concept) {
+            this.worker.deadCheck('processCodes#3');
+            cds.clear();
+            Extensions.checkNoModifiers(cc, 'ValueSetExpander.processCodes', 'set concept reference', vsSrc.vurl);
+            const cctxt = await cs.locate(cc.code, this.allAltCodes);
+            if (cctxt && cctxt.context && (!this.params.activeOnly || !await cs.isInactive(cctxt.context)) && await this.passesFilters(cs, cctxt.context, prep, filters, 0)) {
+              if (filter.passesDesignations(cds) || filter.passes(cc.code)) {
+                let ov = Extensions.readString(cc, 'http://hl7.org/fhir/StructureDefinition/itemWeight');
+                if (!ov) {
+                  ov = await cs.itemWeight(cctxt.context);
+                }
+                this.excludeCode(cs, await cs.system(), await cs.version(), cc.code, expansion, valueSets, vsSrc.url);
               }
-              this.excludeCode(cs, await cs.system(), await cs.version(), cc.code, expansion, valueSets, vsSrc.url);
             }
           }
         }
-      }
 
-      if (cset.filter) {
-        this.worker.opContext.log('prep filters');
-        const prep = await cs.getPrepContext(true);
-        if (!filter.isNull) {
-          await cs.searchFilter(filter, prep, true);
-        }
+        if (cset.filter) {
+          this.worker.opContext.log('prep filters');
+          const prep = await cs.getPrepContext(true);
+          if (!filter.isNull) {
+            await cs.searchFilter(filter, prep, true);
+          }
 
-        if (cs.specialEnumeration()) {
-          await cs.specialFilter(prep, true);
-          Extensions.addBoolean(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed", true);
-          Extensions.addString(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed-reason", 'The code System "' + cs.system() + " has a grammar and so has infinite members. This extension is based on " + cs.specialEnumeration());
-        }
+          if (cs.specialEnumeration()) {
+            await cs.specialFilter(prep, true);
+            Extensions.addBoolean(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed", true);
+            Extensions.addString(expansion, "http://hl7.org/fhir/StructureDefinition/valueset-unclosed-reason", 'The code System "' + cs.system() + " has a grammar and so has infinite members. This extension is based on " + cs.specialEnumeration());
+          }
 
-        let first = true;
-        for (let fc of cset.filter) {
-          this.worker.deadCheck('processCodes#4a');
-          Extensions.checkNoModifiers(fc, 'ValueSetExpander.processCodes', 'filter', vsSrc.vurl);
-          await cs.filter(prep, first, fc.property, fc.op, fc.value);
-          first = false;
-        }
+          let first = true;
+          for (let fc of cset.filter) {
+            this.worker.deadCheck('processCodes#4a');
+            Extensions.checkNoModifiers(fc, 'ValueSetExpander.processCodes', 'filter', vsSrc.vurl);
+            await cs.filter(prep, first, fc.property, fc.op, fc.value);
+            first = false;
+          }
 
-        this.worker.opContext.log('iterate filters');
-        const fset = await cs.executeFilters(prep);
-        if (await cs.filtersNotClosed(prep)) {
-          notClosed.value = true;
-        }
-        //let count = 0;
-        while (await cs.filterMore(prep, fset[0])) {
-          this.worker.deadCheck('processCodes#5');
-          const c = await cs.filterConcept(prep, fset[0]);
-          const ok = (!this.params.activeOnly || !await cs.isInactive(c)) && (await this.passesFilters(cs, c, prep, fset, 1));
-          if (ok) {
-            //count++;
-            if (this.passesImports(valueSets, await cs.system(), await cs.code(c), 0)) {
-              this.excludeCode(cs, await cs.system(), await cs.version(), await cs.code(c), expansion, null, vsSrc.url);
+          this.worker.opContext.log('iterate filters');
+          const fset = await cs.executeFilters(prep);
+          if (await cs.filtersNotClosed(prep)) {
+            notClosed.value = true;
+          }
+          //let count = 0;
+          while (await cs.filterMore(prep, fset[0])) {
+            this.worker.deadCheck('processCodes#5');
+            const c = await cs.filterConcept(prep, fset[0]);
+            const ok = (!this.params.activeOnly || !await cs.isInactive(c)) && (await this.passesFilters(cs, c, prep, fset, 1));
+            if (ok) {
+              //count++;
+              if (this.passesImports(valueSets, await cs.system(), await cs.code(c), 0)) {
+                this.excludeCode(cs, await cs.system(), await cs.version(), await cs.code(c), expansion, null, vsSrc.url);
+              }
             }
           }
+          this.worker.opContext.log('iterate filters finished');
         }
-        this.worker.opContext.log('iterate filters finished');
       }
     }
   }

package/tx/workers/lookup.js

@@ -374,6 +374,12 @@ class LookupWorker extends TerminologyWorker {
             });
           }
 
+          if (designation.status && designation.status !== 'active') {
+            designationParts.push({
+              name: 'status',
+              valueCode: designation.status
+            });
+          }
           designationParts.push({
             name: 'value',
             valueString: designation.value

package/tx/workers/metadata.js

@@ -233,7 +233,7 @@ class MetadataHandler {
               operation: [
                 { name: 'expand', definition: 'http://hl7.org/fhir/OperationDefinition/ValueSet-expand' },
                 { name: 'validate-code', definition: 'http://hl7.org/fhir/OperationDefinition/ValueSet-validate-code' },
-                { name: 'related', definition: 'https://raw.githubusercontent.com/HealthIntersections/FHIRsmith/refs/heads/main/tx/data/OperationDefinition-ValueSet-related.json' }
+                { name: 'compare', definition: 'http://hl7.org/fhir/tools/OperationDefinition/ValueSet-compare' }
               ]
             },
             {
@@ -266,7 +266,8 @@ class MetadataHandler {
             { name: 'validate-code', definition: 'http://hl7.org/fhir/OperationDefinition/Resource-validate-code' },
             { name: 'translate', definition: 'http://hl7.org/fhir/OperationDefinition/ConceptMap-translate' },
             { name: 'closure', definition: 'http://hl7.org/fhir/OperationDefinition/ConceptMap-closure' },
-            { name: 'related', definition: 'https://raw.githubusercontent.com/HealthIntersections/FHIRsmith/refs/heads/main/tx/data/OperationDefinition-ValueSet-related.json' },
+            { name: 'compare', definition: 'http://hl7.org/fhir/tools/OperationDefinition/ValueSet-compare' },
+            { name: 'cache-control', definition: 'http://hl7.org/fhir/tools/OperationDefinition/cache-control' },
             { name: 'versions', definition: 'http://hl7.org/fhir/OperationDefinition/fhir-versions' }
           ]
         }
@@ -395,10 +396,14 @@ class MetadataHandler {
   buildExpansionCapabilities() {
     return {
       parameter: [
-        {
-          name: 'cache-id',
-          documentation: 'This server supports caching terminology resources between calls. Clients only need to send value sets and codesystems once; thereafter they are automatically in scope for calls with the same cache-id. The cache is retained for 30 min from last call'
-        },
+        // NOTE: `cache-id` is deliberately not advertised as an expansion parameter.
+        // Caching is now discovered via the $cache-control operation in the
+        // CapabilityStatement, not by advertising a cache-id parameter here. The old
+        // advertisement implied the implicit "auto-create on first sight" protocol,
+        // which has been replaced: a cache must be created explicitly with
+        // $cache-control?mode=start before its cache-id can be used. Clients that
+        // only know the old mechanism will see no cache-id parameter and simply not
+        // cache (inlining each request), which is correct, just not optimised.
         {
           name: 'tx-resource',
           documentation: 'Additional valuesets needed for evaluation e.g. value sets referred to from the import statement of the value set being expanded'

package/tx/workers/read.js

@@ -179,7 +179,7 @@ class ReadWorker extends TerminologyWorker {
       issue: [{
         severity: 'error',
         code: 'not-found',
-        diagnostics: `ValueSet/${id} not found`
+        diagnostics: `ConceptMap/${id} not found`
       }]
     });
   }

package/tx/workers/translate.js

@@ -205,10 +205,8 @@ class TranslateWorker extends TerminologyWorker {
         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) {
-      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);
@@ -222,7 +220,7 @@ class TranslateWorker extends TerminologyWorker {
     }
 
     // Perform the translation
-    const result = await this.doTranslate(conceptMaps, coding, targetScope, targetSystem, txp, reverse, explicit);
+    const result = await this.doTranslate(conceptMaps, coding, targetScope, targetSystem, txp, reverse);
     return res.status(200).json(result);
   }
 
@@ -322,7 +320,7 @@ class TranslateWorker extends TerminologyWorker {
     return result;
   }
 
-  translateUsingGroupsForwards(cm, coding, targetScope, targetSystem, params, output, explicit) {
+  translateUsingGroupsForwards(cm, coding, targetScope, targetSystem, params, output) {
     let result = false;
     const matches = cm.listTranslations(coding, targetScope, targetSystem);
     if (matches.length > 0) {
@@ -385,12 +383,10 @@ class TranslateWorker extends TerminologyWorker {
                   part: productParts
                 });
               }
-              if (!explicit) {
-                matchParts.push({
-                  name: 'originMap',
-                  valueCanonical: cm.vurl
-                });
-              }
+              matchParts.push({
+                name: 'originMap',
+                valueCanonical: cm.vurl
+              });
               output.push({
                 name: 'match',
                 part: matchParts
@@ -403,7 +399,7 @@ class TranslateWorker extends TerminologyWorker {
     return result;
   }
 
-  translateUsingGroupsReverse(cm, coding, targetScope, targetSystem, params, output, explicit) {
+  translateUsingGroupsReverse(cm, coding, targetScope, targetSystem, params, output) {
     let result = false;
     const matches = cm.listTranslationsReverse(coding, targetScope, targetSystem);
     if (matches.length > 0) {
@@ -474,12 +470,10 @@ class TranslateWorker extends TerminologyWorker {
                 part: productParts
               });
             }
-            if (!explicit) {
-              matchParts.push({
-                name: 'originMap',
-                valueCanonical: cm.vurl
-              });
-            }
+            matchParts.push({
+              name: 'originMap',
+              valueCanonical: cm.vurl
+            });
             output.push({
               name: 'match',
               part: matchParts
@@ -491,7 +485,7 @@ class TranslateWorker extends TerminologyWorker {
     return result;
   }
 
-  async translateUsingCodeSystem(cm, coding, target, params, output, reverse, explicit) {
+  async translateUsingCodeSystem(cm, coding, target, params, output, reverse) {
     let result = false;
     const factory = cm.jsonObj.internalSource;
     let prov = await factory.build(this.opContext, []);
@@ -537,12 +531,10 @@ class TranslateWorker extends TerminologyWorker {
             valueString: t.message
           });
         }
-        if (!explicit) {
-          matchParts.push({
-            name: 'originMap',
-            valueCanonical: cm.vurl
-          });
-        }
+        matchParts.push({
+          name: 'originMap',
+          valueCanonical: cm.vurl
+        });
         output.push({
           name: 'match',
           part: matchParts
@@ -560,10 +552,9 @@ class TranslateWorker extends TerminologyWorker {
    * @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, reverse, explicit) {
+  async doTranslate(conceptMaps, coding, targetScope, targetSystem, params, reverse) {
     this.deadCheck('doTranslate');
 
     const result = [];
@@ -572,11 +563,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, reverse, explicit) || added;
+          added = await this.translateUsingCodeSystem(cm, coding, targetSystem, params, result, reverse) || added;
         } else if (reverse) {
-          added = this.translateUsingGroupsReverse(cm, coding, targetScope, targetSystem, params, result, reverse, explicit) || added;
+          added = this.translateUsingGroupsReverse(cm, coding, targetScope, targetSystem, params, result) || added;
         } else{
-          added = this.translateUsingGroupsForwards(cm, coding, targetScope, targetSystem, params, result, reverse, explicit) || added;
+          added = this.translateUsingGroupsForwards(cm, coding, targetScope, targetSystem, params, result) || added;
         }
       }
       result.push({