fhirsmith 0.12.0 → 0.13.0

package/tx/ocl/cs-ocl.cjs

@@ -1,6 +1,7 @@
 const fs = require('fs/promises');
 const { AbstractCodeSystemProvider } = require('../cs/cs-provider-api');
 const { CodeSystemProvider, CodeSystemFactoryProvider, CodeSystemContentMode, FilterExecutionContext } = require('../cs/cs-api');
+const { BaseCSServices } = require('../cs/cs-base');
 const { CodeSystem } = require('../library/codesystem');
 const { SearchFilterText } = require('../library/designations');
 const { PAGE_SIZE, CONCEPT_PAGE_SIZE, COLD_CACHE_FRESHNESS_MS, OCL_CODESYSTEM_MARKER_EXTENSION } = require('./shared/constants');
@@ -12,8 +13,10 @@ const { computeCodeSystemFingerprint } = require('./fingerprint/fingerprint');
 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 { patchSearchWorkerForOCLCodeFiltering, patchProviderForOCLFactorySync } = require('./shared/patches');
 const regexUtilities = require("../../library/regex-utilities");
+const Logger = require('../../library/logger');
+const oclLog = Logger.getInstance().child({ module: 'ocl' });
 
 patchSearchWorkerForOCLCodeFiltering();
 
