@nsshunt/stsfhirpg 1.2.13 → 1.2.14

package/dist/stsfhirpg.mjs

@@ -7125,6 +7125,7 @@ class SearchParameterManager {
   redis;
   alreadyComplete = null;
   options;
+  cache = {};
   constructor(options) {
     this.options = options;
   }
@@ -7232,451 +7233,62 @@ class SearchParameterManager {
       console.log(`SearchParameterManager(): redis closed`);
     }
   };
-  /*
-      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}`;
-      }
-      */
+  #searchParametersByResourceTypeKey = `__stsfhir__searchParametersByResourceType`;
+  #searchParametersByUrlKey = `__stsfhir__searchParametersByUrl`;
+  #resourcesKey = `__stsfhir__resources`;
+  #typesKey = `__stsfhir__types`;
   #LoadDefinitions = async (resources) => {
     console.log("Data Load Starting ...");
     for (const [key, value] of Object.entries(resources.searchParametersByResourceType)) {
-      await this.redis.hSet(`__stsfhir__searchParametersByResourceType`, key, JSON.stringify(value));
+      await this.redis.hSet(this.#searchParametersByResourceTypeKey, key, JSON.stringify(value));
     }
     for (const [key, value] of Object.entries(resources.searchParametersByUrl)) {
-      await this.redis.hSet(`__stsfhir__searchParametersByUrl`, key, JSON.stringify(value));
+      await this.redis.hSet(this.#searchParametersByUrlKey, key, JSON.stringify(value));
     }
     for (const [key, value] of Object.entries(resources.resources)) {
-      await this.redis.hSet(`__stsfhir__resources`, key, JSON.stringify(value));
+      await this.redis.hSet(this.#resourcesKey, key, JSON.stringify(value));
     }
     for (const [key, value] of Object.entries(resources.types)) {
-      await this.redis.hSet(`__stsfhir__types`, key, JSON.stringify(value));
+      await this.redis.hSet(this.#typesKey, key, JSON.stringify(value));
     }
     console.log("All Done ***********************************************************************************");
   };
   GetSearchParamFromResourceType = async (resourceType) => {
-    const retVal = await this.redis.hGet(`__stsfhir__searchParametersByResourceType`, resourceType);
-    return JSON.parse(retVal);
+    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 retVal = await this.redis.hGet(`__stsfhir__types`, typeName);
-    return JSON.parse(retVal);
+    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 retVal = await this.redis.hGet(`__stsfhir__resources`, resourceType);
-    return JSON.parse(retVal);
+    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 retVal = await this.redis.hGet(`__stsfhir__searchParametersByUrl`, url);
-    return JSON.parse(retVal);
+    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];
   };
-  /*
-  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}`;
-      }
-  
-      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 [ ];
-      }
-      */
 }
 const specPath1 = "./dist/";
 const specPath2 = "./node_modules/@nsshunt/stsfhirpg/dist/";