fhirsmith 0.5.2 → 0.5.4

package/tx/params.js

@@ -36,6 +36,7 @@ class TxParameters {
   validating = false;
   abstractOk = true; // note true!
   inferSystem = false;
+  sort = 'design';
 
   constructor(languages, i18n, validating) {
     validateParameter(languages, 'languages', LanguageDefinitions);
@@ -242,6 +243,10 @@ class TxParameters {
           if (getValuePrimitive(p) == true) this.inferSystem = true;
           break;
         }
+        case 'sort': {
+          this.sort = getValuePrimitive(p);
+          break;
+        }
         case "exclude-system": {
           throw new Issue('error', 'not-supported', null, null, "The parameter 'exclude-system' is not supported by this system", null, 400);
         }
@@ -524,7 +529,7 @@ class TxParameters {
       this.FUid + '|' + b(this.FMembershipOnly) + '|' + this.FProperties.join(',') + '|' +
       b(this.FActiveOnly) + b(this.FDisplayWarning) + b(this.FExcludeNested) + b(this.FGenerateNarrative) + b(this.FExcludeNotForUI) + b(this.FExcludePostCoordinated) +
       b(this.FIncludeDesignations) + b(this.FIncludeDefinition) + b(this.hasActiveOnly) + b(this.hasExcludeNested) + b(this.hasGenerateNarrative) +
-      b(this.hasExcludeNotForUI) + b(this.hasExcludePostCoordinated) + b(this.hasIncludeDesignations) +
+      b(this.hasExcludeNotForUI) + b(this.hasExcludePostCoordinated) + b(this.hasIncludeDesignations) + this.sort+'|'+
       b(this.hasIncludeDefinition) + b(this.hasDefaultToLatestVersion) + b(this.hasDisplayWarning) + b(this.hasExcludeNotForUI) + b(this.hasMembershipOnly) + b(this.FDefaultToLatestVersion);
 
     if (this.hasHTTPLanguages) {
@@ -585,6 +590,7 @@ class TxParameters {
     this.hasDefaultToLatestVersion = other.hasDefaultToLatestVersion;
     this.hasMembershipOnly = other.hasMembershipOnly;
     this.hasDisplayWarning = other.hasDisplayWarning;
+    this.sort = other.sort;
 
     if (other.FProperties) {
       this.FProperties = [...other.FProperties];

package/tx/problems.js

@@ -0,0 +1,90 @@
+const escape = require('escape-html');
+
+class ProblemFinder {
+
+  constructor() {
+    this.map = new Map();
+  }
+
+  async scanValueSets(provider) {
+    let unknownVersions = {};  // system -> Set of versions not known to the server
+    for (let vsp of provider.valueSetProviders) {
+      let sourceUnknownVersions = unknownVersions[vsp.sourcePackage()];
+      if (!sourceUnknownVersions) {
+        sourceUnknownVersions = {};
+        unknownVersions[vsp.sourcePackage()] = sourceUnknownVersions;
+      }
+
+      let list = await vsp.listAllValueSets();
+      for (let url of list) {
+        let vs = await vsp.fetchValueSet(url);
+        if (vs && vs.jsonObj.compose) {
+          await this.scanValueSet(vs.jsonObj.compose, sourceUnknownVersions);
+        }
+      }
+    }
+    let result = '';
+    for (let sp of provider.listValueSetSourceCodes()) {
+      let sourceUnknownVersions = unknownVersions[sp];
+      if (sourceUnknownVersions) {
+        // Filter to only versions the server doesn't know about
+        for (const [system, vset] of Object.entries(sourceUnknownVersions)) {
+          for (let v of [...vset]) {
+            if (await provider.hasCsVersion(system, v)) {
+              vset.delete(v);
+            }
+          }
+          if (vset.size === 0) {
+            delete sourceUnknownVersions[system];
+          }
+        }
+        let list = await this.unknownVersionsHtml(sourceUnknownVersions, provider, sp);
+        if (list) {
+          result = result + `<h4>${sp}</h4>` + list;
+        }
+      }
+    }
+    return result;
+  }
+
+  async unknownVersionsHtml(unknownVersions, provider, source) {
+    const entries = Object.entries(unknownVersions || {});
+    if (entries.length === 0) {
+      return '<p>No unknown system versions found.</p>';
+    }
+    entries.sort((a, b) => a[0].localeCompare(b[0]));
+    let html = '<table class="grid"><thead><tr><th>System</th><th>Unknown Versions</th><th>Known Versions</th></tr></thead><tbody>';
+    for (const [system, vset] of entries) {
+      const systemEsc = escape(system);
+      const versions = [...vset].sort((a, b) => a.localeCompare(b));
+      const versionRefs = [];
+      for (const v of versions) {
+        versionRefs.push(`<a href="ValueSet?system=${systemEsc}|${escape(v)}&source=${source}&_elements=url%2Cversion%2Cname%2Ctitle%2Cstatus%2Ccontent%2Cdate">${v}</a>`);
+      }
+      const knownVersions = [...await provider.listCodeSystemVersions(system)].join('<br/>');
+      html += `<tr><td><a href="CodeSystem?url=${systemEsc}&_elements=url%2Cversion%2Cname%2Ctitle%2Cstatus%2Ccontent%2Cdate">${system}</a></td>`+
+        `<td>${versionRefs.join('<br/>')}</td><td>${knownVersions}</td></tr>`;
+    }
+    html += '</tbody></table>';
+    return html;
+  }
+
+  async scanValueSet(compose, versions) {
+    for (let inc of compose.include || []) {
+      if (inc.system && inc.version) {
+        this.seeVersion(versions, inc.system, inc.version);
+      }
+    }
+  }
+
+  seeVersion(versions, system, version) {
+    let set = versions[system];
+    if (set == null) {
+      set = new Set();
+      versions[system] = set;
+    }
+    set.add(version);
+  }
+}
+
+module.exports = ProblemFinder;

package/tx/provider.js

@@ -218,9 +218,16 @@ class Provider {
         await csp.findImplicitConceptMap(url, version);
       }
     }
-
   }
 
+  listValueSetSourceCodes() {
+    let result = [];
+    for (let vsp of this.valueSetProviders) {
+      result.push(vsp.sourcePackage());
+    }
+    result.sort((a, b) => {a.localeCompare(b)});
+    return result;
+  }
 
   async listCodeSystemVersions(url) {
     let result = new Set();
@@ -399,6 +406,20 @@ class Provider {
     return null;
   }
 
+  async hasCsVersion(system, version) {
+    for (let cs of this.codeSystems.values()) {
+      if (cs.url == system && cs.version == version) {
+        return true;
+      }
+    }
+    for (let cp of this.codeSystemFactories.values()) {
+      if (cp.system() == system && cp.version() == version) {
+        return true;
+      }
+    }
+    return false;
+  }
+
 }
 
 module.exports = { Provider };

package/tx/tx-html.js

@@ -137,7 +137,7 @@ class TxHtmlRenderer {
 
 // eslint-disable-next-line no-unused-vars
   async buildSearchForm(req, mode, params) {
-    const html = await this.liquid.renderFile('search-form', { baseUrl: escape(req.baseUrl) });
+    const html = await this.liquid.renderFile('search-form', { baseUrl: escape(req.baseUrl), sourceOptions : this.buildSourceOptions(req.txProvider) });
     return html;
   }
 
@@ -800,14 +800,128 @@ class TxHtmlRenderer {
     return firstEntry?.resourceType || 'Resource';
   }
 
+  /**
+   * Build a human-readable description of what this search bundle represents,
+   * by parsing the self link URL parameters.
+   */
+  describeSearchBundle(json) {
+    const selfLink = json.link?.find(l => l.relation === 'self')?.url || '';
+    if (!selfLink) return '';
+
+    let urlObj;
+    try {
+      urlObj = new URL(selfLink);
+    } catch {
+      return '';
+    }
+
+    // Extract resource type from path
+    const typeMatch = selfLink.match(/\/(CodeSystem|ValueSet|ConceptMap)\b/);
+    const resourceType = typeMatch ? typeMatch[1] : 'Resource';
+
+    // Human-friendly labels for search params
+    const PARAM_LABELS = {
+      'url': 'URL',
+      'version': 'Version',
+      'name': 'Name',
+      'title': 'Title',
+      'status': 'Status',
+      'publisher': 'Publisher',
+      'description': 'Description',
+      'identifier': 'Identifier',
+      'jurisdiction': 'Jurisdiction',
+      'date': 'Date',
+      'text': 'Text',
+      'system': 'System',
+      'supplements': 'Supplements',
+      'content-mode': 'Content mode',
+      'source': 'Source'
+    };
+
+    const WORDS = {
+      'url': 'contains',
+      'version': 'contains',
+      'name': 'contains',
+      'title': 'contains',
+      'status': 'is',
+      'publisher': 'contains',
+      'description': 'contains',
+      'identifier': 'matches',
+      'jurisdiction': 'contains',
+      'date': 'matches',
+      'text': 'contains',
+      'system': 'matches',
+      'supplements': 'matches',
+      'content-mode': 'is',
+      'source': 'is'
+    };
+
+    const CONTROL_PARAMS = new Set(['_offset', '_count', '_sort', '_summary', '_elements', '_total']);
+
+    // Collect filter criteria
+    const criteria = [];
+    for (const [key, value] of urlObj.searchParams) {
+      if (key != 'mode') {
+        if (CONTROL_PARAMS.has(key) || !value) continue;
+        const label = PARAM_LABELS[key] || key;
+        const word = WORDS[key] || "contains";
+        criteria.push(`<strong>${escape(label)}</strong> ${word} &ldquo;${escape(value)}&rdquo;`);
+      }
+    }
+
+    // Collect display/pagination context
+    const total = json.total;
+    const offset = parseInt(urlObj.searchParams.get('_offset') || '0');
+    const count = parseInt(urlObj.searchParams.get('_count') || '20');
+    const sort = urlObj.searchParams.get('_sort');
+    const summary = urlObj.searchParams.get('_summary');
+    const elementsParam = urlObj.searchParams.get('_elements');
+
+    // Build the description sentence
+    let desc = `Searching <strong>${escape(resourceType)}s</strong>`;
+
+    if (criteria.length > 0) {
+      desc += ' where ' + criteria.join(', ');
+    } else {
+      desc += ' (all)';
+    }
+
+    // Pagination context
+    if (typeof total === 'number') {
+      const from = Math.min(offset + 1, total);
+      const to = Math.min(offset + count, total);
+      if (total === 0) {
+        desc += ' — <strong>no results found</strong>';
+      } else {
+        desc += ` — showing <strong>${from}–${to}</strong> of <strong>${total}</strong>`;
+      }
+    }
+
+    // Sort
+    if (sort) {
+      desc += `, sorted by <strong>${escape(sort)}</strong>`;
+    }
+
+    // Summary mode
+    if (summary && summary !== 'false') {
+      desc += ` [summary: ${escape(summary)}]`;
+    }
+
+    // Elements
+    if (elementsParam) {
+      desc += ` [fields: ${escape(elementsParam)}]`;
+    }
+
+    return `<p class="search-description">${desc}</p>`;
+  }
+
   /**
    * Render search results as a table (when _elements is specified)
    */
   async renderSearchTable(json, elements, req) {
     const entries = json.entry || [];
-    const total = json.total || 0;
 
-    let html = `<p>Found ${total} result(s)</p>`;
+    let html = this.describeSearchBundle(json);
 
     // Pagination links
     html += this.renderPaginationLinks(json);
@@ -859,22 +973,12 @@ class TxHtmlRenderer {
    */
   async renderSearchSummary(json, req) {
     const entries = json.entry || [];
-    const total = json.total || 0;
 
-    let html = `<p>Found ${total} result(s)</p>`;
+    let html = this.describeSearchBundle(json);
 
     // Pagination links
     html += this.renderPaginationLinks(json);
 
-    // Bundle summary
-    html += '<div class="card mb-3">';
-    html += '<div class="card-header">Bundle Summary</div>';
-    html += '<div class="card-body">';
-    html += `<p><strong>Type:</strong> ${escape(json.type)}</p>`;
-    html += `<p><strong>Total:</strong> ${total}</p>`;
-    html += '</div>';
-    html += '</div>';
-
     // Each entry
     for (const entry of entries) {
       html += '<hr/>';
@@ -1010,7 +1114,7 @@ class TxHtmlRenderer {
       html += '<div class="narrative">(No Narrative)</div>';
     }
     if (json.text && json.text.div) {
-    // Collapsible JSON source
+      // Collapsible JSON source
       html += '<div class="xhtml">';
       html += `<button type="button" class="btn btn-sm btn-outline-secondary" onclick="toggleOriginalNarrative('${resourceId}x')">`;
       html += 'Show Original Narrative</button>';
@@ -1047,8 +1151,17 @@ class TxHtmlRenderer {
       valueSetsJson: JSON.stringify(json.valueSets || [])
     });
   }
+
+  buildSourceOptions(provider) {
+    let result = '';
+    result += `<option value="internal">internal</option>`;
+    for (let sp of provider.listValueSetSourceCodes()) {
+      result += `<option value="${sp}">${sp}</option>`;
+    }
+    return result;
+  }
 }
 
 module.exports = {
- TxHtmlRenderer, loadTemplate
-};
+  TxHtmlRenderer, loadTemplate
+};

package/tx/tx.fhir.org.yml

@@ -26,6 +26,7 @@ sources:
   - snomed:sct_nl_20240930.cache
   - snomed:sct_uk_20230412.cache
   - snomed:sct_us_20230301.cache
+  - snomed:sct_us_20240301.cache
   - snomed:sct_us_20250901.cache
   - snomed:sct_test_20250814.cache
   - cpt:CodeSystem-cpt.db|cpt-2023-fragment-0.1.db

package/tx/tx.js

@@ -20,7 +20,7 @@ const packageJson = require("../package.json");
 // Import workers
 const ReadWorker = require('./workers/read');
 const SearchWorker = require('./workers/search');
-const { ExpandWorker } = require('./workers/expand');
+const { ExpandWorker, INTERNAL_DEFAULT_LIMIT, EXTERNAL_DEFAULT_LIMIT} = require('./workers/expand');
 const { ValidateWorker } = require('./workers/validate');
 const TranslateWorker = require('./workers/translate');
 const LookupWorker = require('./workers/lookup');
@@ -48,6 +48,8 @@ const {bundleFromR5} = require("./xversion/xv-bundle");
 const {convertResourceToR5} = require("./xversion/xv-resource");
 const ClosureWorker = require("./workers/closure");
 const {BundleXML} = require("./xml/bundle-xml");
+const ConceptUsageTracker = require("./usage-tracker");
+const ProblemFinder = require("./problems");
 // const {writeFileSync} = require("fs");
 
 class TXModule {
@@ -138,6 +140,7 @@ class TXModule {
       consoleErrors: config.consoleErrors,
       telnetErrors: config.telnetErrors
     });
+    this.usageTracker = new ConceptUsageTracker();
 
     this.log.info('Initializing TX module');
 
@@ -280,6 +283,7 @@ class TXModule {
         acceptLanguage, this.i18n, requestId, 30,
         endpointInfo.resourceCache, endpointInfo.expansionCache
       );
+      opContext.usageTracker = this.usageTracker;
 
       // Attach everything to request
       req.txProvider = endpointInfo.provider;
@@ -448,6 +452,14 @@ class TXModule {
     // Set up routes
     this.setupRoutes(router);
 
+    // Redirect /r5 → /r5/
+    app.use((req, res, next) => {
+      if (req.path === endpointPath) {
+        return res.redirect(301, endpointPath + '/');
+      }
+      next();
+    });
+
     // Register the router with the app
     app.use(endpointPath, router);
     this.routers.set(endpointPath, router);
@@ -609,7 +621,7 @@ class TXModule {
     router.get('/ValueSet/\\$expand', async (req, res) => {
       const start = Date.now();
       try {
-        let worker = new ExpandWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        let worker = new ExpandWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n, this.internalLimit(req), this.externalLimit(req));
         await worker.handle(req, res, this.log);
       } finally {
         this.countRequest('$expand', Date.now() - start);
@@ -618,7 +630,7 @@ class TXModule {
     router.post('/ValueSet/\\$expand', async (req, res) => {
       const start = Date.now();
       try {
-        let worker = new ExpandWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        let worker = new ExpandWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n, this.internalLimit(req), this.externalLimit(req));
         await worker.handle(req, res, this.log);
       } finally {
         this.countRequest('$expand', Date.now() - start);
@@ -773,7 +785,7 @@ class TXModule {
     router.get('/ValueSet/:id/\\$expand', async (req, res) => {
       const start = Date.now();
       try {
-        let worker = new ExpandWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        let worker = new ExpandWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n, this.internalLimit(req), this.externalLimit(req));
         await worker.handleInstance(req, res, this.log);
       } finally {
         this.countRequest('$expand', Date.now() - start);
@@ -782,7 +794,7 @@ class TXModule {
     router.post('/ValueSet/:id/\\$expand', async (req, res) => {
       const start = Date.now();
       try {
-        let worker = new ExpandWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        let worker = new ExpandWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n, this.internalLimit(req), this.externalLimit(req));
         await worker.handleInstance(req, res, this.log);
       } finally {
         this.countRequest('$expand', Date.now() - start);
@@ -882,6 +894,20 @@ class TXModule {
       }
     });
 
+    router.get('/problems.html', async (req, res) => {
+      const start = Date.now();
+      try {
+        let txhtml = new TxHtmlRenderer(new Renderer(req.txOpContext, req.txProvider), this.liquid);
+        const problemFinder = new ProblemFinder();
+        const content = await problemFinder.scanValueSets(req.txProvider);
+        const html = await txhtml.renderPage('Problems', '<h3>ValueSet dependencies on unknown CodeSystem/Versions</h3>'+content, req.txEndpoint, req.txStartTime);
+        res.setHeader('Content-Type', 'text/html');
+        res.send(html);
+      } finally {
+        this.countRequest('problems', Date.now() - start);
+      }
+    });
+
     // Metadata / CapabilityStatement
     router.get('/metadata', async (req, res) => {
       const start = Date.now();
@@ -1072,6 +1098,16 @@ class TXModule {
     }
   }
 
+  internalLimit(req) {
+    let isTest = req.header("User-Agent") == 'Tools/Java';
+    if (this.config.internalLimit && !isTest) return this.config.internalLimit; else return INTERNAL_DEFAULT_LIMIT;
+  }
+
+  externalLimit(req) {
+    let isTest = req.header("User-Agent") == 'Tools/Java';
+    if (this.config.internalLimit && !isTest) return this.config.externalLimit; else return EXTERNAL_DEFAULT_LIMIT;
+  }
+
 }
 
 module.exports = TXModule;

package/tx/usage-tracker.js

@@ -0,0 +1,70 @@
+
+class ConceptUsageTracker {
+
+  constructor() {
+    this.map = new Map();
+  }
+
+  async scanValueSets(library) {
+    let c = 0;
+    for (let vsp of library.valueSetProviders) {
+      let list = await vsp.listAllValueSets();
+      for (let url of list) {
+        let vs = await vsp.fetchValueSet(url);
+        if (vs && vs.jsonObj.compose) {
+          if (await this.scanValueSet(vs.jsonObj.compose)) {
+            c++;
+          }
+        }
+      }
+    }
+    return c;
+  }
+
+  async scanValueSet(compose, versions, active) {
+    let ok = false;
+    for (let inc of compose.include || []) {
+      if (inc.system) {
+        if (active && inc.version) {
+          this.seeVersion(versions, inc.system, inc.version);
+        }
+        for (let c of inc.concept || []) {
+          if (c.code) {
+            ok = true;
+            this.seeConcept(inc.system, c.code);
+          }
+        }
+      }
+    }
+    return ok;
+  }
+
+  seeConcept(system, code) {
+    let cs = this.map.get(system);
+    if (!cs) {
+      cs = new Map();
+      this.map.set(system, cs);
+    }
+    let ci = cs.get(code);
+    if (!ci) {
+      ci = { count : 0 }
+      cs.set(code, ci);
+    }
+    ci.count++;
+  }
+
+  usages(system) {
+    return this.map.get(system) || null;
+  }
+
+  seeVersion(versions, system, version) {
+    let set = versions[system];
+    if (set == null) {
+      set = new Set();
+      versions[system] = set;
+    }
+    set.add(version);
+  }
+}
+
+module.exports = ConceptUsageTracker;

package/tx/vs/vs-api.js

@@ -8,6 +8,9 @@ class AbstractValueSetProvider {
    */
   spaceId;
 
+  code() {
+    throw new Error('code must be implemented by AbstractValueSetProvider subclass');
+  }
   /**
    * ensure that the ids on the value sets are unique, if they are
    * in the global namespace

package/tx/vs/vs-database.js

@@ -37,7 +37,7 @@ class ValueSetDatabase {
       this._db = new sqlite3.Database(this.dbPath, sqlite3.OPEN_READONLY, (err) => {
         if (err) {
           this._db = null;
-          reject(new Error(`Failed to open database: ${err.message}`));
+          reject(new Error(`Failed to open database ${this.dbPath}: ${err.message}`));
         } else {
           resolve(this._db);
         }
@@ -122,7 +122,7 @@ class ValueSetDatabase {
     return new Promise((resolve, reject) => {
       const db = new sqlite3.Database(this.dbPath, (err) => {
         if (err) {
-          reject(new Error(`Failed to create database: ${err.message}`));
+          reject(new Error(`Failed to create database ${this.dbPath}: ${err.message}`));
           return;
         }
 
@@ -177,6 +177,7 @@ class ValueSetDatabase {
               CREATE TABLE valueset_systems (
                                                 valueset_id TEXT,
                                                 system TEXT,
+                                                version TEXT,
                                                 FOREIGN KEY (valueset_id) REFERENCES valuesets(url)
               )
           `);
@@ -193,7 +194,7 @@ class ValueSetDatabase {
           db.run('CREATE INDEX idx_identifiers_value ON valueset_identifiers(value)');
           db.run('CREATE INDEX idx_jurisdictions_system ON valueset_jurisdictions(system)');
           db.run('CREATE INDEX idx_jurisdictions_code ON valueset_jurisdictions(code)');
-          db.run('CREATE INDEX idx_systems_system ON valueset_systems(system)');
+          db.run('CREATE INDEX idx_systems_system ON valueset_systems(system, version)');
 
           db.close((err) => {
             if (err) {
@@ -392,8 +393,8 @@ class ValueSetDatabase {
           pendingOperations++;
 
           db.run(`
-              INSERT INTO valueset_systems (valueset_id, system) VALUES (?, ?)
-          `, [valueSet.id, include.system], function(err) {
+              INSERT INTO valueset_systems (valueset_id, system, version) VALUES (?, ?, ?)
+          `, [valueSet.id, include.system, include.version], function(err) {
             if (err) {
               operationError(new Error(`Failed to insert system: ${err.message}`));
             } else {
@@ -735,8 +736,15 @@ class ValueSetDatabase {
 
         case 'system':
           joins.add('JOIN valueset_systems vs ON v.id = vs.valueset_id');
-          conditions.push('vs.system = ?');
-          params.push(value);
+          if (value.includes('|')) {
+            conditions.push('vs.system = ?');
+            params.push(value.substring(0, value.indexOf('|')));
+            conditions.push('vs.version = ?');
+            params.push(value.substring(value.indexOf('|')+1));
+          } else {
+            conditions.push('vs.system = ?');
+            params.push(value);
+          }
           break;
 
         default:

package/tx/vs/vs-package.js

@@ -23,6 +23,11 @@ class PackageValueSetProvider extends AbstractValueSetProvider {
     this.valueSetMap = new Map();
     this.initialized = false;
     this.count = 0;
+    this.sourcePackageCode = packageLoader.id();
+  }
+
+  sourcePackage() {
+    return this.sourcePackageCode;
   }
 
   /**
@@ -42,7 +47,7 @@ class PackageValueSetProvider extends AbstractValueSetProvider {
       await this._populateDatabase();
     }
 
-    this.valueSetMap = await this.database.loadAllValueSets(this.packageLoader.pid());
+    this.valueSetMap = await this.database.loadAllValueSets(this.sourcePackage());
     this.initialized = true;
   }