fhirsmith 0.4.2 → 0.5.0

package/tx/tx.js

@@ -36,6 +36,19 @@ const {ConceptMapXML} = require("./xml/conceptmap-xml");
 const {TxHtmlRenderer} = require("./tx-html");
 const {Renderer} = require("./library/renderer");
 const {OperationsWorker} = require("./workers/operations");
+const {RelatedWorker} = require("./workers/related");
+const {codeSystemFromR5} = require("./xversion/xv-codesystem");
+const {operationOutcomeFromR5} = require("./xversion/xv-operationoutcome");
+const {parametersFromR5} = require("./xversion/xv-parameters");
+const {conceptMapFromR5} = require("./xversion/xv-conceptmap");
+const {valueSetFromR5} = require("./xversion/xv-valueset");
+const {terminologyCapabilitiesFromR5} = require("./xversion/xv-terminologyCapabilities");
+const {capabilityStatementFromR5} = require("./xversion/xv-capabiliityStatement");
+const {bundleFromR5} = require("./xversion/xv-bundle");
+const {convertResourceToR5} = require("./xversion/xv-resource");
+const ClosureWorker = require("./workers/closure");
+const {BundleXML} = require("./xml/bundle-xml");
+// const {writeFileSync} = require("fs");
 
 class TXModule {
   timers = [];
@@ -69,10 +82,48 @@ class TXModule {
   }
 
   acceptsXml(req) {
-    const accept = req.headers.accept || '';
-    return accept.includes('application/fhir+xml') || accept.includes('application/xml+fhir');
+    let _fmt = req.query._format || req.query.format || req.body?._format;
+    if (_fmt && typeof _fmt !== 'string') {
+      _fmt = null;
+    }
+    if (_fmt && _fmt == 'xml') {
+      return 'application/fhir+xml';
+    }
+    if (!_fmt) {
+      _fmt = req.headers.accept || '';
+    }
+    if (_fmt.includes('application/fhir+xml')) {
+      return 'application/fhir+xml';
+    } else if (_fmt.includes('application/xml+fhir')) {
+      return 'application/xml+fhir';
+    } else if (_fmt.includes('application/xml')) {
+      return 'application/xml';
+    } else {
+      return null;
+    }
   }
 
+  acceptsJson(req) {
+    let _fmt = req.query._format || req.query.format || req.body?._format;
+    if (_fmt && typeof _fmt !== 'string') {
+      _fmt = null;
+    }
+    if (_fmt && _fmt == 'json') {
+      return 'application/fhir+json';
+    }
+    if (!_fmt) {
+      _fmt = req.headers.accept || '';
+    }
+    if (_fmt.includes('application/fhir+json')) {
+      return 'application/fhir+json';
+    } else if (_fmt.includes('application/json+fhir')) {
+      return 'application/json+fhir';
+    } else if (_fmt.includes('application/json')) {
+      return 'application/json';
+    } else {
+      return 'application/fhir+json';
+    }
+  }
 
   /**
    * Initialize the TX module
@@ -103,9 +154,9 @@ class TXModule {
     }
 
     // Load language definitions
-    const langPath = path.join(__dirname, 'data', 'lang.dat');
+    const langPath = path.join(__dirname, 'data');
     this.log.info(`Loading language definitions from: ${langPath}`);
-    this.languages = await LanguageDefinitions.fromFile(langPath);
+    this.languages = await LanguageDefinitions.fromFiles(langPath);
     this.log.info('Language definitions loaded');
 
     // Initialize i18n support
@@ -131,7 +182,7 @@ class TXModule {
 
     // Load the library from YAML
     this.log.info(`Loading library from: ${config.librarySource}`);
-    this.library = new Library(config.librarySource, this.log);
+    this.library = new Library(config.librarySource, config.vsacCfg, this.log, this.stats);
     this.log.info(`Load...`);
     await this.library.load();
     this.log.info('Library loaded successfully');
@@ -180,8 +231,8 @@ class TXModule {
       path: endpointPath,
       fhirVersion,
       context: context || null,
-      resourceCache: new ResourceCache(),
-      expansionCache: new ExpansionCache(expansionCacheSize, expansionCacheMemoryThreshold)
+      resourceCache: new ResourceCache(this.stats),
+      expansionCache: new ExpansionCache(this.stats, expansionCacheSize, expansionCacheMemoryThreshold)
     };
     // Create the provider once for this endpoint
     endpointInfo.provider = await this.library.cloneWithFhirVersion(fhirVersion, context, endpointPath);
@@ -190,6 +241,9 @@ class TXModule {
     // cacheTimeout is in minutes, default to 30 minutes
     const cacheTimeoutMs = cacheTimeoutMinutes * 60 * 1000;
     const pruneIntervalMs = 5 * 60 * 1000; // Run every 5 minutes
+    if (this.stats) {
+      this.stats.addTask("Client Cache", "5 min");
+    }
     this.timers.push(setInterval(() => {
       endpointInfo.resourceCache.prune(cacheTimeoutMs);
     }, pruneIntervalMs));
@@ -197,6 +251,9 @@ class TXModule {
 
     // Set up periodic memory pressure check for expansion cache (if threshold configured)
     if (expansionCacheMemoryThreshold > 0) {
+      if (this.stats) {
+        this.stats.addTask("Expansion Cache", "5 min");
+      }
       this.timers.push(setInterval(() => {
         if (endpointInfo.expansionCache.checkMemoryPressure()) {
           this.log.info(`Expansion cache memory pressure detected for ${endpointPath}, evicted oldest half`);
@@ -244,7 +301,9 @@ class TXModule {
         try {
           const duration = Date.now() - req.txStartTime;
           const isHtml = txhtml.acceptsHtml(req);
-          const isXml = this.acceptsXml(req);
+          const xmlFmt = this.acceptsXml(req);
+          const jsonFmt = this.acceptsJson(req);
+          data = this.transformResourceForVersion(data, endpointInfo.fhirVersion);
 
           let responseSize;
           let result;
@@ -256,28 +315,31 @@ class TXModule {
             responseSize = Buffer.byteLength(html, 'utf8');
             res.setHeader('Content-Type', 'text/html');
             result = res.send(html);
-          } else if (isXml) {
+          } else if (xmlFmt) {
             try {
               const xml = this.convertResourceToXml(data);
               responseSize = Buffer.byteLength(xml, 'utf8');
-              res.setHeader('Content-Type', 'application/fhir+xml');
+              res.setHeader('Content-Type', xmlFmt);
               result = res.send(xml);
             } catch (err) {
               console.error(err);
               // Fall back to JSON if XML conversion not supported
               this.log.warn(`XML conversion failed for ${data.resourceType}: ${err.message}, falling back to JSON`);
+              res.setHeader('Content-Type', jsonFmt);
               const jsonStr = JSON.stringify(data);
               responseSize = Buffer.byteLength(jsonStr, 'utf8');
               result = originalJson(data);
             }
           } else {
             const jsonStr = JSON.stringify(data);
+            res.setHeader('Content-Type', jsonFmt);
+            this.checkProperJson(jsonStr);
             responseSize = Buffer.byteLength(jsonStr, 'utf8');
             result = originalJson(data);
           }
 
           // Log the request with request ID
-          const format = isHtml ? 'html' : (isXml ? 'xml' : 'json');
+          const format = isHtml ? 'html' : (xmlFmt ? 'xml' : 'json');
           let li = req.logInfo ? "(" + req.logInfo + ")" : "";
           this.log.info(`[${requestId}] ${req.method} ${format} ${res.statusCode} ${duration}ms ${responseSize}: ${req.originalUrl} ${li})`);
 
@@ -364,11 +426,24 @@ class TXModule {
             });
           }
         }
+      } else if (contentType != 'application/x-www-form-urlencoded') {
+        return res.status(415).json({
+          resourceType: 'OperationOutcome',
+          issue: [{
+            severity: 'error',
+            code: 'invalid',
+            diagnostics: `Unsupported Media Type: ${contentType}`
+          }]
+        });
       }
 
+      if (req.body) {
+        req.body = convertResourceToR5(req.body, req.txEndpoint.fhirVersion);
+      }
       next();
     });
 
+    app.use(express.urlencoded({ extended: true }));
 
     // Set up routes
     this.setupRoutes(router);
@@ -490,6 +565,26 @@ class TXModule {
       }
     });
 
+    // ValueSet/$related(GET and POST)
+    router.get('/ValueSet/\\$related', async (req, res) => {
+      const start = Date.now();
+      try {
+        let worker = new RelatedWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        await worker.handle(req, res);
+      } finally {
+        this.countRequest('$related', Date.now() - start);
+      }
+    });
+    router.post('/ValueSet/\\$related', async (req, res) => {
+      const start = Date.now();
+      try {
+        let worker = new RelatedWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        await worker.handle(req, res);
+      } finally {
+        this.countRequest('$related', Date.now() - start);
+      }
+    });
+
     // ValueSet/$batch-validate-code (GET and POST)
     router.get('/ValueSet/\\$batch-validate-code', async (req, res) => {
       const start = Date.now();
@@ -554,7 +649,7 @@ class TXModule {
     router.get('/ConceptMap/\\$closure', async (req, res) => {
       const start = Date.now();
       try {
-        let worker = new TranslateWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        let worker = new ClosureWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
         await worker.handle(req, res, this.log);
       } finally {
         this.countRequest('$closure', Date.now() - start);
@@ -563,7 +658,7 @@ class TXModule {
     router.post('/ConceptMap/\\$closure', async (req, res) => {
       const start = Date.now();
       try {
-        let worker = new TranslateWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        let worker = new ClosureWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
         await worker.handle(req, res, this.log);
       } finally {
         this.countRequest('$closure', Date.now() - start);
@@ -653,6 +748,27 @@ class TXModule {
       }
     });
 
+
+    // ValueSet/[id]/$related
+    router.get('/ValueSet/:id/\\$related', async (req, res) => {
+      const start = Date.now();
+      try {
+        let worker = new RelatedWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        await worker.handleInstance(req, res, this.log);
+      } finally {
+        this.countRequest('$related', Date.now() - start);
+      }
+    });
+    router.post('/ValueSet/:id/\\$related', async (req, res) => {
+      const start = Date.now();
+      try {
+        let worker = new RelatedWorker(req.txOpContext, this.log, req.txProvider, this.languages, this.i18n);
+        await worker.handleInstance(req, res, this.log);
+      } finally {
+        this.countRequest('$related', Date.now() - start);
+      }
+    });
+
     // ValueSet/[id]/$expand
     router.get('/ValueSet/:id/\\$expand', async (req, res) => {
       const start = Date.now();
@@ -871,6 +987,7 @@ class TXModule {
     switch (res.resourceType) {
       case "CodeSystem" : return CodeSystemXML._jsonToXml(res);
       case "ValueSet" : return ValueSetXML.toXml(res);
+      case "Bundle" : return BundleXML.toXml(res, this.fhirVersion);
       case "CapabilityStatement" : return CapabilityStatementXML.toXml(res, "R5");
       case "TerminologyCapabilities" : return TerminologyCapabilitiesXML.toXml(res, "R5");
       case "Parameters": return ParametersXML.toXml(res, this.fhirVersion);
@@ -922,6 +1039,39 @@ class TXModule {
     }
     return count;
   }
+
+  ec = 0;
+
+  checkProperJson() { // jsonStr) {
+  //   const errors = [];
+  //   if (jsonStr.includes("[]")) errors.push("Found [] in json");
+  //   if (jsonStr.includes('""')) errors.push('Found "" in json');
+  //
+  //   if (errors.length > 0) {
+  //     this.ec++;
+  //     const filename = `/Users/grahamegrieve/temp/tx-err-log/err${this.ec}.json`;
+  //     writeFileSync(filename, jsonStr);
+  //     throw new Error(errors.join('; '));
+  //   }
+  }
+
+  transformResourceForVersion(data, fhirVersion) {
+    if (fhirVersion == "5.0" || !data.resourceType) {
+        return data;
+    }
+    switch (data.resourceType) {
+      case "CodeSystem": return codeSystemFromR5(data, fhirVersion);
+      case "CapabilityStatement": return capabilityStatementFromR5(data, fhirVersion);
+      case "TerminologyCapabilities": return terminologyCapabilitiesFromR5(data, fhirVersion);
+      case "ValueSet": return valueSetFromR5(data, fhirVersion);
+      case "ConceptMap": return conceptMapFromR5(data, fhirVersion);
+      case "Parameters": return parametersFromR5(data, fhirVersion);
+      case "OperationOutcome": return operationOutcomeFromR5(data, fhirVersion);
+      case "Bundle": return bundleFromR5(data, fhirVersion);
+      default: return data;
+    }
+  }
+
 }
 
 module.exports = TXModule;

package/tx/vs/vs-database.js

@@ -2,7 +2,6 @@ const fs = require('fs').promises;
 const sqlite3 = require('sqlite3').verbose();
 const { VersionUtilities } = require('../../library/version-utilities');
 const ValueSet = require("../library/valueset");
-const row = require("../library/valueset");
 
 // Columns that can be returned directly without parsing JSON
 const INDEXED_COLUMNS = ['id', 'url', 'version', 'date', 'description', 'name', 'publisher', 'status', 'title'];
@@ -279,6 +278,37 @@ class ValueSetDatabase {
     });
   }
 
+  /**
+   * Just update the timestamp on the valueset
+   * @param {Object} valueSet - The ValueSet resource
+   * @returns {Promise<void>}
+   */
+  async seeValueSet(valueSet) {
+    if (!valueSet.url) {
+      throw new Error('ValueSet must have a url property');
+    }
+
+    const db = await this._getWriteConnection();
+
+    return new Promise((resolve, reject) => {
+      db.run(`
+          update valuesets
+          set last_seen = strftime('%s', 'now')
+          where url = ?
+            and version = ?
+      `, [
+        valueSet.url,
+        valueSet.version
+      ], (err) => {
+        if (err) {
+          reject(new Error(`Failed to update value Set: ${err.message}`));
+          return;
+        }
+        resolve();
+      });
+    });
+  }
+
   /**
    * Insert related records for a ValueSet
    * @param {sqlite3.Database} db - Database connection
@@ -380,22 +410,6 @@ class ValueSetDatabase {
     }
   }
 
-  /**
-   * Insert multiple ValueSets in a batch operation
-   * @param {Array<Object>} valueSets - Array of ValueSet resources
-   * @returns {Promise<void>}
-   */
-  async batchUpsertValueSets(valueSets) {
-    if (valueSets.length === 0) {
-      return;
-    }
-
-    // Process sequentially to avoid database locking
-    for (const valueSet of valueSets) {
-      await this.upsertValueSet(valueSet);
-    }
-  }
-
   /**
    * Load all ValueSets from the database
    * @returns {Promise<Map<string, Object>>} Map of all ValueSets keyed by various combinations
@@ -417,29 +431,8 @@ class ValueSetDatabase {
           for (const row of rows) {
             const valueSet = new ValueSet(JSON.parse(row.content));
             valueSet.sourcePackage = source;
-
             // Store by URL and id alone
-            valueSetMap.set(row.url, valueSet);
-            valueSetMap.set(row.id, valueSet);
-
-            if (row.version) {
-              // Store by url|version
-              const versionKey = `${row.url}|${row.version}`;
-              valueSetMap.set(versionKey, valueSet);
-
-              // If version is semver, also store by url|major.minor
-              try {
-                if (VersionUtilities.isSemVer(row.version)) {
-                  const majorMinor = VersionUtilities.getMajMin(row.version);
-                  if (majorMinor) {
-                    const majorMinorKey = `${row.url}|${majorMinor}`;
-                    valueSetMap.set(majorMinorKey, valueSet);
-                  }
-                }
-              } catch (error) {
-                // Ignore version parsing errors, just don't add major.minor key
-              }
-            }
+            this.addToMap(valueSetMap, row.id, row.url, row.version, valueSet);
           }
 
           resolve(valueSetMap);
@@ -450,6 +443,30 @@ class ValueSetDatabase {
     });
   }
 
+  addToMap(valueSetMap, id, url, version, valueSet) {
+    valueSetMap.set(url, valueSet);
+    valueSetMap.set(id, valueSet);
+
+    if (version) {
+      // Store by url|version
+      const versionKey = `${url}|${version}`;
+      valueSetMap.set(versionKey, valueSet);
+
+      // If version is semver, also store by url|major.minor
+      try {
+        if (VersionUtilities.isSemVer(version)) {
+          const majorMinor = VersionUtilities.getMajMin(version);
+          if (majorMinor) {
+            const majorMinorKey = `${url}|${majorMinor}`;
+            valueSetMap.set(majorMinorKey, valueSet);
+          }
+        }
+      } catch (error) {
+        // Ignore version parsing errors, just don't add major.minor key
+      }
+    }
+  }
+
   /**
    * Search for ValueSets based on criteria
    * @param {Array<{name: string, value: string}>} searchParams - Search criteria

package/tx/vs/vs-package.js

@@ -71,10 +71,28 @@ class PackageValueSetProvider extends AbstractValueSetProvider {
     }
 
     if (valueSets.length > 0) {
-      await this.database.batchUpsertValueSets(valueSets);
+      await this.batchUpsertValueSets(valueSets);
     }
   }
 
+
+  /**
+   * Insert multiple ValueSets in a batch operation
+   * @param {Array<Object>} valueSets - Array of ValueSet resources
+   * @returns {Promise<void>}
+   */
+  async batchUpsertValueSets(valueSets) {
+    if (valueSets.length === 0) {
+      return;
+    }
+
+    // Process sequentially to avoid database locking
+    for (const valueSet of valueSets) {
+      await this.database.upsertValueSet(valueSet);
+    }
+  }
+
+
   /**
    * Fetches a value set by URL and version
    * @param {string} url - The canonical URL of the value set
@@ -107,7 +125,7 @@ class PackageValueSetProvider extends AbstractValueSetProvider {
     }
 
     // Finally try just the URL
-    if (this.valueSetMap.has(url)) {
+    if (!version && this.valueSetMap.has(url)) {
       return this.valueSetMap.get(url);
     }
 
@@ -325,6 +343,7 @@ class PackageValueSetProvider extends AbstractValueSetProvider {
     // Get all current entries - we'll iterate and modify
     const entries = Array.from(this.valueSetMap.entries());
 
+    // eslint-disable-next-line no-unused-vars
     for (const [key, vs] of entries) {
       // Skip if we've already processed this ValueSet instance
       if (alreadyPrefixed.has(vs)) {