@nsshunt/stsfhirpg 1.2.5 → 1.2.7

package/dist/stsfhirpg.mjs

@@ -7000,6 +7000,7 @@ const typesPath = "fhir-spec/profiles-types.json";
 const searchParamsPath = "fhir-spec/search-parameters.json";
 class ResourceHelper {
   #definitions;
+  searchParameterManager;
   static instance;
   constructor() {
   }
@@ -7009,7 +7010,7 @@ class ResourceHelper {
     }
     return ResourceHelper.instance;
   }
-  #LoadDefinitions = () => {
+  #LoadDefinitions = async () => {
     let usePath = "";
     if (fs.existsSync(`${specPath1}${resourcesPath}`)) {
       usePath = specPath1;
@@ -7043,23 +7044,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) {
@@ -7068,14 +7071,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
@@ -7198,8 +7204,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];
@@ -7230,44 +7236,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 = (resourceType, url) => {
-    const filterByNameAndUrl = this.definitions.searchParametersByResourceType[resourceType].params.filter((rt) => rt.SP_URL.localeCompare(url) === 0);
+  GetSearchParamFromResourceTypeUrl = async (resourceType, url) => {
+    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 = (resourceType, name) => {
-    const filterByName = this.definitions.searchParametersByResourceType[resourceType].params.filter((rt) => rt.SP_NAME.localeCompare(name) === 0);
+  GetSearchParamFromResourceType = async (resourceType, name) => {
+    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 = (resourceType) => {
-    return this.definitions.searchParametersByResourceType[resourceType].params;
+  GetSearchParamsFromResourceType = async (resourceType) => {
+    await this.GetDefinitions();
+    return this.#definitions.searchParametersByResourceType[resourceType].params;
   };
 }
 var ansiStyles = { exports: {} };
@@ -10669,7 +10678,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;
@@ -10701,12 +10710,12 @@ class DBSearchIndexToken extends DBSearchIndexBase {
     }
     return retVal;
   };
-  OutputIndexRecord = (resource, tir, searchFieldRecord) => {
+  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) => {
@@ -10722,7 +10731,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 [];
   };
@@ -10737,15 +10746,15 @@ class DBSearchIndexComposite extends DBSearchIndexBase {
   // /                root level code and quantity, i.e.  Observation.code                +   Observation.value[x]Quantity
   // /component_0     component level at index 0          Observation.component[0].code   +   Observation.component[0].value[x]Quantity
   // /component_1     component level at index 1          Observation.component[1].code   +   Observation.component[1].value[x]Quantity
-  OutputIndexRecord = (resource, tir, searchFieldRecord) => {
+  OutputIndexRecord = async (resource, tir, searchFieldRecord) => {
     let comboNonUniqueRecords = [];
     const searchIndex = DBSearchIndex.getInstance();
     let index = 0;
     let components = [];
-    searchFieldRecord.component.forEach((searchParamComponentRecord) => {
+    for (const searchParamComponentRecord of searchFieldRecord.component) {
       components.push([]);
       const url = searchParamComponentRecord.definition;
-      const sp = searchIndex.resourceHelper.GetSearchParamFromResourceTypeUrl(resource.resourceType, url);
+      const sp = await searchIndex.resourceHelper.GetSearchParamFromResourceTypeUrl(resource.resourceType, url);
       if (this.IsDefined(sp)) {
         const tir2 = {
           PID: v4(),
@@ -10761,7 +10770,7 @@ class DBSearchIndexComposite extends DBSearchIndexBase {
           COMPOSITE: null,
           COMPOSITE_HASH_EXACT: null
         };
-        const retVal = SearchRegistry.getInstance().searchIndexBaseRegistry[sp.SP_TYPE].OutputIndexRecord(resource, tir2, sp);
+        const retVal = await SearchRegistry.getInstance().searchIndexBaseRegistry[sp.SP_TYPE].OutputIndexRecord(resource, tir2, sp);
         retVal.forEach((rv) => {
           if (!(rv.SP_MISSING && rv.SP_MISSING === true)) {
             if (rv.SP_STR && rv.SP_STR !== void 0) {
@@ -10771,7 +10780,7 @@ class DBSearchIndexComposite extends DBSearchIndexBase {
         });
         index++;
       }
-    });
+    }
     for (let i = 0; i < components[0].length; i++) {
       for (let j = 0; j < components[1].length; j++) {
         const idxString = `${components[0][i].SP_STR}|${components[1][j].SP_STR}`;
@@ -10805,7 +10814,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;
@@ -10884,12 +10893,12 @@ class DBSearchIndexDates extends DBSearchIndexBase {
     }
     return retVal;
   };
-  OutputIndexRecord = (resource, tir, searchFieldRecord) => {
+  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) => {
@@ -10944,7 +10953,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) => {
@@ -10972,12 +10981,12 @@ class DBSearchIndexQuantity extends DBSearchIndexBase {
     }
     return retVal;
   };
-  OutputIndexRecord = (resource, tir, searchFieldRecord) => {
+  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) => {
@@ -11037,7 +11046,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)) {
@@ -11079,12 +11088,12 @@ class DBSearchIndexReference extends DBSearchIndexBase {
     }
     return retVal;
   };
-  OutputIndexRecord = (resource, tir, searchFieldRecord) => {
+  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) => {
@@ -11099,7 +11108,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 = [];
@@ -11112,9 +11121,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++) {
@@ -11169,20 +11178,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;
@@ -11195,12 +11204,12 @@ class DBSearchIndexString extends DBSearchIndexBase {
     }
     return retVal;
   };
-  OutputIndexRecord = (resource, tir, searchParamRecord) => {
+  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) => {
@@ -11225,7 +11234,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) => {
@@ -11249,12 +11258,12 @@ class DBSearchIndexNumber extends DBSearchIndexBase {
     }
     return retVal;
   };
-  OutputIndexRecord = (resource, tir, searchFieldRecord) => {
+  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) => {
@@ -11284,7 +11293,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)) {
@@ -11309,12 +11318,12 @@ class DBSearchIndexURI extends DBSearchIndexBase {
     }
     return retVal;
   };
-  OutputIndexRecord = (resource, tir, searchFieldRecord) => {
+  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) => {
@@ -11368,7 +11377,7 @@ class DBSearchIndex {
     this.#debug("------------------");
     this.#debug(`resource: [${hl(resourceName)}]      resourceId: [${hl(resourceId)}]      SP_NAME: [${hl(searchFieldRecord.SP_NAME)}]      SP_TYPE: [${hl(searchFieldRecord.SP_TYPE)}]      SP_BASE: [${hl(searchFieldRecord.SP_BASE)}]      path: [${hl(searchFieldRecord.path)}]      RESOURCE_DATATYPE: [${hl(searchFieldRecord.RESOURCE_DATATYPE)}]      subFieldDataType: [${hl(searchFieldRecord.subFieldDataType)}]      stringIndexFields: [${hl(searchFieldRecord.stringIndexFields)}]`);
   };
-  UpdateIndex = (resource, searchFieldRecord) => {
+  UpdateIndex = async (resource, searchFieldRecord) => {
     try {
       const tir = {
         PID: v4(),
@@ -11387,7 +11396,7 @@ class DBSearchIndex {
       let saveRecord;
       const searchIndexBaseProcessor = this.searchRegistry.searchIndexBaseRegistry[searchFieldRecord.SP_TYPE];
       if (searchIndexBaseProcessor) {
-        saveRecord = searchIndexBaseProcessor.OutputIndexRecord(resource, tir, searchFieldRecord);
+        saveRecord = await searchIndexBaseProcessor.OutputIndexRecord(resource, tir, searchFieldRecord);
       } else if (searchFieldRecord.SP_TYPE.localeCompare("special") === 0) {
       } else {
         const message = `DBSearchIndex:UpdateIndex(): Error: Search field paramater type: [${searchFieldRecord.SP_TYPE}] unknown.`;
@@ -11400,14 +11409,14 @@ class DBSearchIndex {
       return [];
     }
   };
-  GetSearchIndexData = (resource) => {
+  GetSearchIndexData = async (resource) => {
     try {
-      const searchParamRecords = this.resourceHelper.GetSearchParamsFromResourceType(resource.resourceType);
+      const searchParamRecords = await this.resourceHelper.GetSearchParamsFromResourceType(resource.resourceType);
       const searchIndexData = [];
       for (let i = 0; i < searchParamRecords.length; i++) {
         const searchRecord = searchParamRecords[i];
         try {
-          const retVal = this.UpdateIndex(resource, searchRecord);
+          const retVal = await this.UpdateIndex(resource, searchRecord);
           if (retVal && retVal.length > 0) {
             searchIndexData.push(...retVal);
           }
@@ -11421,10 +11430,10 @@ class DBSearchIndex {
       return [];
     }
   };
-  GetSearchParamFromResourceType = (resourceType, name) => {
+  GetSearchParamFromResourceType = async (resourceType, name) => {
     return this.resourceHelper.GetSearchParamFromResourceType(resourceType, name);
   };
-  GetSearchParamFromResourceTypeUrl = (resourceType, url) => {
+  GetSearchParamFromResourceTypeUrl = async (resourceType, url) => {
     return this.resourceHelper.GetSearchParamFromResourceTypeUrl(resourceType, url);
   };
 }
@@ -18202,7 +18211,7 @@ class PGFhirAccessLayer extends tinyEmitterExports.TinyEmitter {
   UpdateIndexes = async (client2, resource) => {
     let start = performance.now();
     const oa = start;
-    const searchIndexData = this.#dbSearchIndex.GetSearchIndexData(resource);
+    const searchIndexData = await this.#dbSearchIndex.GetSearchIndexData(resource);
     const lap1 = performance.now() - start;
     start = performance.now();
     const InsertResourceLinkRecord = async (client22, resourceLinkIndexRecord) => {