fhirsmith 0.14.0 → 0.14.2

package/tx/tx.js

@@ -54,6 +54,7 @@ const {BundleXML} = require("./xml/bundle-xml");
 const ConceptUsageTracker = require("./usage-tracker");
 const ProblemFinder = require("./problems");
 const { buildOperationOutcome, outcomeFromError } = require('./library/operation-outcome');
+const txOpenApi = require('./openapi');
 // const {writeFileSync} = require("fs");
 
 class TXModule {
@@ -521,6 +522,11 @@ class TXModule {
 
     app.use(express.urlencoded({ extended: true }));
 
+    // The OpenAPI description, on the endpoints it describes (R5)
+    if (txOpenApi.describes(fhirVersion)) {
+      this.setupOpenApi(router, endpointInfo);
+    }
+
     // Set up routes
     this.setupRoutes(router, endpointInfo.path);
 
@@ -540,6 +546,55 @@ class TXModule {
     this.log.info(`Endpoint ${endpointPath} registered`);
   }
 
+  /**
+   * The OpenAPI description of an endpoint: /openapi.json, /openapi.yaml, and /openapi (an
+   * HTML reference for browsers, the JSON otherwise), and an RFC 8631 Link header on every
+   * response that points to them. These are sent directly, not through the res.json the
+   * endpoint wraps for FHIR resources.
+   *
+   * @param {express.Router} router
+   * @param {Object} endpointInfo
+   */
+  setupOpenApi(router, endpointInfo) {
+    const doc = txOpenApi.forEndpoint(endpointInfo.path);
+    const sendJson = (res) => res.type('application/json').send(doc.getJson());
+    router.use((req, res, next) => {
+      res.setHeader('Link', `<${req.baseUrl}/openapi.json>; rel="service-desc", <${req.baseUrl}/openapi>; rel="service-doc"`);
+      next();
+    });
+    const count = (start) => this.countRequest(endpointInfo.path, 'openapi', Date.now() - start);
+    router.get('/openapi.json', (req, res) => {
+      const start = Date.now();
+      try {
+        sendJson(res);
+      } finally {
+        count(start);
+      }
+    });
+    router.get('/openapi.yaml', (req, res) => {
+      const start = Date.now();
+      try {
+        res.type('application/yaml').send(doc.getYaml());
+      } finally {
+        count(start);
+      }
+    });
+    router.get('/openapi', async (req, res) => {
+      const start = Date.now();
+      try {
+        if (!txHtml.acceptsHtml(req)) {
+          return sendJson(res);
+        }
+        const txhtml = new TxHtmlRenderer(new Renderer(req.txOpContext, req.txProvider), this.liquid, this.languages, this.i18n, endpointInfo.path);
+        const html = await txhtml.renderPage('API', doc.renderHtml(), endpointInfo, req.txStartTime);
+        res.setHeader('Content-Type', 'text/html');
+        res.send(html);
+      } finally {
+        count(start);
+      }
+    });
+  }
+
   /**
    * Set up routes for an endpoint
    * @param {express.Router} router - Express router

package/tx/vs/vs-database.js

@@ -743,7 +743,17 @@ class ValueSetDatabase {
           const valueSetMap = new Map();
 
           for (const row of rows) {
-            const valueSet = new ValueSet(JSON.parse(row.content));
+            let valueSet;
+            try {
+              valueSet = new ValueSet(JSON.parse(row.content));
+            } catch (e) {
+              // one unacceptable value set (e.g. one containing a CodeSystem, which the
+              // server doesn't support) must not take the whole package's value sets with it
+              require('../../library/logger').getInstance().child({ module: 'tx' })
+                .warn(`${source || 'ValueSet database'}: skipping ValueSet ${row.url || row.id}${row.version ? '|' + row.version : ''}: ${e.message}`);
+              this.vsCount--;
+              continue;
+            }
             valueSet.sourcePackage = source;
             // Attach the stored content hash so callers can detect changes
             // without recomputing over the full JSON.
@@ -839,10 +849,9 @@ class ValueSetDatabase {
             });
           } else {
             // Fall back to parsing JSON
-            results = rows.map(row => {
-              const vs = map.get(row.id);
-              return vs;
-            });
+            // a value set the map doesn't have was rejected when the map was loaded
+            // (see loadAllValueSets), so it isn't a result
+            results = rows.map(row => map.get(row.id)).filter(vs => vs);
           }
 
           resolve(results);

package/tx/vs/vs-package.js

@@ -3,6 +3,7 @@ const fs = require('fs').promises;
 const { AbstractValueSetProvider } = require('./vs-api');
 const { PackageContentLoader } = require('../../library/package-manager');
 const { ValueSetDatabase } = require('./vs-database');
+const { checkContained } = require('../library/canonical-resource');
 const { VersionUtilities } = require('../../library/version-utilities');
 const {validateParameter} = require("../../library/utilities");
 
@@ -126,6 +127,15 @@ class PackageValueSetProvider extends AbstractValueSetProvider {
     for (const entry of valueSetEntries) {
       const valueSet = await this.packageLoader.loadFile(entry);
       if (valueSet.url) {
+        try {
+          // don't store a value set the server can't use (e.g. one that contains a
+          // CodeSystem): it would be listed by search, and fail when read
+          checkContained(valueSet);
+        } catch (e) {
+          require('../../library/logger').getInstance().child({ module: 'tx' })
+            .warn(`Package ${this.packageLoader.pid ? this.packageLoader.pid() : ''}: skipping ValueSet ${valueSet.url}: ${e.message}`);
+          continue;
+        }
         valueSets.push(valueSet);
       }
     }

package/tx/workers/expand.js

@@ -620,19 +620,23 @@ class ValueSetExpander {
     return count;
   }
 
+  /**
+   * Exclude the codes of an (expanded) value set. Excludes are processed before includes,
+   * so the codes are recorded as excluded - as excludeCode does - and the includes then
+   * skip them. (This used to remove them from what had been included so far, which at
+   * that point is nothing, so excluding a value set excluded nothing.)
+   */
   excludeValueSet(vs, expansion, imports, offset) {
-    for (const c of vs.expansion.contains) {
-      this.worker.deadCheck('excludeValueSet');
-      const s = this.keyC(c);
-      if (this.passesImports(imports, c.system, c.code, offset) && this.map.has(s)) {
-        const idx = this.fullList.indexOf(this.map.get(s));
-        if (idx >= 0) {
-          this.fullList.splice(idx, 1);
+    const walk = (list) => {
+      for (const c of list || []) {
+        this.worker.deadCheck('excludeValueSet');
+        if (c.code && this.passesImports(imports, c.system, c.code, offset)) {
+          this.excluded.add((this.doingVersion && !this.params.versionsMatch ? c.system + '|' + c.version : c.system) + '#' + c.code);
         }
-        this.map.delete(s);
-        this.decTotal();
+        walk(c.contains);
       }
-    }
+    };
+    walk(vs.expansion.contains);
   }
 
   async checkSource(cset, exp, filter, srcURL, ts, vsInfo , source) {
@@ -1012,8 +1016,10 @@ 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 && ivs.valueSet.vurl) {
-            this.addParamUri(expansion, 'used-valueset', ivs.valueSet.vurl);
+          // ivs.valueSet is the expansion (plain JSON), so it has no vurl - as for the
+          // includes, build it
+          if (!vs.isContained && this.worker.makeVurl(ivs.valueSet)) {
+            this.addParamUri(expansion, 'used-valueset', this.worker.makeVurl(ivs.valueSet));
           }
           valueSets.push(ivs);
         }
@@ -1314,13 +1320,22 @@ class ValueSetExpander {
   }
 
   async expand(source, filter, noCacheThisOne) {
-    this.noCacheThisOne = noCacheThisOne;
-    this.totalStatus = 'uninitialised';
-    this.total = 0;
-
     Extensions.checkNoImplicitRules(source,'ValueSetExpander.Expand', 'ValueSet', source.vurl);
     Extensions.checkNoModifiers(source,'ValueSetExpander.Expand', 'ValueSet', source.vurl);
+    // circular reference detection: this value set is in the chain being processed until
+    // its expansion is done
     this.worker.seeValueSet(source, this.params);
+    try {
+      return await this.expandSeen(source, filter, noCacheThisOne);
+    } finally {
+      this.worker.unseeValueSet(source);
+    }
+  }
+
+  async expandSeen(source, filter, noCacheThisOne) {
+    this.noCacheThisOne = noCacheThisOne;
+    this.totalStatus = 'uninitialised';
+    this.total = 0;
     this.valueSet = source;
 
     const result = structuredClone(source.jsonObj);
@@ -1348,6 +1363,10 @@ class ValueSetExpander {
     if (result.expansion) {
       return result; // just return the expansion
     }
+    if (!source.jsonObj.compose) {
+      throw new Issue('error', 'invalid', null, 'VALUESET_NO_COMPOSE',
+        this.worker.i18n.translate('VALUESET_NO_COMPOSE', this.params.httpLanguages, [source.contextKey || source.vurlOrMsg]), 'vs-invalid', 422);
+    }
 
     if (this.params.generateNarrative && !this.noDetails) {
       div_ = div();
@@ -1385,9 +1404,9 @@ class ValueSetExpander {
     }
 
     if (this.params.DisplayLanguages) {
-      this.addParamCode(exp, 'displayLanguage', this.params.DisplayLanguages.asString(true));
+      this.addParamCode(exp, 'displayLanguage', this.params.DisplayLanguages.asParameter());
     } else if (this.params.HTTPLanguages) {
-      this.addParamCode(exp, 'displayLanguage', this.params.HTTPLanguages.asString(true));
+      this.addParamCode(exp, 'displayLanguage', this.params.HTTPLanguages.asParameter());
     }
     if (this.params.designations) {
       for (const s of this.params.designations) {

package/tx/workers/metadata.js

@@ -437,7 +437,6 @@ class MetadataHandler {
         // Parameters the $expand handler reads - see handleTypeLevelExpand in
         // tx/workers/expand.js and TxParameters.seeParameter in tx/params.js.
         // Keep this list in step with those when adding a parameter.
-        { name: '_incomplete' },
         { name: 'abstract' },
         { name: 'activeOnly' },
         { name: 'check-system-version' },
@@ -453,20 +452,12 @@ class MetadataHandler {
         { name: 'filter' },
         { name: 'force-system-version' },
         { name: 'force-valueset-version' },
-        { name: 'inactive' },
-        { name: 'includeAlternateCodes' },
         { name: 'includeDefinition' },
         { name: 'includeDesignations' },
-        { name: 'incomplete-ok' },
         {
           name: 'limit',
           documentation: 'Upper bound on the size of the expansion; the operation fails as too-costly beyond it'
         },
-        { name: 'limitedExpansion' },
-        {
-          name: 'mode',
-          documentation: '=lenient-display-validation'
-        },
         { name: 'no-cache' },
         { name: 'offset' },
         { name: 'profile' },
@@ -479,10 +470,6 @@ class MetadataHandler {
         { name: 'url' },
         { name: 'useSupplement' },
         { name: 'valueSet' },
-        {
-          name: 'valueSetMode',
-          documentation: '= CHECK_MEMBERSHIP_ONLY | NO_MEMBERSHIP_CHECK'
-        },
         { name: 'valueSetVersion' }
       ]
     };

package/tx/workers/translate.js

@@ -1085,9 +1085,14 @@ class TranslateWorker extends TerminologyWorker {
           added = await this.translateUsingGroupsForwards(cm, coding, targetScope, targetSystem, params, result) || added;
         }
       }
+      // A map can say, explicitly, that a concept is NOT related to a target (not-related-to,
+      // or R4's unmatched/disjoint). That is still reported as a match - it is what the map
+      // says - but it is not a translation: "The value can only be true if at least one
+      // returned match has a relationship other than 'not-related-to'" (tx-ecosystem translate-2b)
+      const translated = added && result.some(p => p.name === 'match' && this.isPositiveMatch(p));
       result.push({
         name: 'result',
-        valueBoolean: added
+        valueBoolean: translated
       });
       if (!added) {
         result.push({
@@ -1120,6 +1125,25 @@ class TranslateWorker extends TerminologyWorker {
     };
   }
 
+  /**
+   * Whether a match counts towards result=true. A noMap match says there is no mapping, and
+   * an explicit negative relationship says the target is not related, so neither is a
+   * translation. A match with no relationship otherwise (an unmapped fallback without one,
+   * a code system supplied translation) still counts.
+   */
+  isPositiveMatch(match) {
+    const part = (name) => (match.part || []).find(p => p.name === name);
+    if (part('noMap')?.valueBoolean === true) {
+      return false;
+    }
+    const rel = part('relationship')?.valueCode;
+    const eq = part('equivalence')?.valueCode;
+    if (eq === 'unmatched' || eq === 'disjoint') {
+      return false;
+    }
+    return rel !== 'not-related-to';
+  }
+
   // eslint-disable-next-line no-unused-vars
   isOkTarget(cm, vs) {
     // if cm.target != null then

package/tx/workers/validate.js

@@ -285,7 +285,10 @@ class ValueSetChecker {
   }
 
   seeValueSet() {
-    this.worker.opContext.seeContext(this.valueSet.vurl);
+    const key = this.valueSet.contextKey !== undefined ? this.valueSet.contextKey : this.valueSet.vurl;
+    if (key) {
+      this.worker.opContext.seeContext(key);
+    }
     if (this.valueSet.jsonObj.compose && this.valueSet.jsonObj.compose.extension) {
       for (let ext of this.valueSet.jsonObj.compose.extension) {
         if (ext.url === 'http://hl7.org/fhir/StructureDefinition/valueset-expansion-parameter' || ext.url === 'http://hl7.org/fhir/tools/StructureDefinition/valueset-expansion-parameter') {
@@ -305,8 +308,22 @@ class ValueSetChecker {
   async prepare() {
     if (this.valueSet === null) {
       throw new Issue('error', 'not-found', null, null, 'Error Error: vs = nil', null, 422);
-    } else {
-      this.seeValueSet();
+    }
+    // circular reference detection: this value set is in the chain being processed until
+    // it's prepared (which prepares everything it imports)
+    this.seeValueSet();
+    try {
+      await this.prepareSeen();
+    } finally {
+      const key = this.valueSet.contextKey !== undefined ? this.valueSet.contextKey : this.valueSet.vurl;
+      if (key) {
+        this.worker.opContext.unseeContext(key);
+      }
+    }
+  }
+
+  async prepareSeen() {
+    {
       this.worker.opContext.addNote(this.valueSet, 'Analysing ' + this.valueSet.vurl + ' for validation purposes', this.indentCount);
       if (this.indentCount === 0) {
         this.worker.opContext.addNote(this.valueSet, 'Parameters: ' + this.params.summary(), this.indentCount);
@@ -569,9 +586,14 @@ class ValueSetChecker {
             if (msg) {
               op.addIssue(new Issue('information', 'informational', addToPath(path, 'code'), null, msg, 'process-note'));
             }
-            inactive.value = await cs.isInactive(ctxt.context);
-            inactive.path = path;
-            vstatus.value = await cs.getStatus(ctxt.context);
+            // in a CodeableConcept a later coding must not clear the inactive status an earlier
+            // coding found, or the warning silently disappears when the inactive coding comes first
+            if (!inactive.value) {
+              inactive.value = await cs.isInactive(ctxt.context);
+              inactive.path = path;
+              inactive.code = code;
+              vstatus.value = await cs.getStatus(ctxt.context);
+            }
           }
           if (displays !== null) {
             await this.worker.listDisplaysFromCodeSystem(displays, cs, ctxt.context);
@@ -925,6 +947,7 @@ class ValueSetChecker {
     let pdisp;
     let psys;
     let pcode;
+    let ppath; // the path of the coding that is returned
     let pver;
 
 
@@ -1063,6 +1086,7 @@ class ValueSetChecker {
         if (pcode === undefined) {
           psys = c.system;
           pcode = c.code;
+          ppath = path;
           if (ver.value) {
             pver = ver.value;
           }
@@ -1088,7 +1112,11 @@ class ValueSetChecker {
           mt.push(m);
           op.addIssue(new Issue('error', 'invalid', p, 'Terminology_TX_System_Relative', m, 'invalid-data'));
         }
-        let prov = await this.worker.findCodeSystem(ws, c.version, this.params, ['complete', 'fragment'],  op,true, true, false, this.worker.requiredSupplements);
+        // the code isn't in the value set, but it's still looked up in the code system to report on
+        // it - and that has to be the version the value set selects when the coding doesn't say,
+        // not the server default (tx-ecosystem sct validate-code-pc-none)
+        let lookupVersion = c.version || vsImpliedVersion;
+        let prov = await this.worker.findCodeSystem(ws, lookupVersion, this.params, ['complete', 'fragment'],  op,true, true, false, this.worker.requiredSupplements);
         if (prov === null) {
           let vss = await this.worker.findValueSet(ws, '', null);
           if (vss !== null) {
@@ -1098,7 +1126,7 @@ class ValueSetChecker {
             op.addIssue(new Issue('error', 'invalid', addToPath(path, 'system'), 'Terminology_TX_System_ValueSet2', m, 'invalid-data'));
             cause.value = 'invalid';
           } else {
-            let provS = await this.worker.findCodeSystem(ws, c.version, this.params, ['supplement'], op,true, true, false, this.worker.requiredSupplements);
+            let provS = await this.worker.findCodeSystem(ws, lookupVersion, this.params, ['supplement'], op,true, true, false, this.worker.requiredSupplements);
             if (provS !== null) {
               vss = null;
               let m = this.worker.i18n.translate('CODESYSTEM_CS_NO_SUPPLEMENT', this.params.HTTPLanguages, [provS.vurl()]);
@@ -1109,7 +1137,7 @@ class ValueSetChecker {
               let prov2 = await this.worker.findCodeSystem(ws, '', this.params, ['complete', 'fragment'], op,true, true, false, this.worker.requiredSupplements);
               let bAdd = true;
               let m, mid, vn;
-              if (prov2 === null && !c.version) {
+              if (prov2 === null && !lookupVersion) {
                 mid = 'UNKNOWN_CODESYSTEM';
                 m = this.worker.i18n.translate('UNKNOWN_CODESYSTEM', this.params.HTTPLanguages, [ws]);
                 bAdd = !unknownSystems.has(ws);
@@ -1123,9 +1151,9 @@ class ValueSetChecker {
                   vn = ws;
                 } else {
                   mid = 'UNKNOWN_CODESYSTEM_VERSION';
-                  vn = ws + '|' + c.version;
+                  vn = ws + '|' + lookupVersion;
                 }
-                m = this.worker.i18n.translate(mid, this.params.HTTPLanguages, [ws, c.version,  this.worker.presentVersionList(vl)]);
+                m = this.worker.i18n.translate(mid, this.params.HTTPLanguages, [ws, lookupVersion,  this.worker.presentVersionList(vl)]);
                 bAdd = !unknownSystems.has(vn);
                 if (bAdd) {
                   unknownSystems.add(vn);
@@ -1181,6 +1209,7 @@ class ValueSetChecker {
             if (!this.params.membershipOnly && !inactive.value && await prov.isInactive(ctxt.context)) {
               inactive.value = true;
               inactive.path = path;
+              inactive.code = c.code;
               const st = await prov.getStatus(ctxt.context);
               if (st) {
                 vstatus.value = st;
@@ -1336,9 +1365,14 @@ class ValueSetChecker {
     }
 
     if (inactive.value) {
-      result.addParamBool('inactive', inactive.value);
-      if (vstatus.value && vstatus.value !== 'inactive') {
-        result.addParamCode('status', vstatus.value);
+      // the inactive and status parameters describe the code being returned. In a CodeableConcept
+      // the inactive coding may be a different one (or none was returned at all): it still gets
+      // its warning below, but the parameters are not claimed for the returned code
+      if (mode !== 'codeableConcept' || (pcode && inactive.path === ppath)) {
+        result.addParamBool('inactive', inactive.value);
+        if (vstatus.value && vstatus.value !== 'inactive') {
+          result.addParamCode('status', vstatus.value);
+        }
       }
       let mpath = inactive.path;
       if (!mpath) {
@@ -1350,7 +1384,9 @@ class ValueSetChecker {
         mid1 = 'INACTIVE_CONCEPT_FOUND_ADD';
         mm1 = 'inactive';
       }
-      let m = this.worker.i18n.translate(mid1, this.params.HTTPLanguages, [vstatus.value, tcode, mm1]);
+      // report the code that is actually inactive - in a CodeableConcept that isn't necessarily
+      // the first coding (tcode), which is what this message used to name
+      let m = this.worker.i18n.translate(mid1, this.params.HTTPLanguages, [vstatus.value, inactive.code || tcode, mm1]);
       msg(m);
       op.addIssue(new Issue('warning', 'business-rule', mpath, 'INACTIVE_CONCEPT_FOUND', m, 'code-comment'));
     } else if (vstatus.value && vstatus.value.toLowerCase() === 'deprecated') {
@@ -1544,6 +1580,7 @@ class ValueSetChecker {
           if (!this.params.membershipOnly && role !== 'not in') {
             inactive.value = true;
             inactive.path = path;
+            inactive.code = code;
             if (inactive.value) {
               vstatus.value = await cs.getStatus(loc.context);
             }
@@ -1554,6 +1591,7 @@ class ValueSetChecker {
           if (role !== 'not in') {
             inactive.value = true;
             inactive.path = path;
+            inactive.code = code;
             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);
@@ -1562,9 +1600,12 @@ class ValueSetChecker {
         } else {
           result = true;
           if (role !== 'not in') {
-            inactive.value = await cs.isInactive(loc.context);
-            inactive.path = path;
-            vstatus.value = await cs.getStatus(loc.context);
+            if (!inactive.value) {
+              inactive.value = await cs.isInactive(loc.context);
+              inactive.path = path;
+              inactive.code = code;
+              vstatus.value = await cs.getStatus(loc.context);
+            }
             if (vcc !== null) {
               if (!vcc.coding) {
                 vcc.coding = [];
@@ -1601,6 +1642,7 @@ class ValueSetChecker {
             if (!this.params.membershipOnly) {
               inactive.value = true;
               inactive.path = path;
+              inactive.code = code;
               vstatus.value = await cs.getStatus(loc);
             }
           } else {
@@ -1614,9 +1656,12 @@ class ValueSetChecker {
             } else if (Extensions.has(cc,'http://hl7.org/fhir/StructureDefinition/valueset-deprecated')) {
               op.addIssue(new Issue('warning', 'business-rule', addToPath(path, 'code'), 'CONCEPT_DEPRECATED_IN_VALUESET', this.worker.i18n.translate('CONCEPT_DEPRECATED_IN_VALUESET', this.params.HTTPLanguages, [cs.system(), code, 'deprecated', vs.vurl]), 'code-comment'));
             }
-            inactive.value = await cs.isInactive(loc);
-            inactive.path = path;
-            vstatus.value = await cs.getStatus(loc);
+            if (!inactive.value) {
+              inactive.value = await cs.isInactive(loc);
+              inactive.path = path;
+              inactive.code = code;
+              vstatus.value = await cs.getStatus(loc);
+            }
             result = true;
             return result;
           }
@@ -1665,6 +1710,7 @@ class ValueSetChecker {
           if (!this.params.membershipOnly) {
             inactive.value = true;
             inactive.path = path;
+            inactive.code = code;
             vstatus.value = await cs.getStatus(loc);
           }
         } else {
@@ -1677,6 +1723,7 @@ class ValueSetChecker {
             if (await cs.isInactive(loc)) {
               inactive.value = true;
               inactive.path = path;
+              inactive.code = code;
               // only replace a status we already have with a real one - a filter context
               // doesn't always carry the status (SNOMED, LOINC), and the assembly reads
               // vstatus for the message wording as well as for the status parameter
@@ -1714,9 +1761,12 @@ class ValueSetChecker {
       }
     } else {
       result = true;
-      inactive.value = await cs.isInactive(loc.context);
-      inactive.path = path;
-      vstatus.value = await cs.getStatus(loc.context);
+      if (!inactive.value) {
+        inactive.value = await cs.isInactive(loc.context);
+        inactive.path = path;
+        inactive.code = code;
+        vstatus.value = await cs.getStatus(loc.context);
+      }
       await this.worker.listDisplaysFromCodeSystem(displays, cs, loc.context);
       return result;
     }

package/tx/workers/worker.js

@@ -7,6 +7,7 @@ const {Issue} = require("../library/operation-outcome");
 const {Languages} = require("../../library/languages");
 const {ConceptMap} = require("../library/conceptmap");
 const {Renderer} = require("../library/renderer");
+const {editionName} = require("../sct/editions");
 
 // The cache-id travels as an HTTP header (not an operation parameter) so proxies /
 // load-balancers can act on it and the server can reject it before parsing the body.
@@ -378,14 +379,22 @@ class TerminologyWorker {
       return null;
     }
     if (url.startsWith("#")) {
+      // A local reference: per FHIR, #id is resolved against the contained resources of
+      // the resource being processed - which, when that is itself a contained value set,
+      // means its container's (contained resources are all siblings in one list)
       if (source) {
-        if (source.jsonObj) {
-          source = source.jsonObj;
-        }
-        for (const contained of source.contained || []) {
-          if (contained.id === url.substring(1)) {
+        const container = source.container || source;
+        const json = container.jsonObj || container;
+        for (const contained of json.contained || []) {
+          if (contained && contained.id === url.substring(1)) {
+            if (contained.resourceType !== 'ValueSet') {
+              // the resource wrappers already reject this; this is the second line of defence
+              throw new Issue('error', 'not-supported', null, 'CONTAINED_RESOURCE_NOT_SUPPORTED',
+                `The reference '${url}' is to a contained ${contained.resourceType}, not a ValueSet`, 'not-supported', 400);
+            }
             const ret = this.wrapRawResource(contained);
             ret.isContained = true;
+            ret.container = container.jsonObj ? container : this.wrapRawResource(container);
             return ret;
           }
         }
@@ -476,11 +485,24 @@ class TerminologyWorker {
    *   Note: this is the caller's parameters, not this.params - the worker's own
    *   params is null when expanding an imported ValueSet
    */
+  /** The circular reference key seeValueSet tracks for a value set */
+  valueSetContextKey(vs) {
+    return vs.contextKey !== undefined ? vs.contextKey : (vs.url ? (vs.url + (vs.version ? '|' + vs.version : '')) : null);
+  }
+
+  /** Finished processing a value set: see OperationContext.unseeContext */
+  unseeValueSet(vs) {
+    const key = this.valueSetContextKey(vs);
+    if (key) {
+      this.opContext.unseeContext(key);
+    }
+  }
+
   seeValueSet(vs, params) {
     // Build canonical URL from url and version
-    const vurl = vs.url ? (vs.url + (vs.version ? '|' + vs.version : '')) : null;
-    if (vurl) {
-      this.opContext.seeContext(vurl);
+    const key = this.valueSetContextKey(vs);
+    if (key) {
+      this.opContext.seeContext(key);
     }
     // Check for expansion parameter extensions on compose
     if (vs.jsonObj.compose && vs.jsonObj.compose.extension) {
@@ -1100,42 +1122,9 @@ function Unknown_Code_in_VersionSCT(url, version) {
 function SCTVersion(url, ver) {
   if (url !== 'http://snomed.info/sct' || !ver) {
     return '';
-  } else {
-    let result = 'unknown';
-    let s = ver.split('/');
-    if (s.length >= 5) {
-      if (s[4] === '900000000000207008') result = 'International Edition';
-      else if (s[4] === '449081005') result = 'International Spanish Edition';
-      else if (s[4] === '11000221109') result = 'Argentinian Edition';
-      else if (s[4] === '32506021000036107') result = 'Australian Edition (with drug extension)';
-      else if (s[4] === '11000234105') result = 'Austrian Edition';
-      else if (s[4] === '11000172109') result = 'Belgian Edition';
-      else if (s[4] === '20621000087109') result = 'Canadian English Edition';
-      else if (s[4] === '20611000087101') result = 'Canadian Canadian French Edition';
-      else if (s[4] === '11000279109') result = 'Czech Edition';
-      else if (s[4] === '554471000005108') result = 'Danish Edition';
-      else if (s[4] === '11000181102') result = 'Estonian Edition';
-      else if (s[4] === '11000229106') result = 'Finnish Edition';
-      else if (s[4] === '11000274103') result = 'German Edition';
-      else if (s[4] === '1121000189102') result = 'Indian Edition';
-      else if (s[4] === '827022005') result = 'IPS Terminology';
-      else if (s[4] === '11000220105') result = 'Irish Edition';
-      else if (s[4] === '11000146104') result = 'Netherlands Edition';
-      else if (s[4] === '21000210109') result = 'New Zealand Edition';
-      else if (s[4] === '51000202101') result = 'Norwegian Edition';
-      else if (s[4] === '11000267109') result = 'Republic of Korea Edition (South Korea)';
-      else if (s[4] === '900000001000122104') result = 'Spanish National Edition';
-      else if (s[4] === '45991000052106') result = 'Swedish Edition';
-      else if (s[4] === '2011000195101') result = 'Swiss Edition';
-      else if (s[4] === '83821000000107') result = 'UK Edition';
-      else if (s[4] === '999000021000000109') result = 'UK Clinical Edition';
-      else if (s[4] === '5631000179106') result = 'Uruguay Edition';
-      else if (s[4] === '21000325107') result = 'Chilean Edition';
-      else if (s[4] === '731000124108') result = 'US Edition';
-      else if (s[4] === '5991000124107') result = 'US Edition (with ICD-10-CM maps)';
-    }
-    return result;
   }
+  const s = ver.split('/');
+  return (s.length >= 5 && editionName(s[4])) || 'unknown';
 }
 
 module.exports = {