fhirsmith 0.8.5 → 0.9.0

package/tx/ocl/cs-ocl.cjs

@@ -13,6 +13,7 @@ const { OCLBackgroundJobQueue } = require('./jobs/background-queue');
 const { OCLConceptFilterContext } = require('./model/concept-filter-context');
 const { toConceptContext } = require('./mappers/concept-mapper');
 const { patchSearchWorkerForOCLCodeFiltering } = require('./shared/patches');
+const regexUtilities = require("../../library/regex-utilities");
 
 patchSearchWorkerForOCLCodeFiltering();
 
@@ -735,6 +736,17 @@ class OCLSourceCodeSystemProvider extends CodeSystemProvider {
       return { context: this.conceptCache.get(code), message: null };
     }
 
+    // OCL concept IDs may differ in case from the FHIR code (e.g. "y" vs "Y").
+    // Try a case-insensitive cache lookup before hitting the network.
+    const codeLower = code.toLowerCase();
+    for (const [key, value] of this.conceptCache.entries()) {
+      if (key.toLowerCase() === codeLower) {
+        // Cache under the requested case as well so future lookups are O(1).
+        this.conceptCache.set(code, value);
+        return { context: value, message: null };
+      }
+    }
+
     if (this.scheduleBackgroundLoad) {
       this.scheduleBackgroundLoad('lookup-miss');
     }
@@ -1032,23 +1044,26 @@ class OCLSourceCodeSystemProvider extends CodeSystemProvider {
       this.scheduleBackgroundLoad('concept-miss');
     }
 
-    const url = this.#buildConceptUrl(code);
     const pending = (async () => {
-      let response;
-      try {
-        response = await this.httpClient.get(url, { params: { verbose: true } });
-      } catch (error) {
-        // Missing concept should be treated as not-found, not as an internal server failure.
-        if (error && error.response && error.response.status === 404) {
-          return null;
-        }
-        throw error;
+      const concept = await this.#fetchConceptByCode(code);
+      if (concept) {
+        return concept;
       }
-      const concept = this.#toConceptContext(response.data);
-      if (concept && concept.code) {
-        this.conceptCache.set(concept.code, concept);
+      // OCL concept IDs may differ in case from the FHIR code (e.g. "y" vs "Y").
+      // Try common case alternatives before giving up.
+      const lower = code.toLowerCase();
+      const upper = code.toUpperCase();
+      for (const alt of [lower, upper]) {
+        if (alt !== code) {
+          const altConcept = await this.#fetchConceptByCode(alt);
+          if (altConcept) {
+            // Cache under the originally requested code so future lookups hit directly.
+            this.conceptCache.set(code, altConcept);
+            return altConcept;
+          }
+        }
       }
-      return concept;
+      return null;
     })();
 
     this.pendingConceptRequests.set(pendingKey, pending);
@@ -1059,6 +1074,24 @@ class OCLSourceCodeSystemProvider extends CodeSystemProvider {
     }
   }
 
+  async #fetchConceptByCode(code) {
+    const url = this.#buildConceptUrl(code);
+    let response;
+    try {
+      response = await this.httpClient.get(url, { params: { verbose: true } });
+    } catch (error) {
+      if (error && error.response && error.response.status === 404) {
+        return null;
+      }
+      throw error;
+    }
+    const concept = this.#toConceptContext(response.data);
+    if (concept && concept.code) {
+      this.conceptCache.set(concept.code, concept);
+    }
+    return concept;
+  }
+
   async #allConceptContexts() {
     const concepts = new Map();
 
