fhirsmith 0.13.4 → 0.14.0

package/tx/html/codesystem-operations.liquid

@@ -1,3 +1,17 @@
+<!-- Text Search: the whole code system as an anonymous value set, expanded with the
+     text as the filter parameter. This is what a person opening a code system usually
+     wants - "is there a code for X" - so it comes first. -->
+<div class="operation-form" style="margin-bottom: 15px;">
+  <strong>Text Search</strong>
+  <form method="post" action="{{ expandUrl }}" id="{{ searchId }}_form"
+        data-system="{{ url }}" data-version="{{ systemVersion }}"
+        style="display: inline-block; margin-left: 10px;" onsubmit="return txSearchSubmit('{{ searchId }}')">
+    <input type="text" name="filter" placeholder="Text" size="30"/>
+    <button type="submit" class="btn btn-sm btn-primary">Search</button>
+  </form>
+  <div id="{{ searchId }}_preview" style="display: none; margin-left: 10px; margin-top: 8px;"></div>
+</div>
+
 <div class="operation-form" style="margin-bottom: 15px;">
   <strong>Lookup</strong>
   <form method="get" action="$lookup" style="display: inline-block; margin-left: 10px;">
@@ -16,3 +30,166 @@
     <button type="submit" class="btn btn-sm btn-primary">Subsumes</button>
   </form>
 </div>
