fhirsmith 0.4.2 → 0.5.0

package/tx/library/valueset.js

@@ -1,6 +1,5 @@
 const {CanonicalResource} = require("./canonical-resource");
-const {getValueName} = require("../../library/utilities");
-const {VersionUtilities} = require("../../library/version-utilities");
+const {valueSetToR5, valueSetFromR5} = require("../xversion/xv-valueset");
 
 /**
  * Represents a FHIR ValueSet resource with version conversion support
@@ -23,7 +22,7 @@ class ValueSet extends CanonicalResource {
   constructor(jsonObj, fhirVersion = 'R5') {
     super(jsonObj, fhirVersion);
     // Convert to R5 format internally (modifies input for performance)
-    this.jsonObj = this._convertToR5(jsonObj, fhirVersion);
+    this.jsonObj = valueSetToR5(jsonObj, fhirVersion);
     this.validate();
     this.buildMaps();
   }
@@ -51,241 +50,10 @@ class ValueSet extends CanonicalResource {
    * @returns {string} JSON string
    */
   toJSONString(version = 'R5') {
-    const outputObj = this.convertFromR5(this.jsonObj, version);
+    const outputObj = valueSetFromR5(this.jsonObj, version);
     return JSON.stringify(outputObj);
   }
 
-  /**
-   * Converts input ValueSet to R5 format (modifies input object for performance)
-   * @param {Object} jsonObj - The input ValueSet object
-   * @param {string} version - Source FHIR version
-   * @returns {Object} The same object, potentially modified to R5 format
-   * @private
-   */
-  _convertToR5(jsonObj, version) {
-    if (version === 'R5') {
-      return jsonObj; // Already R5, no conversion needed
-    }
-
-    if (version === 'R3') {
-      // R3 to R5: Remove extensible field (we ignore it completely)
-      if (jsonObj.extensible !== undefined) {
-        delete jsonObj.extensible;
-      }
-      return jsonObj;
-    }
-
-    if (version === 'R4') {
-      // R4 to R5: No structural conversion needed
-      // R5 is backward compatible for the structural elements we care about
-      return jsonObj;
-    }
-
-    throw new Error(`Unsupported FHIR version: ${version}`);
-  }
-
-  /**
-   * Converts R5 ValueSet to target version format (clones object first)
-   * @param {Object} r5Obj - The R5 format ValueSet object
-   * @param {string} targetVersion - Target FHIR version
-   * @returns {Object} New object in target version format
-   * @private
-   */
-  convertFromR5(r5Obj, targetVersion) {
-    if (VersionUtilities.isR5Ver(targetVersion)) {
-      return r5Obj; // No conversion needed
-    }
-
-    // Clone the object to avoid modifying the original
-    const cloned = JSON.parse(JSON.stringify(r5Obj));
-
-    if (VersionUtilities.isR4Ver(targetVersion)) {
-      return this._convertR5ToR4(cloned);
-    } else if (VersionUtilities.isR3Ver(targetVersion)) {
-      return this._convertR5ToR3(cloned);
-    }
-
-    throw new Error(`Unsupported target FHIR version: ${targetVersion}`);
-  }
-
-  /**
-   * Converts R5 ValueSet to R4 format
-   * @param {Object} r5Obj - Cloned R5 ValueSet object
-   * @returns {Object} R4 format ValueSet
-   * @private
-   */
-  _convertR5ToR4(r5Obj) {
-    // Remove R5-specific elements that don't exist in R4
-    if (r5Obj.versionAlgorithmString) {
-      delete r5Obj.versionAlgorithmString;
-    }
-    if (r5Obj.versionAlgorithmCoding) {
-      delete r5Obj.versionAlgorithmCoding;
-    }
-
-    // Filter out R5-only filter operators in compose
-    if (r5Obj.compose && r5Obj.compose.include) {
-      r5Obj.compose.include = r5Obj.compose.include.map(include => {
-        if (include.filter && Array.isArray(include.filter)) {
-          include.filter = include.filter.map(filter => {
-            if (filter.op && this._isR5OnlyFilterOperator(filter.op)) {
-              // Remove R5-only operators
-              return null;
-            }
-            return filter;
-          }).filter(filter => filter !== null);
-        }
-        return include;
-      });
-    }
-
-    if (r5Obj.compose && r5Obj.compose.exclude) {
-      r5Obj.compose.exclude = r5Obj.compose.exclude.map(exclude => {
-        if (exclude.filter && Array.isArray(exclude.filter)) {
-          exclude.filter = exclude.filter.map(filter => {
-            if (filter.op && this._isR5OnlyFilterOperator(filter.op)) {
-              // Remove R5-only operators
-              return null;
-            }
-            return filter;
-          }).filter(filter => filter !== null);
-        }
-        return exclude;
-      });
-    }
-
-    if (r5Obj.expansion) {
-      let exp = r5Obj.expansion;
-
-      // Convert ValueSet.expansion.property to extensions
-      if (exp.property && exp.property.length > 0) {
-        exp.extension = exp.extension || [];
-        for (let prop of exp.property) {
-          exp.extension.push({
-            url: "http://hl7.org/fhir/5.0/StructureDefinition/extension-ValueSet.expansion.property",
-            extension: [
-              { url: "code", valueCode: prop.code },
-              { url: "uri", valueUri: prop.uri }
-            ]
-          });
-        }
-        delete exp.property;
-        this.convertContainsPropertyR5ToR4(exp.contains);
-
-      }
-    }
-
-    return r5Obj;
-  }
-
-  // Recursive function to convert contains.property
-  convertContainsPropertyR5ToR4(containsList) {
-    if (!containsList) return;
-
-    for (let item of containsList) {
-      if (item.property && item.property.length > 0) {
-        item.extension = item.extension || [];
-        for (let prop of item.property) {
-          let ext = {
-            url: "http://hl7.org/fhir/5.0/StructureDefinition/extension-ValueSet.expansion.contains.property",
-            extension: [
-              { url: "code", valueCode: prop.code }
-            ]
-          };
-          let pn = getValueName(prop);
-          let subExt = { url: "value" };
-          subExt[pn] = prop[pn];
-          ext.extension.push(subExt);
-          item.extension.push(ext);
-        }
-        delete item.property;
-      }
-
-      // Recurse into nested contains
-      if (item.contains) {
-        this.convertContainsPropertyR5ToR4(item.contains);
-      }
-    }
-  }
-
-  /**
-   * Converts R5 ValueSet to R3 format
-   * @param {Object} r5Obj - Cloned R5 ValueSet object
-   * @returns {Object} R3 format ValueSet
-   * @private
-   */
-  _convertR5ToR3(r5Obj) {
-    // First apply R4 conversions
-    const r4Obj = this._convertR5ToR4(r5Obj);
-
-    // R3 has more limited filter operator support
-    if (r4Obj.compose && r4Obj.compose.include) {
-      r4Obj.compose.include = r4Obj.compose.include.map(include => {
-        if (include.filter && Array.isArray(include.filter)) {
-          include.filter = include.filter.map(filter => {
-            if (filter.op && !this._isR3CompatibleFilterOperator(filter.op)) {
-              // Remove non-R3-compatible operators
-              return null;
-            }
-            return filter;
-          }).filter(filter => filter !== null);
-        }
-        return include;
-      });
-    }
-
-    if (r4Obj.compose && r4Obj.compose.exclude) {
-      r4Obj.compose.exclude = r4Obj.compose.exclude.map(exclude => {
-        if (exclude.filter && Array.isArray(exclude.filter)) {
-          exclude.filter = exclude.filter.map(filter => {
-            if (filter.op && !this._isR3CompatibleFilterOperator(filter.op)) {
-              // Remove non-R3-compatible operators
-              return null;
-            }
-            return filter;
-          }).filter(filter => filter !== null);
-        }
-        return exclude;
-      });
-    }
-
-    return r4Obj;
-  }
-
-  /**
-   * Checks if a filter operator is R5-only
-   * @param {string} operator - Filter operator code
-   * @returns {boolean} True if operator is R5-only
-   * @private
-   */
-  _isR5OnlyFilterOperator(operator) {
-    const r5OnlyOperators = [
-      'generalizes',  // Added in R5
-      // Add other R5-only operators as they're identified
-    ];
-    return r5OnlyOperators.includes(operator);
-  }
-
-  /**
-   * Checks if a filter operator is compatible with R3
-   * @param {string} operator - Filter operator code
-   * @returns {boolean} True if operator is R3-compatible
-   * @private
-   */
-  _isR3CompatibleFilterOperator(operator) {
-    const r3CompatibleOperators = [
-      '=',           // Equal
-      'is-a',        // Is-A relationship
-      'descendent-of', // Descendant of (note: R3 spelling)
-      'is-not-a',    // Is-Not-A relationship
-      'regex',       // Regular expression
-      'in',          // In set
-      'not-in',      // Not in set
-      'exists',      // Property exists
-    ];
-    return r3CompatibleOperators.includes(operator);
-  }
-
   /**
    * Gets the FHIR version this ValueSet was loaded from
    * @returns {string} FHIR version ('R3', 'R4', or 'R5')

package/tx/library.js

@@ -30,6 +30,7 @@ const {ListCodeSystemProvider} = require("./cs/cs-provider-list");
 const { Provider } = require("./provider");
 const {I18nSupport} = require("../library/i18nsupport");
 const folders = require('../library/folder-setup');
+const {VSACValueSetProvider} = require("./vs/vs-vsac");
 
 /**
  * This class holds all the loaded content ready for processing
@@ -68,6 +69,7 @@ class Library {
   startMemory = process.memoryUsage();
   lastTime = null;
   totalDownloaded = 0;
+  vsacCfg = undefined;
 
   registerProvider(source, factory, isDefault = false) {
     this.#logSystem(factory.system(), factory.version(), source);
@@ -82,9 +84,12 @@ class Library {
     }
   }
 
-  constructor(configFile, log) {
+  constructor(configFile, vsacCfg, log, stats) {
     this.configFile = configFile;
+    this.vsacCfg = vsacCfg;
     this.log = log;
+    this.stats = stats;
+
     // Only synchronous initialization here
     this.codeSystemFactories = new Map();
     this.codeSystemProviders = [];
@@ -140,7 +145,7 @@ class Library {
 
   async load() {
     this.startTime = Date.now();
-    this.languageDefinitions = await LanguageDefinitions.fromFile(path.join(__dirname, '../tx/data/lang.dat'));
+    this.languageDefinitions = await LanguageDefinitions.fromFiles(path.join(__dirname, '../tx/data'));
     this.i18n = new I18nSupport(path.join(__dirname, '../translations'), this.languageDefinitions);
     await this.i18n.load();
 
@@ -243,9 +248,21 @@ class Library {
         break;
 
       case 'npm':
-        await this.loadNpm(packageManager, details, isDefault, mode);
+        await this.loadNpm(packageManager, details, isDefault, mode, false);
+        break;
+
+      case 'npm/cs':
+        await this.loadNpm(packageManager, details, isDefault, mode, true);
+        break;
+
+      case 'url':
+        await this.loadUrl(packageManager, details, isDefault, mode, false);
         break;
 
+      case 'url/cs':
+        await this.loadUrl(packageManager, details, isDefault, mode, true);
+        break;
+        
       default:
         throw new Error(`Unknown source type: ${type}`);
     }
@@ -301,6 +318,21 @@ class Library {
         this.registerProvider('internal', hgvs);
         break;
       }
+      case "vsac" : {
+        if (!this.vsacCfg || !this.vsacCfg.apiKey) {
+          throw new Error("Unable to load VSAC provider unless vsacCfg is provided in the configuration");
+        }
+        let vsac = new VSACValueSetProvider(this.vsacCfg, this.stats);
+        vsac.initialize();
+        this.valueSetProviders.push(vsac);
+        //const mem = process.memoryUsage();
+        let time = Math.floor(Date.now() - this.lastTime).toString().padStart(5)+" ";
+        let system = "vsac".padEnd(50);
+        let version = "n/a".padEnd(62);
+        this.log.info(`${time}${system}${version}${vsac.baseUrl}`);
+        this.lastTime = Date.now();
+        break;
+      }
       default:
         throw new Error("Unknown Internal Provider "+details);
     }
@@ -392,7 +424,7 @@ class Library {
     this.registerProvider(omopFN, omop, isDefault);
   }
 
-  async loadNpm(packageManager, details, isDefault, mode) {
+  async loadNpm(packageManager, details, isDefault, mode, csOnly) {
     // Parse packageId and version from details (e.g., "hl7.terminology.r4#6.0.2")
     let packageId = details;
     let version = null;
@@ -422,14 +454,52 @@ class Library {
       csc++;
     }
     this.codeSystemProviders.push(cp);
-    const vs = new PackageValueSetProvider(contentLoader);
-    await vs.initialize();
-    this.valueSetProviders.push(vs);
-    const cm = new PackageConceptMapProvider(contentLoader);
-    await cm.initialize();
-    this.conceptMapProviders.push(cm);
-
-    this.#logPackage(contentLoader.id(), contentLoader.version(), csc, vs.valueSetMap.size);
+    let vs = null;
+    if (!csOnly) {
+      vs = new PackageValueSetProvider(contentLoader);
+      await vs.initialize();
+      this.valueSetProviders.push(vs);
+      const cm = new PackageConceptMapProvider(contentLoader);
+      await cm.initialize();
+      this.conceptMapProviders.push(cm);
+    }
+
+    this.#logPackage(contentLoader.id(), contentLoader.version(), csc, vs ? vs.valueSetMap.size : 0);
+  }
+
+  async loadUrl(packageManager, url, isDefault, mode, csOnly) {
+    const packagePath = await packageManager.fetchUrl(url);
+    if (mode === "fetch" || mode === "cs") {
+      return;
+    }
+    const fullPackagePath = path.join(this.cacheFolder, packagePath);
+    const contentLoader = new PackageContentLoader(fullPackagePath);
+    await contentLoader.initialize();
+
+    this.contentSources.push(contentLoader.id()+"#"+contentLoader.version());
+
+    let cp = new ListCodeSystemProvider();
+    const resources = await contentLoader.getResourcesByType("CodeSystem");
+    let csc = 0;
+    for (const resource of resources) {
+      const cs = new CodeSystem(await contentLoader.loadFile(resource, contentLoader.fhirVersion()));
+      cs.sourcePackage = contentLoader.pid();
+      cp.codeSystems.set(cs.url, cs);
+      cp.codeSystems.set(cs.vurl, cs);
+      csc++;
+    }
+    this.codeSystemProviders.push(cp);
+    let vs = null;
+    if (!csOnly) {
+      vs = new PackageValueSetProvider(contentLoader);
+      await vs.initialize();
+      this.valueSetProviders.push(vs);
+      const cm = new PackageConceptMapProvider(contentLoader);
+      await cm.initialize();
+      this.conceptMapProviders.push(cm);
+    }
+
+    this.#logPackage(contentLoader.id(), contentLoader.version(), csc, vs ? vs.valueSetMap.size : 0);
   }
 
   /**
@@ -442,6 +512,17 @@ class Library {
     // Ensure folder exists
     await this.ensureFolderExists(this.cacheFolder);
 
+    if (fileName.includes("|")) {
+      // in this case, we split it into two. if the first file exists, we go with that. Otherwise
+      // fallback to the second.
+      let firstName = fileName.substring(0, fileName.indexOf("|"));
+      fileName = fileName.substring(fileName.indexOf("|")+1);
+
+      const firstPath = path.join(this.cacheFolder, firstName);
+      if (await this.fileExists(firstPath)) {
+        return firstPath;
+      }
+    }
     const filePath = path.join(this.cacheFolder, fileName);
 
     // Check if file already exists
@@ -581,7 +662,7 @@ class Library {
 
     // Load FHIR packages - these will be added to valueSetProviders first
     for (const packageId of fhirPackages) {
-      await provider.loadNpm(this.packageManager, this.cacheFolder, packageId, false, "npm");
+      await provider.loadNpm(this.packageManager, this.cacheFolder, packageId, false, "npm", false);
     }
 
 
@@ -608,6 +689,12 @@ class Library {
     provider.valueSetProviders.push(...this.valueSetProviders);
     provider.conceptMapProviders.push(...this.conceptMapProviders);
 
+    // bind UCUM common value set
+    let ucum = provider.codeSystemFactories.get("http://unitsofmeasure.org");
+    let vs = await provider.findValueSet(null, "http://hl7.org/fhir/ValueSet/ucum-common", null);
+    if (ucum && vs) {
+      ucum.processCommonUnits(vs);
+    }
     return provider;
   }
 

package/tx/operation-context.js

@@ -49,7 +49,8 @@ class TimeTracker {
  * Stores resources by cache-id for reuse across requests
  */
 class ResourceCache {
-  constructor() {
+  constructor(stats) {
+    this.stats = stats;
     this.cache = new Map();
     this.locks = new Map(); // For thread-safety with async operations
   }
@@ -135,12 +136,20 @@ class ResourceCache {
    * @param {number} maxAge - Maximum age in milliseconds
    */
   prune(maxAge = 3600000) { // Default 1 hour
+    if (this.stats) {
+      this.stats.task("Client Cache", `Pruning (${this.cache.size} entries)`);
+    }
+    let i = 0;
     const now = Date.now();
     for (const [cacheId, entry] of this.cache.entries()) {
       if (now - entry.lastUsed > maxAge) {
+        i++;
         this.cache.delete(cacheId);
       }
     }
+    if (this.stats) {
+      this.stats.task("Client Cache", `Pruned ${i} of ${this.cache.size} entries`);
+    }
   }
 
   /**
@@ -184,7 +193,8 @@ class ExpansionCache {
    * @param {number} maxSize - Maximum number of entries to keep (default 1000)
    * @param {number} memoryThresholdMB - Heap usage in MB that triggers dropping oldest half (0 = disabled)
    */
-  constructor(maxSize = ExpansionCache.DEFAULT_MAX_SIZE, memoryThresholdMB = 0) {
+  constructor(stats, maxSize = ExpansionCache.DEFAULT_MAX_SIZE, memoryThresholdMB = 0) {
+    this.stats = stats;
     this.cache = new Map();
     this.maxSize = maxSize;
     this.memoryThresholdBytes = memoryThresholdMB * 1024 * 1024;
@@ -322,13 +332,22 @@ class ExpansionCache {
    * @returns {boolean} True if eviction was triggered
    */
   checkMemoryPressure() {
+    if (this.stats) {
+      this.stats.task('Expansion Cache', 'Checking Memory Pressure');
+    }
     if (this.memoryThresholdBytes <= 0) return false;
 
     const heapUsed = process.memoryUsage().heapUsed;
     if (heapUsed > this.memoryThresholdBytes) {
-      this.evictOldestHalf();
+      const i = this.evictOldestHalf();
+      if (this.stats) {
+        this.stats.task('Expansion Cache', `Checked Memory Pressure: evicted half (${i} entries)`);
+      }
       return true;
     }
+    if (this.stats) {
+      this.stats.task('Expansion Cache', `Checked Memory Pressure - OK (${this.cache.size} entries)`);
+    }
     return false;
   }
 
@@ -464,7 +483,7 @@ class OperationContext {
   seeContext(vurl) {
     if (this.contexts.includes(vurl)) {
       const contextList = '[' + this.contexts.join(', ') + ']';
-      throw new Issue("error", "processing", null, 'VALUESET_CIRCULAR_REFERENCE', this.i18n.formatMessage(this.langs, 'VALUESET_CIRCULAR_REFERENCE', [vurl, contextList]), null).handleAsOO(400);
+      throw new Issue("error", "processing", null, 'VALUESET_CIRCULAR_REFERENCE', this.i18n.formatMessage(this.langs, 'VALUESET_CIRCULAR_REFERENCE', [vurl, contextList]), "vs-invalid").handleAsOO(400);
     }
     this.contexts.push(vurl);
   }