@@ -1135,7 +1168,7 @@ class OCLSourceCodeSystemProvider extends CodeSystemProvider {
 
   #buildPropertyMatcher(prop, op, value) {
     if (op === 'regex') {
-      const regex = new RegExp(String(value), 'i');
+      const regex = regexUtilities.compile(String(value), 'i');
       return concept => {
         const candidate = this.#valueForFilter(concept, prop);
         if (candidate == null) {

package/tx/ocl/vs-ocl.cjs

@@ -389,20 +389,26 @@ class OCLValueSetProvider extends AbstractValueSetProvider {
   }
 
   #indexValueSet(vs) {
-    const existing = this.valueSetMap.get(vs.url)
-      || (vs.version ? this.valueSetMap.get(`${vs.url}|${vs.version}`) : null)
-      || this._idMap.get(vs.id)
-      || null;
-
-    // Só indexa se não existe ou se for o mesmo objeto
-    if (!existing || existing === vs) {
-      this.valueSetMap.set(vs.url, vs);
-      if (vs.version) {
-        this.valueSetMap.set(`${vs.url}|${vs.version}`, vs);
-      }
-      this.valueSetMap.set(vs.id, vs);
-      this._idMap.set(vs.id, vs);
+    const existing = this.valueSetMap.get(vs.url) || null;
+
+    // When fresh discovery metadata replaces a cold-cached entry, carry over
+    // the enumerated compose so the expand engine doesn't fall back to
+    // "include whole CodeSystem".  The background expansion will eventually
+    // refresh it with up-to-date collection contents.
+    if (existing && existing !== vs
+      && Array.isArray(existing.jsonObj?.compose?.include)
+      && existing.jsonObj.compose.include.some(inc => Array.isArray(inc.concept) && inc.concept.length > 0)
+      && (!vs.jsonObj.compose || !Array.isArray(vs.jsonObj.compose.include) || vs.jsonObj.compose.include.length === 0)
+    ) {
+      vs.jsonObj.compose = existing.jsonObj.compose;
+    }
+
+    this.valueSetMap.set(vs.url, vs);
+    if (vs.version) {
+      this.valueSetMap.set(`${vs.url}|${vs.version}`, vs);
     }
+    this.valueSetMap.set(vs.id, vs);
+    this._idMap.set(vs.id, vs);
   }
 
   #toValueSet(collection) {
@@ -568,6 +574,17 @@ class OCLValueSetProvider extends AbstractValueSetProvider {
         ? vs.jsonObj.compose.include
         : [];
 
+      // If the compose already has enumerated concepts (from background expansion),
+      // it is the authoritative representation of the collection contents — don't
+      // overwrite it with system-only entries that would cause the expand engine
+      // to include ALL concepts from the CodeSystem.
+      const hasEnumeratedConcepts = existingInclude.some(
+        inc => Array.isArray(inc.concept) && inc.concept.length > 0
+      );
+      if (hasEnumeratedConcepts) {
+        return;
+      }
+
       // Always normalize existing compose entries first because discovery metadata
       // can carry non-canonical preferred_source values.
       const include = this.#normalizeComposeIncludes(existingInclude);
@@ -972,9 +989,12 @@ class OCLValueSetProvider extends AbstractValueSetProvider {
       return;
     }
 
-    const cached = this.backgroundExpansionCache.get(cacheKey);
+    let cached = this.backgroundExpansionCache.get(cacheKey);
+    let invalidated = false;
     if (cached && !this.#isCachedExpansionValid(vs, cached)) {
       this.backgroundExpansionCache.delete(cacheKey);
+      cached = null;
+      invalidated = true;
     }
 
     // Already have a cached compose ready
@@ -982,23 +1002,22 @@ class OCLValueSetProvider extends AbstractValueSetProvider {
       return;
     }
 
-    const cacheFilePath = getCacheFilePath(CACHE_VS_DIR, vs.url, vs.version || null, paramsKey);
-    const cacheAgeFromFileMs = getColdCacheAgeMs(cacheFilePath);
-    const persistedCache = this.backgroundExpansionCache.get(cacheKey);
-    const cacheAgeFromMetadataMs = Number.isFinite(persistedCache?.createdAt)
-      ? Math.max(0, Date.now() - persistedCache.createdAt)
-      : null;
-
-    // Treat cache as fresh when either file mtime or persisted timestamp is recent.
-    const freshnessCandidates = [cacheAgeFromFileMs, cacheAgeFromMetadataMs].filter(age => age != null);
-    const freshestCacheAgeMs = freshnessCandidates.length > 0 ? Math.min(...freshnessCandidates) : null;
-    if (freshestCacheAgeMs != null && freshestCacheAgeMs <= COLD_CACHE_FRESHNESS_MS) {
-      const freshnessSource = cacheAgeFromFileMs != null && cacheAgeFromMetadataMs != null
-        ? 'file+metadata'
-        : cacheAgeFromFileMs != null
-          ? 'file'
-          : 'metadata';
-      return;
+    // Skip freshness check when cache was just invalidated (VS metadata changed
+    // on the server) — the cold cache file is stale even if recently written.
+    if (!invalidated) {
+      const cacheFilePath = getCacheFilePath(CACHE_VS_DIR, vs.url, vs.version || null, paramsKey);
+      const cacheAgeFromFileMs = getColdCacheAgeMs(cacheFilePath);
+      const persistedCache = this.backgroundExpansionCache.get(cacheKey);
+      const cacheAgeFromMetadataMs = Number.isFinite(persistedCache?.createdAt)
+        ? Math.max(0, Date.now() - persistedCache.createdAt)
+        : null;
+
+      // Treat cache as fresh when either file mtime or persisted timestamp is recent.
+      const freshnessCandidates = [cacheAgeFromFileMs, cacheAgeFromMetadataMs].filter(age => age != null);
+      const freshestCacheAgeMs = freshnessCandidates.length > 0 ? Math.min(...freshnessCandidates) : null;
+      if (freshestCacheAgeMs != null && freshestCacheAgeMs <= COLD_CACHE_FRESHNESS_MS) {
+        return;
+      }
     }
 
     const jobKey = `vs:${cacheKey}`;
@@ -1121,7 +1140,11 @@ class OCLValueSetProvider extends AbstractValueSetProvider {
         if (!systemConcepts.has(entry.system)) {
           systemConcepts.set(entry.system, []);
         }
-        systemConcepts.get(entry.system).push(entry.code);
+        const concept = { code: entry.code };
+        if (Array.isArray(entry.designation) && entry.designation.length > 0) {
+          concept.designation = entry.designation;
+        }
+        systemConcepts.get(entry.system).push(concept);
         totalCount++;
       }
       if (progressState) {
@@ -1138,9 +1161,9 @@ class OCLValueSetProvider extends AbstractValueSetProvider {
     }
 
     return {
-      include: Array.from(systemConcepts.entries()).map(([system, codes]) => ({
+      include: Array.from(systemConcepts.entries()).map(([system, concepts]) => ({
         system,
-        concept: codes.map(code => ({ code }))
+        concept: concepts
       }))
     };
   }

package/tx/operation-context.js

@@ -15,7 +15,7 @@ function isDebugging() {
   }
   // Also check for debug flags in case inspector not yet attached
   return process.execArgv.some(arg =>
-    arg.includes('--inspect') || arg.includes('--debug')
+      arg.includes('--inspect') || arg.includes('--debug')
   );
 }
 
@@ -233,16 +233,16 @@ class ExpansionCache {
     // Resources are now CodeSystem/ValueSet wrappers, not raw JSON
     if (additionalResources && additionalResources.length > 0) {
       const resourceHashes = additionalResources
-        .map(r => {
-          // Get the JSON object from wrapper or use directly
-          const json = r.jsonObj || r;
-          // Create a content hash for this resource
-          return crypto.createHash('sha256')
-            .update(JSON.stringify(json))
-            .digest('hex')
-            .substring(0, 16); // Use first 16 chars for brevity
-        })
-        .sort();
+          .map(r => {
+            // Get the JSON object from wrapper or use directly
+            const json = r.jsonObj || r;
+            // Create a content hash for this resource
+            return crypto.createHash('sha256')
+                .update(JSON.stringify(json))
+                .digest('hex')
+                .substring(0, 16); // Use first 16 chars for brevity
+          })
+          .sort();
       keyParts.push(`additional:${resourceHashes.join(',')}`);
     }
 
@@ -314,7 +314,7 @@ class ExpansionCache {
 
     // Get entries sorted by lastUsed (oldest first)
     const entries = Array.from(this.cache.entries())
-      .sort((a, b) => a[1].lastUsed - b[1].lastUsed);
+        .sort((a, b) => a[1].lastUsed - b[1].lastUsed);
 
     const toEvict = Math.min(count, entries.length);
     for (let i = 0; i < toEvict; i++) {
@@ -413,7 +413,29 @@ class ExpansionCache {
 }
 
 
+/**
+ * Read the cgroup memory limit once at startup.
+ * Returns the byte limit, or 0 if unavailable (disables the check).
+ */
+function readMemoryLimit() {
+  try {
+    const raw = require('fs').readFileSync('/sys/fs/cgroup/memory.max', 'utf8').trim();
+    if (raw === 'max') return 0; // no cgroup limit
+    return parseInt(raw);
+  } catch {
+    return 0; // not on Linux / no cgroup
+  }
+}
+
+const MEMORY_LIMIT = readMemoryLimit();
+const MEMORY_FRACTION = 0.98;
+const MEMORY_THRESHOLD = MEMORY_LIMIT > 0 ? MEMORY_LIMIT * MEMORY_FRACTION : 0; // 90% of cgroup limit
+const CHECK_FREQUENCY = 100;
+
 class OperationContext {
+  // Shared counter across all instances — only check RSS every CHECK_FREQUENCY calls
+  static _checkCounter = 0;
+
   constructor(langs, i18n = null, id = null, timeLimit = 30, resourceCache = null, expansionCache = null) {
     this.i18n = i18n;
     this.langs = this._ensureLanguages(langs);
@@ -445,8 +467,8 @@ class OperationContext {
    */
   copy() {
     const newContext = new OperationContext(
-      this.langs, this.i18n, this.id, this.timeLimit / 1000,
-      this.resourceCache, this.expansionCache
+        this.langs, this.i18n, this.id, this.timeLimit / 1000,
+        this.resourceCache, this.expansionCache
     );
     newContext.contexts = [...this.contexts];
     newContext.startTime = this.startTime;
@@ -458,31 +480,64 @@ class OperationContext {
   }
 
   /**
-   * Check if operation has exceeded time limit
+   * Check if operation has exceeded time limit, or is pushing is over the memory limit
    * Skipped when running under debugger
+   *
+   * note: if the server pushes over the memory limit for the process, the process is terminated.
+   * the memory check here is intended to prevent process termination on the grounds that some
+   * big operation is pushing the limit. It might not be the big operation that is terminated first,
+   * but eventually it'll get terminated.
+   *
+   * this is called a *lot* so it's important to be efficient. Only check every CHECK_FREQUENCY
+   * times means that there could be a small overrun, but it's called often enough that the
+   * overrun won't be that signiifcant
+   *
    * @param {string} place - Location identifier for debugging
    * @returns {boolean} true if operation should be terminated
    */
   deadCheck(place = 'unknown') {
-    // Skip time limit checks when debugging
     if (this.debugging) {
       return false;
     }
 
-    const elapsed = performance.now() - this.startTime;
+    OperationContext._checkCounter++;
+    if (OperationContext._checkCounter < CHECK_FREQUENCY) {
+      return false;
+    }
+    OperationContext._checkCounter = 0;
 
+    // Time check
+    const elapsed = performance.now() - this.startTime;
     if (elapsed > this.timeLimit) {
       const timeInSeconds = Math.round(this.timeLimit / 1000);
       this.log(`Operation took too long @ ${place} (${this.constructor.name})`);
-
-      const error = new Issue("error", "too-costly", null, `Operation exceeded time limit of ${timeInSeconds} seconds at ${place}`);
+      const error = new Issue("error", "too-costly", null,
+          `Operation exceeded time limit of ${timeInSeconds} seconds at ${place}`);
       error.diagnostics = this.diagnostics();
       throw error;
     }
 
+    // Memory check (piggyback on same sample)
+    if (MEMORY_THRESHOLD > 0) {
+      const rss = process.memoryUsage.rss();
+      if (rss > MEMORY_THRESHOLD) {
+        const usedGB = (rss / 1024 / 1024 / 1024).toFixed(1);
+        const limitGB = (MEMORY_LIMIT / 1024 / 1024 / 1024).toFixed(1);
+        this.log(`Memory Limit: ${usedGB} GB of ${limitGB} GB limit @ ${place}`);
+        const error = new Issue("error", "too-costly", null,
+            `Operation aborted: server memory usage (${usedGB} GB) exceeds safe threshold (${MEMORY_FRACTION * 100}% of ${limitGB} GB limit) at ${place}`);
+        error.diagnostics = this.diagnostics();
+        throw error;
+      }
+    }
+
     return false;
   }
 
+  unSeeAll() {
+    this.contexts = [];
+  }
+
   /**
    * Track a context URL and detect circular references
    * @param {string} vurl - Value set URL to track

package/tx/tx-html.js

@@ -319,7 +319,7 @@ class TxHtmlRenderer {
           case 'Parameters':
             return await this.renderParameters(json);
           case 'CodeSystem':
-            return await this.renderCodeSystem(json, inBundle, _fmt, op);
+            return await this.renderCodeSystem(json, inBundle, _fmt, op, req.sourcePackage);
           case 'ValueSet': {
             let exp = undefined;
             if (!inBundle && !op && (!_fmt || _fmt == 'html')) {
@@ -330,10 +330,10 @@ class TxHtmlRenderer {
                 exp = error;
               }
             }
-            return await this.renderValueSet(json, inBundle, _fmt, op, exp);
+            return await this.renderValueSet(json, inBundle, _fmt, op, exp, req.sourcePackage);
           }
           case 'ConceptMap':
-            return await this.renderConceptMap(json, inBundle, _fmt, op);
+            return await this.renderConceptMap(json, inBundle, _fmt, op, req.sourcePackage);
           case 'CapabilityStatement':
             return await this.renderCapabilityStatement(json, inBundle);
           case 'TerminologyCapabilities':
@@ -632,7 +632,7 @@ class TxHtmlRenderer {
   /**
    * Render CodeSystem resource
    */
-  async renderCodeSystem(json, inBundle, _fmt) {
+  async renderCodeSystem(json, inBundle, _fmt, op, sourcePackage) {
     if (inBundle) {
       return await this.renderResourceWithNarrative(json, await this.renderer.renderCodeSystem(json));
     } else {
@@ -645,7 +645,7 @@ class TxHtmlRenderer {
       html += `</ul>`;
 
       if (!_fmt || _fmt == 'html') {
-        html += await this.renderResourceWithNarrative(json, await this.renderer.renderCodeSystem(json));
+        html += await this.renderResourceWithNarrative(json, await this.renderer.renderCodeSystem(json, sourcePackage));
       } else if (_fmt == "html/json") {
         html += await this.renderResourceJson(json);
       } else if (_fmt == "html/xml") {

package/tx/tx.fhir.org.yml

@@ -18,11 +18,11 @@ sources:
   - unii:unii_20240622.db
   - snomed:sct_intl_20240201.cache
   - snomed!:sct_intl_20250201.cache
-  - snomed:sct_se_20231130.cache
-  - snomed:sct_au_20230731.cache
-  - snomed:sct_be_20231115.cache
+#  - snomed:sct_se_20231130.cache
+#  - snomed:sct_au_20230731.cache
+#  - snomed:sct_be_20231115.cache
   - snomed:sct_ch_20230607.cache
-  - snomed:sct_dk_20250930.cache
+#  - snomed:sct_dk_20250930.cache
   - snomed:sct_ips_20241216.cache
   - snomed:sct_nl_20240930.cache
   - snomed:sct_uk_20230412.cache

package/tx/tx.js

@@ -173,6 +173,7 @@ class TXModule {
     this.metadataHandler = new MetadataHandler({
       baseUrl: config.baseUrl,
       serverVersion: packageJson.version,
+      txVersion: packageJson.txVersion,
       softwareName: config.softwareName || 'FHIRsmith',
       name: config.name || 'FHIRTerminologyServer',
       title: config.title || 'FHIR Terminology Server',