@nsshunt/stsfhirpg 1.2.7 → 1.2.9

package/dist/stsfhirpg.cjs

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const fs = require("node:fs");
+const require$$0 = require("crypto");
 const stsutils = require("@nsshunt/stsutils");
-const stsfhirclient = require("@nsshunt/stsfhirclient");
 const stsconfig = require("@nsshunt/stsconfig");
+const redis = require("redis");
+const stsfhirclient = require("@nsshunt/stsfhirclient");
 const cluster = require("cluster");
-const require$$0 = require("crypto");
 const require$$0$3 = require("events");
 const require$$1$1 = require("util");
 const require$$0$2 = require("dns");
@@ -6995,6 +6996,635 @@ function hashReferenceParam(reference) {
 function hashUriParam(uri, lowercase = false) {
   return murmur64Signed(lowercase ? uri.toLowerCase() : uri);
 }
+const RELEASE_SCRIPT = `
+if redis.call("get", KEYS[1]) == ARGV[1] then
+  return redis.call("del", KEYS[1])
+else
+  return 0
+end
+`;
+const RENEW_SCRIPT = `
+if redis.call("get", KEYS[1]) == ARGV[1] then
+  return redis.call("pexpire", KEYS[1], ARGV[2])
+else
+  return 0
+end
+`;
+class RedisDistributedLock {
+  client;
+  ttlMs;
+  heartbeatMs;
+  keyPrefix;
+  constructor(client2, options) {
+    this.client = client2;
+    this.ttlMs = options?.ttlMs ?? 3e4;
+    this.heartbeatMs = options?.heartbeatMs ?? Math.floor(this.ttlMs / 3);
+    this.keyPrefix = options?.keyPrefix ?? "lock:";
+    if (this.ttlMs <= 0) {
+      throw new Error("ttlMs must be > 0");
+    }
+    if (this.heartbeatMs <= 0) {
+      throw new Error("heartbeatMs must be > 0");
+    }
+    if (this.heartbeatMs >= this.ttlMs) {
+      throw new Error("heartbeatMs should be less than ttlMs");
+    }
+  }
+  buildKey(name) {
+    return `${this.keyPrefix}${name}`;
+  }
+  async acquire(name, ttlMs) {
+    const key = this.buildKey(name);
+    const token = require$$0.randomUUID();
+    const effectiveTtlMs = ttlMs ?? this.ttlMs;
+    const result2 = await this.client.set(key, token, {
+      NX: true,
+      PX: effectiveTtlMs
+    });
+    if (result2 !== "OK") {
+      return null;
+    }
+    return {
+      key,
+      token,
+      ttlMs: effectiveTtlMs
+    };
+  }
+  async release(lock) {
+    const result2 = await this.client.eval(RELEASE_SCRIPT, {
+      keys: [lock.key],
+      arguments: [lock.token]
+    });
+    return Number(result2) === 1;
+  }
+  async renew(lock, ttlMs) {
+    const effectiveTtlMs = ttlMs ?? lock.ttlMs;
+    const result2 = await this.client.eval(RENEW_SCRIPT, {
+      keys: [lock.key],
+      arguments: [lock.token, String(effectiveTtlMs)]
+    });
+    return Number(result2) === 1;
+  }
+  async isOwner(lock) {
+    const currentValue = await this.client.get(lock.key);
+    return currentValue === lock.token;
+  }
+  async runExclusive(name, task, options) {
+    const lock = await this.acquire(name, options?.ttlMs);
+    if (!lock) {
+      if (options?.onLockNotAcquired) {
+        await options.onLockNotAcquired();
+      }
+      return { acquired: false };
+    }
+    let timer = null;
+    let stopped = false;
+    let renewalError = null;
+    const autoRenew = options?.autoRenew ?? false;
+    const heartbeatMs = options?.heartbeatMs ?? this.heartbeatMs;
+    const stopHeartbeat = () => {
+      stopped = true;
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+      }
+    };
+    if (autoRenew) {
+      timer = setInterval(async () => {
+        if (stopped) {
+          return;
+        }
+        try {
+          const ok = await this.renew(lock, lock.ttlMs);
+          if (!ok) {
+            renewalError = new Error(
+              `Lost lock ownership while renewing "${lock.key}"`
+            );
+            stopHeartbeat();
+          }
+        } catch (err) {
+          renewalError = err instanceof Error ? err : new Error(String(err));
+          stopHeartbeat();
+        }
+      }, heartbeatMs).unref();
+    }
+    try {
+      const result2 = await task();
+      if (renewalError) {
+        throw renewalError;
+      }
+      return { acquired: true, result: result2 };
+    } finally {
+      stopHeartbeat();
+      try {
+        await this.release(lock);
+      } catch {
+      }
+    }
+  }
+}
+class SearchParameterManager {
+  redis;
+  alreadyComplete = null;
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  EnsureSearchParameterDataLoaded = async () => {
+    if (this.alreadyComplete) {
+      return this.alreadyComplete;
+    }
+    if (!this.redis) {
+      const redisUrl = stsconfig.goptions.imRedisMessageProcessorUrl;
+      console.log(`SearchParameterManager(): redis trying to connect ...`);
+      this.redis = redis.createClient({
+        url: redisUrl
+      });
+      await this.redis.connect();
+      console.log(`SearchParameterManager(): redis connected`);
+    }
+    try {
+      const pollIntervalMs = this.options?.pollIntervalMs ?? 250;
+      const lockTtlMs = this.options?.lockTtlMs ?? 3e4;
+      const autoRenew = this.options?.autoRenew ?? true;
+      const heartbeatMs = this.options?.heartbeatMs ?? 1e4;
+      const completeTtlSeconds = this.options?.completeTtlSeconds;
+      const timeoutMs = this.options?.timeoutMs;
+      const completeKey = `fhir:searchparam:${this.options.name}:complete`;
+      const startedAt = Date.now();
+      const lockManager = new RedisDistributedLock(this.redis, {
+        ttlMs: 3e4,
+        heartbeatMs: 1e4,
+        keyPrefix: "lock:"
+      });
+      while (true) {
+        if (typeof timeoutMs === "number" && timeoutMs > 0) {
+          const elapsedMs = Date.now() - startedAt;
+          if (elapsedMs >= timeoutMs) {
+            throw new Error(
+              `Timed out waiting for search param "${this.options.name}" to be loaded`
+            );
+          }
+        }
+        try {
+          this.alreadyComplete = await this.redis.get(completeKey);
+          if (this.alreadyComplete) {
+            console.log(`ensureSearchParamLoaded():alreadyComplete: PID: [${process.pid}] data loaded: [${this.alreadyComplete}]`);
+            return this.alreadyComplete;
+          }
+        } catch (error) {
+          console.error(error);
+          throw error;
+        }
+        const runResult = await lockManager.runExclusive(
+          `fhir:searchparam:${this.options.name}`,
+          async () => {
+            console.log(`ensureSearchParamLoaded(): PID: [${process.pid}] lock acquired`);
+            this.alreadyComplete = await this.redis.get(completeKey);
+            if (this.alreadyComplete) {
+              console.log(`ensureSearchParamLoaded():completeAfterLock: PID: [${process.pid}] data loaded: [${this.alreadyComplete}]`);
+              return;
+            }
+            try {
+              await this.#LoadDefinitions();
+            } catch (error) {
+              console.error(error);
+              throw error;
+            }
+            const completeValue = JSON.stringify({
+              loaded: true,
+              loadedAt: (/* @__PURE__ */ new Date()).toLocaleString(),
+              name: this.options.name,
+              workerPid: process.pid
+            });
+            console.log(`ensureSearchParamLoaded(): PID: [${process.pid}] data loaded: [${completeValue}]`);
+            if (typeof completeTtlSeconds === "number" && completeTtlSeconds > 0) {
+              await this.redis.set(completeKey, completeValue, {
+                EX: completeTtlSeconds
+              });
+            } else {
+              await this.redis.set(completeKey, completeValue);
+            }
+            this.alreadyComplete = completeValue;
+          },
+          {
+            ttlMs: lockTtlMs,
+            autoRenew,
+            heartbeatMs
+          }
+        );
+        if (runResult.acquired) {
+          if (this.alreadyComplete) {
+            return this.alreadyComplete;
+          } else {
+            throw new Error(`EnsureSearchParameterDataLoaded(): runResult.acquired is true but this.alreadyComplete not set`);
+          }
+        }
+        console.log(`ensureSearchParamLoaded(): PID: [${process.pid}] Did not get lock`);
+        await stsutils.Sleep(pollIntervalMs);
+      }
+    } catch (error) {
+      console.error(`SearchParameterManager:EnsureSearchParameterDataLoaded(): Error: [${error}]`);
+      throw error;
+    }
+  };
+  Stop = async () => {
+    if (this.redis) {
+      await this.redis.close();
+      console.log(`SearchParameterManager(): redis closed`);
+    }
+  };
+  #LoadDefinitions = async () => {
+    console.log("Data Load Starting ...");
+    for (let i = 0; i < 10; i++) {
+      console.log(`Loading ...: [${i}]`);
+      await stsutils.Sleep(500);
+    }
+    console.log("All Done ***********************************************************************************");
+  };
+  /*
+      private GetTypeKey(typeName: string) {
+          return `stsfhir_type_${typeName}`;
+      }
+  
+      private GetSearchParameterByFullUrlKey(fullUrl: string) {
+          return `stsfhir_sp_${fullUrl}`;
+      }
+  
+      private GetResourceKey(resourceType: string) {
+          return `stsfhir_resource_${resourceType}`;
+      }
+  
+      private GetSearchParameterByResourceTypeKey(resourceType: string) {
+          return `stsfhir_sp_resource_${resourceType}`;
+      }
+  
+      private GetSTSCustomSearchParameterByResourceTypeKey(resourceType: string) {
+          return `stsfhir_stscustom_sp_resource_${resourceType}`;
+      }
+  
+      // Remove ( ) when either are present
+      private _RemoveOuterParentheses = (input: string): string => {
+          return input.replace(/^\(|\)$/g, '');
+      }
+  
+      // Remove ( ) only when both are present
+      private _RemoveSurroundingParentheses = (input: string): string => {
+          return input.replace(/^\((.*)\)$/, '$1').trim();
+      }
+      */
+  /*
+  NamingSystem                  derived-from                  reference      NamingSystem.relatedArtifact.where(type='derived-from').resource
+  										
+  NamingSystem                  predecessor                   reference      NamingSystem.relatedArtifact.where(type='predecessor').resource
+  
+  ClinicalUseDefinition         product                       reference      ClinicalUseDefinition.subject.where(resolve() is MedicinalProductDefinition)
+  
+  OrganizationAffiliation       email                         token          OrganizationAffiliation.contact.telecom.where(system='email')
+  OrganizationAffiliation       phone                         token          OrganizationAffiliation.contact.telecom.where(system='phone')
+  
+  PackagedProductDefinition     biological                    reference      PackagedProductDefinition.packaging.containedItem.item.reference
+  PackagedProductDefinition     contained-item                reference      PackagedProductDefinition.packaging.containedItem.item.reference
+  
+  Patient                       deceased                      token          Patient.deceased.exists() and Patient.deceased != false
+  Practitioner                  deceased                      token          Practitioner.deceased.exists() and Practitioner.deceased != false
+  
+  Location                      contains                      special        Location.extension('http://hl7.org/fhir/StructureDefinition/location-boundary-geojson').value
+  
+  QuestionnaireResponse         item-subject                  reference      QuestionnaireResponse.item.where(extension('http://hl7.org/fhir/StructureDefinition/questionnaireresponse-isSubject').exists()).answer.valueReference
+      */
+  /*
+      private _ProcessExpressions = (resourceName: string, SP_EXPRESSION: string): any => {
+          let expressions: any[] = [];
+  
+          //SP_EXPRESSION = this.#RemoveSurroundingParentheses(val2.expression);
+          expressions = SP_EXPRESSION.split('|').map(e => e.trim());
+  
+          expressions = expressions.map(e => this._RemoveSurroundingParentheses(e).trim());
+  
+          if (resourceName !== '') {
+              expressions = expressions.filter(e => e.split('.')[0].trim().localeCompare(resourceName) === 0);
+          }
+  
+          let original_expressions = [ ...expressions ];
+  
+          // ofType processing
+          expressions = expressions.map((e: string) => {
+              let capturedTypeOf = undefined;
+              return {
+                  path: e.replace(
+                      /\.ofType\(([^)]+)\)/g,
+                      (_: string, typeName: string) => {
+                          capturedTypeOf = true;
+                          return typeName.charAt(0).toUpperCase() + typeName.slice(1)
+                      }),
+                  typeOf: capturedTypeOf
+              }
+          });
+  
+          //@@ exists processing here is more or less hard coded to the deceased attribute.
+          //@@ in future, we need an actual fhir language parser.
+          expressions.forEach(expression => {
+              try {
+                  const sp = expression as ISearchParamExpressionRecord;
+                  if (sp.path.indexOf('exists()') >= 0) {
+                      // Person.deceased.exists() and Person.deceased != false
+                      const parts = sp.path.split(' ');
+                      const i = parts[0].indexOf('exists()');
+                      if (i >= 0) {
+                          let fieldExistsEx = parts[0].substring(0, i-1);
+                          let op = parts[1];
+                          let fieldTestEx = parts[2];
+                          let comparator = parts[3];
+                          let value = parts[4];
+  
+                          const fieldExistsParts = fieldExistsEx.split('.');
+                          let fieldExists = fieldExistsParts.slice(1).join('.');
+  
+                          const fieldTestParts = fieldTestEx.split('.');
+                          let fieldTest = fieldTestParts.slice(1).join('.');
+  
+                          sp.exists = {
+                              fieldExists: [ `${fieldExists}Boolean`, `${fieldExists}DataTime` ], // [x]Boolean or [x]DateTime
+                              op,
+                              fieldTest: [ `${fieldTest}Boolean`, `${fieldTest}DataTime` ],
+                              comparator,
+                              value: [ value, undefined ]
+                          }
+                      }
+                  }
+              } catch (error) {
+  
+              }
+          });
+  
+          // where(resolve()) processing
+          let capturedType: string | undefined;
+          expressions = expressions.map((obj: any) => {
+              capturedType = undefined;
+              const { path, typeOf, exists } = obj;
+              return {
+                  path: path.replace(
+                      /\.where\(resolve\(\)\s+is\s+([^)]+)\)/,
+                      (_: string, typeName: string) => {
+                          capturedType = typeName;
+                          //return ` // reference = ${capturedType}`; // remove the .where(...) part (you can put ` // ${capturedType}` if you want to keep a comment)
+                          return '';
+                      }),
+                  typeOf,
+                  reference: capturedType,
+                  exists
+              }
+          });
+  
+          // .where processing
+          // The element before the .where will be an array. So this test checks which element(s) from that array are satisifed.
+          let capturedWhere: any = undefined;
+          expressions = expressions.map((obj: any) => {
+              capturedWhere = undefined;
+              const { path, reference, typeOf, exists } = obj;
+              const retVal: any = {
+                  path: path.replace(/([^.]+)\.where\(([^=]+)='([^']+)'\)/g, (_: string, field: string, subfield: string, value: string) => {
+                      capturedWhere = { field, subfield, value } 
+                      return field;
+                  }),
+                  typeOf,
+                  reference,
+                  exists
+              }
+              if (capturedWhere) {
+                  capturedWhere.full = `${capturedWhere.field}[*].${capturedWhere.subfield}=${capturedWhere.value}`;
+                  retVal.where = capturedWhere;
+              }
+              return retVal;
+          });
+  
+  
+          return {
+              expressions,
+              original_expressions
+          };
+      }
+  
+      #LoadDefinitions = async (): Promise<void> => {
+          try {
+              let usePath = '';
+              if (fs.existsSync(`${specPath1}${resourcesPath}`)) {
+                  usePath = specPath1;
+              } else {
+                  usePath = specPath2;
+              }
+              const __resources: any = JSON.parse(fs.readFileSync(`${usePath}${resourcesPath}`, 'utf-8'));
+              const __types: any = JSON.parse(fs.readFileSync(`${usePath}${typesPath}`, 'utf-8'));
+              const __searchParams: any = JSON.parse(fs.readFileSync(`${usePath}${searchParamsPath}`, 'utf-8'));
+  
+              for (let i=0; i < (__resources.entry as any[]).length; i++) {
+                  const entry = __resources.entry[i];
+                  const resource: any = entry.resource;
+                  if (resource?.snapshot?.element) {
+                      const rt = resource.type as string;
+                      await this.redis!.set(this.GetResourceKey(rt), JSON.stringify(resource.snapshot.element));
+                  }
+              };
+          
+              for (let i=0; i < (__types.entry as any[]).length; i++) {
+                  const entry = __types.entry[i];
+                  const type = entry.resource;
+                  if (type?.snapshot?.element) {
+                      await this.redis!.set(this.GetTypeKey(type.type), JSON.stringify(type.snapshot.element));
+                  }
+              };
+  
+              for (let i=0; i < (__searchParams.entry as any[]).length; i++) {
+                  const entry = __searchParams.entry[i];
+                  await this.redis!.set(this.GetSearchParameterByFullUrlKey(entry.fullUrl), JSON.stringify(entry.resource));
+                  const { code, base } = entry.resource;
+                  if (base)  {
+                      for (let j=0; j < base.length; j++) {
+                          const resourceType = base[j];
+                          await this.redis!.hSet(this.GetSearchParameterByResourceTypeKey(resourceType), code, JSON.stringify(entry.resource));
+                      }
+                  }
+              };
+  
+              //await this.#LoadDefinitionsPass2(__searchParams);
+  
+              console.log(`All completed ...`);
+          } catch (error) {
+              console.error(error);
+              throw error;
+          }
+      }
+      */
+  /*
+      #LoadDefinitionsPass2 = async (__searchParams: any): Promise<void> => {
+          try {
+              for (let i=0; i < (__searchParams.entry as any[]).length; i++) {
+  
+                  console.log(`Processing (i) entry: [${i}]`);
+  
+                  if (i === 47 ) {
+                      console.log(`here...`)
+                  }
+  
+                  const entry = __searchParams.entry[i];
+  
+                  const { id, url, code, base, type, expression, component, target } = entry.resource;
+  
+                  if (base)  {
+                      for (let j=0; j < base.length; j++) {
+                          const resourceType = base[j];
+                          const SP_ID = id;
+                          const SP_NAME = code; // code is the true SP name (but in the spec, name is usually the same as code)
+                          const SP_TYPE = type;
+                          const SP_URL = url;
+                          const SP_TARGET = target;
+                          let SP_EXPRESSION: string = expression;
+                          let expressions: any[] = [];
+                          let original_expressions: any[] = [];
+                          if (SP_EXPRESSION) {
+                              const retVal = this._ProcessExpressions(code, SP_EXPRESSION);
+                              expressions = retVal.expressions;
+                              original_expressions = retVal.original_expressions;
+                          }
+  
+                          const record: ISearchParamRecord = {
+                              SP_ID,
+                              SP_NAME,
+                              SP_TYPE,
+                              SP_URL,
+                              SP_TARGET,
+                              expressions,
+                              original_expressions,
+                              SP_DEFINITION: entry.resource // this.resourceHelper.GetSearchParam(SP_URL)
+                          };
+  
+                          for (let i=0; i < record.expressions.length; i++) {
+                              //console.log(record.expressions[i]);
+                              const rf = await this.GetResourceField(resourceType, record.expressions[i].path);
+                              if (rf) {
+                                  expressions[i].RES_FIELD = rf;
+                              }
+                          }
+  
+                          if (component) {
+                              record.component = [ ...component ];
+                              for (let k=0; k < record.component.length; k++) {
+                                  const c = record.component[k] as any;
+                                  //c.SP_RAW_PATHS = (c.expression.split('|') as any[]).map(rp => rp.trim());
+                                  //c.SP_PATHS = (c.SP_RAW_PATHS as any[]).map(rawPath => this.ResolveFhirChoiceType(rawPath));
+                                  const retVal = this._ProcessExpressions('', c.expression);
+                                  c.expressions = retVal.expressions;
+                                  c.original_expressions = retVal.original_expressions;
+  
+                                  let def = null;
+                                  const foundSearchParameter = await this.redis!.get(this.GetSearchParameterByFullUrlKey(c.definition));
+                                  if (foundSearchParameter) {
+                                      def = JSON.parse(foundSearchParameter);
+                                  }
+                                  //const def = await this.GetSearchParam(c.definition); //@@ fails here ...
+  
+                                  if (def && def.type) {
+                                      c.type = def.type
+                                  }
+                              }
+                          }
+  
+                          await this.redis!.hSet(this.GetSTSCustomSearchParameterByResourceTypeKey(resourceType), 
+                              code, JSON.stringify(record));
+  
+                          console.log(`Loaded...(j): [${j}]`);                            
+                      }
+                      console.log(`All Loaded...`);
+                  }
+                  console.log(`Loaded...(i): [${i}]`);
+              };
+              console.log(`Loaded...`);
+          } catch (error) {
+              console.error(error);
+              throw error;
+          }
+      }
+      */
+  /*
+      GetType = async (typeName: string): Promise<any[]> => {
+          await this.EnsureSearchParameterDataLoaded();
+          const foundType = await this.redis!.get(this.GetTypeKey(typeName));
+          if (foundType) {
+              return JSON.parse(foundType);
+          }
+          return [ ];
+      }
+  
+      GetResource = async (resourceType: string): Promise<any[]> => {
+          await this.EnsureSearchParameterDataLoaded();
+          const foundResourceType = await this.redis!.get(this.GetResourceKey(resourceType));
+          if (foundResourceType) {
+              return JSON.parse(foundResourceType);
+          }
+          return [ ];
+      }
+  
+      GetResourceField = async (resourceType: string, fieldPath: string): Promise<any> => {
+          const resource: any[] = await this.GetResource(resourceType);
+          if (resource) {
+              const foundRecord = resource.filter(o => o.id === fieldPath);
+              if (foundRecord.length > 0) {
+                  return foundRecord[0];
+              }
+              return undefined;
+          }
+      }
+  
+      GetSearchParam = async (fullUrl: string): Promise<any> => {
+          await this.EnsureSearchParameterDataLoaded();
+          const foundSearchParameter = await this.redis!.get(this.GetSearchParameterByFullUrlKey(fullUrl));
+          if (foundSearchParameter) {
+              return JSON.parse(foundSearchParameter);
+          }
+          return null;
+      }
+  
+      GetSearchParamsByResourceType = async (resourceType: string): Promise<SearchParameter[]> => {
+          await this.EnsureSearchParameterDataLoaded();
+          const all = await this.redis!.hGetAll(this.GetSearchParameterByResourceTypeKey(resourceType));
+          const parsed = Object.values(all).map(v => JSON.parse(v));
+          return parsed;
+      }
+  
+      GetSTSCustomSearchParametersByResourceType = async (resourceType: string): Promise<ISearchParamRecord[]> => {
+          await this.EnsureSearchParameterDataLoaded();
+          const all = await this.redis!.hGetAll(this.GetSTSCustomSearchParameterByResourceTypeKey(resourceType));
+          const parsed = Object.values(all).map(v => JSON.parse(v));
+          return parsed;
+      }
+  
+      GetSearchParamFromResourceTypeUrl = async (resourceType: string, url: string): Promise<ISearchParamRecord | undefined> => {
+          const customSearchParameters = await this.GetSTSCustomSearchParametersByResourceType(resourceType);
+          const filterByNameAndUrl = customSearchParameters.filter(rt => rt.SP_URL.localeCompare(url) === 0);
+          if (filterByNameAndUrl.length > 0) {
+              return filterByNameAndUrl[0];
+          }
+      }
+  
+      GetSearchParamFromResourceType = async (resourceType: string, name: string): Promise<ISearchParamRecord | undefined> => {
+          const customSearchParameters = await this.GetSTSCustomSearchParametersByResourceType(resourceType);
+          const filterByName = customSearchParameters.filter(rt => rt.SP_NAME.localeCompare(name) === 0);
+          if (filterByName.length > 0) {
+              return filterByName[0];
+          }
+      }
+  
+      GetPathsFromResourceType = async (resourceType: string, name: string): Promise<string[]> => {
+          const customSearchParameters = await this.GetSTSCustomSearchParametersByResourceType(resourceType);
+          const filterByName = customSearchParameters.filter(rt => rt.SP_NAME.localeCompare(name) === 0);
+          if (filterByName.length > 0) {
+              return filterByName[0].expressions.map(e => e.path)
+          }
+          return [ ];
+      }
+      */
+}
 const specPath1 = "./dist/";
 const specPath2 = "./node_modules/@nsshunt/stsfhirpg/dist/";
 const resourcesPath = "fhir-spec/profiles-resources.json";
