@nsshunt/stsfhirpg 1.1.7 → 1.2.2

package/dist/stsfhirpg.cjs

@@ -15,7 +15,6 @@ const require$$1$2 = require("tls");
 const require$$0$7 = require("path");
 const require$$0$6 = require("stream");
 const require$$0$5 = require("buffer");
-const redis = require("redis");
 class LuxonError extends Error {
 }
 class InvalidDateTimeError extends LuxonError {
@@ -7026,7 +7025,8 @@ class ResourceHelper {
       this.#definitions = {
         resources: {},
         types: {},
-        searchParameters: {}
+        searchParametersByUrl: {},
+        searchParametersByResourceType: {}
       };
     }
     __resources.entry.forEach((entry) => {
@@ -7043,25 +7043,22 @@ class ResourceHelper {
       }
     });
     __searchParams.entry.forEach((entry) => {
-      this.#definitions.searchParameters[entry.fullUrl] = entry.resource;
+      this.#definitions.searchParametersByUrl[entry.fullUrl] = entry.resource;
     });
+    this._LoadSearchParameters();
     return this.#definitions;
   };
-  GetType = (typeName) => {
+  get definitions() {
     if (!this.#definitions) {
       this.#LoadDefinitions();
     }
-    if (this.#definitions) {
-      const foundType = this.#definitions.types[typeName];
-      return foundType;
-    }
-    return [];
+    return this.#definitions;
+  }
+  GetType = (typeName) => {
+    return this.definitions.types[typeName];
   };
   GetResource = (resourceType) => {
-    if (!this.#definitions) {
-      this.#LoadDefinitions();
-    }
-    return this.#definitions.resources[resourceType];
+    return this.definitions.resources[resourceType];
   };
   GetResourceField = (resourceType, fieldPath) => {
     const resource = this.GetResource(resourceType);
@@ -7074,22 +7071,215 @@ class ResourceHelper {
     }
   };
   GetSearchParam = (url) => {
-    if (!this.#definitions) {
-      this.#LoadDefinitions();
-    }
-    return this.#definitions.searchParameters[url];
+    return this.definitions.searchParametersByUrl[url];
   };
   GetSearchParams = () => {
-    if (!this.#definitions) {
-      this.#LoadDefinitions();
-    }
-    return this.#definitions.searchParameters;
+    return this.definitions.searchParametersByUrl;
   };
   GetSearchParamsByResource = (resource) => {
-    if (!this.#definitions) {
-      this.#LoadDefinitions();
+    return Object.values(this.definitions.searchParametersByUrl).filter((sp) => sp.base.includes(resource)).map((sp) => sp);
+  };
+  // ------------------------------------------------------------------------------------------------------------------
+  // Remove ( ) when either are present
+  #RemoveOuterParentheses = (input) => {
+    return input.replace(/^\(|\)$/g, "");
+  };
+  // Remove ( ) only when both are present
+  #RemoveSurroundingParentheses = (input) => {
+    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
+      */
+  ProcessExpressions = (resourceName, SP_EXPRESSION) => {
+    let expressions = [];
+    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);
     }
