@nsshunt/stsfhirpg 1.2.1 → 1.2.3

package/dist/stsfhirpg.mjs

@@ -7023,7 +7023,8 @@ class ResourceHelper {
       this.#definitions = {
         resources: {},
         types: {},
-        searchParameters: {}
+        searchParametersByUrl: {},
+        searchParametersByResourceType: {}
       };
     }
     __resources.entry.forEach((entry) => {
@@ -7040,25 +7041,22 @@ class ResourceHelper {
       }
     });
     __searchParams.entry.forEach((entry) => {
-      this.#definitions.searchParameters[entry.fullUrl] = entry.resource;
+      this.#definitions.searchParametersByUrl[entry.fullUrl] = entry.resource;
     });
+    this._LoadSearchParameters();
     return this.#definitions;
   };
-  GetType = (typeName) => {
+  get definitions() {
     if (!this.#definitions) {
       this.#LoadDefinitions();
     }
-    if (this.#definitions) {
-      const foundType = this.#definitions.types[typeName];
-      return foundType;
-    }
-    return [];
+    return this.#definitions;
+  }
+  GetType = (typeName) => {
+    return this.definitions.types[typeName];
   };
   GetResource = (resourceType) => {
-    if (!this.#definitions) {
-      this.#LoadDefinitions();
-    }
-    return this.#definitions.resources[resourceType];
+    return this.definitions.resources[resourceType];
   };
   GetResourceField = (resourceType, fieldPath) => {
     const resource = this.GetResource(resourceType);
@@ -7071,22 +7069,214 @@ class ResourceHelper {
     }
   };
   GetSearchParam = (url) => {
-    if (!this.#definitions) {
-      this.#LoadDefinitions();
-    }
-    return this.#definitions.searchParameters[url];
+    return this.definitions.searchParametersByUrl[url];
   };
   GetSearchParams = () => {
-    if (!this.#definitions) {
-      this.#LoadDefinitions();
-    }
-    return this.#definitions.searchParameters;
+    return this.definitions.searchParametersByUrl;
   };
   GetSearchParamsByResource = (resource) => {
-    if (!this.#definitions) {
-      this.#LoadDefinitions();
+    return Object.values(this.definitions.searchParametersByUrl).filter((sp) => sp.base.includes(resource)).map((sp) => sp);
+  };
+  // ------------------------------------------------------------------------------------------------------------------
+  // Remove ( ) when either are present
+  #RemoveOuterParentheses = (input) => {
+    return input.replace(/^\(|\)$/g, "");
+  };
+  // Remove ( ) only when both are present
+  #RemoveSurroundingParentheses = (input) => {
+    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
+      */
+  ProcessExpressions = (resourceName, SP_EXPRESSION) => {
+    let expressions = [];
+    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];
+    expressions = expressions.map((e) => {
+      let capturedTypeOf = void 0;
+      return {
+        path: e.replace(
+          /\.ofType\(([^)]+)\)/g,
+          (_, typeName) => {
+            capturedTypeOf = true;
+            return typeName.charAt(0).toUpperCase() + typeName.slice(1);
+          }
+        ),
+        typeOf: capturedTypeOf
+      };
+    });
+    expressions.forEach((expression) => {
+      try {
+        const sp = expression;
+        if (sp.path.indexOf("exists()") >= 0) {
+          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, void 0]
+            };
+          }
+        }
+      } catch (error) {
+      }
+    });
+    let capturedType;
+    expressions = expressions.map((obj) => {
+      capturedType = void 0;
+      const { path, typeOf, exists } = obj;
+      return {
+        path: path.replace(
+          /\.where\(resolve\(\)\s+is\s+([^)]+)\)/,
+          (_, typeName) => {
+            capturedType = typeName;
+            return "";
+          }
+        ),
+        typeOf,
+        reference: capturedType,
+        exists
+      };
+    });
+    let capturedWhere = void 0;
+    expressions = expressions.map((obj) => {
+      capturedWhere = void 0;
+      const { path, reference, typeOf, exists } = obj;
+      const retVal = {
+        path: path.replace(/([^.]+)\.where\(([^=]+)='([^']+)'\)/g, (_, field, subfield, value) => {
+          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
+    };
+  };
+  _LoadSearchParameters = () => {
+    for (const [key, val] of Object.entries(this.GetSearchParams())) {
+      const { id, url, code, base, type, expression, component, target } = val;
+      for (let i = 0; i < base.length; i++) {
+        const resourceName = base[i];
+        if (!this.#definitions?.searchParametersByResourceType[resourceName]) {
+          this.#definitions.searchParametersByResourceType[resourceName] = {
+            resourceName,
+            params: []
+          };
+        }
+        const SP_ID = id;
+        const SP_NAME = code;
+        const SP_TYPE = type;
+        const SP_URL = url;
+        const SP_TARGET = target;
+        let SP_EXPRESSION = expression;
+        let expressions = [];
+        let original_expressions = [];
+        if (SP_EXPRESSION) {
+          const retVal = this.ProcessExpressions(resourceName, SP_EXPRESSION);
+          expressions = retVal.expressions;
+          original_expressions = retVal.original_expressions;
+        }
+        const record = {
+          SP_ID,
+          SP_NAME,
+          SP_TYPE,
+          SP_URL,
+          SP_TARGET,
+          expressions,
+          original_expressions,
+          SP_DEFINITION: this.GetSearchParam(SP_URL)
+        };
+        for (let i2 = 0; i2 < record.expressions.length; i2++) {
+          const rf = this.GetResourceField(resourceName, record.expressions[i2].path);
+          if (rf) {
+            expressions[i2].RES_FIELD = rf;
+          }
+        }
+        if (component) {
+          record.component = [...component];
+          record.component.forEach((c) => {
+            const retVal = this.ProcessExpressions("", c.expression);
+            c.expressions = retVal.expressions;
+            c.original_expressions = retVal.original_expressions;
+            const def = 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);
+    if (filterByNameAndUrl.length > 0) {
+      return filterByNameAndUrl[0];
     }
-    return Object.values(this.#definitions.searchParameters).filter((sp) => sp.base.includes(resource)).map((sp) => sp);
+  };
+  GetSearchParamFromResourceType = (resourceType, name) => {
+    const filterByName = this.definitions.searchParametersByResourceType[resourceType].params.filter((rt) => rt.SP_NAME.localeCompare(name) === 0);
+    if (filterByName.length > 0) {
+      return filterByName[0];
+    }
+  };
+  /*
+  GetPathsFromResourceType = (resourceType: string, name: string): string[] => {
+      const filterByName = this.definitions.searchParametersByResourceType[resourceType].params.filter(rt => rt.SP_NAME.localeCompare(name) === 0);
+      if (filterByName.length > 0) {
+          return filterByName[0].expressions.map(e => e.path)
+      }
+      return [ ];
+  }
+  */
+  GetSearchParamsFromResourceType = (resourceType) => {
+    return this.definitions.searchParametersByResourceType[resourceType].params;
   };
 }
 var ansiStyles = { exports: {} };
@@ -10564,7 +10754,7 @@ class DBSearchIndexComposite extends DBSearchIndexBase {
     searchFieldRecord.component.forEach((searchParamComponentRecord) => {
       components.push([]);
       const url = searchParamComponentRecord.definition;
-      const sp = searchIndex.GetSearchParamFromResourceTypeUrl(resource.resourceType, url);
+      const sp = searchIndex.resourceHelper.GetSearchParamFromResourceTypeUrl(resource.resourceType, url);
       if (this.IsDefined(sp)) {
         const tir2 = {
           PID: v4(),
@@ -11219,27 +11409,13 @@ class DBSearchIndex {
       return [];
     }
   };
-  ResolveFhirChoiceType = (path) => {
-    const match2 = path.match(/^(.+?)\.ofType\((.+?)\)$/);
-    if (!match2) {
-      return path;
-    }
-    const base = match2[1];
-    const fhirType = match2[2];
-    const capitalizedType = fhirType.charAt(0).toUpperCase() + fhirType.slice(1);
-    return `${base}${capitalizedType}`;
-  };
   GetSearchIndexData = (resource) => {
     try {
-      const st = performance.now();
-      if (!this.#searchParams) {
-        this.LoadSearchParameters();
-      }
+      const searchParamRecords = this.resourceHelper.GetSearchParamsFromResourceType(resource.resourceType);
       const searchIndexData = [];
-      for (let i = 0; i < this.#searchParams[resource.resourceType].params.length; i++) {
-        const searchRecord = this.#searchParams[resource.resourceType].params[i];
+      for (let i = 0; i < searchParamRecords.length; i++) {
+        const searchRecord = searchParamRecords[i];
         try {
-          const st2 = performance.now();
           const retVal = this.UpdateIndex(resource, searchRecord);
           if (retVal && retVal.length > 0) {
             searchIndexData.push(...retVal);
@@ -11254,286 +11430,18 @@ class DBSearchIndex {
       return [];
     }
   };
-  GetSearchParamFromResourceTypeUrl = (resourceType, url) => {
-    if (!this.#searchParams) {
-      this.LoadSearchParameters();
-    }
-    const filterByNameAndUrl = this.#searchParams[resourceType].params.filter((rt) => rt.SP_URL.localeCompare(url) === 0);
-    if (filterByNameAndUrl.length > 0) {
-      return filterByNameAndUrl[0];
-    }
-  };
   GetSearchParamFromResourceType = (resourceType, name) => {
-    if (!this.#searchParams) {
-      this.LoadSearchParameters();
-    }
-    const filterByName = this.#searchParams[resourceType].params.filter((rt) => rt.SP_NAME.localeCompare(name) === 0);
-    if (filterByName.length > 0) {
-      return filterByName[0];
-    }
-  };
-  GetPathsFromResourceType = (resourceType, name) => {
-    if (!this.#searchParams) {
-      this.LoadSearchParameters();
-    }
-    const filterByName = this.#searchParams[resourceType].params.filter((rt) => rt.SP_NAME.localeCompare(name) === 0);
-    if (filterByName.length > 0) {
-      return filterByName[0].expressions.map((e) => e.path);
-    }
-    return [];
-  };
-  // Remove ( ) when either are present
-  #RemoveOuterParentheses = (input) => {
-    return input.replace(/^\(|\)$/g, "");
-  };
-  // Remove ( ) only when both are present
-  #RemoveSurroundingParentheses = (input) => {
-    return input.replace(/^\((.*)\)$/, "$1").trim();
+    return this.resourceHelper.GetSearchParamFromResourceType(resourceType, name);
   };
   /*
-      
-  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
-      */
-  ProcessExpressions = (resourceName, SP_EXPRESSION) => {
-    let expressions = [];
-    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];
-    expressions = expressions.map((e) => {
-      let capturedTypeOf = void 0;
-      return {
-        path: e.replace(
-          /\.ofType\(([^)]+)\)/g,
-          (_, typeName) => {
-            capturedTypeOf = true;
-            return typeName.charAt(0).toUpperCase() + typeName.slice(1);
-          }
-        ),
-        typeOf: capturedTypeOf
-      };
-    });
-    expressions.forEach((expression) => {
-      try {
-        const sp = expression;
-        if (sp.path.indexOf("exists()") >= 0) {
-          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, void 0]
-            };
-          }
-        }
-      } catch (error) {
-      }
-    });
-    let capturedType;
-    expressions = expressions.map((obj) => {
-      capturedType = void 0;
-      const { path, typeOf, exists } = obj;
-      return {
-        path: path.replace(
-          /\.where\(resolve\(\)\s+is\s+([^)]+)\)/,
-          (_, typeName) => {
-            capturedType = typeName;
-            return "";
-          }
-        ),
-        typeOf,
-        reference: capturedType,
-        exists
-      };
-    });
-    let capturedWhere = void 0;
-    expressions = expressions.map((obj) => {
-      capturedWhere = void 0;
-      const { path, reference, typeOf, exists } = obj;
-      const retVal = {
-        path: path.replace(/([^.]+)\.where\(([^=]+)='([^']+)'\)/g, (_, field, subfield, value) => {
-          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
-    };
-  };
-  LoadSearchParameters = () => {
-    const searchParamData = {};
-    for (const [key, val] of Object.entries(this.resourceHelper.GetSearchParams())) {
-      const { id, url, code, base, type, expression, component, target } = val;
-      for (let i = 0; i < base.length; i++) {
-        const resourceName = base[i];
-        if (!searchParamData[resourceName]) {
-          searchParamData[resourceName] = {
-            resourceName,
-            params: []
-          };
-        }
-        const SP_ID = id;
-        const SP_NAME = code;
-        const SP_TYPE = type;
-        const SP_URL = url;
-        const SP_TARGET = target;
-        let SP_EXPRESSION = expression;
-        let expressions = [];
-        let original_expressions = [];
-        if (SP_EXPRESSION) {
-          const retVal = this.ProcessExpressions(resourceName, SP_EXPRESSION);
-          expressions = retVal.expressions;
-          original_expressions = retVal.original_expressions;
-        }
-        const record = {
-          SP_ID,
-          SP_NAME,
-          SP_TYPE,
-          SP_URL,
-          SP_TARGET,
-          expressions,
-          original_expressions,
-          SP_DEFINITION: this.resourceHelper.GetSearchParam(SP_URL)
-        };
-        for (let i2 = 0; i2 < record.expressions.length; i2++) {
-          const rf = this.resourceHelper.GetResourceField(resourceName, record.expressions[i2].path);
-          if (rf) {
-            expressions[i2].RES_FIELD = rf;
-          }
-        }
-        if (component) {
-          record.component = [...component];
-          record.component.forEach((c) => {
-            const retVal = this.ProcessExpressions("", c.expression);
-            c.expressions = retVal.expressions;
-            c.original_expressions = retVal.original_expressions;
-            const def = this.resourceHelper.GetSearchParam(c.definition);
-            if (def && def.type) {
-              c.type = def.type;
-            }
-          });
-        }
-        searchParamData[resourceName].params.push(record);
+      GetSearchParamFromResourceTypeUrl = (resourceType: string, url: string): ISearchParamRecord | undefined  => {
+          return this.resourceHelper.GetSearchParamFromResourceTypeUrl(resourceType, url);
       }
-    }
-    this.#searchParams = searchParamData;
-    return searchParamData;
-  };
-  /*
-          
-  
-          for (const [resourceName,val] of Object.entries(searchParams)) {
-  
-              const patientSearchList: Record<string, any> = (val as any).resourceSpecific;
-  
-              for (const [key2,val2] of Object.entries(patientSearchList)) {
-  
-                  const SP_ID = val2.id;
-                  const SP_NAME = key2;
-                  const SP_TYPE = val2.type;
-                  const SP_URL = val2.url;
-                  let SP_EXPRESSION: string = val2.expression;
-                  let expressions: any[] = [];
-                  let original_expressions: any[] = [];
-                  if (SP_EXPRESSION) {
-                      const retVal = this.ProcessExpressions(resourceName, SP_EXPRESSION);
-                      expressions = retVal.expressions;
-                      original_expressions = retVal.original_expressions;
-                  }
   
-                  if (!searchParamData[resourceName]) {
-                      searchParamData[resourceName] = {
-                          resourceName,
-                          params: [ ]
-                      }
-                  }
-  
-                  // GetResourceField
-  
-                  const record: ISearchParamRecord = {
-                      SP_ID,
-                      SP_NAME,
-                      SP_TYPE,
-                      SP_URL,
-                      expressions,
-                      original_expressions,
-                      SP_DEFINITION: this.resourceHelper.GetSearchParam(SP_URL)
-                  };
-  
-                  for (let i=0; i < record.expressions.length; i++) {
-                      //console.log(record.expressions[i]);
-                      const rf = this.resourceHelper.GetResourceField(resourceName, record.expressions[i].path);
-                      if (rf) {
-                          expressions[i].RES_FIELD = rf;
-                      }
-                  }
-                  
-                  if (val2.component) {
-                      record.component = [ ...val2.component ];
-                      (record.component as any[]).forEach(c => {
-                          //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;
-                          const def = this.resourceHelper.GetSearchParam(c.definition);
-                          if (def && def.type) {
-                              c.type = def.type
-                          }
-                      })
-                  }
-  
-                  searchParamData[resourceName].params.push(record);
-              }
-          }
-  
-          this.#searchParams = searchParamData;
-  
-          return searchParamData;
+      GetPathsFromResourceType = (resourceType: string, name: string): string[] => {
+          return this.resourceHelper.GetPathsFromResourceType(resourceType, name);
       }
-          */
+      */
 }
 var lib$1 = { exports: {} };
 var defaults = { exports: {} };