@@ -66,17 +69,17 @@ class OCLCodeSystemProvider extends AbstractCodeSystemProvider {
     this._initializePromise = (async () => {
       try {
         const sources = await this.#fetchSourcesForDiscovery();
-        console.log(`[OCL] Fetched ${sources.length} sources`);
+        oclLog.info(`Fetched ${sources.length} sources`);
 
         const snapshot = this.#buildSourceSnapshot(sources);
         this.#applySnapshot(snapshot);
 
-        console.log(`[OCL] Loaded ${this._codeSystemsByCanonical.size} code systems`);
+        oclLog.info(`Loaded ${this._codeSystemsByCanonical.size} code systems`);
         this._initialized = true;
       } catch (error) {
-        console.error(`[OCL] Initialization failed:`, error.message);
+        oclLog.error(`Initialization failed: ${error.message}`);
         if (error.response) {
-          console.error(`[OCL] HTTP ${error.response.status}: ${error.response.statusText}`);
+          oclLog.error(`HTTP ${error.response.status}: ${error.response.statusText}`);
         }
         throw error;
       }
@@ -149,9 +152,18 @@ class OCLCodeSystemProvider extends AbstractCodeSystemProvider {
         const nextSnapshot = this.#buildSourceSnapshot(sources);
         const changes = this.#diffSnapshots(this._sourceStateByCanonical, nextSnapshot);
         this.#applySnapshot(nextSnapshot);
+        for (const cs of changes.added || []) {
+          const entry = nextSnapshot.get(cs.url);
+          if (entry?.meta && !OCLSourceCodeSystemFactory.hasFactory(cs.url, cs.version || null)) {
+            const factory = OCLSourceCodeSystemFactory.createForDiscoveredSource(this.httpClient, entry.meta);
+            if (factory) {
+              oclLog.info(`Factory created for newly discovered source: ${cs.url}`);
+            }
+          }
+        }
         this._pendingChanges = changes;
       } catch (error) {
-        console.error('[OCL] Incremental source refresh failed:', error.message);
+        oclLog.error(`Incremental source refresh failed: ${error.message}`);
         this._pendingChanges = this.#emptyChanges();
       } finally {
         this._refreshPromise = null;
@@ -326,7 +338,7 @@ class OCLCodeSystemProvider extends AbstractCodeSystemProvider {
       const versionChanged = (previousEntry.cs.version || null) !== (nextEntry.cs.version || null);
       if (checksumChanged || versionChanged) {
         if (checksumChanged) {
-          console.log(`[OCL] CodeSystem checksum changed: ${canonicalUrl} (${previousChecksum} -> ${nextChecksum})`);
+          oclLog.info(`CodeSystem checksum changed: ${canonicalUrl} (${previousChecksum} -> ${nextChecksum})`);
         }
         changed.push(nextEntry.cs);
       }
@@ -553,8 +565,8 @@ class OCLCodeSystemProvider extends AbstractCodeSystemProvider {
       const result = await fetchAllPages(this.httpClient, path, {
         pageSize: PAGE_SIZE,
         baseUrl: this.baseUrl,
-        logger: console,
-        loggerPrefix: '[OCL]'
+        logger: oclLog,
+        loggerPrefix: ''
       });
       // Extra check: payload must be object or array
       if (!result || (typeof result !== 'object' && !Array.isArray(result))) {
@@ -563,8 +575,8 @@ class OCLCodeSystemProvider extends AbstractCodeSystemProvider {
       return result;
     } catch (error) {
       if (error.response) {
-        console.error(`[OCL] HTTP ${error.response.status}: ${error.response.statusText}`);
-        console.error('[OCL] Response:', error.response.data);
+        oclLog.error(`HTTP ${error.response.status}: ${error.response.statusText}`);
+        oclLog.error(`Response: ${JSON.stringify(error.response.data)}`);
       }
       throw error;
     }
@@ -586,7 +598,7 @@ class OCLCodeSystemProvider extends AbstractCodeSystemProvider {
   }
 }
 
-class OCLSourceCodeSystemProvider extends CodeSystemProvider {
+class OCLSourceCodeSystemProvider extends BaseCSServices {
   constructor(opContext, supplements, client, meta, sharedCaches = null) {
     super(opContext, supplements);
     this.httpClient = client;
@@ -727,6 +739,36 @@ class OCLSourceCodeSystemProvider extends CodeSystemProvider {
     }
   }
 
+  async extendLookup(ctxt, props, params) {
+    const context = await this.#ensureContext(ctxt);
+    const extras = context && context.extras;
+    if (!extras || typeof extras !== 'object') {
+      return;
+    }
+    for (const [key, value] of Object.entries(extras)) {
+      if (!key || value === null || value === undefined) {
+        continue;
+      }
+      if (!this._hasProp(props, key, true)) {
+        continue;
+      }
+      const part = [{ name: 'code', valueCode: key }];
+      if (typeof value === 'boolean') {
+        part.push({ name: 'value', valueBoolean: value });
+      } else if (typeof value === 'number' && Number.isInteger(value)) {
+        part.push({ name: 'value', valueInteger: value });
+      } else if (typeof value === 'number' && Number.isFinite(value)) {
+        part.push({ name: 'value', valueDecimal: value });
+      } else if (typeof value === 'string') {
+        part.push({ name: 'value', valueString: value });
+      } else {
+        // Extras may hold arbitrary JSON (arrays, objects); serialize rather than drop data.
+        part.push({ name: 'value', valueString: JSON.stringify(value) });
+      }
+      params.push({ name: 'property', part });
+    }
+  }
+
   async locate(code) {
     if (!code || typeof code !== 'string') {
       return { context: null, message: 'Empty code' };
@@ -1251,6 +1293,14 @@ class OCLSourceCodeSystemProvider extends CodeSystemProvider {
 
 class OCLSourceCodeSystemFactory extends CodeSystemFactoryProvider {
   static factoriesByKey = new Map();
+  static #sharedI18n = null;
+
+  static createForDiscoveredSource(httpClient, meta) {
+    if (!OCLSourceCodeSystemFactory.#sharedI18n) {
+      return null;
+    }
+    return new OCLSourceCodeSystemFactory(OCLSourceCodeSystemFactory.#sharedI18n, httpClient, meta);
+  }
 
   static #normalizeSystem(system) {
     return normalizeCanonicalSystem(system);
@@ -1319,6 +1369,9 @@ class OCLSourceCodeSystemFactory extends CodeSystemFactoryProvider {
 
   constructor(i18n, client, meta) {
     super(i18n);
+    if (!OCLSourceCodeSystemFactory.#sharedI18n) {
+      OCLSourceCodeSystemFactory.#sharedI18n = i18n;
+    }
     this.httpClient = client;
     this.meta = meta;
     this.sharedConceptCache = new Map();
@@ -1375,7 +1428,7 @@ class OCLSourceCodeSystemFactory extends CodeSystemFactoryProvider {
 
     } catch (error) {
       if (error.code !== 'ENOENT') {
-        console.error(`[OCL] Failed to load cold cache for CodeSystem ${canonicalUrl}:`, error.message);
+        oclLog.error(`Failed to load cold cache for CodeSystem ${canonicalUrl}: ${error.message}`);
       }
     }
   }
@@ -1402,7 +1455,7 @@ class OCLSourceCodeSystemFactory extends CodeSystemFactoryProvider {
       
       return fingerprint;
     } catch (error) {
-      console.error(`[OCL] Failed to save cold cache for CodeSystem ${canonicalUrl}:`, error.message);
+      oclLog.error(`Failed to save cold cache for CodeSystem ${canonicalUrl}: ${error.message}`);
       return null;
     }
   }
@@ -1542,9 +1595,9 @@ class OCLSourceCodeSystemFactory extends CodeSystemFactoryProvider {
         }
       }
 
-      console.log(`[OCL] CodeSystem loaded: ${this.system()} (${count} concepts)`);
+      oclLog.info(`CodeSystem loaded: ${this.system()} (${count} concepts)`);
     } catch (error) {
-      console.error(`[OCL] CodeSystem background load failed: ${key}: ${error.message}`);
+      oclLog.error(`CodeSystem background load failed: ${key}: ${error.message}`);
     }
   }
 
@@ -1660,7 +1713,7 @@ class OCLSourceCodeSystemFactory extends CodeSystemFactoryProvider {
         this.meta.codeSystem.jsonObj.content = CodeSystemContentMode.NotPresent;
         delete this.meta.codeSystem.jsonObj.concept;
       }
-      console.log(`[OCL] CodeSystem checksum changed, invalidated warm cache: ${this.#resourceKey()}`);
+      oclLog.info(`CodeSystem checksum changed, invalidated warm cache: ${this.#resourceKey()}`);
     }
   }
 
@@ -1824,8 +1877,11 @@ class OCLSourceCodeSystemFactory extends CodeSystemFactoryProvider {
   }
 }
 
+patchProviderForOCLFactorySync(() => OCLSourceCodeSystemFactory.factoriesByKey);
+
 module.exports = {
   OCLCodeSystemProvider,
+  OCLSourceCodeSystemProvider,
   OCLSourceCodeSystemFactory,
   OCLBackgroundJobQueue
 };

package/tx/ocl/jobs/background-queue.cjs

@@ -1,3 +1,6 @@
+const Logger = require('../../../library/logger');
+const oclLog = Logger.getInstance().child({ module: 'ocl' });
+
 class OCLBackgroundJobQueue {
   static MAX_CONCURRENT = 2;
   static HEARTBEAT_INTERVAL_MS = 30000;
@@ -42,7 +45,7 @@ class OCLBackgroundJobQueue {
       .catch((error) => {
         this.queuedOrRunningKeys.delete(jobKey);
         const message = error && error.message ? error.message : String(error);
-        console.error(`[OCL] Failed to enqueue background job: ${jobType || 'background-job'} ${jobKey}: ${message}`);
+        oclLog.error(`Failed to enqueue background job: ${jobType || 'background-job'} ${jobKey}: ${message}`);
       });
 
     return true;
@@ -125,7 +128,7 @@ class OCLBackgroundJobQueue {
       lines.push(`   progress: ${this.formatProgress(job.getProgress)}`);
     });
 
-    console.log(lines.join('\n'));
+    oclLog.info(lines.join('\n'));
   }
 
   static formatProgress(getProgress) {
@@ -181,7 +184,7 @@ class OCLBackgroundJobQueue {
         .then(() => job.runJob())
         .catch((error) => {
           const message = error && error.message ? error.message : String(error);
-          console.error(`[OCL] Background job failed: ${job.jobType} ${job.jobKey}: ${message}`);
+          oclLog.error(`Background job failed: ${job.jobType} ${job.jobKey}: ${message}`);
         })
         .finally(() => {
           this.activeCount -= 1;

package/tx/ocl/mappers/concept-mapper.cjs

@@ -8,13 +8,21 @@ function toConceptContext(concept) {
     return null;
   }
 
-  return {
+  const ctx = {
     code,
     display: concept.display_name || concept.display || concept.name || null,
     definition: concept.description || concept.definition || null,
     retired: concept.retired === true,
       designation: extractDesignations(concept)
   };
+
+  const extras = concept.extras;
+  if (extras && typeof extras === 'object' && !Array.isArray(extras)
+      && Object.keys(extras).length > 0) {
+    ctx.extras = extras;
+  }
+
+  return ctx;
 }
 
 function extractDesignations(concept) {

package/tx/ocl/shared/patches.cjs

@@ -254,9 +254,56 @@ function patchValueSetExpandWholeSystemForOcl() {
 }
 
 
+const OCL_PROVIDER_FACTORY_SYNC_PATCH_FLAG = Symbol.for('fhirsmith.ocl.provider.factory-sync.patch');
+
+function patchProviderForOCLFactorySync(getFactoriesByKey) {
+  let ProviderModule;
+  try {
+    ProviderModule = require('../../provider');
+  } catch (_error) {
+    return;
+  }
+
+  const Provider = ProviderModule?.Provider;
+  const proto = Provider?.prototype;
+  if (!proto || proto[OCL_PROVIDER_FACTORY_SYNC_PATCH_FLAG] === true) {
+    return;
+  }
+  if (typeof proto.updateCodeSystemList !== 'function') {
+    return;
+  }
+
+  const originalUpdateCodeSystemList = proto.updateCodeSystemList;
+  proto.updateCodeSystemList = async function patchedUpdateCodeSystemList() {
+    await originalUpdateCodeSystemList.call(this);
+    const factoriesByKey = getFactoriesByKey();
+    for (const factory of factoriesByKey.values()) {
+      if (!factory) continue;
+      const system = typeof factory.system === 'function' ? factory.system() : null;
+      if (!system) continue;
+      const ver = typeof factory.version === 'function' ? (factory.version() ?? '') : '';
+      const vurl = `${system}|${ver}`;
+      if (!this.codeSystemFactories.has(vurl)) {
+        if (!this.codeSystemFactories.has(system)) {
+          this.codeSystemFactories.set(system, factory);
+        }
+        this.codeSystemFactories.set(vurl, factory);
+      }
+    }
+  };
+
+  Object.defineProperty(proto, OCL_PROVIDER_FACTORY_SYNC_PATCH_FLAG, {
+    value: true,
+    writable: false,
+    configurable: false,
+    enumerable: false
+  });
+}
+
 module.exports = {
   patchSearchWorkerForOCLCodeFiltering,
   ensureTxParametersHashIncludesFilter,
   patchValueSetExpandWholeSystemForOcl,
-  normalizeFilterForCacheKey
+  normalizeFilterForCacheKey,
+  patchProviderForOCLFactorySync
 };

package/tx/ocl/vs-ocl.cjs

@@ -13,6 +13,8 @@ const { CACHE_VS_DIR, getCacheFilePath } = require('./cache/cache-paths');
 const { ensureCacheDirectories, getColdCacheAgeMs, formatCacheAgeMinutes } = require('./cache/cache-utils');
 const { computeValueSetExpansionFingerprint } = require('./fingerprint/fingerprint');
 const { ensureTxParametersHashIncludesFilter, patchValueSetExpandWholeSystemForOcl } = require('./shared/patches');
+const Logger = require('../../library/logger');
+const oclVsLog = Logger.getInstance().child({ module: 'ocl-vs' });
 
 
 ensureTxParametersHashIncludesFilter(TxParameters);
@@ -122,16 +124,16 @@ class OCLValueSetProvider extends AbstractValueSetProvider {
           this.valueSetFingerprints.set(cacheKey, cached.fingerprint || null);
           loadedCount++;
         } catch (error) {
-          console.error(`[OCL-ValueSet] Failed to load cold cache file ${file}:`, error.message);
+          oclVsLog.error(`Failed to load cold cache file ${file}: ${error.message}`);
         }
       }
 
       if (loadedCount > 0) {
-        console.log(`[OCL-ValueSet] Loaded ${loadedCount} ValueSet expansions from cold cache`);
+        oclVsLog.info(`Loaded ${loadedCount} ValueSet expansions from cold cache`);
       }
     } catch (error) {
       if (error.code !== 'ENOENT') {
-        console.error('[OCL-ValueSet] Failed to load cold cache:', error.message);
+        oclVsLog.error(`Failed to load cold cache: ${error.message}`);
       }
     }
   }
@@ -165,11 +167,11 @@ class OCLValueSetProvider extends AbstractValueSetProvider {
       };
 
       await fs.writeFile(cacheFilePath, JSON.stringify(cacheData, null, 2), 'utf-8');
-      console.log(`[OCL-ValueSet] Saved ValueSet compose to cold cache: ${canonicalUrl} (${conceptCount} concepts, fingerprint=${fingerprint?.substring(0, 8)})`);
+      oclVsLog.info(`Saved ValueSet compose to cold cache: ${canonicalUrl} (${conceptCount} concepts, fingerprint=${fingerprint?.substring(0, 8)})`);
 
       return fingerprint;
     } catch (error) {
-      console.error(`[OCL-ValueSet] Failed to save cold cache for ValueSet ${canonicalUrl}:`, error.message);
+      oclVsLog.error(`Failed to save cold cache for ValueSet ${canonicalUrl}: ${error.message}`);
       return null;
     }
   }
@@ -194,7 +196,7 @@ class OCLValueSetProvider extends AbstractValueSetProvider {
         await this.#loadColdCacheForValueSets();
 
         const collections = await this.#fetchCollectionsForDiscovery();
-        console.log(`[OCL-ValueSet] Fetched ${collections.length} collections`);
+        oclVsLog.info(`Fetched ${collections.length} collections`);
 
         for (const collection of collections) {
           const valueSet = this.#toValueSet(collection);
@@ -204,12 +206,12 @@ class OCLValueSetProvider extends AbstractValueSetProvider {
           this.#indexValueSet(valueSet);
         }
 
-        console.log(`[OCL-ValueSet] Loaded ${this.valueSetMap.size} value sets`);
+        oclVsLog.info(`Loaded ${this.valueSetMap.size} value sets`);
         this._initialized = true;
       } catch (error) {
-        console.error(`[OCL-ValueSet] Initialization failed:`, error.message);
+        oclVsLog.error(`Initialization failed: ${error.message}`);
         if (error.response) {
-          console.error(`[OCL-ValueSet] HTTP ${error.response.status}: ${error.response.statusText}`);
+          oclVsLog.error(`HTTP ${error.response.status}: ${error.response.statusText}`);
         }
         throw error;
       }
@@ -1104,9 +1106,9 @@ class OCLValueSetProvider extends AbstractValueSetProvider {
       // Ensure no stale inline expansion
       delete vs.jsonObj.expansion;
 
-      console.log(`[OCL-ValueSet] compose cached: ${vs.url} (${conceptCount} concepts)`);
+      oclVsLog.info(`compose cached: ${vs.url} (${conceptCount} concepts)`);
     } catch (error) {
-      console.error(`[OCL-ValueSet] ValueSet background expansion failed: ${cacheKey}: ${error.message}`);
+      oclVsLog.error(`ValueSet background expansion failed: ${cacheKey}: ${error.message}`);
     } finally {
       this.backgroundExpansionProgress.delete(cacheKey);
     }
@@ -1350,7 +1352,7 @@ class OCLValueSetProvider extends AbstractValueSetProvider {
 
     this._organizationIdsFetchPromise = (async () => {
       const endpoint = '/orgs/';
-      console.log(`[OCL-ValueSet] Loading organizations from: ${this.baseUrl}${endpoint}`);
+      oclVsLog.info(`Loading organizations from: ${this.baseUrl}${endpoint}`);
       const orgs = await this.#fetchAllPages(endpoint);
 
       const ids = [];
@@ -1468,7 +1470,7 @@ class OCLValueSetProvider extends AbstractValueSetProvider {
         this.pendingCollectionConceptPageRequests.delete(cacheKey);
       }
     } catch (error) {
-      console.error(`[OCL-ValueSet] #fetchConceptPage ERROR: ${error.message}`);
+      oclVsLog.error(`#fetchConceptPage ERROR: ${error.message}`);
       throw error;
     }
   }