+
+
+<!-- Filter: builds a throwaway ValueSet (uuid url, one include for this code system carrying
+     every filter row) and posts it to $expand, replacing the page with the rendered expansion. -->
+<div class="operation-form" style="margin-bottom: 15px;">
+  <strong>Filter</strong>
+  <form method="post" action="{{ expandUrl }}" id="{{ filterId }}_form"
+        data-system="{{ url }}" data-version="{{ systemVersion }}"
+        style="margin-left: 10px; margin-top: 5px;" onsubmit="return txFilterSubmit('{{ filterId }}')">
+    <datalist id="{{ filterId }}_props">{{ filterPropertyOptions }}</datalist>
+    <table class="grid" cellpadding="0" cellspacing="0">
+      <thead>
+        <tr><th>Property</th><th>Operation</th><th>Value</th><th></th></tr>
+      </thead>
+      <tbody id="{{ filterId }}_rows">
+        <tr>
+          <td><input type="text" name="property" list="{{ filterId }}_props" size="24" autocomplete="off"/></td>
+          <td><select name="op">{{ filterOpOptions }}</select></td>
+          <td><input type="text" name="value" size="24"/></td>
+          <td><button type="button" class="btn btn-sm" title="Remove this filter" onclick="txFilterRemoveRow(this)">&#215;</button></td>
+        </tr>
+      </tbody>
+    </table>
+    <button type="button" class="btn btn-sm" onclick="txFilterAddRow('{{ filterId }}')">Add Filter</button>
+    <button type="submit" class="btn btn-sm btn-primary">Expand</button>
+  </form>
+  <div id="{{ filterId }}_preview" style="display: none; margin-left: 10px; margin-top: 8px;"></div>
+</div>
+
+<script>
+// The two forms on this tab that expand something both do the same thing: build an
+// anonymous value set over the code system being viewed and post it to $expand, then
+// replace the page with whatever comes back. They differ only in what they put on the
+// include (nothing, for a text search) and what they put on the request (the filter).
+
+function txOpMessage(id, text) {
+  var preview = document.getElementById(id + '_preview');
+  preview.textContent = text;
+  preview.style.display = 'block';
+  return false;
+}
+
+function txOpUuid() {
+  if (window.crypto && typeof crypto.randomUUID === 'function') {
+    return crypto.randomUUID();
+  }
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+    var r = Math.random() * 16 | 0;
+    return (c === 'x' ? r : ((r & 0x3) | 0x8)).toString(16);
+  });
+}
+
+// One include, so that filters are ANDed. The value set exists only for the duration of
+// the expansion - it is never stored - so its url is a uuid.
+function txOpBuildValueSet(form, filters) {
+  var include = { system: form.dataset.system };
+  if (form.dataset.version) {
+    include.version = form.dataset.version;
+  }
+  if (filters && filters.length > 0) {
+    include.filter = filters.map(function (f) {
+      return { property: f.property, op: f.op, value: f.value };
+    });
+  }
+  return {
+    resourceType: 'ValueSet',
+    // Marks the value set as one that exists only for this request, so that the server
+    // renders the expansion rather than a summary of a value set nobody can look up.
+    extension: [{ url: 'http://healthintersections.com.au/fhirsmith/StructureDefinition/valueset-transient', valueBoolean: true }],
+    url: 'urn:uuid:' + txOpUuid(),
+    status: 'active',
+    compose: { include: [include] }
+  };
+}
+
+// The value set goes in the body; anything that is an expansion parameter rather than
+// part of the value set goes on the query, which $expand reads either way.
+function txOpExpand(id, form, valueSet, params) {
+  var url = new URL(form.getAttribute('action'), window.location.href);
+  // The definition has to come back for the transient marker and the filters to survive
+  // the expansion - $expand drops both along with the rest of the definition otherwise.
+  url.searchParams.set('includeDefinition', 'true');
+  for (var name in params || {}) {
+    url.searchParams.set(name, params[name]);
+  }
+  txOpMessage(id, 'Expanding...');
+  fetch(url.toString(), {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/fhir+json', 'Accept': 'text/html' },
+    body: JSON.stringify(valueSet)
+  }).then(function (response) {
+    return response.text();
+  }).then(function (html) {
+    document.open();
+    document.write(html);
+    document.close();
+  }).catch(function (err) {
+    txOpMessage(id, 'Expansion failed: ' + err.message);
+  });
+  return false;
+}
+
+function txSearchSubmit(id) {
+  var form = document.getElementById(id + '_form');
+  var text = form.querySelector('input[name="filter"]').value.trim();
+  if (text === '') {
+    return txOpMessage(id, 'Enter some text to search for.');
+  }
+  return txOpExpand(id, form, txOpBuildValueSet(form, null), { filter: text });
+}
+
+function txFilterClearRow(row) {
+  row.querySelectorAll('input').forEach(function (input) { input.value = ''; });
+  row.querySelectorAll('select').forEach(function (select) { select.selectedIndex = 0; });
+}
+
+function txFilterAddRow(id) {
+  var rows = document.getElementById(id + '_rows');
+  var row = rows.rows[0].cloneNode(true);
+  txFilterClearRow(row);
+  rows.appendChild(row);
+}
+
+function txFilterRemoveRow(btn) {
+  var row = btn.closest('tr');
+  var rows = row.parentNode;
+  if (rows.rows.length > 1) {
+    rows.removeChild(row);
+  } else {
+    txFilterClearRow(row);
+  }
+}
+
+// Every row that has anything in it. Rows left entirely blank are ignored, so an unused
+// extra row does not stop the expansion; a half-filled one is an error the user must fix.
+function txFilterCollect(id) {
+  var filters = [];
+  var rows = document.getElementById(id + '_rows').rows;
+  for (var i = 0; i < rows.length; i++) {
+    var property = rows[i].querySelector('input[name="property"]').value.trim();
+    var op = rows[i].querySelector('select[name="op"]').value;
+    var value = rows[i].querySelector('input[name="value"]').value.trim();
+    if (property !== '' || value !== '') {
+      filters.push({ row: i + 1, property: property, op: op, value: value });
+    }
+  }
+  return filters;
+}
+
+function txFilterSubmit(id) {
+  var form = document.getElementById(id + '_form');
+  var filters = txFilterCollect(id);
+  if (filters.length === 0) {
+    return txOpMessage(id, 'No filters specified.');
+  }
+  for (var i = 0; i < filters.length; i++) {
+    if (filters[i].property === '' || filters[i].value === '') {
+      return txOpMessage(id, 'Filter ' + filters[i].row + ' needs both a property and a value.');
+    }
+  }
+  return txOpExpand(id, form, txOpBuildValueSet(form, filters), null);
+}
+</script>

package/tx/html/ecl-panel.liquid

