fhirsmith 0.18.1 → 1.0.0

package/tx/workers/metadata.js

@@ -376,6 +376,8 @@ class MetadataHandler {
       }
     }
 
+    this.markDefaultVersions(provider, seenSystems);
+
     // Convert map to array and sort by URI
     const entries = Array.from(seenSystems.values());
     entries.sort((a, b) => (a.uri || '').localeCompare(b.uri || ''));
@@ -383,6 +385,39 @@ class MetadataHandler {
     return entries.length > 0 ? entries : undefined;
   }
 
+  /**
+   * Mark the version a request that names no version gets - the default - as isDefault. That's
+   * what getCodeSystemProvider() finds under the url alone: a native code system (factory) first,
+   * else the CodeSystem resource the provider keeps there (the most recent of the versions loaded,
+   * see Provider.addCodeSystem). A code system with only one version has that as its default,
+   * however it's held
+   */
+  markDefaultVersions(provider, seenSystems) {
+    for (const [url, entry] of seenSystems) {
+      if (!entry.version || entry.version.length === 0) {
+        continue;
+      }
+      let def = null;
+      const factory = provider && provider.codeSystemFactories ? provider.codeSystemFactories.get(url) : null;
+      if (factory) {
+        def = factory.version();
+      } else {
+        const cs = provider && provider.codeSystems ? provider.codeSystems.get(url) : null;
+        if (cs) {
+          def = cs.version || (cs.jsonObj && cs.jsonObj.version) || null;
+        }
+      }
+      if (!def && entry.version.length === 1) {
+        def = entry.version[0].code;
+      }
+      for (const v of entry.version) {
+        if (v.code === def) {
+          v.isDefault = true;
+        }
+      }
+    }
+  }
+
   /**
    * Add or update a code system entry
    * @param {Map} seenSystems - Map of URL to entry

package/tx/workers/search.js

@@ -7,6 +7,7 @@
 
 const { TerminologyWorker } = require('./worker');
 const {Utilities} = require("../../library/utilities");
+const { VersionUtilities } = require("../../library/version-utilities");
 const {debugLog} = require("../operation-context");
 const {acceptsHtml} = require("../tx-html");
 
@@ -116,6 +117,9 @@ class SearchWorker extends TerminologyWorker {
 
       // Sort results
       matches = this.sortResults(matches, sort);
+      if (summary !== 'count') {
+        matches = await this.loadPage(matches, offset, count);
+      }
 
       // Build and return the bundle
       const bundle = this.buildSearchBundle(
@@ -142,7 +146,7 @@ class SearchWorker extends TerminologyWorker {
     const searchParams = {};
     for (const [key, value] of Object.entries(params)) {
       if (!key.startsWith('_') && value && SearchWorker.ALLOWED_PARAMS.includes(key)) {
-        searchParams[key] = key == 'url' ? value : value.toLowerCase();
+        searchParams[key] = key == 'url' || key == 'version' ? value : value.toLowerCase();
       }
     }
 
@@ -266,6 +270,44 @@ class SearchWorker extends TerminologyWorker {
     return false;
   }
 
+  /**
+   * A provider that doesn't hold its resources in memory can return matches that only carry
+   * what a search is sorted by, and a load() that reads the resource (see VSACValueSetProvider):
+   * read the ones on this page. One that can't be read (it was rejected when it was parsed) is
+   * dropped, and the next match moves up onto the page; the total counts the dropped ones less.
+   * A rejected match on a page not asked for is still counted: rejected rows are rare, and
+   * finding out exactly which matches are good would mean reading all of them
+   */
+  async loadPage(matches, offset, count) {
+    let start = offset;
+    let end = Math.min(matches.length, offset + count);
+    while (start < end) {
+      this.deadCheck('search-load');
+      const page = [];
+      for (let i = start; i < end; i++) {
+        if (matches[i].load) {
+          page.push(i);
+        }
+      }
+      const loaded = await Promise.all(page.map(i => matches[i].load()));
+      let dropped = 0;
+      page.forEach((i, n) => {
+        matches[i] = loaded[n] || null;
+        if (!loaded[n]) {
+          dropped++;
+        }
+      });
+      if (dropped === 0) {
+        break;
+      }
+      // the matches after the page move up to fill it: read those
+      matches = matches.filter(m => m !== null);
+      start = end - dropped;
+      end = Math.min(matches.length, offset + count);
+    }
+    return matches;
+  }
+
   /**
    * Sort results by the specified field
    */
