fhirsmith 0.18.1 → 1.0.0

package/tx/vs/vs-package.js

@@ -8,6 +8,8 @@ const { checkContained } = require('../library/canonical-resource');
 const { VersionUtilities } = require('../../library/version-utilities');
 const {validateParameter} = require("../../library/utilities");
 const { applyIdPrefix, stripIdPrefix } = require('../library/resource-ids');
+const { keepForPinnedReference } = require('../library/tho-precedence');
+const { waitForCache } = require('../library/wait-for-cache');
 
 /**
  * Package-based ValueSet provider using shared database layer
@@ -17,15 +19,19 @@ class PackageValueSetProvider extends AbstractValueSetProvider {
 
   /**
    * @param {PackageContentLoader} packageLoader - Path to the extracted package folder
+   * @param {Object} [options]
+   * @param {boolean} [options.readOnly] - a tx-worker (cluster.md): the cache is the master's; it
+   *   is opened read-only, waited for until the master has finished it, and never built or changed
    */
-  constructor(packageLoader) {
+  constructor(packageLoader, options = {}) {
     super();
     validateParameter(packageLoader, "packageLoader", PackageContentLoader);
     this.packageLoader = packageLoader;
     // -2: caches from before value sets were checked for active content in their narrative
     // are rebuilt (see initialize)
     this.dbPath = path.join(packageLoader.packageFolder, '.valuesets-2.db');
-    this.database = new ValueSetDatabase(this.dbPath);
+    this.readOnly = !!options.readOnly;
+    this.database = new ValueSetDatabase(this.dbPath, { readOnly: this.readOnly });
     this.valueSetMap = new Map();
     this.initialized = false;
     this.count = 0;
@@ -48,6 +54,13 @@ class PackageValueSetProvider extends AbstractValueSetProvider {
       return;
     }
     await this.packageLoader.initialize();
+    if (this.readOnly) {
+      await waitForCache(async () => (await this.database.exists()) && (await this.database.isComplete()),
+        `Package ${this.packageLoader.pid ? this.packageLoader.pid() : ''}: value set cache ${this.dbPath}`);
+      this.valueSetMap = await this.database.loadAllValueSets(this.sourcePackage());
+      this.#finishLoad();
+      return;
+    }
     await fs.rm(path.join(this.packageLoader.packageFolder, '.valuesets.db'), { force: true }); // the old cache
 
     // A cache is only used once its population finished. One that was cut short
@@ -76,7 +89,10 @@ class PackageValueSetProvider extends AbstractValueSetProvider {
       await this.#buildDatabase();
       this.valueSetMap = await this.database.loadAllValueSets(this.sourcePackage());
     }
+    this.#finishLoad();
+  }
 
+  #finishLoad() {
     // Mark each value set as cached as it enters the store: it is retained in
     // memory for the process lifetime, so its compose.include.filter elements
     // persist and a provider may memoise resolved filter analysis on them
@@ -267,7 +283,7 @@ class PackageValueSetProvider extends AbstractValueSetProvider {
 
         // Only process each ValueSet once (use URL to deduplicate)
         const vsUrl = json.url;
-        if (seen.has(vsUrl)) {
+        if (seen.has(vsUrl) || this.#excludedUrls.has(vsUrl)) {
           continue;
         }
 
@@ -291,6 +307,13 @@ class PackageValueSetProvider extends AbstractValueSetProvider {
               isMatch = false;
               break;
             }
+          } else if (param === 'version') {
+            // version-aware matching, on the version as asked for (not lower cased)
+            const asked = searchParams.find(sp => sp.name === 'version').value;
+            if (!VersionUtilities.versionSearchMatches(asked, json.version, VersionUtilities.versionAlgorithmOf(json))) {
+              isMatch = false;
+              break;
+            }
           } else if (param === 'jurisdiction') {
             // Special handling for jurisdiction - array of CodeableConcept
             if (!this._matchJurisdiction(json.jurisdiction, searchValue)) {
@@ -304,8 +327,9 @@ class PackageValueSetProvider extends AbstractValueSetProvider {
               break;
             }
           } else if (param === 'url') {
-            const propValue = json[param];
-            if (!this._matchValueFull(propValue, searchValue)) {
+            // a left match, on the url as asked for (not lower cased)
+            const asked = searchParams.find(sp => sp.name === 'url').value;
+            if (!(json.url || '').startsWith(asked)) {
               isMatch = false;
               break;
             }
@@ -460,35 +484,38 @@ class PackageValueSetProvider extends AbstractValueSetProvider {
     return this.#excludedUrls.size === 0 ? urls : urls.filter(url => !this.#excludedUrls.has(url));
   }
 
-  // the value sets left out by excludeUrls - by url, and by their own (unprefixed) id
+  // the value sets left out by keepPinnedOnly - by url, and by their own (unprefixed) id
   #excludedUrls = new Set();
   #excludedIds = new Set();
 
   /**
-   * Leave out the value sets with any of these urls: they can't be fetched, and they aren't
-   * found by search. The FHIR core package's value sets are left out where hl7.terminology
-   * provides the same url (see Provider.applyTHOPrecedence). Must be called once the
-   * provider is initialized - the database is shared, so it isn't changed.
+   * The value sets with these urls are hl7.terminology's to provide (see
+   * Provider.applyTHOPrecedence): from this (core) package they are only available to a
+   * reference that names their version, where THO doesn't provide that version itself. They
+   * aren't the default for their url, can't be read by id, aren't found by search or listed.
+   * Must be called once the provider is initialized - the database is shared, so it isn't
+   * changed.
    *
-   * @param {Set<string>} urls
+   * @param {Map<string, Set<string>>} thoVersions - url -> the versions hl7.terminology provides
    */
-  excludeUrls(urls) {
-    const excluded = new Set();
+  keepPinnedOnly(thoVersions) {
+    const affected = new Set();
     for (const vs of this.valueSetMap.values()) {
-      if (vs && urls.has(vs.url)) {
-        excluded.add(vs);
+      if (vs && thoVersions.has(vs.url)) {
+        affected.add(vs);
       }
     }
     for (const [key, vs] of [...this.valueSetMap]) {
-      if (excluded.has(vs)) {
+      if (affected.has(vs) && !keepForPinnedReference(key, vs, thoVersions.get(vs.url))) {
         this.valueSetMap.delete(key);
       }
     }
-    for (const vs of excluded) {
+    for (const vs of affected) {
       this.#excludedUrls.add(vs.url);
       this.#excludedIds.add(stripIdPrefix(vs.id, this.spaceId) ?? vs.id);
     }
   }
+
 }
 
 module.exports = {