@@ -0,0 +1,93 @@
+<p>Expand a SNOMED CT expression constraint. The expression is run as a value set that
+  composes SNOMED CT with a <code>constraint</code> filter; the result appears below, and
+  the inputs stay where they are so the expression can be adjusted and run again.</p>
+
+{% if hasVersions %}
+<div class="operation-form" style="margin-bottom: 15px;">
+  <form id="{{ eclId }}_form" action="{{ expandUrl }}" data-system="{{ system }}"
+        data-transient="{{ transientExtension }}" onsubmit="return eclRun('{{ eclId }}')">
+    <table class="grid" cellpadding="0" cellspacing="0" style="width: 100%;">
+      <tr>
+        <td style="width: 100%;">ECL: <input type="text" name="ecl" id="{{ eclId }}_ecl" size="80"
+              style="width: 90%;" autocomplete="off" placeholder="&lt; 404684003 |Clinical finding|"/></td>
+      </tr>
+      <tr>
+        <td>Edition: <select name="version" id="{{ eclId }}_version">{{ versionOptions }}</select>
+          <button type="submit" class="btn btn-sm btn-primary" id="{{ eclId }}_go">Go</button>
+        </td>
+      </tr>
+    </table>
+  </form>
+</div>
+
+<div id="{{ eclId }}_results"></div>
+
+<script>
+function eclUuid() {
+  if (window.crypto && typeof crypto.randomUUID === 'function') {
+    return crypto.randomUUID();
+  }
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+    var r = Math.random() * 16 | 0;
+    return (c === 'x' ? r : ((r & 0x3) | 0x8)).toString(16);
+  });
+}
+
+function eclMessage(id, text) {
+  document.getElementById(id + '_results').innerHTML = '';
+  var p = document.createElement('p');
+  p.textContent = text;
+  document.getElementById(id + '_results').appendChild(p);
+  return false;
+}
+
+// The expansion comes back as a fragment rather than a page, so it can go straight under
+// the inputs. An error arrives the same way - as the rendered OperationOutcome - which is
+// the point: an ECL is usually wrong several times before it is right, and the message
+// belongs next to the expression that caused it.
+function eclRun(id) {
+  var form = document.getElementById(id + '_form');
+  var ecl = document.getElementById(id + '_ecl').value.trim();
+  var version = document.getElementById(id + '_version').value;
+  var go = document.getElementById(id + '_go');
+
+  if (ecl === '') {
+    return eclMessage(id, 'Enter an expression constraint.');
+  }
+
+  var valueSet = {
+    resourceType: 'ValueSet',
+    extension: [{ url: form.dataset.transient, valueBoolean: true }],
+    url: 'urn:uuid:' + eclUuid(),
+    status: 'active',
+    compose: {
+      include: [{
+        system: form.dataset.system,
+        version: version,
+        filter: [{ property: 'constraint', op: '=', value: ecl }]
+      }]
+    }
+  };
+
+  eclMessage(id, 'Expanding...');
+  go.disabled = true;
+  fetch(form.getAttribute('action'), {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/fhir+json', 'Accept': 'text/html' },
+    body: JSON.stringify(valueSet)
+  }).then(function (response) {
+    return response.text();
+  }).then(function (html) {
+    document.getElementById(id + '_results').innerHTML = html;
+  }).catch(function (err) {
+    eclMessage(id, 'Expansion failed: ' + err.message);
+  }).then(function () {
+    go.disabled = false;
+  });
+  return false;
+}
+</script>
+{% else %}
+<p><em>This endpoint has no SNOMED CT editions loaded, so there is nothing to run an
+  expression constraint against.</em></p>
+{% endif %}

package/tx/html/home-metrics.liquid

@@ -4,8 +4,8 @@
     <canvas id="memoryChart" height="200"></canvas>
   </div>
   <div style="flex: 1;">
-    <h6>Expansion Cache</h6>
-    <canvas id="cacheChart" height="200"></canvas>
+    <h6>Requests per Minute</h6>
+    <canvas id="requestChart" height="200"></canvas>
   </div>
   <div style="flex: 1;">
     <h6>Turnaround Time</h6>
@@ -13,18 +13,18 @@
   </div>
 </div>
 <div style="display: flex; gap: 20px; margin-bottom: 20px;">
