fhirsmith 0.18.1 → 1.0.0

package/tx/library/renderer.js

@@ -23,14 +23,28 @@ const VALID_CONCEPTMAP_EQUIVALENCES = new Set([
 const VALID_CODESYSTEM_CONTENT = new Set([
   'not-present', 'example', 'fragment', 'complete', 'supplement'
 ]);
+// How many of an include's listed codes displayValueSetInclude writes out before
+// summarising the rest as a count.
+const MAX_INCLUDE_CODES_SHOWN = 20;
+
 const VALID_PUBLICATION_STATUS = new Set(['draft', 'active', 'retired', 'unknown']);
 
+/**
+ * How many of the codes a ValueSet.compose include (or exclude) lists are rendered by
+ * default. Past this, the list ends with a line saying how many more there are and, when
+ * the renderer has been given showAllCodesHref, a link to the page with all of them.
+ * VSAC's Medication Brand Name lists 33,341 codes in one include.
+ */
+const MAX_RENDERED_INCLUDE_CODES = 500;
+
 /**
  * @typedef {Object} TerminologyLinkResolver
  * @property {function(OperationContext, string, string=): {description: string, link: string}|null} resolveURL
  *   Given a URL and optional version, returns description and link, or null if not found
  * @property {function(OperationContext, string, string, string=): {display: string, link: string}|null} resolveCode
  *   Given a URL, code, and optional version, returns display and link, or null if not found
+ * @property {function(OperationContext, string, string, string[]): Array<{description: string, link: string}|null>} [resolveCodes]
+ *   resolveCode for many codes of one code system, in their order; used where present
  */
 
 class Renderer {
@@ -38,6 +52,10 @@ class Renderer {
   constructor(opContext, linkResolver = null) {
     this.opContext = opContext;
     this.linkResolver = linkResolver;
+    /** How many codes of an include to render; null renders them all. */
+    this.includeCodeLimit = MAX_RENDERED_INCLUDE_CODES;
+    /** Where "Show all" goes when an include is cut short; null for no link. */
+    this.showAllCodesHref = null;
   }
 
   displayCoded(...args) {
@@ -108,22 +126,21 @@ class Renderer {
     return '[' + result + ']';
   }
 
+  /**
+   * A one-line summary of a compose include/exclude, for the operation log and the
+   * $validate-code diagnostics. An include that lists many codes is summarised: the
+   * first MAX_INCLUDE_CODES_SHOWN codes, then how many more there are. (Written in
+   * full, a 33,000-code include is a ~250 KB string, built and kept for every
+   * validation against the value set.)
+   */
   displayValueSetInclude(inc) {
     let result;
     if (inc.system) {
       result = '(' + inc.system + ')';
       if (inc.concept) {
-        result = result + '(';
-        let first = true;
-        for (const cc of inc.concept) {
-          if (first) {
-            first = false;
-          } else {
-            result = result + ',';
-          }
-          result = result + cc.code;
-        }
-        result = result + ')';
+        const shown = inc.concept.slice(0, MAX_INCLUDE_CODES_SHOWN).map(cc => cc.code).join(',');
+        const more = inc.concept.length - MAX_INCLUDE_CODES_SHOWN;
+        result = result + '(' + shown + (more > 0 ? ',... +' + more + ' more (' + inc.concept.length + ' codes)' : '') + ')';
       }
       if (inc.filter) {
         result = result + '(';
@@ -297,6 +314,7 @@ class Renderer {
         span.tx(value);
         let btn = span.button();
         btn.attr("class", "btn-copy");
+        btn.attr("aria-label", "Copy");
         btn.attr("data-clipboard-text", value);
         btn.attr("data-original-title", this.translate('GENERAL_COPY'));
       }
@@ -631,15 +649,15 @@ class Renderer {
     this._requireAllowed(vs.status, VALID_PUBLICATION_STATUS, 'ValueSet.status', 'invalid status');
 
     let div_ = div();
-    div_.h2().tx("Properties");
+    div_.h4().tx("Properties");
     let tbl = div_.table("grid");
     await this.renderMetadataTable(vs, tbl);
     if (vs.compose) {
-      div_.h2().tx("Logical Definition");
+      div_.h4().tx("Logical Definition");
       await this.renderCompose(vs, div_.table("grid"));
     }
     if (vs.expansion) {
-      div_.h2().tx("Expansion");
+      div_.h4().tx("Expansion");
       await this.renderExpansion(div_, vs, tbl);
     }
 
@@ -726,8 +744,14 @@ class Renderer {
         const ul = li.ul();
         for (let c of inc.concept) {
           this._requireValidCode(c.code, 'ValueSet.compose.include.concept.code');
+        }
+        const limit = this.includeCodeLimit;
+        const shown = limit != null && inc.concept.length > limit ? inc.concept.slice(0, limit) : inc.concept;
+        const links = await this.resolveIncludeCodes(inc, shown);
+        for (let i = 0; i < shown.length; i++) {
+          const c = shown[i];
+          const link = links[i];
           const li = ul.li();
-          const link = this.linkResolver ? await this.linkResolver.resolveCode(this.opContext, inc.system, inc.version, c.code) : null;
           if (link) {
             li.ah(link.link).tx(c.code);
           } else {
@@ -739,6 +763,15 @@ class Renderer {
             li.span("opaque: 0.5").tx(": "+link.description);
           }
         }
+        if (shown.length < inc.concept.length) {
+          const more = inc.concept.length - shown.length;
+          const li = ul.li();
+          li.i().tx(`\u2026 and ${more.toLocaleString('en-US')} more code${more === 1 ? '' : 's'}.`);
+          if (this.showAllCodesHref) {
+            li.tx(" ");
+            li.ah(this.showAllCodesHref).tx("Show all");
+          }
+        }
       } else {
         li.tx(this.translate('VALUE_SET_CODES_FROM')+" ");
         await this.renderLink(li,inc.system+(inc.version ? "|"+inc.version : ""));
@@ -777,6 +810,29 @@ class Renderer {
     }
   }
 
+  /**
+   * The link and description for each of the codes of an include that are shown, in one
+   * request to the link resolver for the include's code system where it can take one.
+   *
+   * @param {Object} inc the include
+   * @param {Object[]} concepts the include's concepts being rendered
+   * @returns {Promise<Array<{link: string, description: string}|null>>}
+   */
+  async resolveIncludeCodes(inc, concepts) {
+    if (!this.linkResolver || concepts.length === 0) {
+      return concepts.map(() => null);
+    }
+    const codes = concepts.map((c) => c.code);
+    if (this.linkResolver.resolveCodes) {
+      return await this.linkResolver.resolveCodes(this.opContext, inc.system, inc.version, codes);
+    }
+    const links = [];
+    for (const code of codes) {
+      links.push(await this.linkResolver.resolveCode(this.opContext, inc.system, inc.version, code));
+    }
+    return links;
+  }
+
   async generateProperties(x, cs) {
     if (!cs.property || cs.property.length === 0) {
       return false;
@@ -1389,7 +1445,7 @@ class Renderer {
     let div_ = div();
     let tbl;
     if (showProps) {
-      div_.h2().tx("Expansion Properties");
+      div_.h3().tx("Expansion Properties");
       tbl = div_.table("grid");
     } else {
       tbl = div(); // dummy
@@ -1828,7 +1884,7 @@ class Renderer {
 
     // Formats
     if (cs.format && cs.format.length > 0) {
-      div_.h3().tx(this.translate('Formats') || 'Formats');
+      div_.h4().tx(this.translate('Formats') || 'Formats');
       div_.para().tx(cs.format.join(', '));
     }
 
@@ -2098,7 +2154,7 @@ class Renderer {
 
     // Code Systems
     if (tc.codeSystem && tc.codeSystem.length > 0) {
-      div_.h3().tx('Code Systems');
+      div_.h4().tx('Code Systems');
       const ul = div_.ul();
       for (const cs of tc.codeSystem) {
         if (cs.uri) {
@@ -2192,10 +2248,10 @@ class Renderer {
     let div_ = div();
 
     // Metadata table
-    div_.h3().tx("Properties");
+    div_.h4().tx("Properties");
     await this.renderMetadataTable(cm, div_.table("grid"));
 
-    div_.h3("Mapping Details");
+    div_.h4("Mapping Details");
     // Source/Target scope line (mirrors Java: CONC_MAP_FROM / CONC_MAP_TO)
     const p = div_.para();
     p.tx(this.translate('CONC_MAP_FROM') + " ");
@@ -2769,4 +2825,4 @@ class Renderer {
 
 }
 
-module.exports = { Renderer, VALID_FILTER_OPS };
+module.exports = { Renderer, VALID_FILTER_OPS, MAX_RENDERED_INCLUDE_CODES, MAX_INCLUDE_CODES_SHOWN };

package/tx/library/sqlite-utilities.js

@@ -0,0 +1,2 @@
+// moved to library/sqlite-utilities.js, so that every module can use it
+module.exports = require('../../library/sqlite-utilities');

package/tx/library/tho-precedence.js

@@ -0,0 +1,40 @@
+//
+// THO precedence for value sets and concept maps (see Provider.applyTHOPrecedence).
+//
+// Where hl7.terminology provides a resource with the same url as one in the FHIR core
+// package, THO's copy is the one used - versions were reset when content moved to THO, so
+// version order can't decide. But the core copy is still what a reference that names its
+// version (url|5.0.0) means, so it stays available to that reference, and only to it.
+//
+
+const { VersionUtilities } = require('../../library/version-utilities');
+
+/**
+ * Whether a package provider should keep a map key for a resource that THO also provides.
+ * Only the keys that name a version are kept - url|version, and url|major.minor for a
+ * semver version - and only where THO doesn't provide that version itself. The bare url
+ * (the default for a reference with no version) and the resource's id are not kept.
+ *
+ * @param {string} key - the map key
+ * @param {{url: string, version: string}} resource - the core package's resource
+ * @param {Set<string>} thoVersions - the versions of the url that hl7.terminology provides
+ * @returns {boolean}
+ */
+function keepForPinnedReference(key, resource, thoVersions) {
+  const version = resource.version;
+  if (!version) {
+    return false;
+  }
+  if (key === resource.url + '|' + version) {
+    return !thoVersions.has(version);
+  }
+  if (VersionUtilities.isSemVer(version)) {
+    const mm = VersionUtilities.getMajMin(version);
+    if (mm && key === resource.url + '|' + mm) {
+      return ![...thoVersions].some(v => v && VersionUtilities.isSemVer(v) && VersionUtilities.getMajMin(v) === mm);
+    }
+  }
+  return false;
+}
+
+module.exports = { keepForPinnedReference };

package/tx/library/ucum-parsers.js

@@ -185,6 +185,11 @@ class Lexer {
 }
 
 // Expression parser for UCUM unit expressions (port of ExpressionParser.java)
+// A UCUM expression parses into a chain of Terms, one level per operator and per bracket, and
+// the parser and every walker of the result recurse along that chain. Bound it so that a hostile
+// unit is a clean error rather than a RangeError (stack overflow). Real units have a few terms.
+const MAX_UCUM_TERMS = 100;
+
 class ExpressionParser {
   constructor(model) {
     this.model = model;
@@ -192,6 +197,7 @@ class ExpressionParser {
 
   parse(code) {
     const lexer = new Lexer(code);
+    this.terms = 0;
     const res = this._parseTerm(lexer, true);
 
     if (!lexer.finished()) {
@@ -202,6 +208,9 @@ class ExpressionParser {
   }
 
   _parseTerm(lexer, first) {
+    if (++this.terms > MAX_UCUM_TERMS) {
+      lexer.error(`The unit has more than ${MAX_UCUM_TERMS} terms and brackets`);
+    }
     const res = new Term();
 
     if (first && lexer.getType() === TokenType.NONE) {
@@ -1026,5 +1035,6 @@ module.exports = {
   UcumEssenceParser,
   Search,
   Converter,
-  UcumValidator
+  UcumValidator,
+  MAX_UCUM_TERMS
 };

package/tx/library/wait-for-cache.js

@@ -0,0 +1,43 @@
+/**
+ * A tx-worker (cluster.md) only reads the package caches the master builds. Until the master
+ * has finished one - normally it has, since the workers start once it is ready - the worker
+ * waits for it, and gives up with a clear error rather than building it itself.
+ *
+ * @module tx/library/wait-for-cache
+ */
+
+// how long a worker waits for the master to finish a cache, and how often it looks
+const DEFAULT_WAIT_MS = 5 * 60 * 1000;
+const POLL_MS = 500;
+
+/**
+ * Resolve once isReady() says true; reject if it hasn't within waitMs.
+ *
+ * @param {function(): Promise<boolean>} isReady
+ * @param {string} what - the cache, for the messages
+ * @param {Object} [options]
+ * @param {number} [options.waitMs] - default DEFAULT_WAIT_MS, or FHIRSMITH_CACHE_WAIT_MS
+ * @returns {Promise<void>}
+ */
+async function waitForCache(isReady, what, options = {}) {
+  const waitMs = options.waitMs ?? (Number(process.env.FHIRSMITH_CACHE_WAIT_MS) || DEFAULT_WAIT_MS);
+  const start = Date.now();
+  let logged = false;
+  for (;;) {
+    if (await isReady()) {
+      return;
+    }
+    if (Date.now() - start >= waitMs) {
+      throw new Error(`${what} is not ready after ${Math.round(waitMs / 1000)} s. A tx-worker only reads it; ` +
+        'the master builds it: start the master first, and the workers once it answers /health (cluster.md)');
+    }
+    if (!logged) {
+      logged = true;
+      require('../../library/logger').getInstance().child({ module: 'tx' })
+        .warn(`${what} is missing, incomplete or not yet migrated: waiting for the master to finish it`);
+    }
+    await new Promise(resolve => setTimeout(resolve, POLL_MS));
+  }
+}
+
+module.exports = { waitForCache };