@@ -7012,6 +7642,12 @@ class ResourceHelper {
     }
     return ResourceHelper.instance;
   }
+  Stop = async () => {
+    if (this.searchParameterManager) {
+      await this.searchParameterManager.Stop();
+    }
+    this.searchParameterManager = void 0;
+  };
   #LoadDefinitions = async () => {
     let usePath = "";
     if (fs.existsSync(`${specPath1}${resourcesPath}`)) {
@@ -7049,6 +7685,18 @@ class ResourceHelper {
     await this._LoadSearchParameters();
     return this.#definitions;
   };
+  PreLoadSearchParameterData = async () => {
+    console.log(`PreLoadSearchParameterData(): Start ...`);
+    this.searchParameterManager = new SearchParameterManager({
+      name: "stsfhirspdata",
+      pollIntervalMs: 250,
+      lockTtlMs: 3e4,
+      autoRenew: true,
+      heartbeatMs: 1e4
+    });
+    await this.searchParameterManager.EnsureSearchParameterDataLoaded();
+    console.log(`PreLoadSearchParameterData(): End`);
+  };
   GetDefinitions = async () => {
     if (!this.#definitions) {
       await this.#LoadDefinitions();
@@ -11374,6 +12022,9 @@ class DBSearchIndex {
   get searchRegistry() {
     return SearchRegistry.getInstance();
   }
+  Stop = async () => {
+    await this.resourceHelper.Stop();
+  };
   #OutputSearchDetails = (resourceName, resourceId, searchFieldRecord) => {
     const hl = chalk.yellow.bold.italic;
     this.#debug("------------------");