-  <div style="flex: 1;">
-    <h6>Requests per Minute</h6>
-    <canvas id="requestChart" height="200"></canvas>
-  </div>
   <div style="flex: 1;">
     <h6>Client Cache</h6>
     <canvas id="clientCacheChart" height="200"></canvas>
   </div>
   <div style="flex: 1;">
-    <h6>Node Blocking</h6>
+    <h6>Node Blocking (mean)</h6>
     <canvas id="blockChart" height="200"></canvas>
   </div>
+  <div style="flex: 1;">
+    <h6>Node Blocking (max)</h6>
+    <canvas id="blockMaxChart" height="200"></canvas>
+  </div>
 </div>
 
 <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
@@ -99,36 +99,6 @@
     }
   });
 
-  // Expansion cache chart
-  new Chart(document.getElementById('cacheChart'), {
-    type: 'line',
-    data: {
-      labels: historyData.map(d => formatTime(d.time)),
-      datasets: [{
-        data: historyData.map(d => d.expansion),
-        borderColor: '#7b7b7b',
-        backgroundColor: 'rgba(123, 123, 123, 0.1)',
-        fill: true,
-        tension: 0.3,
-        pointRadius: 2
-      }]
-    },
-    options: {
-      ...chartOptions,
-      scales: {
-        ...chartOptions.scales,
-        y: {
-          ...chartOptions.scales.y,
-          title: {
-            display: true,
-            text: 'Expansion cache # items'
-          }
-        }
-      }
-    }
-  });
-
-
   // Tat chart
   new Chart(document.getElementById('tatChart'), {
     type: 'line',
@@ -215,48 +185,41 @@
       }
     }
   });