-    return Object.values(this.#definitions.searchParameters).filter((sp) => sp.base.includes(resource)).map((sp) => sp);
+    let original_expressions = [...expressions];
+    expressions = expressions.map((e) => {
+      let capturedTypeOf = void 0;
+      return {
+        path: e.replace(
+          /\.ofType\(([^)]+)\)/g,
+          (_, typeName) => {
+            capturedTypeOf = true;
+            return typeName.charAt(0).toUpperCase() + typeName.slice(1);
+          }
+        ),
+        typeOf: capturedTypeOf
+      };
+    });
+    expressions.forEach((expression) => {
+      try {
+        const sp = expression;
+        if (sp.path.indexOf("exists()") >= 0) {
+          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, void 0]
+            };
+          }
+        }
+      } catch (error) {
+      }
+    });
+    let capturedType;
+    expressions = expressions.map((obj) => {
+      capturedType = void 0;
+      const { path, typeOf, exists } = obj;
+      return {
+        path: path.replace(
+          /\.where\(resolve\(\)\s+is\s+([^)]+)\)/,
+          (_, typeName) => {
+            capturedType = typeName;
+            return "";
+          }
+        ),
+        typeOf,
+        reference: capturedType,
+        exists
+      };
+    });
+    let capturedWhere = void 0;
+    expressions = expressions.map((obj) => {
+      capturedWhere = void 0;
+      const { path, reference, typeOf, exists } = obj;
+      const retVal = {
+        path: path.replace(/([^.]+)\.where\(([^=]+)='([^']+)'\)/g, (_, field, subfield, value) => {
+          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
+    };
+  };
+  _LoadSearchParameters = () => {
+    for (const [key, val] of Object.entries(this.GetSearchParams())) {
+      const { id, url, code, base, type, expression, component, target } = val;
+      for (let i = 0; i < base.length; i++) {
+        const resourceName = base[i];
+        if (!this.#definitions?.searchParametersByResourceType[resourceName]) {
+          this.#definitions.searchParametersByResourceType[resourceName] = {
+            resourceName,
+            params: []
+          };
+        }
+        const SP_ID = id;
+        const SP_NAME = code;
+        const SP_TYPE = type;
+        const SP_URL = url;
+        const SP_TARGET = target;
+        let SP_EXPRESSION = expression;
+        let expressions = [];
+        let original_expressions = [];
+        if (SP_EXPRESSION) {
+          const retVal = this.ProcessExpressions(resourceName, SP_EXPRESSION);
+          expressions = retVal.expressions;
+          original_expressions = retVal.original_expressions;
+        }
+        const record = {
+          SP_ID,
+          SP_NAME,
+          SP_TYPE,
+          SP_URL,
+          SP_TARGET,
+          expressions,
+          original_expressions,
+          SP_DEFINITION: this.GetSearchParam(SP_URL)
+        };
+        for (let i2 = 0; i2 < record.expressions.length; i2++) {
+          const rf = this.GetResourceField(resourceName, record.expressions[i2].path);
+          if (rf) {
+            expressions[i2].RES_FIELD = rf;
+          }
+        }
+        if (component) {
+          record.component = [...component];
+          record.component.forEach((c) => {
+            const retVal = this.ProcessExpressions("", c.expression);
+            c.expressions = retVal.expressions;
+            c.original_expressions = retVal.original_expressions;
+            const def = this.GetSearchParam(c.definition);
+            if (def && def.type) {
+              c.type = def.type;
+            }
+          });
+        }
+        this.#definitions.searchParametersByResourceType[resourceName].params.push(record);
+      }
+    }
+  };
+  GetSearchParamFromResourceTypeUrl = (resourceType, url) => {
+    const filterByNameAndUrl = this.definitions.searchParametersByResourceType[resourceType].params.filter((rt) => rt.SP_URL.localeCompare(url) === 0);
+    if (filterByNameAndUrl.length > 0) {
+      return filterByNameAndUrl[0];
+    }
+  };
+  /*
+      GetSearchParamFromResourceType = (resourceType: string, name: string): ISearchParamRecord | undefined  => {
+          const filterByName = this.definitions.searchParametersByResourceType[resourceType].params.filter(rt => rt.SP_NAME.localeCompare(name) === 0);
+          if (filterByName.length > 0) {
+              return filterByName[0];
+          }
+      }
+  
+      GetPathsFromResourceType = (resourceType: string, name: string): string[] => {
+          const filterByName = this.definitions.searchParametersByResourceType[resourceType].params.filter(rt => rt.SP_NAME.localeCompare(name) === 0);
+          if (filterByName.length > 0) {
+              return filterByName[0].expressions.map(e => e.path)
+          }
+          return [ ];
+      }
+      */
+  GetSearchParamsFromResourceType = (resourceType) => {
+    return this.definitions.searchParametersByResourceType[resourceType].params;
   };
 }
 var ansiStyles = { exports: {} };
