fhirsmith 0.13.3 → 0.14.0

package/tx/workers/subsumes.js

@@ -107,9 +107,16 @@ class SubsumesWorker extends TerminologyWorker {
       codingA = params.get('codingA');
       codingB = params.get('codingB');
 
+      // A Coding with no system has no defined meaning, so there is nothing to test. This is a
+      // problem with the request (400/invalid), not a code system the server can't find
+      for (const [name, coding] of [['codingA', codingA], ['codingB', codingB]]) {
+        if (!coding.system) {
+          throw this.parameterIssue(txp, 'SUBSUMPTION_NO_SYSTEM', [name], name);
+        }
+      }
       // Codings must have the same system
       if (codingA.system !== codingB.system) {
-        throw new Issue('error', 'not-found', null, null, 'codingA and codingB must have the same system', null, 400);
+        throw this.parameterIssue(txp, 'SUBSUMPTION_SYSTEM_MISMATCH', [codingA.system, codingB.system], 'codingB');
       }
       // Get the code system provider from the coding's system
       csProvider = await this.findCodeSystem(codingA.system, codingA.version || '', txp, ['complete'], null, false);
@@ -117,7 +124,7 @@ class SubsumesWorker extends TerminologyWorker {
     } else if (params.has('codeA') && params.has('codeB')) {
       // Using codeA, codeB - system is required
       if (!params.has('system')) {
-        throw new Issue('error', 'not-found', null, null, 'system parameter is required when using codeA and codeB', null, 404);
+        throw this.parameterIssue(txp, 'SUBSUMPTION_NO_SYSTEM', ['codeA'], 'codeA');
       }
 
       csProvider = await this.findCodeSystem(params.get('system'), params.get('version') || '', txp, ['complete'], null, false);
@@ -318,6 +325,15 @@ class SubsumesWorker extends TerminologyWorker {
     };
   }
 
+  /**
+   * Build the Issue for a request that is malformed - a missing or unusable parameter. These
+   * are 400 / invalid: the request can't be processed as given, whatever the server knows
+   */
+  parameterIssue(txp, msgId, args, path) {
+    const msg = this.i18n.translate(msgId, txp.HTTPLanguages, args);
+    return new Issue('error', 'invalid', path, msgId, msg, 'invalid-data', 400);
+  }
+
   /**
    * Build the Issue for a code that isn't in the code system. Uses the same message ids
    * and tx-issue-type detail code as $validate-code, so clients get consistent errors

package/tx/workers/translate.js

@@ -15,6 +15,7 @@ const {ConceptMap} = require("../library/conceptmap");
 const {Extensions} = require("../library/extensions");
 const {VersionUtilities} = require("../../library/version-utilities");
 const {debugLog} = require("../operation-context");
+const {ValueSetChecker, ValidationCheckMode} = require("./validate");
 
 // ConceptMap.group.element.comment is R6; on an R5 ConceptMap it is carried by the
 // cross-version extension. Read both, so a preadopted R5 resource and a native R6 one
@@ -260,6 +261,22 @@ class TranslateWorker extends TerminologyWorker {
         targetSystem = params.get('system');
       }
     }
+    // The sourceScope parameter is a precondition on the whole operation, not a way of picking
+    // maps: the client is saying which codes it is asking about. So it is evaluated once, before
+    // any map is considered, and if the code is not in it then no map applies under any
+    // condition - including a map the client nominated by url. Once the code has been shown to
+    // be in it, the parameter has done its work and plays no further part; each map is then
+    // judged by its own scope. Under reverse the two scopes have already swapped above, so
+    // sourceScope here is the scope of the concept that was named either way.
+    if (sourceScope) {
+      const inScope = await this.codeInScope(sourceScope, coding, txp,
+        `${reverse ? 'targetScope' : 'sourceScope'} parameter`);
+      if (!inScope) {
+        return res.status(200).json(this.noMapsResponse(coding, sourceScope, targetScope, targetSystem, reverse,
+          `'${coding.system}#${coding.code}' is not in the value set '${sourceScope}', so no ConceptMap can translate it`));
+      }
+    }
+
     // If no explicit concept map, we need to find one based on source/target
     if (conceptMaps.length == 0) {
       if (reverse) {
@@ -269,25 +286,19 @@ class TranslateWorker extends TerminologyWorker {
         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) {
-        // The client did not nominate a map, and this server knows none that covers this
-        // source and target. That is an answer - there is no translation - not an error;
-        // a nominated map that cannot be found is the error case, and is reported when
-        // the url parameter is resolved above.
-        const from = reverse ? (targetSystem || sourceScope) : coding.system;
-        const to = reverse ? coding.system : (targetSystem || targetScope);
-        return res.status(200).json({
-          resourceType: 'Parameters',
-          parameter: [{
-            name: 'message',
-            valueString: `No ConceptMap is available to translate from '${from || '(unspecified)'}' to '${to || '(unspecified)'}'`
-          },
-          {
-            name: 'result',
-            valueBoolean: false
-          }]
-        });
-      }
+    }
+
+    // Whether the map was nominated or found, it only applies if the code is within its own
+    // declared scope, so the filter goes here rather than in the selection above - a nominated
+    // map never passes through selection at all.
+    const scoped = await this.filterMapsByScope(conceptMaps, coding, txp, reverse);
+    conceptMaps = scoped.maps;
+
+    if (conceptMaps.length == 0) {
+      // No map covers this code. That is an answer - there is no translation - not an error;
+      // a nominated map that cannot be *found* is the error case, and is reported when the url
+      // parameter is resolved above.
+      return res.status(200).json(this.noMapsResponse(coding, sourceScope, targetScope, targetSystem, reverse, null, scoped.anyScoped));
     }
 
     // Perform the translation
@@ -371,8 +382,15 @@ class TranslateWorker extends TerminologyWorker {
     let conceptMaps = [];
     conceptMaps.push(conceptMap);
 
+    // Naming the map by id does not put an out-of-scope code into its scope, any more than
+    // naming it by url does: the map either covers this code or it does not.
+    const scoped = await this.filterMapsByScope(conceptMaps, coding, txp, false);
+    if (scoped.maps.length === 0) {
+      return res.status(200).json(this.noMapsResponse(coding, null, targetScope, targetSystem, false, null, scoped.anyScoped));
+    }
+
     // Perform the translation
-    const result = await this.doTranslate(conceptMaps, coding, targetScope, targetSystem, params);
+    const result = await this.doTranslate(scoped.maps, coding, targetScope, targetSystem, params);
     return res.status(200).json(result);
   }
 
@@ -906,6 +924,135 @@ class TranslateWorker extends TerminologyWorker {
     return result;
   }
 
+  /**
+   * ConceptMap.sourceScope "limits the scope of the map to source codes that are members of
+   * this value set", so a code outside it means the map does not apply at all - not that the
+   * map has no element for it. The difference matters because group.unmapped answers the
+   * second question and must not answer the first: a map with unmapped mode=fixed would
+   * otherwise translate every code in the code system its group names, whatever its author
+   * declared, and sourceScope would have no effect on any map that has an unmapped.
+   *
+   * Resolving a scope costs a value set lookup and a $validate-code, and the same scope is
+   * usually shared by several of the candidate maps, so both are memoised for the life of the
+   * operation. They are deliberately not cached beyond it: tx-resource makes the resolution of
+   * a canonical a property of the request, not of the server.
+   */
+  scopeVsCache = new Map();    // canonical -> ValueSet
+  scopeCodeCache = new Map();  // canonical + coding -> boolean
+
+  async resolveScopeValueSet(canonical, why) {
+    if (this.scopeVsCache.has(canonical)) {
+      return this.scopeVsCache.get(canonical);
+    }
+    const { url, version } = VersionUtilities.splitCanonical(canonical);
+    let vs = null;
+    try {
+      vs = await this.findValueSet(url, version);
+    } catch (e) {
+      if (e instanceof Issue) {
+        throw e;
+      }
+      vs = null;
+    }
+    if (!vs) {
+      // Fatal to the operation, deliberately. A scope that cannot be resolved is a scope that
+      // cannot be evaluated, and dropping the map silently would report "no translation" for
+      // what is really "cannot tell" - the same trap as answering not-subsumed when the real
+      // answer is unknown.
+      throw new Issue('error', 'not-found', null, null,
+        `The value set '${canonical}', which is the ${why}, could not be found, so the scope of the translation cannot be determined`, null, 404);
+    }
+    this.scopeVsCache.set(canonical, vs);
+    return vs;
+  }
+
+  async codeInScope(canonical, coding, params, why) {
+    const key = canonical + '\u0000' + coding.system + '|' + (coding.version || '') + '#' + coding.code;
+    if (this.scopeCodeCache.has(key)) {
+      return this.scopeCodeCache.get(key);
+    }
+    const vs = await this.resolveScopeValueSet(canonical, why);
+    let inScope;
+    try {
+      const checker = new ValueSetChecker(this, vs, params);
+      await checker.prepare();
+      // The coding is wrapped in a CodeableConcept so that this goes through
+      // checkCodeableConcept - the same path every $validate-code takes, and the only one the
+      // test suite exercises.
+      const outcome = await checker.checkCodeableConcept('Coding',
+        { coding: [{ system: coding.system, version: coding.version, code: coding.code }] },
+        ValidationCheckMode.Coding);
+      inScope = outcome.has('result') && outcome.get('result') === true;
+    } catch (e) {
+      if (e instanceof Issue) {
+        throw e;
+      }
+      // The value set resolved; checking the code against it is what failed. Say so - the
+      // earlier wording claimed it could not be found, which sent the reader looking for a
+      // missing resource that was in fact right there.
+      throw new Issue('error', 'not-supported', null, null,
+        `The value set '${canonical}' was found, but '${coding.system}#${coding.code}' could not be checked against it (${e.message}), so the ${why} cannot be evaluated`, null, 422);
+    }
+    this.scopeCodeCache.set(key, inScope);
+    return inScope;
+  }
+
+  /**
+   * The answer when nothing can translate this code: a successful operation with a negative
+   * result, not an error. Where any candidate map declared a scope, the message names the code,
+   * because the code is then the reason - saying only that no map goes from this system to that
+   * one would be wrong, since such maps exist and simply do not cover this code.
+   */
+  noMapsResponse(coding, sourceScope, targetScope, targetSystem, reverse, message, anyScoped) {
+    let text = message;
+    if (!text) {
+      const from = reverse ? (targetSystem || sourceScope) : coding.system;
+      const to = reverse ? coding.system : (targetSystem || targetScope);
+      text = anyScoped
+        ? `No ConceptMap that translates from '${from || '(unspecified)'}' to '${to || '(unspecified)'}' has '${coding.system}#${coding.code}' in scope`
+        : `No ConceptMap is available to translate from '${from || '(unspecified)'}' to '${to || '(unspecified)'}'`;
+    }
+    return {
+      resourceType: 'Parameters',
+      parameter: [{
+        name: 'message',
+        valueString: text
+      },
+      {
+        name: 'result',
+        valueBoolean: false
+      }]
+    };
+  }
+
+  /**
+   * Drop the candidate maps that do not apply to this code. A map that declares no scope on the
+   * relevant side is not filtered - it applies on the strength of its group source/target
+   * systems alone. Under reverse the concept named is the target concept, so it is
+   * ConceptMap.targetScope that governs.
+   * @returns {Promise<{maps: Object[], anyScoped: boolean}>} anyScoped says whether any candidate
+   *   declared a scope, which decides whether the "no map" message names the code
+   */
+  async filterMapsByScope(conceptMaps, coding, params, reverse) {
+    const maps = [];
+    let anyScoped = false;
+    const side = reverse ? 'target' : 'source';
+    for (const cm of conceptMaps) {
+      const canonical = reverse ? cm.targetScope : cm.sourceScope;
+      if (!canonical) {
+        maps.push(cm);
+        continue;
+      }
+      anyScoped = true;
+      if (await this.codeInScope(canonical, coding, params, `${side} scope of the ConceptMap '${cm.url || '(inline)'}'`)) {
+        maps.push(cm);
+      } else {
+        this.opContext.addNote(null, `ConceptMap '${cm.url}' does not apply: '${coding.code}' is not in its ${side} scope '${canonical}'`, 0);
+      }
+    }
+    return { maps, anyScoped };
+  }
+
   /**
    * Perform the actual translate operation
    * @param {Object} conceptMap - ConceptMap resource

package/tx/workers/validate.js

@@ -86,11 +86,13 @@ class ValueSetChecker {
           op.addIssueIfNew(new Issue('information', 'business-rule', '', 'MSG_EXPERIMENTAL', this.worker.i18n.translate('MSG_EXPERIMENTAL', this.params.HTTPLanguages, [vurl, '', rtype]), 'status-check'), false);
         } else if ((status === 'draft' || standardsStatus === 'draft') &&
           !((source.status === 'draft') || (Extensions.readString(source, 'http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status') === 'draft'))) {
-          if (pid) {
-            op.addIssueIfNew(new Issue('information', 'business-rule', '', 'MSG_DRAFT', this.worker.i18n.translate('MSG_DRAFT_SRC', this.params.HTTPLanguages, [vurl, pid, rtype]), 'status-check'), false);
-          } else {
-            op.addIssueIfNew(new Issue('information', 'business-rule', '', 'MSG_DRAFT', this.worker.i18n.translate('MSG_DRAFT', this.params.HTTPLanguages, [vurl, '', rtype]), 'status-check'), false);
-          }
+          // MSG_DRAFT_SRC_STATUS names the referring resource's status and type as well as its
+          // url, so the reader can see why the reference is reported at all: a resource that is
+          // not draft pointing at one that is. Matches ValueSetProcessBase.checkCanonical in the
+          // java implementation, so both terminology services report this the same way
+          op.addIssueIfNew(new Issue('information', 'business-rule', '', 'MSG_DRAFT_SRC_STATUS',
+            this.worker.i18n.translate('MSG_DRAFT_SRC_STATUS', this.params.HTTPLanguages,
+              [vurl, this.worker.makeVurl(source), rtype, source.status, source.resourceType]), 'status-check'), false);
         }
       }
     }
@@ -886,101 +888,6 @@ class ValueSetChecker {
     return result;
   }
 
-  async checkCoding(issuePath, coding) {
-    let inactive = false;
-    let path = issuePath;
-    let unknownSystems = new Set();
-    let unkCodes = [];
-    let messages = [];
-    let result = new Parameters();
-
-    this.worker.opContext.clearContexts();
-    if (this.params.inferSystem) {
-      this.worker.opContext.addNote(this.valueSet, 'Validate "' + this.worker.renderer.displayCoded(coding) + '" and infer system', this.indentCount);
-    } else {
-      this.worker.opContext.addNote(this.valueSet, 'Validate "' + this.worker.renderer.displayCoded(coding) + '"', this.indentCount);
-    }
-
-    let op = new OperationOutcome();
-    this.checkCanonicalStatus(path, op, this.valueSet, this.valueSet);
-    let list = new Designations(this.worker.languages);
-    let ver = {value: ''};
-    inactive = {value: false};
-    let normalForm = {value: ''};
-    let vstatus = {value: ''};
-    let cause = {value: null};
-    let contentMode = {value: null};
-    let impliedSystem = {value: ''};
-    let defLang = {value: null};
-
-    let ok = await this.check(path, coding.system, coding.version, coding.code, list, unknownSystems, ver, inactive, normalForm, vstatus, cause, op, null, result, contentMode, impliedSystem, unkCodes, messages, defLang);
-    if (ok === true) {
-      result.AddParamBool('result', true);
-      if ((cause.value === 'not-found' && contentMode.value !== 'complete') || contentMode.value === 'example') {
-        result.addParamStr('message', 'The system "' + coding.system + ' was found but did not contain enough information to properly validate the code (mode = ' + contentMode.value + ')');
-      }
-      if (coding.display && !list.hasDisplay(this.params.workingLanguages(), defLang.value, coding.display, false, DisplayCheckingStyle.CASE_INSENSITIVE).found) {
-        let baseMsg = 'Display_Name_for__should_be_one_of__instead_of';
-        let dc = list.displayCount(this.params.workingLanguages(), null, true);
-        if (dc > 0) {
-          if (list.hasDisplay(this.params.workingLanguages(), defLang.value, coding.display, false, DisplayCheckingStyle.CASE_INSENSITIVE).difference === DisplayDifference.Normalised) {
-            baseMsg = 'Display_Name_WS_for__should_be_one_of__instead_of';
-          }
-          if (dc === 1) {
-            result.addParamStr('message', this.worker.i18n.translate(baseMsg + '_one', this.params.HTTPLanguages,
-              ['', coding.system, coding.code, list.present(this.params.workingLanguages(), defLang.value, true), coding.display, this.params.langSummary()]));
-          } else {
-            result.addParamStr('message', this.worker.i18n.translate(baseMsg + '_other', this.params.HTTPLanguages, [dc.toString(), coding.system, coding.code, list.present(this.params.workingLanguages(), defLang.value, true), coding.display, this.params.langSummary()]));
-          }
-        }
-      }
-      let pd = list.preferredDisplay(this.params.workingLanguages());
-      if (pd) {
-        result.addParamStr('display', pd);
-      }
-      result.addParamUri('system', coding.system);
-      if (ver.value) {
-        result.addParamStr('version', ver.value);
-      }
-      if (cause.value !== 'null') {
-        result.AddParamCode('cause', cause.value);
-      }
-      if (inactive.value) {
-        result.AddParamBool('inactive', inactive.value);
-        if (vstatus.value && vstatus.value !== 'inactive') {
-          result.addParamCode('status', vstatus.value);
-        }
-        let msg = this.worker.i18n.translate('INACTIVE_CONCEPT_FOUND', this.params.HTTPLanguages, [vstatus.value, coding.code]);
-        messages.push(msg);
-        op.addIssue(new Issue('warning', 'business-rule', path, 'INACTIVE_CONCEPT_FOUND', msg, 'code-comment'));
-      } else if (vstatus.value && vstatus.value.toLowerCase() === 'deprecated') {
-        result.addParamCode('status', vstatus.value);
-        let msg = this.worker.i18n.translate('DEPRECATED_CONCEPT_FOUND', this.params.HTTPLanguages, [vstatus.value, coding.code]);
-        messages.push(msg);
-        op.addIssue(new Issue('warning', 'business-rule', path, 'DEPRECATED_CONCEPT_FOUND', msg, 'code-comment'));
-      }
-    } else if (ok === null) {
-      result.AddParamBool('result', false);
-      result.addParamStr('message', 'The CodeSystem "' + coding.system + '" is unknown, so the code "' + coding.code + '" is not known to be in the ' + this.valueSet.name);
-      for (let us of unknownSystems) {
-        result.addParamCanonical('x-caused-by-unknown-system', us);
-      }
-    } else {
-      result.AddParamBool('result', false);
-      if (ver.value) {
-        result.addParamStr('version', ver.value);
-      }
-      result.addParamStr('message', 'The system/code "' + coding.system + '"/"' + coding.code + '" is not in the value set ' + this.valueSet.name);
-      if (cause.value !== 'null') {
-        result.AddParamCode('cause', cause.value);
-      }
-    }
-    if (op.hasIssues) {
-      result.addParam('issues').resource = op.jsonObj;
-    }
-    return result;
-  }
-
   valueSetDependsOnCodeSystem(url, version) {
     for (let inc of this.valueSet.include) {
       this.worker.deadCheck('valueSetDependsOnCodeSystem');
@@ -1051,6 +958,7 @@ class ValueSetChecker {
     this.checkCanonicalStatus(issuePath, op, this.valueSet.jsonObj, this.valueSet.jsonObj);
     let list = new Designations(this.worker.languages);
     let ok = false;
+    let noCode = false;
     let matchedCodings = new Set();
     let codelist = '';
     mt = [];
@@ -1071,8 +979,22 @@ class ValueSetChecker {
         path = issuePath;
       }
       if (!c.code) {
-        let msg = `Coding has no code for system ${c.system} and cannot be validated`;
-        op.addIssue(new Issue('error', 'invalid', path, null, msg, 'invalid-data'));
+        // No code at all, so there is nothing to look up and the value set check below has
+        // nothing to report either (see noCode). A coding with neither a system nor a code gets
+        // ONE message about the pair of them rather than one about each: there is nothing there
+        // to validate, and saying so twice does not make it clearer
+        if (!c.system && !this.params.inferSystem) {
+          let m = this.worker.i18n.translate('Coding_has_no_system_or_code__cannot_validate', this.params.HTTPLanguages, []);
+          msg(m);
+          op.addIssue(new Issue('warning', 'invalid', path, 'Coding_has_no_system_or_code__cannot_validate', m, 'invalid-data'));
+        } else {
+          let m = c.system
+            ? `Coding has no code for system ${c.system} and cannot be validated`
+            : `Coding has no code and cannot be validated`;
+          msg(m);
+          op.addIssue(new Issue('warning', 'invalid', path, null, m, 'invalid-data'));
+        }
+        noCode = true;
         break;
       }
       list.clear();
@@ -1338,7 +1260,13 @@ class ValueSetChecker {
     // for an internally defined value set (CodeSystem validation), the code-system-level
     // message is preferred - but if nothing produced an error, this is the only
     // explanation there will be, so it can't be suppressed
-    if (ok === false && (!this.valueSet.jsonObj.internallyDefined || !op.hasErrors())) {
+    // "none of the provided codes are in the value set" is only meaningful if a code was provided:
+    // for a Coding with no code, the issue above has already said the only thing there is to say.
+    // A CodeableConcept still gets its own summary error, since the concept as a whole did not
+    // validate - but not when the value set is the internal one built for a CodeSystem
+    // $validate-code, where it would name a value set the caller never mentioned
+    let noCodeSummary = noCode && (mode !== 'codeableConcept' || this.valueSet.jsonObj.internallyDefined);
+    if (ok === false && !noCodeSummary && (!this.valueSet.jsonObj.internallyDefined || !op.hasErrors())) {
       let mid, m, p;
       if (mode === 'codeableConcept') {
         mid = 'TX_GENERAL_CC_ERROR_MESSAGE';
@@ -1539,78 +1467,6 @@ class ValueSetChecker {
     }
   }
 
-  async checkSystemCode(issuePath, system, version, code) {
-    this.worker.opContext.clearContexts();
-    if (this.params.inferSystem) {
-      this.worker.opContext.addNote(this.valueSet, 'Validate "' + code + '" and infer system', this.indentCount);
-    } else {
-      this.worker.opContext.addNote(this.valueSet, 'Validate "' + this.worker.renderer.displayCoded(system, version, code) + '"', this.indentCount);
-    }
-    let unknownSystems = new Set();
-    let unkCodes = [];
-    let messages = [];
-    let result = new Parameters();
-    let op = new OperationOutcome();
-    this.checkCanonicalStatus(issuePath, op, this.valueSet, this.valueSet);
-    let list = new Designations(this.worker.languages);
-    let ver = {value: ''};
-    let inactive = {value: false};
-    let normalForm = {value: ''};
-    let vstatus = {value: ''};
-    let cause = {value: null};
-    let contentMode = {value: null};
-    let impliedSystem = {value: ''};
-    let defLang = {value: null};
-
-    let ok = await this.check(issuePath, system, version, code, true, list, unknownSystems, ver, inactive, normalForm, vstatus, cause, op, null, result, contentMode, impliedSystem, unkCodes, messages, defLang);
-    if (ok === true) {
-      result.AddParamBool('result', true);
-      let pd = list.preferredDisplay(this.params.workingLanguages());
-      if (pd) {
-        result.addParamStr('display', pd);
-      }
-      result.addParamUri('system', system);
-      if ((cause.value === 'not-found' && contentMode.value !== 'complete') || contentMode.value === 'example') {
-        result.addParamStr('message', 'The system "' + system + ' was found but did not contain enough information to properly validate the code (mode = ' + contentMode.value + ')');
-      }
-      if (cause.value) {
-        result.addParamCode('cause', cause.value);
-      }
-      if (inactive.value) {
-        result.addParamBool('inactive', inactive.value);
-        if (vstatus.value && vstatus.value !== 'inactive') {
-          result.addParamCode('status', vstatus.value);
-        }
-        let msg = this.worker.i18n.translate('INACTIVE_CONCEPT_FOUND', this.params.HTTPLanguages, [vstatus.value, code]);
-        messages.push(msg);
-        op.addIssue(new Issue('warning', 'business-rule', 'code', 'INACTIVE_CONCEPT_FOUND', msg, 'code-comment'));
-      } else if (vstatus.value && vstatus.value.toLowerCase() === 'deprecated') {
-        result.addParamCode('status', vstatus.value);
-        let msg = this.worker.i18n.translate('DEPRECATED_CONCEPT_FOUND', this.params.HTTPLanguages, [vstatus.value, code]);
-        messages.push(msg);
-        op.addIssue(new Issue('warning', 'business-rule', 'code', 'DEPRECATED_CONCEPT_FOUND', msg, 'code-comment'));
-      }
-    } else if (ok === null) {
-      result.AddParamBool('result', false);
-      result.addParamStr('message', 'The system "' + system + '" is unknown so the /"' + code + '" cannot be confirmed to be in the value set ' + this.valueSet.name);
-      op.addIssue(new Issue('error', cause.value, 'code', null, 'The system "' + system + '" is unknown so the /"' + code + '" cannot be confirmed to be in the value set ' + this.valueSet.name, 'not-found'));
-      for (let us of unknownSystems) {
-        result.addParamCanonical('x-caused-by-unknown-system', us);
-      }
-    } else {
-      result.AddParamBool('result', false);
-      result.addParamStr('message', 'The system/code "' + system + '"/"' + code + '" is not in the value set ' + this.valueSet.name);
-      op.addIssue(new Issue('error', cause.value, 'code', null, 'The system/code "' + system + '"/"' + code + '" is not in the value set ' + this.valueSet.name, 'not-in-vs'));
-      if (cause.value) {
-        result.AddParamCode('cause', cause.value);
-      }
-    }
-    if (op.hasIssues()) {
-      result.addParam('issues').resource = op.jsonObj;
-    }
-    return result;
-  }
-
   /**
    * The code as submitted differs from the code as the code system renders it. Report why.
    *
@@ -2046,7 +1902,7 @@ class ValidateWorker extends TerminologyWorker {
 
       // Extract coded value
       mode = {mode: null};
-      coded = this.extractCodedValue(params, true, mode);
+      coded = this.extractCodedValue(params, true, mode, txp);
       if (!coded) {
         throw new Issue('error', 'invalid', null, null, 'Unable to find code to validate (looked for coding | codeableConcept | code in parameters)', null, 400).handleAsOO(400);
       }
@@ -2056,7 +1912,7 @@ class ValidateWorker extends TerminologyWorker {
       if (!codeSystem) {
         if (!coded?.coding?.[0].system) {
           let msg = this.i18n.translate('Coding_has_no_system__cannot_validate', txp.HTTPLanguages, []);
-          throw new Issue('warning', 'invalid', mode.issuePath, 'Coding_has_no_system__cannot_validate', msg, 'invalid-data');
+          throw new Issue('warning', 'invalid', this.codingPath(mode), 'Coding_has_no_system__cannot_validate', msg, 'invalid-data');
         } else {
           throw new Issue('error', 'invalid', null, null, 'No CodeSystem specified - provide url parameter or codeSystem resource', null, 400);
         }
@@ -2092,6 +1948,20 @@ class ValidateWorker extends TerminologyWorker {
     }
   }
 
+  /**
+   * The path to the coding itself, for an issue about the coding rather than one of its properties.
+   * A CodeableConcept is validated one coding at a time, so an issue raised before that loop starts
+   * still belongs to the first coding, not to the CodeableConcept - which is what the value set path
+   * reports (see ValueSetChecker.checkCodeableConcept).
+   */
+  codingPath(mode) {
+    switch (mode.mode) {
+      case 'code': return '';
+      case 'coding': return 'Coding';
+      default: return 'CodeableConcept.coding[0]';
+    }
+  }
+
   /**
    * Handle an instance-level CodeSystem $validate-code request
    * GET/POST /CodeSystem/{id}/$validate-code
@@ -2119,7 +1989,7 @@ class ValidateWorker extends TerminologyWorker {
 
       // Extract coded value
       let mode = { mode : null }
-      const coded = this.extractCodedValue(params, true, mode);
+      const coded = this.extractCodedValue(params, true, mode, txp);
       if (!coded) {
         return res.status(400).json(this.operationOutcome('error', 'invalid',
           'Unable to find code to validate (looked for coding | codeableConcept | code in parameters =codingX:Coding)'));
@@ -2179,7 +2049,7 @@ class ValidateWorker extends TerminologyWorker {
     // Extract coded value
 
     let mode = { mode : null };
-    const coded = this.extractCodedValue(params, false, mode);
+    const coded = this.extractCodedValue(params, false, mode, txp);
     if (!coded) {
       throw new Issue("error", "invalid", null, null, 'Unable to find code to validate (looked for coding | codeableConcept | code+system | code+inferSystem in parameters', null, 422);
     }
@@ -2218,7 +2088,7 @@ class ValidateWorker extends TerminologyWorker {
 
       // Extract coded value
       let mode = { mode : null };
-      const coded = this.extractCodedValue(params, false, mode);
+      const coded = this.extractCodedValue(params, false, mode, txp);
       if (!coded) {
         return res.status(400).json(this.operationOutcome('error', 'invalid',
           'Unable to find code to validate (looked for coding | codeableConcept | code in parameters =codingX:Coding)'));
@@ -2250,7 +2120,7 @@ class ValidateWorker extends TerminologyWorker {
     if (csResource) {
       return new FhirCodeSystemProvider(this.opContext, new CodeSystem(csResource), []); // todo: supplements
     }
-    let path = coded == null ? null : mode.issuePath+".system";
+    let path = coded == null ? null : this.systemPath(mode);
     let fromCoded = false;
     // Check for url parameter
     let url = this.getStringParam(params, 'url');
@@ -2347,14 +2217,22 @@ class ValidateWorker extends TerminologyWorker {
    * Extract the coded value to validate as a CodeableConcept
    * @param {Object} params - Parameters resource
    * @param {string} mode - 'cs' for CodeSystem, 'vs' for ValueSet
+   * @param {Object} txp - the operation parameters. inferSystem is cleared on these unless the
+   *   code parameter is the one being validated - see below
    * @returns {Object|null} CodeableConcept or null
    */
-  extractCodedValue(params, isCs, mode) {
+  extractCodedValue(params, isCs, mode, txp) {
+    // inferSystem is defined for the code parameter only: it does not apply to a Coding, nor to
+    // the codings of a CodeableConcept. Those carry their own system (or fail to), and a server
+    // that inferred one here would be answering about a code the caller never named
+    const noInfer = () => { if (txp) { txp.inferSystem = false; } };
+
     // Priority 1: codeableConcept parameter
     const cc = this.getCodeableConceptParam(params, 'codeableConcept');
     if (cc) {
       mode.mode = 'codeableConcept';
       mode.issuePath = "CodeableConcept";
+      noInfer();
       return cc;
     }
 
@@ -2363,6 +2241,7 @@ class ValidateWorker extends TerminologyWorker {
     if (coding) {
       mode.mode = 'coding';
       mode.issuePath = "Coding";
+      noInfer();
       return {coding: [coding]};
     }
 

package/tx/workers/worker.js

@@ -33,6 +33,15 @@ class TerminologyWorker {
   foundParameters = [];
   renderer;
 
+  // ValueSetChecker reads both of these off whatever worker it is given, so they belong to
+  // every worker that can construct one - not just the validate and expand workers that
+  // happen to have declared them first. A worker without them fails inside the checker with
+  // "Cannot read properties of undefined (reading 'size')", a long way from the cause.
+  // ValidateWorker and ExpandWorker redeclare them; a subclass field initialiser overrides
+  // the base one, so their behaviour is unchanged.
+  requiredSupplements = new Set();
+  usedSupplements = new Set();
+
   /**
    * @param {OperationContext} opContext - Operation context
    * @param {Logger} log - Provider for code systems and resources