@nsshunt/stsfhirpg 1.2.12 → 1.2.14

package/dist/stsfhirpg.mjs

@@ -7125,10 +7125,11 @@ class SearchParameterManager {
   redis;
   alreadyComplete = null;
   options;
+  cache = {};
   constructor(options) {
     this.options = options;
   }
-  EnsureSearchParameterDataLoaded = async () => {
+  EnsureSearchParameterDataLoaded = async (resources) => {
     if (this.alreadyComplete) {
       return this.alreadyComplete;
     }
@@ -7184,7 +7185,7 @@ class SearchParameterManager {
               return;
             }
             try {
-              await this.#LoadDefinitions();
+              await this.#LoadDefinitions(resources);
             } catch (error) {
               console.error(error);
               throw error;
@@ -7232,396 +7233,62 @@ class SearchParameterManager {
       console.log(`SearchParameterManager(): redis closed`);
     }
   };
-  #LoadDefinitions = async () => {
+  #searchParametersByResourceTypeKey = `__stsfhir__searchParametersByResourceType`;
+  #searchParametersByUrlKey = `__stsfhir__searchParametersByUrl`;
+  #resourcesKey = `__stsfhir__resources`;
+  #typesKey = `__stsfhir__types`;
+  #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(this.#searchParametersByResourceTypeKey, key, JSON.stringify(value));
+    }
+    for (const [key, value] of Object.entries(resources.searchParametersByUrl)) {
+      await this.redis.hSet(this.#searchParametersByUrlKey, key, JSON.stringify(value));
+    }
+    for (const [key, value] of Object.entries(resources.resources)) {
+      await this.redis.hSet(this.#resourcesKey, key, JSON.stringify(value));
+    }
+    for (const [key, value] of Object.entries(resources.types)) {
+      await this.redis.hSet(this.#typesKey, key, JSON.stringify(value));
     }
     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 [ ];
-      }
-      */
+  GetSearchParamFromResourceType = async (resourceType) => {
+    const key = `${this.#searchParametersByResourceTypeKey}_${resourceType}`;
+    if (this.cache[key]) {
+      return this.cache[key];
+    }
+    const retVal = await this.redis.hGet(this.#searchParametersByResourceTypeKey, resourceType);
+    this.cache[key] = JSON.parse(retVal);
+    return this.cache[key];
+  };
+  GetType = async (typeName) => {
+    const key = `${this.#typesKey}_${typeName}`;
+    if (this.cache[key]) {
+      return this.cache[key];
+    }
+    const retVal = await this.redis.hGet(this.#typesKey, typeName);
+    this.cache[key] = JSON.parse(retVal);
+    return this.cache[key];
+  };
+  GetResource = async (resourceType) => {
+    const key = `${this.#resourcesKey}_${resourceType}`;
+    if (this.cache[key]) {
+      return this.cache[key];
+    }
+    const retVal = await this.redis.hGet(this.#resourcesKey, resourceType);
+    this.cache[key] = JSON.parse(retVal);
+    return this.cache[key];
+  };
+  GetSearchParam = async (url) => {
+    const key = `${this.#searchParametersByUrlKey}_${url}`;
+    if (this.cache[key]) {
+      return this.cache[key];
+    }
+    const retVal = await this.redis.hGet(this.#searchParametersByUrlKey, url);
+    this.cache[key] = JSON.parse(retVal);
+    return this.cache[key];
+  };
 }
 const specPath1 = "./dist/";
 const specPath2 = "./node_modules/@nsshunt/stsfhirpg/dist/";
@@ -7630,6 +7297,7 @@ const typesPath = "fhir-spec/profiles-types.json";
 const searchParamsPath = "fhir-spec/search-parameters.json";
 class ResourceHelper {
   #definitions;
+  #loaded = false;
   searchParameterManager;
   static instance;
   constructor() {
@@ -7682,7 +7350,8 @@ class ResourceHelper {
     });
     await this._LoadSearchParameters();
     await this.PreLoadSearchParameterData();
-    return this.#definitions;
+    this.#loaded = true;
+    this.#definitions = void 0;
   };
   PreLoadSearchParameterData = async () => {
     console.log(`PreLoadSearchParameterData(): Start ...`);
@@ -7693,25 +7362,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) {
@@ -7720,18 +7386,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 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 Object.values(this.#definitions.searchParametersByUrl).filter((sp) => sp.base.includes(resource)).map((sp) => sp);
+    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) => {
@@ -7854,7 +7555,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];
@@ -7885,10 +7586,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;
           }
@@ -7899,7 +7600,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;
             }
@@ -7911,21 +7612,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: {} };