@@ -10567,7 +10757,7 @@ class DBSearchIndexComposite extends DBSearchIndexBase {
     searchFieldRecord.component.forEach((searchParamComponentRecord) => {
       components.push([]);
       const url = searchParamComponentRecord.definition;
-      const sp = searchIndex.GetSearchParamFromResourceTypeUrl(resource.resourceType, url);
+      const sp = searchIndex.resourceHelper.GetSearchParamFromResourceTypeUrl(resource.resourceType, url);
       if (this.IsDefined(sp)) {
         const tir2 = {
           PID: v4(),
@@ -11222,27 +11412,13 @@ class DBSearchIndex {
       return [];
     }
   };
-  ResolveFhirChoiceType = (path) => {
-    const match2 = path.match(/^(.+?)\.ofType\((.+?)\)$/);
-    if (!match2) {
-      return path;
-    }
-    const base = match2[1];
-    const fhirType = match2[2];
-    const capitalizedType = fhirType.charAt(0).toUpperCase() + fhirType.slice(1);
-    return `${base}${capitalizedType}`;
-  };
   GetSearchIndexData = (resource) => {
     try {
-      const st = performance.now();
-      if (!this.#searchParams) {
-        this.LoadSearchParameters();
-      }
+      const searchParamRecords = this.resourceHelper.GetSearchParamsFromResourceType(resource.resourceType);
       const searchIndexData = [];
-      for (let i = 0; i < this.#searchParams[resource.resourceType].params.length; i++) {
-        const searchRecord = this.#searchParams[resource.resourceType].params[i];
+      for (let i = 0; i < searchParamRecords.length; i++) {
+        const searchRecord = searchParamRecords[i];
         try {
-          const st2 = performance.now();
           const retVal = this.UpdateIndex(resource, searchRecord);
           if (retVal && retVal.length > 0) {
             searchIndexData.push(...retVal);
@@ -11257,286 +11433,19 @@ class DBSearchIndex {
       return [];
     }
   };
-  GetSearchParamFromResourceTypeUrl = (resourceType, url) => {
-    if (!this.#searchParams) {
-      this.LoadSearchParameters();
-    }
-    const filterByNameAndUrl = this.#searchParams[resourceType].params.filter((rt) => rt.SP_URL.localeCompare(url) === 0);
-    if (filterByNameAndUrl.length > 0) {
-      return filterByNameAndUrl[0];
-    }
-  };
-  GetSearchParamFromResourceType = (resourceType, name) => {
-    if (!this.#searchParams) {
-      this.LoadSearchParameters();
-    }
-    const filterByName = this.#searchParams[resourceType].params.filter((rt) => rt.SP_NAME.localeCompare(name) === 0);
-    if (filterByName.length > 0) {
-      return filterByName[0];
-    }
-  };
-  GetPathsFromResourceType = (resourceType, name) => {
-    if (!this.#searchParams) {
-      this.LoadSearchParameters();
-    }
-    const filterByName = this.#searchParams[resourceType].params.filter((rt) => rt.SP_NAME.localeCompare(name) === 0);
-    if (filterByName.length > 0) {
-      return filterByName[0].expressions.map((e) => e.path);
-    }
-    return [];
-  };
-  // Remove ( ) when either are present
-  #RemoveOuterParentheses = (input) => {
-    return input.replace(/^\(|\)$/g, "");
-  };
-  // Remove ( ) only when both are present
-  #RemoveSurroundingParentheses = (input) => {
-    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
-      */
-  ProcessExpressions = (resourceName, SP_EXPRESSION) => {
-    let expressions = [];
-    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];
-    expressions = expressions.map((e) => {
-      let capturedTypeOf = void 0;
-      return {
-        path: e.replace(
-          /\.ofType\(([^)]+)\)/g,
-          (_, typeName) => {
-            capturedTypeOf = true;
-            return typeName.charAt(0).toUpperCase() + typeName.slice(1);
-          }
-        ),
-        typeOf: capturedTypeOf
-      };
-    });
-    expressions.forEach((expression) => {
-      try {
-        const sp = expression;
-        if (sp.path.indexOf("exists()") >= 0) {
-          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, void 0]
-            };
-          }
-        }
-      } catch (error) {
+      GetSearchParamFromResourceTypeUrl = (resourceType: string, url: string): ISearchParamRecord | undefined  => {
+          return this.resourceHelper.GetSearchParamFromResourceTypeUrl(resourceType, url);
       }
-    });
-    let capturedType;
-    expressions = expressions.map((obj) => {
-      capturedType = void 0;
-      const { path, typeOf, exists } = obj;
-      return {
-        path: path.replace(
-          /\.where\(resolve\(\)\s+is\s+([^)]+)\)/,
-          (_, typeName) => {
-            capturedType = typeName;
-            return "";
-          }
-        ),
-        typeOf,
-        reference: capturedType,
-        exists
-      };
-    });
-    let capturedWhere = void 0;
-    expressions = expressions.map((obj) => {
-      capturedWhere = void 0;
-      const { path, reference, typeOf, exists } = obj;
-      const retVal = {
-        path: path.replace(/([^.]+)\.where\(([^=]+)='([^']+)'\)/g, (_, field, subfield, value) => {
-          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
-    };
-  };
-  LoadSearchParameters = () => {
-    const searchParamData = {};
-    for (const [key, val] of Object.entries(this.resourceHelper.GetSearchParams())) {
-      const { id, url, code, base, type, expression, component, target } = val;
-      for (let i = 0; i < base.length; i++) {
-        const resourceName = base[i];
-        if (!searchParamData[resourceName]) {
-          searchParamData[resourceName] = {
-            resourceName,
-            params: []
-          };
-        }
-        const SP_ID = id;
-        const SP_NAME = code;
-        const SP_TYPE = type;
-        const SP_URL = url;
-        const SP_TARGET = target;
-        let SP_EXPRESSION = expression;
-        let expressions = [];
-        let original_expressions = [];
-        if (SP_EXPRESSION) {
-          const retVal = this.ProcessExpressions(resourceName, SP_EXPRESSION);
-          expressions = retVal.expressions;
-          original_expressions = retVal.original_expressions;
-        }
-        const record = {
-          SP_ID,
-          SP_NAME,
-          SP_TYPE,
-          SP_URL,
-          SP_TARGET,
-          expressions,
-          original_expressions,
-          SP_DEFINITION: this.resourceHelper.GetSearchParam(SP_URL)
-        };
-        for (let i2 = 0; i2 < record.expressions.length; i2++) {
-          const rf = this.resourceHelper.GetResourceField(resourceName, record.expressions[i2].path);
-          if (rf) {
-            expressions[i2].RES_FIELD = rf;
-          }
-        }
-        if (component) {
-          record.component = [...component];
-          record.component.forEach((c) => {
-            const retVal = this.ProcessExpressions("", c.expression);
-            c.expressions = retVal.expressions;
-            c.original_expressions = retVal.original_expressions;
-            const def = this.resourceHelper.GetSearchParam(c.definition);
-            if (def && def.type) {
-              c.type = def.type;
-            }
-          });
-        }
-        searchParamData[resourceName].params.push(record);
-      }
-    }
-    this.#searchParams = searchParamData;
-    return searchParamData;
-  };
-  /*
-          
-  
-          for (const [resourceName,val] of Object.entries(searchParams)) {
-  
-              const patientSearchList: Record<string, any> = (val as any).resourceSpecific;
-  
-              for (const [key2,val2] of Object.entries(patientSearchList)) {
-  
-                  const SP_ID = val2.id;
-                  const SP_NAME = key2;
-                  const SP_TYPE = val2.type;
-                  const SP_URL = val2.url;
-                  let SP_EXPRESSION: string = val2.expression;
-                  let expressions: any[] = [];
-                  let original_expressions: any[] = [];
-                  if (SP_EXPRESSION) {
-                      const retVal = this.ProcessExpressions(resourceName, SP_EXPRESSION);
-                      expressions = retVal.expressions;
-                      original_expressions = retVal.original_expressions;
-                  }
   
-                  if (!searchParamData[resourceName]) {
-                      searchParamData[resourceName] = {
-                          resourceName,
-                          params: [ ]
-                      }
-                  }
-  
-                  // GetResourceField
-  
-                  const record: ISearchParamRecord = {
-                      SP_ID,
-                      SP_NAME,
-                      SP_TYPE,
-                      SP_URL,
-                      expressions,
-                      original_expressions,
-                      SP_DEFINITION: this.resourceHelper.GetSearchParam(SP_URL)
-                  };
-  
-                  for (let i=0; i < record.expressions.length; i++) {
-                      //console.log(record.expressions[i]);
-                      const rf = this.resourceHelper.GetResourceField(resourceName, record.expressions[i].path);
-                      if (rf) {
-                          expressions[i].RES_FIELD = rf;
-                      }
-                  }
-                  
-                  if (val2.component) {
-                      record.component = [ ...val2.component ];
-                      (record.component as any[]).forEach(c => {
-                          //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;
-                          const def = this.resourceHelper.GetSearchParam(c.definition);
-                          if (def && def.type) {
-                              c.type = def.type
-                          }
-                      })
-                  }
-  
-                  searchParamData[resourceName].params.push(record);
-              }
-          }
-  
-          this.#searchParams = searchParamData;
+      GetSearchParamFromResourceType = (resourceType: string, name: string): ISearchParamRecord | undefined  => {
+          return this.resourceHelper.GetSearchParamFromResourceType(resourceType, name);
+      }
   
-          return searchParamData;
+      GetPathsFromResourceType = (resourceType: string, name: string): string[] => {
+          return this.resourceHelper.GetPathsFromResourceType(resourceType, name);
       }
-          */
+      */
 }
 var lib$1 = { exports: {} };
 var defaults = { exports: {} };
@@ -18945,229 +18854,10 @@ class PGFhirAccessLayer extends tinyEmitterExports.TinyEmitter {
     }
   };
 }
-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;
-  EnsureSearchParameterDataLoaded = async (name, loadFn, options) => {
-    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 = options?.pollIntervalMs ?? 250;
-      const lockTtlMs = options?.lockTtlMs ?? 3e4;
-      const autoRenew = options?.autoRenew ?? true;
-      const heartbeatMs = options?.heartbeatMs ?? 1e4;
-      const completeTtlSeconds = options?.completeTtlSeconds;
-      const timeoutMs = options?.timeoutMs;
-      const completeKey = `fhir:searchparam:${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 "${name}" to be loaded`
-            );
-          }
-        }
-        try {
-          const alreadyComplete = await this.redis.get(completeKey);
-          if (alreadyComplete) {
-            console.log(`ensureSearchParamLoaded():alreadyComplete: PID: [${process.pid}] data loaded: [${alreadyComplete}]`);
-            return;
-          }
-        } catch (error) {
-          console.error(error);
-          throw error;
-        }
-        const runResult = await lockManager.runExclusive(
-          `fhir:searchparam:${name}`,
-          async () => {
-            console.log(`ensureSearchParamLoaded(): PID: [${process.pid}] lock acquired`);
-            const completeAfterLock = await this.redis.get(completeKey);
-            if (completeAfterLock) {
-              console.log(`ensureSearchParamLoaded():completeAfterLock: PID: [${process.pid}] data loaded: [${completeAfterLock}]`);
-              return;
-            }
-            await loadFn();
-            const completeValue = JSON.stringify({
-              loaded: true,
-              loadedAt: (/* @__PURE__ */ new Date()).toLocaleString(),
-              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);
-            }
-          },
-          {
-            ttlMs: lockTtlMs,
-            autoRenew,
-            heartbeatMs
-          }
-        );
-        if (runResult.acquired) {
-          return;
-        }
-        console.log(`ensureSearchParamLoaded(): PID: [${process.pid}] Did not get lock`);
-        await stsutils.Sleep(pollIntervalMs);
-      }
-    } finally {
-      if (this.redis) {
-        this.redis.close();
-        console.log(`SearchParameterManager(): redis closed`);
-      }
-    }
-  };
-}
 exports.DBSearchIndex = DBSearchIndex;
 exports.FHIRDateUtils = FHIRDateUtils;
 exports.PGFhirAccessLayer = PGFhirAccessLayer;
-exports.RedisDistributedLock = RedisDistributedLock;
 exports.ResourceHelper = ResourceHelper;
-exports.SearchParameterManager = SearchParameterManager;
 exports.hashReferenceParam = hashReferenceParam;
 exports.hashStringParam = hashStringParam;
 exports.hashTokenParam = hashTokenParam;