@nsshunt/stsfhirpg 1.2.11 → 1.2.13

package/dist/stsfhirpg.mjs

@@ -7128,7 +7128,7 @@ class SearchParameterManager {
   constructor(options) {
     this.options = options;
   }
-  EnsureSearchParameterDataLoaded = async () => {
+  EnsureSearchParameterDataLoaded = async (resources) => {
     if (this.alreadyComplete) {
       return this.alreadyComplete;
     }
@@ -7184,7 +7184,7 @@ class SearchParameterManager {
               return;
             }
             try {
-              await this.#LoadDefinitions();
+              await this.#LoadDefinitions(resources);
             } catch (error) {
               console.error(error);
               throw error;
@@ -7232,14 +7232,69 @@ class SearchParameterManager {
       console.log(`SearchParameterManager(): redis closed`);
     }
   };
-  #LoadDefinitions = async () => {
+  /*
+      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}`;
+      }
+      */
+  #LoadDefinitions = async (resources) => {
     console.log("Data Load Starting ...");
-    for (let i = 0; i < 10; i++) {
-      console.log(`Loading ...: [${i}]`);
-      await Sleep(500);
+    for (const [key, value] of Object.entries(resources.searchParametersByResourceType)) {
+      await this.redis.hSet(`__stsfhir__searchParametersByResourceType`, key, JSON.stringify(value));
+    }
+    for (const [key, value] of Object.entries(resources.searchParametersByUrl)) {
+      await this.redis.hSet(`__stsfhir__searchParametersByUrl`, key, JSON.stringify(value));
+    }
+    for (const [key, value] of Object.entries(resources.resources)) {
+      await this.redis.hSet(`__stsfhir__resources`, key, JSON.stringify(value));
+    }
+    for (const [key, value] of Object.entries(resources.types)) {
+      await this.redis.hSet(`__stsfhir__types`, key, JSON.stringify(value));
     }
     console.log("All Done ***********************************************************************************");
   };
+  GetSearchParamFromResourceType = async (resourceType) => {
+    const retVal = await this.redis.hGet(`__stsfhir__searchParametersByResourceType`, resourceType);
+    return JSON.parse(retVal);
+  };
+  GetType = async (typeName) => {
+    const retVal = await this.redis.hGet(`__stsfhir__types`, typeName);
+    return JSON.parse(retVal);
+  };
+  GetResource = async (resourceType) => {
+    const retVal = await this.redis.hGet(`__stsfhir__resources`, resourceType);
+    return JSON.parse(retVal);
+  };
+  GetSearchParam = async (url) => {
+    const retVal = await this.redis.hGet(`__stsfhir__searchParametersByUrl`, url);
+    return JSON.parse(retVal);
+  };
+  /*
+  GetSearchParams = async (): Promise<SearchParameter[]> => {
+      const retVal = await this.redis!.hGetAll(`__stsfhir__searchParametersByUrl`);
+      const searchParameters: SearchParameter[] = [ ];
+      for (const [key, value] of Object.entries(retVal)) {
+          searchParameters.push(JSON.parse(value));
+      }
+      return searchParameters;
+  }
+  */
   /*
       private GetTypeKey(typeName: string) {
           return `stsfhir_type_${typeName}`;
@@ -7630,6 +7685,7 @@ const typesPath = "fhir-spec/profiles-types.json";
 const searchParamsPath = "fhir-spec/search-parameters.json";
 class ResourceHelper {
   #definitions;
+  #loaded = false;
   searchParameterManager;
   static instance;
   constructor() {
@@ -7681,7 +7737,9 @@ class ResourceHelper {
       this.#definitions.searchParametersByUrl[entry.fullUrl] = entry.resource;
     });
     await this._LoadSearchParameters();
-    return this.#definitions;
+    await this.PreLoadSearchParameterData();
+    this.#loaded = true;
+    this.#definitions = void 0;
   };
   PreLoadSearchParameterData = async () => {
     console.log(`PreLoadSearchParameterData(): Start ...`);
@@ -7692,25 +7750,22 @@ class ResourceHelper {
       autoRenew: true,
       heartbeatMs: 1e4
     });
-    await this.searchParameterManager.EnsureSearchParameterDataLoaded();
+    await this.searchParameterManager.EnsureSearchParameterDataLoaded(this.#definitions);
     console.log(`PreLoadSearchParameterData(): End`);
   };
   GetDefinitions = async () => {
-    if (!this.#definitions) {
-      await this.#LoadDefinitions();
+    if (!this.#loaded) {
+      if (!this.#definitions) {
+        await this.#LoadDefinitions();
+      }
     }
-    return this.#definitions;
   };
-  GetType = async (typeName) => {
-    await this.GetDefinitions();
-    return this.#definitions.types[typeName];
-  };
-  GetResource = async (resourceType) => {
+  _GetResource = async (resourceType) => {
     await this.GetDefinitions();
     return this.#definitions.resources[resourceType];
   };
-  GetResourceField = async (resourceType, fieldPath) => {
-    const resource = await 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) {
@@ -7719,18 +7774,53 @@ class ResourceHelper {
       return void 0;
     }
   };
-  GetSearchParam = async (url) => {
+  _GetSearchParam = async (url) => {
     await this.GetDefinitions();
     return this.#definitions.searchParametersByUrl[url];
   };
-  GetSearchParams = async () => {
+  _GetSearchParams = async () => {
     await this.GetDefinitions();
     return this.#definitions.searchParametersByUrl;
   };
-  GetSearchParamsByResource = async (resource) => {
+  GetType = async (typeName) => {
+    await this.GetDefinitions();
+    return await this.searchParameterManager.GetType(typeName);
+  };
+  GetResource = async (resourceType) => {
     await this.GetDefinitions();
-    return Object.values(this.#definitions.searchParametersByUrl).filter((sp) => sp.base.includes(resource)).map((sp) => sp);
+    return await this.searchParameterManager.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) {
+        return foundRecord[0];
+      }
+      return void 0;
+    }
+  };
+  GetSearchParam = async (url) => {
+    await this.GetDefinitions();
+    return await this.searchParameterManager.GetSearchParam(url);
+  };
+  /*
+      private GetSearchParams = async (): Promise<SearchParameter[]> => {
+          await this.GetDefinitions();
+          return await this.searchParameterManager!.GetSearchParams();
+      }
+  
+      GetSearchParamsByResource = async (resource: string): Promise<SearchParameter[]> => {
+          await this.GetDefinitions();
+          const searchParams = await this.GetSearchParams();
+          return searchParams
+              .filter(sp => sp.base.includes(resource))
+              .map(sp => sp)
+          //return Object.values(this.#definitions!.searchParametersByUrl)
+              //.filter(sp => sp.base.includes(resource))
+              //.map(sp => sp)
+      }
+      */
   // ------------------------------------------------------------------------------------------------------------------
   // Remove ( ) when either are present
   #RemoveOuterParentheses = (input) => {
@@ -7853,7 +7943,7 @@ class ResourceHelper {
     };
   };
   _LoadSearchParameters = async () => {
-    for (const [key, val] of Object.entries(await this.GetSearchParams())) {
+    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];
@@ -7884,10 +7974,10 @@ class ResourceHelper {
           SP_TARGET,
           expressions,
           original_expressions,
-          SP_DEFINITION: await this.GetSearchParam(SP_URL)
+          SP_DEFINITION: await this._GetSearchParam(SP_URL)
         };
         for (let i2 = 0; i2 < record.expressions.length; i2++) {
-          const rf = await this.GetResourceField(resourceName, record.expressions[i2].path);
+          const rf = await this._GetResourceField(resourceName, record.expressions[i2].path);
           if (rf) {
             expressions[i2].RES_FIELD = rf;
           }
@@ -7898,7 +7988,7 @@ class ResourceHelper {
             const retVal = this.ProcessExpressions("", c.expression);
             c.expressions = retVal.expressions;
             c.original_expressions = retVal.original_expressions;
-            const def = await this.GetSearchParam(c.definition);
+            const def = await this._GetSearchParam(c.definition);
             if (def && def.type) {
               c.type = def.type;
             }
@@ -7910,21 +8000,24 @@ class ResourceHelper {
   };
   GetSearchParamFromResourceTypeUrl = async (resourceType, url) => {
     await this.GetDefinitions();
-    const filterByNameAndUrl = this.#definitions.searchParametersByResourceType[resourceType].params.filter((rt) => rt.SP_URL.localeCompare(url) === 0);
+    const rt = await this.searchParameterManager?.GetSearchParamFromResourceType(resourceType);
+    const filterByNameAndUrl = rt.params.filter((rt2) => rt2.SP_URL.localeCompare(url) === 0);
     if (filterByNameAndUrl.length > 0) {
       return filterByNameAndUrl[0];
     }
   };
   GetSearchParamFromResourceType = async (resourceType, name) => {
     await this.GetDefinitions();
-    const filterByName = this.#definitions.searchParametersByResourceType[resourceType].params.filter((rt) => rt.SP_NAME.localeCompare(name) === 0);
+    const rt = await this.searchParameterManager?.GetSearchParamFromResourceType(resourceType);
+    const filterByName = rt.params.filter((rt2) => rt2.SP_NAME.localeCompare(name) === 0);
     if (filterByName.length > 0) {
       return filterByName[0];
     }
   };
   GetSearchParamsFromResourceType = async (resourceType) => {
     await this.GetDefinitions();
-    return this.#definitions.searchParametersByResourceType[resourceType].params;
+    const rt = await this.searchParameterManager?.GetSearchParamFromResourceType(resourceType);
+    return rt.params;
   };
 }
 var ansiStyles = { exports: {} };