@@ -456,6 +498,11 @@ class SearchWorker extends TerminologyWorker {
               isMatch = false;
               break;
             }
+          } else if (param === 'version') { // version-aware matching
+            if (!VersionUtilities.versionSearchMatches(searchValue, json.version, VersionUtilities.versionAlgorithmOf(json))) {
+              isMatch = false;
+              break;
+            }
           } else if (param === 'url' || param === 'system') { // exact match
             const propValue = json.url;
             if (propValue !== searchValue) {
@@ -527,6 +574,11 @@ class SearchWorker extends TerminologyWorker {
             isMatch = false;
             break;
           }
+        } else if (param === 'version') { // version-aware matching
+          if (!VersionUtilities.versionSearchMatches(searchValue, json.version)) {
+            isMatch = false;
+            break;
+          }
         } else if (param === 'url' || param === 'system') { // exact match
           const propValue = json.url;
           if (propValue !== searchValue) {

package/tx/workers/supplement-filters.js

@@ -0,0 +1,145 @@
+const regexUtilities = require('../../library/regex-utilities');
+
+/**
+ * A value set filter on a property that a supplement in use defines, and the code system
+ * itself doesn't (catalog-group = renal-diabetes on LOINC, with a supplement that gives
+ * LOINC codes a catalog-group). The supplement says which codes have which values, so the
+ * filter is evaluated from the supplement, the same way whatever the code system and
+ * whichever provider serves it - the provider never sees the filter.
+ *
+ * A filter that selects codes the supplement lists (=, in, regex, exists = true) can drive
+ * an expansion on its own; one that selects codes by what the supplement doesn't say
+ * (not-in, exists = false) can only narrow what other filters select.
+ */
+class SupplementPropertyFilter {
+  /**
+   * @param {string} property
+   * @param {string} op
+   * @param {string} value
+   * @param {CodeSystem[]} supplements - the supplements in use that define the property
+   */
+  constructor(property, op, value, supplements) {
+    this.property = property;
+    this.op = op;
+    this.value = value;
+    this.values = new Map(); // code -> string[] (the property's values on that code)
+    for (const supplement of supplements) {
+      this.#scan(supplement.jsonObj.concept || []);
+    }
+    if (op === 'regex') {
+      this.regex = regexUtilities.compile('^(?:' + value + ')$'); // the whole value: a|b is ^(?:a|b)$, not ^a|b$
+    } else if (op === 'in' || op === 'not-in') {
+      this.list = value.split(',').map(s => s.trim());
+    }
+  }
+
+  #scan(concepts) {
+    for (const concept of concepts) {
+      for (const p of concept.property || []) {
+        if (p.code === this.property) {
+          const v = SupplementPropertyFilter.valueOf(p);
+          if (v !== null) {
+            if (!this.values.has(concept.code)) {
+              this.values.set(concept.code, []);
+            }
+            this.values.get(concept.code).push(v);
+          }
+        }
+      }
+      this.#scan(concept.concept || []);
+    }
+  }
+
+  /** the value of a CodeSystem.concept.property, as a string to compare with a filter value */
+  static valueOf(p) {
+    for (const [k, v] of Object.entries(p)) {
+      if (k.startsWith('value') && v !== undefined && v !== null) {
+        if (typeof v === 'object') {
+          return v.code !== undefined ? String(v.code) : null; // Coding
+        }
+        return String(v);
+      }
+    }
+    return null;
+  }
+
+  static ops() {
+    return ['=', 'in', 'not-in', 'regex', 'exists'];
+  }
+
+  /** whether the codes this filter selects are all codes the supplement lists */
+  get enumerable() {
+    return this.op !== 'not-in' && !(this.op === 'exists' && this.value === 'false');
+  }
+
+  #valueMatches(v) {
+    switch (this.op) {
+      case '=': return v === this.value;
+      case 'in': return this.list.includes(v);
+      case 'regex': return this.regex.test(v);
+      default: return false;
+    }
+  }
+
+  /** whether the code passes this filter */
+  matches(code) {
+    const vals = this.values.get(code) || [];
+    switch (this.op) {
+      case 'exists': return (vals.length > 0) === (this.value === 'true');
+      case 'not-in': return !vals.some(v => this.list.includes(v));
+      default: return vals.some(v => this.#valueMatches(v));
+    }
+  }
+
+  /** the codes this filter selects (only for an enumerable filter), in the supplement's order */
+  codes() {
+    return [...this.values.keys()].filter(code => this.matches(code));
+  }
+
+  toString() {
+    return this.property + ' ' + this.op + ' ' + this.value;
+  }
+}
+
+/**
+ * The supplement filter for a ValueSet filter on this code system, or null when the filter is
+ * the code system's own (it isn't on a property a supplement in use defines, or the code system
+ * does the filter itself, which takes precedence)
+ *
+ * @param {CodeSystemProvider} cs
+ * @param {Object} fc - the ValueSet.compose.include.filter
+ * @returns {Promise<SupplementPropertyFilter|null>}
+ */
+async function supplementFilter(cs, fc) {
+  const supplements = (cs.supplements || []).filter(s => (s.jsonObj.property || []).some(p => p.code === fc.property));
+  if (supplements.length === 0 || !SupplementPropertyFilter.ops().includes(fc.op) || !fc.value) {
+    return null;
+  }
+  if (await cs.doesFilter(fc.property, fc.op, fc.value)) {
+    return null;
+  }
+  return new SupplementPropertyFilter(fc.property, fc.op, fc.value, supplements);
+}
+
+/**
+ * Split a ValueSet include's filters into the code system's own, and those on properties
+ * that supplements define
+ *
+ * @param {CodeSystemProvider} cs
+ * @param {Object[]} filters
+ * @returns {Promise<{base: Object[], supplement: SupplementPropertyFilter[]}>}
+ */
+async function splitFilters(cs, filters) {
+  const result = { base: [], supplement: [] };
+  for (const fc of filters || []) {
+    const sf = await supplementFilter(cs, fc);
+    if (sf) {
+      result.supplement.push(sf);
+    } else {
+      result.base.push(fc);
+    }
+  }
+  return result;
+}
+
+module.exports = { SupplementPropertyFilter, supplementFilter, splitFilters };

package/tx/workers/translate.js

@@ -30,6 +30,14 @@ function elementComment(em) {
 // checkTargetConcepts leaves it alone. A symbol key, so it never reaches the JSON output
 const TRUSTED_TARGET = Symbol('trustedTarget');
 
+/** The source, for a message: quoted, unless it is already a description (see describeSourceSystem). */
+function quoteFrom(from) {
+  if (!from) {
+    return "'(unspecified)'";
+  }
+  return from.startsWith("'") ? from : `'${from}'`;
+}
+
 class TranslateWorker extends TerminologyWorker {
   /**
    * @param {OperationContext} opContext - Operation context
@@ -281,6 +289,9 @@ class TranslateWorker extends TerminologyWorker {
       }
     }
 
+    // the no-maps message names the source's version - which, for SNOMED CT, is the edition
+    this.sourceDescription = reverse ? null : await this.describeSourceSystem(coding, txp);
+
     // If no explicit concept map, we need to find one based on source/target
     if (conceptMaps.length == 0) {
       if (reverse) {
@@ -289,7 +300,24 @@ class TranslateWorker extends TerminologyWorker {
       } else {
         await this.findConceptMapsInAdditionalResources(conceptMaps, coding.system, sourceScope, targetScope, targetSystem);
         await this.provider.findConceptMapForTranslation(this.opContext, conceptMaps, coding.system, coding.version, sourceScope, targetScope, targetSystem, coding.code);
+        // targetScope with no targetSystem: the code systems (and versions) the value set draws
+        // on are the target systems - which is how implicit maps are found, since they belong
+        // to code systems, not value sets (a national SNOMED CT edition to the International
+        // Edition the value set is built on, say). What they produce is then held to the value
+        // set (see doTranslate)
+        if (targetScope && !targetSystem) {
+          for (const system of await this.systemsOfScope(targetScope)) {
+            // as the value set has it (system|version - what an implicit map into one SNOMED CT
+            // edition needs), and as the bare system (what a map's group.target usually is)
+            const targets = system.includes('|') ? [system, system.substring(0, system.indexOf('|'))] : [system];
+            for (const target of targets) {
+              await this.findConceptMapsInAdditionalResources(conceptMaps, coding.system, sourceScope, null, target);
+              await this.provider.findConceptMapForTranslation(this.opContext, conceptMaps, coding.system, coding.version, sourceScope, null, target, coding.code);
+            }
+          }
+        }
       }
+      conceptMaps = this.uniqueConceptMaps(conceptMaps);
     }
 
     // Whether the map was nominated or found, it only applies if the code is within its own
@@ -385,6 +413,7 @@ class TranslateWorker extends TerminologyWorker {
 
     let conceptMaps = [];
     conceptMaps.push(conceptMap);
+    this.sourceDescription = await this.describeSourceSystem(coding, txp);
 
     // 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.
@@ -1032,6 +1061,138 @@ class TranslateWorker extends TerminologyWorker {
     return inScope;
   }
 
+  /**
+   * The source's code system and version, for messages: system|version as given, or - when
+   * no version was given - the system, and the version the server takes it to be (the default
+   * edition, for SNOMED CT). Which version it is decides which maps apply.
+   * @returns {Promise<string>} quoted (see quoteFrom)
+   */
+  async describeSourceSystem(coding, params) {
+    if (!coding || !coding.system) {
+      return null;
+    }
+    if (coding.version) {
+      return `'${coding.system}|${coding.version}'`;
+    }
+    let version = null;
+    try {
+      const cs = await this.findCodeSystem(coding.system, '', params, ['complete', 'fragment'], null, true);
+      version = cs ? cs.version() : null;
+    } catch (e) {
+      version = null;
+    }
+    return version
+      ? `'${coding.system}' (no version given, so '${coding.system}|${version}')`
+      : `'${coding.system}' (no version given)`;
+  }
+
+  /**
+   * The code systems a value set draws on, as system|version when the include names a version:
+   * the targets to look for maps to when targetScope is given without targetSystem. Value sets
+   * it imports are looked into too (once each).
+   * @returns {Promise<string[]>}
+   */
+  async systemsOfScope(canonical, seen = new Set()) {
+    if (seen.has(canonical)) {
+      return [];
+    }
+    seen.add(canonical);
+    const vs = await this.resolveScopeValueSet(canonical, 'targetScope parameter');
+    const systems = new Set();
+    const compose = vs.jsonObj?.compose;
+    for (const inc of Array.isArray(compose?.include) ? compose.include : []) {
+      if (inc.system) {
+        systems.add(inc.version ? `${inc.system}|${inc.version}` : inc.system);
+      }
+      for (const imported of Array.isArray(inc.valueSet) ? inc.valueSet : []) {
+        try {
+          for (const s of await this.systemsOfScope(imported, seen)) {
+            systems.add(s);
+          }
+        } catch (e) {
+          // an import that can't be found doesn't stop the others: the membership check
+          // (doTranslate) will report it, if it matters
+        }
+      }
+    }
+    if (!compose) {
+      for (const c of Array.isArray(vs.jsonObj?.expansion?.contains) ? vs.jsonObj.expansion.contains : []) {
+        if (c.system) {
+          systems.add(c.version ? `${c.system}|${c.version}` : c.system);
+        }
+      }
+    }
+    return [...systems];
+  }
+
+  /** The candidate maps, each once (the same map can be found for more than one target). */
+  uniqueConceptMaps(conceptMaps) {
+    const seen = new Set();
+    const result = [];
+    for (const cm of conceptMaps) {
+      const key = cm.url ? `${cm.url}|${cm.version || ''}` : cm;
+      if (!seen.has(key)) {
+        seen.add(key);
+        result.push(cm);
+      }
+    }
+    return result;
+  }
+
+  /**
+   * targetScope "limits the scope of the $translate operation to target codes that are members
+   * of this value set": a match whose target concept isn't in it is dropped, and a message says
+   * so. A target that can't be checked against it is kept, with a note saying it wasn't checked.
+   *
+   * A target the code system produced itself can name a version the server doesn't hold: an
+   * edition to edition translation names the release of the International Edition that the
+   * national edition was built on, and the server may have another release, or none on its own.
+   * Then it is checked as a code of the edition (the version without its date - whichever
+   * release of it the server has, and what an include that names the edition means), with a
+   * note saying so; and if the server doesn't have the edition either, it is kept, unchecked.
+   */
+  async holdToTargetScope(result, targetScope, params) {
+    const dropped = [];
+    for (let i = result.length - 1; i >= 0; i--) {
+      const match = result[i];
+      if (match.name !== 'match' || !Array.isArray(match.part)) {
+        continue;
+      }
+      const concept = match.part.find(p => p.name === 'concept')?.valueCoding;
+      if (!concept || !concept.system || !concept.code) {
+        continue;
+      }
+      let coding = concept;
+      if (concept.version && !(await this.resolveCode(concept.system, concept.version, concept.code, params)).known) {
+        const edition = concept.version.includes('/version/') ? concept.version.substring(0, concept.version.indexOf('/version/')) : null;
+        if (edition && (await this.resolveCode(concept.system, edition, concept.code, params)).known) {
+          coding = { system: concept.system, version: edition, code: concept.code };
+          match.part.push({ name: 'note', valueString: `Checked against the target scope '${targetScope}' as a code of '${edition}': '${concept.version}' is not available on this server` });
+        } else {
+          match.part.push({ name: 'note', valueString: `'${concept.system}#${concept.code}' could not be checked against the target scope '${targetScope}': '${concept.version}' is not available on this server` });
+          continue;
+        }
+      }
+      let inScope;
+      try {
+        inScope = await this.codeInScope(targetScope, coding, params, 'targetScope parameter');
+      } catch (e) {
+        match.part.push({ name: 'note', valueString: `'${concept.system}#${concept.code}' could not be checked against the target scope '${targetScope}' (${e.message})` });
+        continue;
+      }
+      if (!inScope) {
+        const key = `${concept.system}#${concept.code}`;
+        if (!dropped.includes(key)) {
+          dropped.unshift(key);
+        }
+        result.splice(i, 1);
+      }
+    }
+    if (dropped.length > 0) {
+      result.push({ name: 'message', valueString: `${dropped.length === 1 ? 'A translation was' : `${dropped.length} translations were`} left out because ${dropped.length === 1 ? 'it is' : 'they are'} not in the target scope '${targetScope}': ${dropped.join(', ')}` });
+    }
+  }
+
   /**
    * 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,
@@ -1041,11 +1202,11 @@ class TranslateWorker extends TerminologyWorker {
   noMapsResponse(coding, sourceScope, targetScope, targetSystem, reverse, message, anyScoped) {
     let text = message;
     if (!text) {
-      const from = reverse ? (targetSystem || sourceScope) : coding.system;
+      const from = reverse ? (targetSystem || sourceScope) : (this.sourceDescription || 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)'}'`;
+        ? `No ConceptMap that translates from ${quoteFrom(from)} to '${to || '(unspecified)'}' has '${coding.system}#${coding.code}' in scope`
+        : `No ConceptMap is available to translate from ${quoteFrom(from)} to '${to || '(unspecified)'}'`;
     }
     return {
       resourceType: 'Parameters',
@@ -1128,6 +1289,9 @@ class TranslateWorker extends TerminologyWorker {
       // 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)
       await this.checkTargetConcepts(result, params);
+      if (targetScope && !reverse) {
+        await this.holdToTargetScope(result, targetScope, params);
+      }
       const translated = added && result.some(p => p.name === 'match' && this.isPositiveMatch(p));
       result.push({
         name: 'result',
@@ -1177,7 +1341,8 @@ class TranslateWorker extends TerminologyWorker {
     if (!system || !code) {
       return { known: false };
     }
-    this.deadCheck('translate-resolve');
+    // called per element: a turn for the event loop now and then, so a client that has gone is seen
+    await this.checkAndYield('translate-resolve');
     let cs;
     try {
       cs = await this.findCodeSystem(system, version || '', params, ['complete', 'fragment'], null, true);