-  // Blocking chart
-  new Chart(document.getElementById('blockChart'), {
-    type: 'line',
-    data: {
-      labels: historyData.map(d => formatTime(d.time)),
-      datasets: [{
-        label: 'mean',
-        data: historyData.map(d => d.block),
-        borderColor: '#2845a7',
-        backgroundColor: 'rgba(40, 69, 167, 0.1)',
-        fill: true,
-        tension: 0.3,
-        pointRadius: 2
-      }, {
-        // Worst single event-loop stall in the window: the mean dilutes a
-        // multi-second block into noise, so this is the line that shows
-        // request-freezing stalls.
-        label: 'max',
-        data: historyData.map(d => d.blockMax),
-        borderColor: '#a72828',
-        fill: false,
-        tension: 0.3,
-        pointRadius: 2
-      }]
-    },
-    options: {
-      ...chartOptions,
-      plugins: {
-        ...chartOptions.plugins,
-        legend: { display: true }
+  // Blocking charts. Mean and max are separate charts because they are on different
+  // scales: a multi-second stall puts max in the thousands of ms while the mean sits at
+  // a few ms, so on one chart the mean is a flat line along the bottom.
+  function blockChart(id, field, colour, fill) {
+    new Chart(document.getElementById(id), {
+      type: 'line',
+      data: {
+        labels: historyData.map(d => formatTime(d.time)),
+        datasets: [{
+          data: historyData.map(d => d[field]),
+          borderColor: colour,
+          backgroundColor: fill,
+          fill: true,
+          tension: 0.3,
+          pointRadius: 2
+        }]
       },
-      scales: {
-        ...chartOptions.scales,
-        y: {
-          ...chartOptions.scales.y,
-          title: {
-            display: true,
-            text: 'ms'
+      options: {
+        ...chartOptions,
+        scales: {
+          ...chartOptions.scales,
+          y: {
+            ...chartOptions.scales.y,
+            title: {
+              display: true,
+              text: 'ms'
+            }
           }
         }
       }
-    }
-  });
+    });
+  }
+  // the average event-loop delay over each interval
+  blockChart('blockChart', 'block', '#2845a7', 'rgba(40, 69, 167, 0.1)');
+  // the worst single stall in each interval: the one that shows request-freezing blocks
+  blockChart('blockMaxChart', 'blockMax', '#a72828', 'rgba(167, 40, 40, 0.1)');
 })();
 </script>

package/tx/html/tx-template.html

@@ -89,6 +89,7 @@
             <a href="[%endpoint-path%]/metadata" style="color: gold">Capability Statement</a>  &nbsp;|&nbsp;
             <a href="[%endpoint-path%]/metadata?mode=terminology" style="color: gold">Terminology Capabilities</a>  &nbsp;|&nbsp;
             <a href="[%endpoint-path%]/op.html" style="color: gold">Operations</a>  &nbsp;|&nbsp;
+            <a href="[%endpoint-path%]/ecl" style="color: gold">ECL</a>  &nbsp;|&nbsp;
             <a href="[%endpoint-path%]/problems.html" style="color: gold">Problems</a>  &nbsp;|&nbsp;
             [%library-link%]
   &nbsp;

package/tx/library/conceptmap.js

@@ -196,6 +196,14 @@ class ConceptMap extends CanonicalResource {
    * their elements matched. group.unmapped only applies to a group that was in scope
    * for the translation, so the caller needs the same source/target test that
    * listTranslations applies - without the per-element filter.
+   *
+   * "In scope" here is only about this group's source and target code systems. It assumes
+   * the MAP itself is in scope, which is a separate and prior question: ConceptMap.sourceScope
+   * limits the map to codes that are members of that value set, and a map that does not cover
+   * the code has no groups in scope at all, whatever their systems say. That test needs a value
+   * set lookup and a $validate-code, so it lives in the worker (TranslateWorker.filterMapsByScope)
+   * and is applied to the map before this is ever called. Do not read a group coming back from
+   * here as evidence that the map applies.
    * @returns {Object[]} the matching group objects
    */
   listGroupsInScope(coding, targetScope, targetSystem) {
@@ -238,19 +246,27 @@ class ConceptMap extends CanonicalResource {
     return result;
   }
     /**
-   * Gets the source scope (R5) or source system (R3/R4)
-   * @returns {string|undefined} Source scope/system
+   * Gets the source scope (R5+) or source (R3/R4).
+   *
+   * R5 renamed ConceptMap.source[x] to ConceptMap.sourceScope[x], so an R4 resource spells this
+   * sourceUri / sourceCanonical and an R5 one sourceScopeUri / sourceScopeCanonical. Both have to
+   * be read: this server serves R4 as well as R5, and the R4 client sends the R4 spelling. Reading
+   * only the R5 names made this silently undefined on an R4 server, which made every map look
+   * unscoped - so the scope never limited anything, and $translate answered for codes outside it.
+   * @returns {string|undefined} Source scope
    */
   get sourceScope() {
-    return this.jsonObj.sourceScopeUri ? this.jsonObj.sourceScopeUri : this.jsonObj.sourceScopeCanonical;
+    return this.jsonObj.sourceScopeUri || this.jsonObj.sourceScopeCanonical
+      || this.jsonObj.sourceUri || this.jsonObj.sourceCanonical;
   }
 
   /**
-   * Gets the target scope (R5) or target system (R3/R4)
-   * @returns {string|undefined} Target scope/system
+   * Gets the target scope (R5+) or target (R3/R4). See sourceScope for why both are read.
+   * @returns {string|undefined} Target scope
    */
   get targetScope() {
-    return this.jsonObj.targetScopeUri ? this.jsonObj.targetScopeUri : this.jsonObj.targetScopeCanonical;
+    return this.jsonObj.targetScopeUri || this.jsonObj.targetScopeCanonical
+      || this.jsonObj.targetUri || this.jsonObj.targetCanonical;
   }
 
   /**

package/tx/library/designations.js

@@ -26,6 +26,10 @@ class SearchFilterText {
 
     this.filter = filter ? filter.toLowerCase() : null;
     this.stems = [];
+    // The words the stems came from, index-aligned with stems. A provider whose text
+    // index cannot hold a particular token (RxNorm's stem table has nothing that starts
+    // with a digit, for one) needs the word itself to search the text with instead.
+    this.words = [];
     this.stemmer = natural.PorterStemmer;
     if (filter) {
       this._process();
@@ -135,6 +139,7 @@ class SearchFilterText {
 
   _process() {
     let i = 0;
+    const found = [];
 
     while (i < this.filter.length) {
       if (this._isAlphaNumeric(this.filter[i])) {
@@ -142,14 +147,18 @@ class SearchFilterText {
         while (i < this.filter.length && this._isAlphaNumeric(this.filter[i])) {
           i++;
         }
-        const word = this.filter.substring(j, i);
-        this.stems.push(this.stemmer.stem(word.toLowerCase()));
+        const word = this.filter.substring(j, i).toLowerCase();
+        found.push({ word: word, stem: this.stemmer.stem(word) });
       } else {
         i++;
       }
     }
 
-    this.stems.sort();
+    // Sorted by stem, because _find() binary searches stems - words ride along so that
+    // words[n] is always the word stems[n] came from.
+    found.sort((a, b) => (a.stem < b.stem ? -1 : (a.stem > b.stem ? 1 : 0)));
+    this.stems = found.map((f) => f.stem);
+    this.words = found.map((f) => f.word);
   }
 
   _isAlphaNumeric(char) {

package/tx/library/operation-outcome.js

@@ -198,7 +198,9 @@ class OperationOutcome {
   listMissedErrors(list) {
     for (let iss of this.jsonObj.issue || []) {
       if (iss.severity === 'error' && iss.details && iss.details.text && !list.find(msg => msg === iss.details.text )) {
-        return list.push(iss.details.text);
+        // every error that nothing else reported, not just the first one - an early return here
+        // meant the summary message named only one of them
+        list.push(iss.details.text);
       }
     }
 

package/tx/library/renderer.js

@@ -1445,6 +1445,7 @@ class Renderer {
 
     // Analyze columns needed
     const columnInfo = this.analyzeExpansionColumns(vs.expansion);
+    columnInfo.versions = this.expansionVersions(vs);
 
     // Build the expansion table
     const expTbl = x.table("codes");
@@ -1595,6 +1596,40 @@ class Renderer {
   /**
    * Add a row for an expansion contains entry
    */
+  /**
+   * The version each code system was expanded at, by system uri.
+   *
+   * An expansion.contains only carries a version when the expansion needed to distinguish
+   * one, so a link built from the row alone would silently point at whichever version the
+   * server happens to prefer - not what the reader is looking at. The expansion says which
+   * version it used in its used-codesystem parameters, and a value set that came with its
+   * definition says so in its compose; either will do.
+   *
+   * @param {Object} vs the expanded ValueSet
+   * @returns {Map<string, string>} system uri to version
+   */
+  expansionVersions(vs) {
+    const versions = new Map();
+    for (const inc of vs.compose?.include || []) {
+      if (inc.system && inc.version && !versions.has(inc.system)) {
+        versions.set(inc.system, inc.version);
+      }
+    }
+    for (const p of vs.expansion?.parameter || []) {
+      if (p.name !== 'used-codesystem') {
+        continue;
+      }
+      const vurl = getValuePrimitive(p);
+      if (vurl && vurl.includes('|')) {
+        const system = vurl.substring(0, vurl.indexOf('|'));
+        if (!versions.has(system)) {
+          versions.set(system, vurl.substring(vurl.indexOf('|') + 1));
+        }
+      }
+    }
+    return versions;
+  }
+
   async addExpansionRow(tbl, contains, level, columnInfo) {
     const tr = tbl.tr();
 
@@ -1617,12 +1652,14 @@ class Renderer {
       codeTd.tx('\u00A0'.repeat(level * 2)); // Non-breaking spaces for indentation
     }
 
-    // Try to link the code
+    // The code links to $lookup on it - what a reader wants from a row in an expansion is
+    // to find out what that code is - at the version the expansion used.
     if (contains.code) {
-      const link = this.linkResolver ?
-          await this.linkResolver.resolveCode(this.opContext, contains.system, contains.version, contains.code) : null;
+      const version = contains.version || columnInfo.versions?.get(contains.system) || null;
+      const link = this.linkResolver?.lookupLink
+        ? this.linkResolver.lookupLink(contains.system, version, contains.code) : null;
       if (link) {
-        codeTd.ah(link.link).tx(contains.code);
+        codeTd.ah(link, 'Look this code up').code().tx(contains.code);
       } else {
         codeTd.code().tx(contains.code);
       }
@@ -2732,4 +2769,4 @@ class Renderer {
 
 }
 
-module.exports = { Renderer };
+module.exports = { Renderer, VALID_FILTER_OPS };