@nsshunt/stsfhirpg 1.2.6 → 1.2.8

package/dist/stsfhirpg.cjs

@@ -7002,6 +7002,7 @@ const typesPath = "fhir-spec/profiles-types.json";
 const searchParamsPath = "fhir-spec/search-parameters.json";
 class ResourceHelper {
   #definitions;
+  searchParameterManager;
   static instance;
   constructor() {
   }
@@ -7011,7 +7012,7 @@ class ResourceHelper {
     }
     return ResourceHelper.instance;
   }
-  #LoadDefinitions = () => {
+  #LoadDefinitions = async () => {
     let usePath = "";
     if (fs.existsSync(`${specPath1}${resourcesPath}`)) {
       usePath = specPath1;
@@ -7045,23 +7046,25 @@ class ResourceHelper {
     __searchParams.entry.forEach((entry) => {
       this.#definitions.searchParametersByUrl[entry.fullUrl] = entry.resource;
     });
-    this._LoadSearchParameters();
+    await this._LoadSearchParameters();
     return this.#definitions;
   };
-  get definitions() {
+  GetDefinitions = async () => {
     if (!this.#definitions) {
-      this.#LoadDefinitions();
+      await this.#LoadDefinitions();
     }
     return this.#definitions;
-  }
-  GetType = (typeName) => {
-    return this.definitions.types[typeName];
   };
-  GetResource = (resourceType) => {
-    return this.definitions.resources[resourceType];
+  GetType = async (typeName) => {
+    await this.GetDefinitions();
+    return this.#definitions.types[typeName];
+  };
+  GetResource = async (resourceType) => {
+    await this.GetDefinitions();
+    return this.#definitions.resources[resourceType];
   };
-  GetResourceField = (resourceType, fieldPath) => {
-    const resource = this.GetResource(resourceType);
+  GetResourceField = async (resourceType, fieldPath) => {
+    const resource = await this.GetResource(resourceType);
     if (resource) {
       const foundRecord = resource.filter((o) => o.id === fieldPath);
       if (foundRecord.length > 0) {
@@ -7070,14 +7073,17 @@ class ResourceHelper {
       return void 0;
     }
   };
-  GetSearchParam = (url) => {
-    return this.definitions.searchParametersByUrl[url];
+  GetSearchParam = async (url) => {
+    await this.GetDefinitions();
+    return this.#definitions.searchParametersByUrl[url];
   };
-  GetSearchParams = () => {
-    return this.definitions.searchParametersByUrl;
+  GetSearchParams = async () => {
+    await this.GetDefinitions();
+    return this.#definitions.searchParametersByUrl;
   };
-  GetSearchParamsByResource = (resource) => {
-    return Object.values(this.definitions.searchParametersByUrl).filter((sp) => sp.base.includes(resource)).map((sp) => sp);
+  GetSearchParamsByResource = async (resource) => {
+    await this.GetDefinitions();
+    return Object.values(this.#definitions.searchParametersByUrl).filter((sp) => sp.base.includes(resource)).map((sp) => sp);
   };
   // ------------------------------------------------------------------------------------------------------------------
   // Remove ( ) when either are present
@@ -7200,8 +7206,8 @@ class ResourceHelper {
       original_expressions
     };
   };
-  _LoadSearchParameters = () => {
-    for (const [key, val] of Object.entries(this.GetSearchParams())) {
+  _LoadSearchParameters = async () => {
+    for (const [key, val] of Object.entries(await this.GetSearchParams())) {
       const { id, url, code, base, type, expression, component, target } = val;
       for (let i = 0; i < base.length; i++) {
         const resourceName = base[i];
@@ -7232,44 +7238,47 @@ class ResourceHelper {
           SP_TARGET,
           expressions,
           original_expressions,
-          SP_DEFINITION: this.GetSearchParam(SP_URL)
+          SP_DEFINITION: await this.GetSearchParam(SP_URL)
         };
         for (let i2 = 0; i2 < record.expressions.length; i2++) {
-          const rf = this.GetResourceField(resourceName, record.expressions[i2].path);
+          const rf = await this.GetResourceField(resourceName, record.expressions[i2].path);
           if (rf) {
             expressions[i2].RES_FIELD = rf;
           }
         }
         if (component) {
           record.component = [...component];
-          record.component.forEach((c) => {
+          for (const c of record.component) {
             const retVal = this.ProcessExpressions("", c.expression);
             c.expressions = retVal.expressions;
             c.original_expressions = retVal.original_expressions;
-            const def = this.GetSearchParam(c.definition);
+            const def = await this.GetSearchParam(c.definition);
             if (def && def.type) {
               c.type = def.type;
             }
-          });
+          }
         }
         this.#definitions.searchParametersByResourceType[resourceName].params.push(record);
       }
     }
   };
   GetSearchParamFromResourceTypeUrl = async (resourceType, url) => {
-    const filterByNameAndUrl = this.definitions.searchParametersByResourceType[resourceType].params.filter((rt) => rt.SP_URL.localeCompare(url) === 0);
+    await this.GetDefinitions();
+    const filterByNameAndUrl = this.#definitions.searchParametersByResourceType[resourceType].params.filter((rt) => rt.SP_URL.localeCompare(url) === 0);
     if (filterByNameAndUrl.length > 0) {
       return filterByNameAndUrl[0];
     }
   };
   GetSearchParamFromResourceType = async (resourceType, name) => {
-    const filterByName = this.definitions.searchParametersByResourceType[resourceType].params.filter((rt) => rt.SP_NAME.localeCompare(name) === 0);
+    await this.GetDefinitions();
+    const filterByName = this.#definitions.searchParametersByResourceType[resourceType].params.filter((rt) => rt.SP_NAME.localeCompare(name) === 0);
     if (filterByName.length > 0) {
       return filterByName[0];
     }
   };
   GetSearchParamsFromResourceType = async (resourceType) => {
-    return this.definitions.searchParametersByResourceType[resourceType].params;
+    await this.GetDefinitions();
+    return this.#definitions.searchParametersByResourceType[resourceType].params;
   };
 }
 var ansiStyles = { exports: {} };
@@ -10671,7 +10680,7 @@ class DBSearchIndexToken extends DBSearchIndexBase {
       }
     }
   };
-  OutputIndexRecordFromFhirElement = (path, inputTokens, tir) => {
+  OutputIndexRecordFromFhirElement = async (path, inputTokens, tir) => {
     const _OutputMissingParamater = () => {
       const tirc = this.GetNewBaseIndexRecord(tir);
       tirc.SP_MISSING = true;
@@ -10705,10 +10714,10 @@ class DBSearchIndexToken extends DBSearchIndexBase {
   };
   OutputIndexRecord = async (resource, tir, searchFieldRecord) => {
     let retVal = [];
-    searchFieldRecord.expressions.forEach((expression) => {
+    for (const expression of searchFieldRecord.expressions) {
       let tokens = this.GetValueFromPath(resource, expression.path, searchFieldRecord, expression);
-      retVal.push(...this.OutputIndexRecordFromFhirElement(expression.path, tokens, tir));
-    });
+      retVal.push(...await this.OutputIndexRecordFromFhirElement(expression.path, tokens, tir));
+    }
     return retVal;
   };
   OutputIndexRecordToConsole = (tir) => {
@@ -10724,7 +10733,7 @@ class DBSearchIndexComposite extends DBSearchIndexBase {
   #warn = (message) => {
   };
   // This method is empty becuase the composite processor will not call itself recursively
-  OutputIndexRecordFromFhirElement = (path, inputReferenceVal, tir) => {
+  OutputIndexRecordFromFhirElement = async (path, inputReferenceVal, tir) => {
     this.#warn(`DBSearchIndexComposite:__OutputIndexRecordFromFhirElement(): composite (recursive) not supported within a composite expression. inputReferenceVal: [${inputReferenceVal}], tir: [${tir}]`);
     return [];
   };
@@ -10807,7 +10816,7 @@ class DBSearchIndexDates extends DBSearchIndexBase {
   | `Period`  | Explicit, though the upper or lower bound might not actually be specified in resources. |
   | `Timing`  | The specified scheduling details are ignored and only the outer limits matter. For instance, a schedule that specifies every second day between 31-Jan-2013 and 24-Mar-2013 includes 1-Feb-2013, even though that is on an odd day that is not specified by the period. This is to keep the server load processing queries reasonable. |
   */
-  OutputIndexRecordFromFhirElement = (path, inputReferenceVal, tir) => {
+  OutputIndexRecordFromFhirElement = async (path, inputReferenceVal, tir) => {
     let retVal = [];
     const _OutputDate = (referenceVal, tir2, index) => {
       let parsedDate;
@@ -10888,10 +10897,10 @@ class DBSearchIndexDates extends DBSearchIndexBase {
   };
   OutputIndexRecord = async (resource, tir, searchFieldRecord) => {
     let retVal = [];
-    searchFieldRecord.expressions.forEach((expression) => {
+    for (const expression of searchFieldRecord.expressions) {
       let referenceVal = this.GetValueFromPath(resource, expression.path, searchFieldRecord, expression);
-      retVal.push(...this.OutputIndexRecordFromFhirElement(expression.path, referenceVal, tir));
-    });
+      retVal.push(...await this.OutputIndexRecordFromFhirElement(expression.path, referenceVal, tir));
+    }
     return retVal;
   };
   OutputIndexRecordToConsole = (tir) => {
@@ -10946,7 +10955,7 @@ class DBSearchIndexQuantity extends DBSearchIndexBase {
     }
     return quantityIndexRecords;
   };
-  OutputIndexRecordFromFhirElement = (path, inputQuantityVal, tir) => {
+  OutputIndexRecordFromFhirElement = async (path, inputQuantityVal, tir) => {
     const retVal = [];
     if (this.IsDefined(inputQuantityVal)) {
       const _PushQty = (qVal, index) => {
@@ -10976,10 +10985,10 @@ class DBSearchIndexQuantity extends DBSearchIndexBase {
   };
   OutputIndexRecord = async (resource, tir, searchFieldRecord) => {
     const retVal = [];
-    searchFieldRecord.expressions.forEach((expression) => {
+    for (const expression of searchFieldRecord.expressions) {
       let quantityVal = this.GetValueFromPath(resource, expression.path, searchFieldRecord, expression);
-      retVal.push(...this.OutputIndexRecordFromFhirElement(expression.path, quantityVal, tir));
-    });
+      retVal.push(...await this.OutputIndexRecordFromFhirElement(expression.path, quantityVal, tir));
+    }
     return retVal;
   };
   OutputIndexRecordToConsole = (tir) => {
@@ -11039,7 +11048,7 @@ class DBSearchIndexReference extends DBSearchIndexBase {
       throw error;
     }
   };
-  OutputIndexRecordFromFhirElement = (path, inputReferenceVal, tir, searchParamExpressionRecord, resource) => {
+  OutputIndexRecordFromFhirElement = async (path, inputReferenceVal, tir, searchParamExpressionRecord, resource) => {
     const _OutputReferencesFromFhirElement = (referenceVal, index) => {
       let resourceReference;
       if (this.IsDefined(referenceVal) && this.IsDefined(referenceVal.identifier) && this.IsDefined(referenceVal.identifier.value)) {
@@ -11083,10 +11092,10 @@ class DBSearchIndexReference extends DBSearchIndexBase {
   };
   OutputIndexRecord = async (resource, tir, searchFieldRecord) => {
     let retVal = [];
-    searchFieldRecord.expressions.forEach((expression) => {
+    for (const expression of searchFieldRecord.expressions) {
       const referenceVal = this.GetValueFromPath(resource, expression.path, searchFieldRecord, expression);
-      retVal.push(...this.OutputIndexRecordFromFhirElement(expression.path, referenceVal, tir, expression, resource));
-    });
+      retVal.push(...await this.OutputIndexRecordFromFhirElement(expression.path, referenceVal, tir, expression, resource));
+    }
     return retVal;
   };
   OutputIndexRecordToConsole = (tir) => {
@@ -11101,7 +11110,7 @@ class DBSearchIndexString extends DBSearchIndexBase {
   }
   #debug = (message) => {
   };
-  #OutputString = (stringInputVal, tir, expression) => {
+  #OutputString = async (stringInputVal, tir, expression) => {
     const stringIndexRecords = [];
     if (this.IsDefined(expression) && typeof stringInputVal === "object") {
       let fields = [];
@@ -11114,9 +11123,9 @@ class DBSearchIndexString extends DBSearchIndexBase {
         }
         let res;
         if (this.IsDefined(expressionType) && this.IsDefined(expressionType.code)) {
-          res = this.#resourceHelper.GetType(expressionType.code);
+          res = await this.#resourceHelper.GetType(expressionType.code);
         } else {
-          res = this.#resourceHelper.GetType(expressionType);
+          res = await this.#resourceHelper.GetType(expressionType);
         }
         if (this.IsDefined(res)) {
           for (let i = 0; i < res.length; i++) {
@@ -11171,20 +11180,20 @@ class DBSearchIndexString extends DBSearchIndexBase {
       }
     }
   };
-  OutputIndexRecordFromFhirElement = (path, inputStringVal, tir, expression) => {
+  OutputIndexRecordFromFhirElement = async (path, inputStringVal, tir, expression) => {
     const retVal = [];
     if (this.IsDefined(inputStringVal)) {
-      const _PushStrings = (stringVals, index) => {
+      const _PushStrings = async (stringVals, index) => {
         if (Array.isArray(stringVals)) {
           for (let i = 0; i < stringVals.length; i++) {
-            _PushStrings(stringVals[i], i);
+            await _PushStrings(stringVals[i], i);
           }
         } else {
           this.ComputeCompositeHash(path, index, tir);
-          retVal.push(...this.#OutputString(stringVals, tir, expression));
+          retVal.push(...await this.#OutputString(stringVals, tir, expression));
         }
       };
-      _PushStrings(inputStringVal, 0);
+      await _PushStrings(inputStringVal, 0);
     } else {
       const tirc = this.GetNewBaseIndexRecord(tir);
       tirc.SP_MISSING = true;
@@ -11199,10 +11208,10 @@ class DBSearchIndexString extends DBSearchIndexBase {
   };
   OutputIndexRecord = async (resource, tir, searchParamRecord) => {
     const retVal = [];
-    searchParamRecord.expressions.forEach((expression) => {
+    for (const expression of searchParamRecord.expressions) {
       let stringVal = this.GetValueFromPath(resource, expression.path, searchParamRecord, expression);
-      retVal.push(...this.OutputIndexRecordFromFhirElement(expression.path, stringVal, tir, expression));
-    });
+      retVal.push(...await this.OutputIndexRecordFromFhirElement(expression.path, stringVal, tir, expression));
+    }
     return retVal;
   };
   OutputIndexRecordToConsole = (tir) => {
@@ -11227,7 +11236,7 @@ class DBSearchIndexNumber extends DBSearchIndexBase {
     }
     return quantityIndexRecords;
   };
-  OutputIndexRecordFromFhirElement = (path, inputNumberVal, tir) => {
+  OutputIndexRecordFromFhirElement = async (path, inputNumberVal, tir) => {
     const retVal = [];
     if (this.IsDefined(inputNumberVal)) {
       const _PushNumberVal = (numberVal, index) => {
@@ -11253,10 +11262,10 @@ class DBSearchIndexNumber extends DBSearchIndexBase {
   };
   OutputIndexRecord = async (resource, tir, searchFieldRecord) => {
     const retVal = [];
-    searchFieldRecord.expressions.forEach((expression) => {
+    for (const expression of searchFieldRecord.expressions) {
       let numberVal = this.GetValueFromPath(resource, expression.path, searchFieldRecord, expression);
-      retVal.push(...this.OutputIndexRecordFromFhirElement(expression.path, numberVal, tir));
-    });
+      retVal.push(...await this.OutputIndexRecordFromFhirElement(expression.path, numberVal, tir));
+    }
     return retVal;
   };
   OutputIndexRecordToConsole = (tir) => {
@@ -11286,7 +11295,7 @@ class DBSearchIndexURI extends DBSearchIndexBase {
     }
     return uriIndexRecords;
   };
-  OutputIndexRecordFromFhirElement = (path, inputUriVal, tir) => {
+  OutputIndexRecordFromFhirElement = async (path, inputUriVal, tir) => {
     const retVal = [];
     const _processUriVal = (uriVal, index) => {
       if (Array.isArray(uriVal)) {
@@ -11313,10 +11322,10 @@ class DBSearchIndexURI extends DBSearchIndexBase {
   };
   OutputIndexRecord = async (resource, tir, searchFieldRecord) => {
     const retVal = [];
-    searchFieldRecord.expressions.forEach((expression) => {
+    for (const expression of searchFieldRecord.expressions) {
       let uriVal = this.GetValueFromPath(resource, expression.path, searchFieldRecord, expression);
-      retVal.push(...this.OutputIndexRecordFromFhirElement(expression.path, uriVal, tir));
-    });
+      retVal.push(...await this.OutputIndexRecordFromFhirElement(expression.path, uriVal, tir));
+    }
     return retVal;
   };
   OutputIndexRecordToConsole = (tir) => {