fhirsmith 0.18.2 → 1.0.0

package/tx/workers/worker.js

@@ -174,28 +174,45 @@ class TerminologyWorker {
     if (!noVParams) {
       version = this.determineVersionBase(url, version, params);
     }
-    let codeSystemResource = null;
-    let provider = null;
-    const supplements = this.loadSupplements(url, version, statedSupplements);
-
     // First check additional resources
-    codeSystemResource = this.findInAdditionalResources(url, version, 'CodeSystem', !nullOk);
+    const codeSystemResource = this.findInAdditionalResources(url, version, 'CodeSystem', !nullOk);
 
-    if (codeSystemResource) {
-      if (codeSystemResource.content === 'complete') {
+    const build = async (supplements) => {
+      let provider = null;
+      if (codeSystemResource && codeSystemResource.content === 'complete') {
         // Create provider from complete code system
         provider = await this.provider.createCodeSystemProvider(this.opContext, codeSystemResource, supplements);
       }
-    }
-
-    // If no provider from additional resources, try main provider
-    if (!provider) {
-      provider = await this.provider.getCodeSystemProvider(this.opContext, url, version, supplements);
-    }
+      // If no provider from additional resources, try main provider
+      if (!provider) {
+        provider = await this.provider.getCodeSystemProvider(this.opContext, url, version, supplements);
+      }
+      // If still no provider but we have a code system with allowed content mode
+      if (!provider && codeSystemResource && kinds.includes(codeSystemResource.content)) {
+        provider = await this.provider.createCodeSystemProvider(this.opContext, codeSystemResource, supplements);
+      }
+      // Track for lifecycle cleanup at end of request, at once: what follows can throw (a client
+      // that has gone, in loadSupplements). Providers built from a factory open a fresh sqlite
+      // connection that needs releasing; resource-built providers and others are no-ops.
+      this.opContext.registerProvider(provider);
+      return provider;
+    };
 
-    // If still no provider but we have a code system with allowed content mode
-    if (!provider && codeSystemResource && kinds.includes(codeSystemResource.content)) {
-      provider = await this.provider.createCodeSystemProvider(this.opContext, codeSystemResource, supplements);
+    const supplements = this.loadSupplements(url, version, statedSupplements);
+    let provider = await build(supplements);
+
+    // The supplements were chosen for the version asked for. When no version was asked for (or
+    // only part of one), it's the version the provider turned out to be that decides which apply:
+    // a supplement pinned to another version of the code system (supplements = url|2.80 on
+    // LOINC 2.83) is not used - so a value set that requires it fails - and one pinned to this
+    // version is
+    const actual = provider ? provider.version() : null;
+    if (actual && actual !== version) {
+      const fitting = this.loadSupplements(url, actual, statedSupplements);
+      const key = (list) => list.map(cs => cs.vurl || cs.url).sort().join(' ');
+      if (key(fitting) !== key(supplements)) {
+        provider = await build(fitting);
+      }
     }
 
     if (!provider && !nullOk) {
@@ -210,14 +227,8 @@ class TerminologyWorker {
         }
       }
     }
-    if (provider) {
-      if (checkVer) {
-        this.checkVersion(url, provider.version(), params, provider.versionAlgorithm(), op);
-      }
-      // Track for lifecycle cleanup at end of request. Providers built from
-      // a factory open a fresh sqlite connection that needs releasing;
-      // resource-built providers and others without close() are no-ops.
-      this.opContext.registerProvider(provider);
+    if (provider && checkVer) {
+      this.checkVersion(url, provider.version(), params, provider.versionAlgorithm(), op);
     }
 
     return provider;
@@ -284,10 +295,52 @@ class TerminologyWorker {
    * @returns {Array<CodeSystem>} Supplement code systems
    */
   loadSupplements(url, version = '', statedSupplements) {
+    return this.#oneVersionEach(this.#findSupplements(url, version, statedSupplements), statedSupplements);
+  }
+
+  /**
+   * Only one version of a supplement applies. When more than one is in scope (the server has
+   * one, and the request passes another in tx-resource), the one the request names by version
+   * (useSupplement url|version, or a value set's supplement extension) wins; failing that, the
+   * request's own over the server's; failing that, the latest
+   *
+   * @param {CodeSystem[]} supplements - server ones first, then the request's
+   * @param {Set<string>} statedSupplements
+   * @returns {CodeSystem[]}
+   */
+  #oneVersionEach(supplements, statedSupplements) {
+    const byUrl = new Map();
+    for (const cs of supplements) {
+      if (!byUrl.has(cs.url)) {
+        byUrl.set(cs.url, []);
+      }
+      byUrl.get(cs.url).push(cs);
+    }
+    if ([...byUrl.values()].every(list => list.length === 1)) {
+      return supplements;
+    }
+    const result = [];
+    for (const list of byUrl.values()) {
+      if (list.length === 1) {
+        result.push(list[0]);
+        continue;
+      }
+      let chosen = statedSupplements ? list.find(cs => cs.version && statedSupplements.has(cs.vurl)) : null;
+      if (!chosen) {
+        chosen = list.find(cs => (this.additionalResources || []).includes(cs));
+      }
+      if (!chosen) {
+        chosen = list.reduce((a, b) => (VersionUtilities.compareVersionsGeneral(b.version, a.version) > 0 ? b : a));
+      }
+      result.push(chosen);
+    }
+    return result;
+  }
+
+  #findSupplements(url, version, statedSupplements) {
     const supplements = [];
 
     supplements.push(...this.provider.loadSupplements(url, version, statedSupplements));
-    // todo: look in provider for supplements
 
     if (!this.additionalResources) {
       return supplements;
@@ -298,14 +351,16 @@ class TerminologyWorker {
       if (resource.resourceType === 'CodeSystem' && resource instanceof CodeSystem) {
         const cs = resource;
         // Check if this code system supplements the target URL
-        const supplementsUrl = cs.jsonObj.supplements;
+        // (supplementsUrl rather than jsonObj.supplements: a resource from the shared
+        // resource cache answers it without being loaded - see resource-cache-sqlite.js)
+        const supplementsUrl = cs.supplementsUrl;
 
         if (!supplementsUrl) {
           continue;
         }
 
-        // we consider either language packs or specified supplements
-        if (!(cs.isLangPack() || (statedSupplements && (statedSupplements.has(cs.url) || statedSupplements.has(cs.vurl))))) {
+        // we consider either global supplements or specified supplements
+        if (!(cs.isGlobalSupplement() || (statedSupplements && (statedSupplements.has(cs.url) || statedSupplements.has(cs.vurl))))) {
           continue;
         }
         if (this.hasSupplement(cs, supplements)) {
@@ -325,7 +380,11 @@ class TerminologyWorker {
           } else {
             // Version specified, check if it matches the tail of supplements URL
             const supplementsVersion = supplementsUrl.substring(`${url}|`.length);
-            if (supplementsVersion === version || VersionUtilities.versionMatches(supplementsVersion, version)) {
+            // not every code system's versions are semver (SNOMED CT's are URIs, ICF's are dates):
+            // versionMatches throws on those, so match by the version's own algorithm, as
+            // CodeSystem.isSupplementFor does for the server's own supplements
+            if (supplementsVersion === version || VersionUtilities.versionMatchesByAlgorithm(supplementsVersion, version,
+                VersionUtilities.guessVersionAlgorithmFromVersion(version))) {
               supplements.push(cs);
             }
           }
@@ -420,7 +479,12 @@ class TerminologyWorker {
 
     // Then try the provider
     if (this.provider && this.provider.findValueSet) {
-      const vs = await this.provider.findValueSet(this.opContext, effectiveUrl, effectiveVersion);
+      // an implicit value set in the generic form (http://snomed.info/sct?fhir_vs...) is drawn
+      // from the code system version the request asks for, if it asks for one
+      const systemVersionFor = this.params && this.params.requestedSystemVersion
+        ? (system) => this.params.requestedSystemVersion(system)
+        : null;
+      const vs = await this.provider.findValueSet(this.opContext, effectiveUrl, effectiveVersion, systemVersionFor);
       if (vs) {
         return vs;
       }
@@ -740,7 +804,7 @@ class TerminologyWorker {
       if (!this.opContext.resourceCache.isSealed(cacheId)) {
         const toCache = txResources.concat(primaryResources);
         if (toCache.length > 0) {
-          this.opContext.resourceCache.add(cacheId, toCache);
+          this.addToClientCache(cacheId, toCache);
         }
         this.additionalResources = this.opContext.resourceCache.get(cacheId);
       } else {
@@ -756,6 +820,34 @@ class TerminologyWorker {
     }
   }
 
+  /**
+   * Add resources to the client side cache cacheId. If that would take the cache over
+   * cacheMaxConcepts, the cache is dropped and this throws the 404 cache-id-unknown
+   * (CACHE_ID_DISCARDED_TOO_BIG), in the request's language: the operation is not performed.
+   * @param {string} cacheId
+   * @param {Object[]} resources
+   */
+  addToClientCache(cacheId, resources) {
+    try {
+      this.opContext.resourceCache.add(cacheId, resources);
+    } catch (e) {
+      throw this.translateCacheIssue(e);
+    }
+  }
+
+  /**
+   * The resource cache raises its limits (CACHE_ID_DISCARDED_TOO_BIG, CACHE_REQUEST_TOO_BIG,
+   * CACHE_START_TOO_BIG) in English, with their parameters: put the message in the request's language
+   * @param {Error} e
+   * @returns {Error} e
+   */
+  translateCacheIssue(e) {
+    if (e && e.msgId && e.msgParams) {
+      e.message = this.i18n.translate(e.msgId, this.opContext.langs, e.msgParams);
+    }
+    return e;
+  }
+
   /**
    * Wrap a raw resource in its appropriate class wrapper
    * @param {Object} resource - Raw resource object

package/tx/xversion/xv-valueset.js

@@ -160,12 +160,15 @@ function valueSetR5ToR4(r5Obj) {
     if (exp.property && exp.property.length > 0) {
       exp.extension = exp.extension || [];
       for (let prop of exp.property) {
+        // uri is 0..1: a property without one (a provider that doesn't declare its properties)
+        // must not produce an empty uri extension, which is not valid
+        const ext = [{ url: "code", valueCode: prop.code }];
+        if (prop.uri) {
+          ext.push({ url: "uri", valueUri: prop.uri });
+        }
         exp.extension.push({
           url: "http://hl7.org/fhir/5.0/StructureDefinition/extension-ValueSet.expansion.property",
-          extension: [
-            { url: "code", valueCode: prop.code },
-            { url: "uri", valueUri: prop.uri }
-          ]
+          extension: ext
         });
       }
       delete exp.property;

package/utilities/submit-test-report.js

@@ -120,7 +120,9 @@ async function main() {
   console.log(`Submitting ${path.basename(opts.file)} (${report.result}, ${Array.isArray(report.test) ? report.test.length : 0} tests) to ${url}`);
   let res;
   try {
-    res = await fetch(url, { method: 'POST', headers, body });
+    // sent compact: the file is pretty-printed (about 1.7x the size), and the server limits
+    // the size of a report (npm.fhir.org: about 1.5 MB)
+    res = await fetch(url, { method: 'POST', headers, body: JSON.stringify(report) });
   } catch (e) {
     console.error(`Could not reach ${url}: ${e.cause ? e.cause.message : e.message}`);
     process.exit(1);