fhirsmith 0.16.0 → 0.17.0

package/registry/registry.js

@@ -19,6 +19,12 @@ const { FhirsmithReleases, isFhirsmith, describeAge } = require('./fhirsmith-rel
 const DISCOVERY_PARAMS = ['registry', 'server', 'fhirVersion', 'url', 'authoritativeOnly', 'language'];
 const RESOLVE_PARAMS = ['fhirVersion', 'url', 'version', 'valueSet', 'authoritativeOnly', 'language', 'usage'];
 
+// A link to a URL from a registry list or a crawled server: those are other people's
+// content, so only an http(s) URL is linked, and it is escaped
+function safeHref(url) {
+  return typeof url === 'string' && /^https?:\/\//i.test(url.trim()) ? escape(url) : '#';
+}
+
 class RegistryModule {
   constructor(stats) {
     this.router = express.Router();
@@ -50,7 +56,8 @@ class RegistryModule {
         masterUrl: config.masterUrl || 'https://fhir.github.io/ig-registry/tx-servers.json',
         timeout: config.timeout || 30000,
         userAgent: config.userAgent || 'FHIRRegistryServer/1.0',
-        apiKeys: config.apiKeys || {}
+        apiKeys: config.apiKeys || {},
+        maxResponseMB: config.maxResponseMB
       };
 
       this.crawler = new RegistryCrawler(crawlerConfig, this.stats);
@@ -536,7 +543,7 @@ class RegistryModule {
     for (const row of rows) {
       html += '<tr>';
       html += `<td>${escape(row.name)}</td>`;
-      html += `<td><a href="${escape(row.url)}" target="_blank" rel="noopener">${escape(row.url)}</a>`;
+      html += `<td><a href="${safeHref(row.url)}" target="_blank" rel="noopener">${escape(row.url)}</a>`;
       if (row.error) {
         html += ` <span class="text-danger" title="${escape(row.error)}">(unreachable)</span>`;
       }
@@ -682,7 +689,7 @@ class RegistryModule {
 
     for (const server of serverVersions) {
       html += '<tr>';
-      html += `<td><a href="${server.serverUrl}" target="_blank">${escape(server.serverUrl)}</a></td>`;
+      html += `<td><a href="${safeHref(server.serverUrl)}" target="_blank">${escape(server.serverUrl)}</a></td>`;
       html += `<td>${escape(server.software.replace("Reference Server", "HealthIntersections"))}</td>`;
       html += `<td>${escape(server.authority.replace("Published by", ""))}</td>`;
       html += `<td>${escape(server.version)}</td>`;
@@ -1032,7 +1039,7 @@ class RegistryModule {
       const rowspan = cs.servers.length;
       html += '<tr>';
       html += `<td rowspan="${rowspan}">${this._highlightWildcard(escape(formattedMask))}</td>`;
-      html += `<td><a href="${escape(cs.servers[0].url)}" target="_blank">${escape(cs.servers[0].url)}</a>${this._renderLanguageScope(cs.servers[0])}</td>`;
+      html += `<td><a href="${safeHref(cs.servers[0].url)}" target="_blank">${escape(cs.servers[0].url)}</a>${this._renderLanguageScope(cs.servers[0])}</td>`;
 
       // Format versions as R3/R4/R5
       const formattedVersions = cs.servers[0].versions.map(v => this._formatFhirVersion(v));
@@ -1042,7 +1049,7 @@ class RegistryModule {
       // Additional rows for this code system (if any)
       for (let i = 1; i < cs.servers.length; i++) {
         html += '<tr>';
-        html += `<td><a href="${escape(cs.servers[i].url)}" target="_blank">${escape(cs.servers[i].url)}</a>${this._renderLanguageScope(cs.servers[i])}</td>`;
+        html += `<td><a href="${safeHref(cs.servers[i].url)}" target="_blank">${escape(cs.servers[i].url)}</a>${this._renderLanguageScope(cs.servers[i])}</td>`;
 
         // Format versions as R3/R4/R5
         const formattedVersions = cs.servers[i].versions.map(v => this._formatFhirVersion(v));
@@ -1088,7 +1095,7 @@ class RegistryModule {
       const rowspan = vs.servers.length;
       html += '<tr>';
       html += `<td rowspan="${rowspan}">${this._highlightWildcard(escape(vs.mask))}</td>`;
-      html += `<td><a href="${escape(vs.servers[0].url)}" target="_blank">${escape(vs.servers[0].url)}</a>${this._renderLanguageScope(vs.servers[0])}</td>`;
+      html += `<td><a href="${safeHref(vs.servers[0].url)}" target="_blank">${escape(vs.servers[0].url)}</a>${this._renderLanguageScope(vs.servers[0])}</td>`;
 
       // Format versions as R3/R4/R5
       const formattedVersions = vs.servers[0].versions.map(v => this._formatFhirVersion(v));
@@ -1098,7 +1105,7 @@ class RegistryModule {
       // Additional rows for this value set (if any)
       for (let i = 1; i < vs.servers.length; i++) {
         html += '<tr>';
-        html += `<td><a href="${escape(vs.servers[i].url)}" target="_blank">${escape(vs.servers[i].url)}</a>${this._renderLanguageScope(vs.servers[i])}</td>`;
+        html += `<td><a href="${safeHref(vs.servers[i].url)}" target="_blank">${escape(vs.servers[i].url)}</a>${this._renderLanguageScope(vs.servers[i])}</td>`;
 
         // Format versions as R3/R4/R5
         const formattedVersions = vs.servers[i].versions.map(v => this._formatFhirVersion(v));
@@ -1322,7 +1329,7 @@ class RegistryModule {
     html += '<div class="card-body">';
     html += `<p><strong>FHIR Version:</strong> ${escape(fhirVersion)}</p>`;
     html += `<p><strong>Resource URL:</strong> ${escape(resourceUrl)}</p>`;
-    html += `<p><strong>Registry URL:</strong> <a href="${result['registry-url']}" target="_blank">${escape(result['registry-url'])}</a></p>`;
+    html += `<p><strong>Registry URL:</strong> <a href="${safeHref(result['registry-url'])}" target="_blank">${escape(result['registry-url'])}</a></p>`;
     if (usage) {
       html += `<p><strong>Usage:</strong> ${escape(usage)}</p>`;
     }
@@ -1355,7 +1362,7 @@ class RegistryModule {
       result.authoritative.forEach(server => {
         html += '<tr>';
         html += `<td>${escape(server['server-name'])}</td>`;
-        html += `<td><a href="${server.url}" target="_blank">${escape(server.url)}</a></td>`;
+        html += `<td><a href="${safeHref(server.url)}" target="_blank">${escape(server.url)}</a></td>`;
         html += `<td>${this.renderSecurityTags(server)}</td>`;
         html += `<td>${server.languages ? escape(server.languages.join(', ')) : ''}</td>`;
         html += `<td>${server.access_info ? escape(server.access_info) : ''}</td>`;
@@ -1395,7 +1402,7 @@ class RegistryModule {
       result.candidates.forEach(server => {
         html += '<tr>';
         html += `<td>${escape(server['server-name'])}</td>`;
-        html += `<td><a href="${server.url}" target="_blank">${escape(server.url)}</a></td>`;
+        html += `<td><a href="${safeHref(server.url)}" target="_blank">${escape(server.url)}</a></td>`;
         html += `<td>${this.renderSecurityTags(server)}</td>`;
         if (server['language-support'] === 'unknown') {
           html += '<td><span class="text-muted" title="This server hosts the code system, but the ecosystem does not know whether it can supply the requested language">unknown</span></td>';
@@ -1570,7 +1577,7 @@ class RegistryModule {
             res.send(html);
           } catch (error) {
             this.logger.error('Error rendering log page:', error);
-            res.status(500).send(`<pre>Error rendering log page: ${error.message}</pre>`);
+            res.status(500).send(`<pre>Error rendering log page: ${escape(error.message)}</pre>`);
           }
         } else {
           // Return JSON logs

package/release.sh

@@ -0,0 +1,80 @@
+#!/usr/bin/env bash
+#
+# Release FHIRsmith: ./release.sh 0.17.0
+#
+# Checks that the release is ready, submits the tx test report to the /testing server, then
+# tags the release and pushes the tag (which starts .github/workflows/release.yml).
+# Stops at the first problem, before anything is tagged.
+#
+# The test report: run the tx tests first (npx jest tests/tx/test-cases.test.js). If the
+# /testing server needs a token, set FHIRSMITH_TESTING_TOKEN.
+
+set -euo pipefail
+
+fail() {
+  echo "gr.sh: $*" >&2
+  exit 1
+}
+
+[ $# -eq 1 ] || fail "usage: ./gr.sh <version>, e.g. ./gr.sh 0.17.0"
+VERSION="${1#v}"
+TAG="v$VERSION"
+[[ "$VERSION" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]] || fail "'$1' is not a release version (X.Y.Z)"
+
+cd "$(dirname "$0")"
+
+# --- git: on main, nothing uncommitted, and exactly what is on GitHub -------------------
+[ "$(git rev-parse --abbrev-ref HEAD)" = "main" ] || fail "not on main"
+[ -z "$(git status --porcelain --untracked-files=no)" ] || fail "there are uncommitted changes"
+git fetch --quiet origin main --tags
+[ "$(git rev-parse HEAD)" = "$(git rev-parse origin/main)" ] \
+  || fail "main is not the same as origin/main - push (or pull) first, so the tag is on a commit GitHub has"
+! git rev-parse -q --verify "refs/tags/$TAG" >/dev/null || fail "tag $TAG already exists"
+
+# --- versions: what release.yml's verify-version job checks ----------------------------
+check_version() {
+  local what="$1" found="$2"
+  [ "$found" = "$VERSION" ] || fail "$what is '$found', not $VERSION (npm version --no-git-tag-version $VERSION && npm install --package-lock-only)"
+}
+check_version "package.json version" "$(node -p "require('./package.json').version")"
+check_version "package-lock.json version" "$(node -p "require('./package-lock.json').version")"
+check_version 'package-lock.json packages[""]' "$(node -p "require('./package-lock.json').packages[''].version")"
+
+# --- CHANGELOG: a dated section for this version, with the conformance statement in -----
+HEADING=$(grep -E "^## \[v?${VERSION//./\\.}\]" CHANGELOG.md || true)
+[ -n "$HEADING" ] || fail "CHANGELOG.md has no section for $VERSION"
+[[ "$HEADING" =~ [0-9]{4}-[0-9]{2}-[0-9]{2}$ ]] || fail "the CHANGELOG.md section for $VERSION has no date: $HEADING"
+SECTION=$(sed -n "/^## \[v\{0,1\}${VERSION//./\\.}\]/,/^## \[/p" CHANGELOG.md | sed '$d')
+! grep -qx '(paste)' <<<"$SECTION" || fail "the Tx Conformance Statement for $VERSION hasn't been pasted into CHANGELOG.md"
+
+# --- the test report: this version, passed, and run on what is being released ----------
+REPORT=test-cases-report.json
+[ -f "$REPORT" ] || fail "no $REPORT - run the tx tests first (npx jest tests/tx/test-cases.test.js)"
+# the last commit that changed what the tests run - not the notes, nor the version bump
+CODE_COMMITTED=$(git log -1 --format=%cI -- . ':(exclude)*.md' ':(exclude)release.sh' ':(exclude)package.json' ':(exclude)package-lock.json')
+node - "$REPORT" "$VERSION" "$CODE_COMMITTED" <<'NODE' || exit 1
+const [file, version, committed] = process.argv.slice(2);
+const report = JSON.parse(require('fs').readFileSync(file, 'utf8'));
+const fhirsmith = (report.participant || []).find(p => p.uri === 'https://github.com/HealthIntersections/FHIRsmith');
+const problems = [];
+if (!fhirsmith || fhirsmith.version !== version) {
+  problems.push(`it is from FHIRsmith ${fhirsmith ? fhirsmith.version : '(unknown)'}, not ${version}`);
+}
+if (report.result !== 'pass') {
+  problems.push(`its result is '${report.result}', not 'pass'`);
+}
+if (!report.issued || new Date(report.issued) < new Date(committed)) {
+  problems.push(`it was run (${report.issued}) before the last change to the code (${committed})`);
+}
+if (problems.length > 0) {
+  console.error(`gr.sh: ${file} can't be submitted for ${version}: ${problems.join('; ')} - run the tx tests again`);
+  process.exit(1);
+}
+NODE
+
+# --- submit the report, then tag ---------------------------------------------------------
+node utilities/submit-test-report.js -file "$REPORT" || fail "the test report was not accepted, so $TAG has not been tagged"
+
+git tag -a "$TAG" -m "FHIRsmith $VERSION"
+git push origin "$TAG"
+echo "Tagged and pushed $TAG - the release workflow is now running"

package/shl/shl.js

@@ -418,10 +418,12 @@ class SHLModule {
     }
   }
 
-  stopCleanupJob() {
+  // node-cron 4: stop() may return a promise
+  async stopCleanupJob() {
     if (this.cleanupJob) {
-      this.cleanupJob.stop();
+      const job = this.cleanupJob;
       this.cleanupJob = null;
+      await job.stop();
     }
   }
 
@@ -1060,7 +1062,7 @@ class SHLModule {
   async shutdown() {
     shlLog.info('Shutting down SHL module...');
 
-    this.stopCleanupJob();
+    await this.stopCleanupJob();
 
     // Stop FHIR validator
     if (this.fhirValidator) {

package/testing/readme.md

@@ -31,7 +31,7 @@ shown on any page.
 
 FHIRsmith's own tx test run writes its results as `test-cases-report.json` in the
 FHIRsmith root; `node utilities/submit-test-report.js [-server url] [-token token]` sends it
-to a /testing server (by default https://testing.fhir.org/testing).
+to a /testing server (by default https://npm.fhir.org/testing).
 
 ## Reading and searching
 

package/tx/cm/cm-database.js

@@ -2,6 +2,9 @@ const fs = require('fs').promises;
 const sqlite3 = require('sqlite3').verbose();
 const { VersionUtilities } = require('../../library/version-utilities');
 const { ConceptMap } = require('../library/conceptmap');
+// Key of the row written once the cache has been fully populated (see isComplete)
+const CACHE_COMPLETE_KEY = 'cache-complete';
+
 // Columns that can be returned directly without parsing JSON
 const INDEXED_COLUMNS = ['id', 'url', 'version', 'date', 'description', 'name', 'publisher', 'status', 'title'];
 
@@ -113,6 +116,14 @@ class ConceptMapDatabase {
           db.run('CREATE INDEX idx_jurisdictions_code ON conceptmap_jurisdictions(code)');
           db.run('CREATE INDEX idx_systems_system ON conceptmap_systems(system)');
 
+          // Cache status (key-value) - holds the marker that population finished
+          db.run(`
+              CREATE TABLE cache_status (
+                                          key TEXT PRIMARY KEY,
+                                          value TEXT
+              )
+          `);
+
           db.close((err) => {
             if (err) {
               reject(new Error(`Failed to close database after creation: ${err.message}`));
@@ -125,6 +136,57 @@ class ConceptMapDatabase {
     });
   }
 
+  /**
+   * True if this cache was fully populated: markComplete() was reached. A cache
+   * whose population was cut short (the process killed part way through) has no
+   * marker - nor does one built before the marker existed, or a file too damaged
+   * to read - so it reports false.
+   * @returns {Promise<boolean>}
+   */
+  async isComplete() {
+    return new Promise((resolve) => {
+      const db = new sqlite3.Database(this.dbPath, sqlite3.OPEN_READONLY, (err) => {
+        if (err) {
+          resolve(false);
+          return;
+        }
+        db.get('SELECT value FROM cache_status WHERE key = ?', [CACHE_COMPLETE_KEY], (err, row) => {
+          db.close(() => resolve(!err && row != null));
+        });
+      });
+    });
+  }
+
+  /**
+   * Record that this cache has been fully populated. Called once, after the last
+   * concept map has been written
+   * @returns {Promise<void>}
+   */
+  async markComplete() {
+    return new Promise((resolve, reject) => {
+      const db = new sqlite3.Database(this.dbPath, (err) => {
+        if (err) {
+          reject(new Error(`Failed to open database: ${err.message}`));
+          return;
+        }
+        db.serialize(() => {
+          db.run('CREATE TABLE IF NOT EXISTS cache_status (key TEXT PRIMARY KEY, value TEXT)');
+          db.run(`INSERT INTO cache_status (key, value) VALUES (?, ?)
+                    ON CONFLICT(key) DO UPDATE SET value = excluded.value`,
+            [CACHE_COMPLETE_KEY, new Date().toISOString()], (err) => {
+              db.close((closeErr) => {
+                if (err || closeErr) {
+                  reject(new Error(`Failed to mark cache complete: ${(err || closeErr).message}`));
+                } else {
+                  resolve();
+                }
+              });
+            });
+        });
+      });
+    });
+  }
+
   /**
    * Insert or update a single ConceptMap in the database
    * @param {Object} conceptMap - The ConceptMap resource

package/tx/cm/cm-package.js

@@ -1,4 +1,6 @@
 const path = require('path');
+const fs = require('fs').promises;
+const { assertNoActiveContent } = require('../../library/narrative-check');
 const { AbstractConceptMapProvider } = require('./cm-api');
 const { PackageContentLoader } = require('../../library/package-manager');
 const { ConceptMapDatabase } = require('./cm-database');
@@ -20,7 +22,9 @@ class PackageConceptMapProvider extends AbstractConceptMapProvider {
     super();
     validateParameter(packageLoader, "packageLoader", PackageContentLoader);
     this.packageLoader = packageLoader;
-    this.dbPath = path.join(packageLoader.packageFolder, '.conceptmaps.db');
+    // -2: caches from before concept maps were checked for active content in their
+    // narrative are rebuilt (see initialize)
+    this.dbPath = path.join(packageLoader.packageFolder, '.conceptmaps-2.db');
     this.database = new ConceptMapDatabase(this.dbPath);
     this.conceptMapMap = new Map();
     this.initialized = false;
@@ -36,12 +40,23 @@ class PackageConceptMapProvider extends AbstractConceptMapProvider {
       return;
     }
     await this.packageLoader.initialize();
-
-    const dbExists = await this.database.exists();
+    await fs.rm(path.join(this.packageLoader.packageFolder, '.conceptmaps.db'), { force: true }); // the old cache
+
+    // A cache is only used once its population finished. One that was cut short
+    // (the process killed part way through) would otherwise be trusted forever,
+    // silently missing whatever hadn't been written yet
+    let dbExists = await this.database.exists();
+    if (dbExists && !(await this.database.isComplete())) {
+      require('../../library/logger').getInstance().child({ module: 'tx' })
+        .warn(`Package ${this.packageLoader.pid ? this.packageLoader.pid() : ''}: concept map cache ${this.dbPath} is incomplete - rebuilding it`);
+      await fs.rm(this.dbPath, { force: true });
+      dbExists = false;
+    }
 
     if (!dbExists) {
       await this.database.create();
       await this._populateDatabase();
+      await this.database.markComplete();
     }
 
     this.conceptMapMap = await this.database.loadAllConceptMaps();
@@ -68,6 +83,8 @@ class PackageConceptMapProvider extends AbstractConceptMapProvider {
       const conceptMap = await this.packageLoader.loadFile(entry);
       if (conceptMap.url) {
         try {
+          // its narrative is shown as-is in a page, so it must not carry script
+          assertNoActiveContent(conceptMap);
           conceptMaps.push(new ConceptMap(conceptMap, this.packageLoader.fhirVersion())); // get in converted to R5 format
         } catch (e) {
           // one unacceptable concept map (e.g. one with contained resources, which the

package/tx/cs/cs-cs.js

@@ -19,6 +19,63 @@ const regexUtilities = require("../../library/regex-utilities");
 // filter results do not depend on forIteration, so one form is stored per version.
 const FILTER_ANALYSIS = Symbol('filterAnalysis');
 
+// The texts of each concept as a text filter compares them, by concept. Folding is
+// the costly part of a search over a large code system, so it is done once per
+// concept, and dropped with the code system.
+const SEARCH_TEXTS = new WeakMap();
+
+/**
+ * Lower case without accents, so "colera" finds "Cólera". Only marks on Latin, Greek and
+ * Cyrillic letters are accents: in other scripts, such as kana or Devanagari, marks are
+ * part of how a word is spelt, and dropping them would make "がん" find "かん".
+ */
+function foldSearchText(text) {
+  return text.normalize('NFD')
+    .replace(/([\p{Script=Latin}\p{Script=Greek}\p{Script=Cyrillic}])\p{M}+/gu, '$1')
+    .toLowerCase();
+}
+
+/**
+ * A text as a text filter compares it: `text` folded, and `words` the same with each
+ * run of other characters made one space and a space in front, so that " " + word
+ * finds where a word starts.
+ */
+function searchText(text) {
+  const folded = foldSearchText(text);
+  return { text: folded, words: ' ' + folded.replace(/[^\p{L}\p{N}]+/gu, ' ') };
+}
+
+function conceptSearchTexts(concept) {
+  let texts = SEARCH_TEXTS.get(concept);
+  if (texts === undefined) {
+    texts = {
+      code: foldSearchText(concept.code),
+      display: concept.display ? searchText(concept.display) : null,
+      definition: concept.definition ? foldSearchText(concept.definition) : null,
+      designations: Array.isArray(concept.designation)
+        ? concept.designation.filter(designation => designation.value).map(designation => searchText(designation.value))
+        : []
+    };
+    SEARCH_TEXTS.set(concept, texts);
+  }
+  return texts;
+}
+
+/**
+ * Whether every word starts a word of the text.
+ */
+function startsWords(text, words) {
+  return words.every(word => text.words.includes(' ' + word));
+}
+
+/**
+ * How much of the text the words cover, from 0 to 1, counting one space between words
+ * whatever separated them in the search.
+ */
+function wordsRatio(words, text) {
+  return Math.min(1, words.join(' ').length / text.text.length);
+}
+
 /**
  * Context class for FHIR CodeSystem provider concepts
  */
@@ -1145,14 +1202,15 @@ class FhirCodeSystemProvider extends BaseCSServices {
     
 
     const results = new FhirCodeSystemProviderFilterContext();
-    const searchTerm = filter.filter.toLowerCase();
+    const searchTerm = foldSearchText(filter.filter);
+    const searchWords = searchTerm.split(/[^\p{L}\p{N}]+/u).filter(word => word !== '');
 
     // Search through all concepts
     const allConcepts = this.codeSystem.getAllConcepts();
 
     for (const concept of allConcepts) {
       this.opContext.deadCheck('cs:searchFilter');
-      const rating = this._calculateSearchRating(concept, searchTerm);
+      const rating = this._calculateSearchRating(concept, searchTerm, searchWords);
       if (rating > 0) {
         results.add(concept, rating);
       }
@@ -1174,47 +1232,57 @@ class FhirCodeSystemProvider extends BaseCSServices {
   /**
    * Calculate search relevance rating for a concept
    * @param {Object} concept - The concept to rate
-   * @param {string} searchTerm - The search term (lowercase)
+   * @param {string} searchTerm - The search term (folded: lower case, no accents)
+   * @param {string[]} searchWords - The words of the search term
    * @returns {number} Rating (0 = no match, higher = better match)
    * @private
    */
-  _calculateSearchRating(concept, searchTerm) {
+  _calculateSearchRating(concept, searchTerm, searchWords) {
+    const texts = conceptSearchTexts(concept);
+    const display = texts.display;
     let rating = 0;
 
     // Exact matches get highest rating
-    if (concept.code.toLowerCase() === searchTerm) {
+    if (texts.code === searchTerm) {
       rating = 100;
-    } else if (concept.display && concept.display.toLowerCase() === searchTerm) {
+    } else if (display && display.text === searchTerm) {
       rating = 100;
     }
     // Code starts with search term
-    else if (concept.code.toLowerCase().startsWith(searchTerm)) {
+    else if (texts.code.startsWith(searchTerm)) {
       rating = 90;
     }
     // Display starts with search term
-    else if (concept.display && concept.display.toLowerCase().startsWith(searchTerm)) {
-      const lengthRatio = searchTerm.length / concept.display.length;
+    else if (display && display.text.startsWith(searchTerm)) {
+      const lengthRatio = searchTerm.length / display.text.length;
       rating = 80 + (10 * lengthRatio);
     }
     // Code contains search term
-    else if (concept.code.toLowerCase().includes(searchTerm)) {
+    else if (texts.code.includes(searchTerm)) {
       rating = 60;
     }
     // Display contains search term
-    else if (concept.display && concept.display.toLowerCase().includes(searchTerm)) {
+    else if (display && display.text.includes(searchTerm)) {
       rating = 50;
     }
     // Definition contains search term
-    else if (concept.definition && concept.definition.toLowerCase().includes(searchTerm)) {
+    else if (texts.definition && texts.definition.includes(searchTerm)) {
       rating = 30;
     }
     // Check designations
-    else if (concept.designation && Array.isArray(concept.designation)) {
-      for (const designation of concept.designation) {
-        if (designation.value && designation.value.toLowerCase().includes(searchTerm)) {
-          rating = 40;
-          break;
-        }
+    else if (texts.designations.some(designation => designation.text.includes(searchTerm))) {
+      rating = 40;
+    }
+    // Each word of a search of several starts a word of the display, in any order;
+    // the shorter the display, the closer the match
+    else if (searchWords.length > 1 && display && startsWords(display, searchWords)) {
+      rating = 20 + (10 * wordsRatio(searchWords, display));
+    }
+    // Or of one designation
+    else if (searchWords.length > 1) {
+      const designation = texts.designations.find(designation => startsWords(designation, searchWords));
+      if (designation) {
+        rating = 10 + (10 * wordsRatio(searchWords, designation));
       }
     }
 

package/tx/cs/cs-loinc.js

@@ -664,9 +664,10 @@ class LoincServices extends BaseCSServices {
     filterContext.filters.push(filter);
   }
 
-  async searchFilter(filterContext, filterText, sort) {
+  async searchFilter(filterContext, filterText, sort) { // eslint-disable-line no-unused-vars
     const filter = new LoincFilterHolder();
-    await this.#executeFilterQuery('$text', (sort ? '>' : '<'), filterText.filter, filter);
+    // LOINC does not rate its matches, so sorted or not they come in description order
+    await this.#executeFilterQuery('$text', '<', filterText.filter, filter);
     filterContext.filters.push(filter);
   }
 
@@ -859,12 +860,7 @@ class LoincServices extends BaseCSServices {
     }
     // Concept hierarchy filters (is-a, descendent-of)
     else if (prop === 'concept' && ['is-a', 'descendent-of'].includes(op)) {
-      sql = `SELECT DescendentKey as Key FROM Closure
-             WHERE AncestorKey IN (SELECT CodeKey FROM Codes WHERE Code = '${this.#sqlWrapString(value)}')
-             ORDER BY DescendentKey ASC`;
-      lsql = `SELECT COUNT(DescendentKey) FROM Closure
-              WHERE AncestorKey IN (SELECT CodeKey FROM Codes WHERE Code = '${this.#sqlWrapString(value)}')
-                AND DescendentKey = `;
+      ({ sql, lsql } = this.#hierarchyFilterSql(op, value));
     }
     // Concept equal filter (workaround for VSAC misuse)
     else if (prop === 'concept' && op === '=') {
@@ -887,12 +883,7 @@ class LoincServices extends BaseCSServices {
     }
     // Code property filters (workaround for VSAC misuse)
     else if (prop === 'code' && ['is-a', 'descendent-of'].includes(op)) {
-      sql = `SELECT DescendentKey as Key FROM Closure
-             WHERE AncestorKey IN (SELECT CodeKey FROM Codes WHERE Code = '${this.#sqlWrapString(value)}')
-             ORDER BY DescendentKey ASC`;
-      lsql = `SELECT COUNT(DescendentKey) FROM Closure
-              WHERE AncestorKey IN (SELECT CodeKey FROM Codes WHERE Code = '${this.#sqlWrapString(value)}')
-                AND DescendentKey = `;
+      ({ sql, lsql } = this.#hierarchyFilterSql(op, value));
     }
     else if (prop === 'code' && op === '=') {
       sql = `SELECT CodeKey as Key FROM Codes
@@ -936,6 +927,33 @@ class LoincServices extends BaseCSServices {
     }
   }
 
+  /**
+   * The SQL for an is-a or descendent-of filter. The Closure table holds the strict descendants
+   * of each part (and never the part itself), which is descendent-of. is-a also includes the
+   * concept itself, as FHIR defines it.
+   *
+   * The closure follows LOINC's ComponentHierarchyBySystem path by path: a code is a descendant
+   * of the parts on its own PATH_TO_ROOT. A part that sits under two parents has its children by
+   * system listed separately under each, and they are not inherited across the paths - reading
+   * the file as a graph would, for example, put Glucose in Serum or Plasma under Urinalysis,
+   * because Protein appears under both.
+   */
+  #hierarchyFilterSql(op, value) {
+    const code = this.#sqlWrapString(value);
+    const descendants = `SELECT DescendentKey as Key FROM Closure
+             WHERE AncestorKey IN (SELECT CodeKey FROM Codes WHERE Code = '${code}')`;
+    const set = op === 'is-a'
+      ? `${descendants}
+             UNION
+             SELECT CodeKey as Key FROM Codes WHERE Code = '${code}'`
+      : descendants;
+    return {
+      sql: `${set}
+             ORDER BY Key ASC`,
+      lsql: `SELECT COUNT(*) FROM (${set}) WHERE Key = `
+    };
+  }
+
 // Helper method for regex matching
   async #findRegexMatches(sql, pattern, valueColumn, keyColumn = 'Key') {
     return new Promise((resolve, reject) => {

package/tx/library/resource-ids.js

@@ -58,6 +58,21 @@ function stripIdPrefix(id, spaceId) {
   return id.startsWith(prefix) && id.length > prefix.length ? id.substring(prefix.length) : null;
 }
 
+/**
+ * The id a resource had in its source, for an id in any id space: everything after the
+ * prefix, which never contains a '-' (see checkIdPrefix). Null if the id has no prefix.
+ *
+ * @param {string} id
+ * @returns {string|null}
+ */
+function originalId(id) {
+  if (typeof id !== 'string') {
+    return null;
+  }
+  const i = id.indexOf('-');
+  return i > 0 && i < id.length - 1 ? id.substring(i + 1) : null;
+}
+
 /**
  * Whether a prefix given in the library YAML is acceptable. It's the start of an id, so it
  * may only use id characters, and no '-', so that the prefix of any id is unambiguous.
@@ -104,4 +119,4 @@ function assignIdSpace(provider, spaceId) {
 
 const CORE_PREFIX = 'core';
 
-module.exports = { applyIdPrefix, stripIdPrefix, checkIdPrefix, assignIdSpace, CORE_PREFIX };
+module.exports = { applyIdPrefix, stripIdPrefix, originalId, checkIdPrefix, assignIdSpace, CORE_PREFIX };

package/tx/library.js

@@ -5,6 +5,7 @@ const yaml = require('yaml'); // npm install yaml
 const { PackageManager, PackageContentLoader } = require('../library/package-manager');
 const { FolderContentLoader, FileContentLoader } = require('../library/folder-content-loader');
 const { CodeSystem } = require("./library/codesystem");
+const { assertNoActiveContent } = require('../library/narrative-check');
 const {CountryCodeFactoryProvider} = require("./cs/cs-country");
 const {Iso4217FactoryProvider} = require("./cs/cs-currency");
 const {AreaCodeFactoryProvider} = require("./cs/cs-areacode");
@@ -738,7 +739,10 @@ class Library {
     for (const resource of resources) {
       let cs;
       try {
-        cs = new CodeSystem(await contentLoader.loadFile(resource, contentLoader.fhirVersion()));
+        const json = await contentLoader.loadFile(resource, contentLoader.fhirVersion());
+        // narrative is shown as-is in a page, so it must not carry script (see narrative-check.js)
+        assertNoActiveContent(json);
+        cs = new CodeSystem(json);
       } catch (e) {
         // one unacceptable resource (e.g. contained resources the server doesn't support)
         // must not stop the rest of the package loading
@@ -857,7 +861,10 @@ class Library {
     for (const entry of csEntries) {
       let cs;
       try {
-        cs = new CodeSystem(await contentLoader.loadFile(entry, contentLoader.fhirVersion()));
+        const json = await contentLoader.loadFile(entry, contentLoader.fhirVersion());
+        // narrative is shown as-is in a page, so it must not carry script (see narrative-check.js)
+        assertNoActiveContent(json);
+        cs = new CodeSystem(json);
       } catch (e) {
         // one unacceptable resource must not stop the rest of the package loading
         this.log.warn(`Package ${contentLoader.pid()}: skipping CodeSystem ${entry.id || entry.filename || ''}: ${e.message}`);