@smile-cdr/fhirts 2.3.0 → 2.4.0

package/src/library/ResourceUtils/ResourceUtils.ts

@@ -1,4 +1,4 @@
-import { CodingKeys, IdentifierKeys } from "../dataTypes";
+import { CodingKeys, IdentifierKeys } from '../dataTypes';
 
 export class ResourceUtils {
   /**
@@ -8,94 +8,103 @@ export class ResourceUtils {
    * @returns json property if it exists
    * @limitation currently just supports get for top level property on resource
    */
-  getResourceProperty(inputJson: object, propertyName: string) {
+  getResourceProperty(inputJson: Record<string, any>, propertyName: string) {
     let resourcePropertyValue = null;
-    if (inputJson.hasOwnProperty(propertyName)) {
+    if (Object.prototype.hasOwnProperty.call(inputJson, propertyName)) {
       resourcePropertyValue = inputJson[propertyName];
     }
     return resourcePropertyValue;
   }
 
   /**
+   * Get identifiers from a list filtered by property value
    *
+   * @template T - The identifier type to return (defaults to any for backward compatibility)
    * @param identifierList list of identifiers
    * @param propertyToCompare identifier property to compare
    * @param propertyValue value we want to compare against
    * @returns array of matches
    * @limitations currently does not work with identifier.type, identifier.period & identifier.assigner
    */
-  getIdentifiersByProperty(
-    identifierList: any[],
+  getIdentifiersByProperty<T = any>(
+    identifierList: any[] | null,
     propertyToCompare: IdentifierKeys,
     propertyValue: any[IdentifierKeys]
-  ): any[] {
+  ): T[] {
     return identifierList?.length
       ? identifierList.filter((x) => x[propertyToCompare] === propertyValue)
       : [];
   }
 
   /**
+   * Get extensions from a list filtered by URL
    *
+   * @template T - The extension type to return (defaults to any for backward compatibility)
    * @param extensionList list of extensions
    * @param extensionUrl Extension.url to compare
    * @returns array of matches
    */
-  getExtensionsByUrl(extensionList: any[], extensionUrl: string): any[] {
-    return extensionList?.length
-      ? extensionList.filter((x) => x["url"] === extensionUrl)
-      : [];
+  getExtensionsByUrl<T = any>(extensionList: any[] | null, extensionUrl: string): T[] {
+    return extensionList?.length ? extensionList.filter((x) => x['url'] === extensionUrl) : [];
   }
 
   /**
+   * Get codings from a list filtered by property value
    *
+   * @template T - The coding type to return (defaults to any for backward compatibility)
    * @param codingList list of codings
    * @param propertyToCompare coding property to compare
    * @param propertyValue value we want to compare against string or boolean
    * @returns array of matches
    */
-  getCodingsByProperty(
-    codingList: any[],
+  getCodingsByProperty<T = any>(
+    codingList: any[] | null,
     propertyToCompare: CodingKeys,
     propertyValue: any[CodingKeys]
-  ): any[] {
+  ): T[] {
     return codingList?.length
       ? codingList.filter((x) => x[propertyToCompare] === propertyValue)
       : [];
   }
 
   /**
+   * Get values at a specific path in a FHIR resource
    *
+   * @template T - The value type to return (defaults to any for backward compatibility)
    * @param resource resource for which path needs to be validated
-   * @param elementPath path to validate in resource
+   * @param elementPath path to validate in resource (e.g., "Patient.name.given")
    * @returns array of elements found at the provided path
    */
-  getValuesAtResourcePath(resource: any, elementPath: string): any[] {
+  getValuesAtResourcePath<T = any>(resource: any, elementPath: string): T[] {
     const pathSections = elementPath.split('.');
-    if (!resource || (resource.resourceType !== pathSections[0])) return [];
+    if (!resource || resource.resourceType !== pathSections[0]) {
+      return [];
+    }
     return this.getValuesAtResourcePathInner(resource, pathSections);
   }
 
   private getValuesAtResourcePathInner(resource: any, pathSections: string[]): any[] {
-    let resourcePathValue;
+    let resourcePathValue: any;
     for (let index = 1; index < pathSections.length; index++) {
-      const subPaths = pathSections[index];
+      const subPaths: string = pathSections[index] ?? '';
       resourcePathValue = resourcePathValue ? resourcePathValue[subPaths] : resource[subPaths];
       if (resourcePathValue) {
         if (this.isPrimitive(resourcePathValue) || pathSections.length === 2) {
           return Array.isArray(resourcePathValue) ? [...resourcePathValue] : [resourcePathValue];
         } else if (Array.isArray(resourcePathValue) && resourcePathValue.length > 0) {
-          let resultSet = [];
+          const resultSet = [];
           for (let subPathIndex = 0; subPathIndex < resourcePathValue.length; subPathIndex++) {
             const subPathValue = resourcePathValue[subPathIndex];
             if (this.isPrimitive(subPathValue)) {
               resultSet.push(subPathValue);
-            }
-            else {
-              resultSet.push(...this.getValuesAtResourcePathInner(subPathValue, pathSections.slice(index)));
+            } else {
+              resultSet.push(
+                ...this.getValuesAtResourcePathInner(subPathValue, pathSections.slice(index))
+              );
             }
           }
           return resultSet;
-        } else if (typeof (resourcePathValue) === 'object') {
+        } else if (typeof resourcePathValue === 'object') {
           return this.getValuesAtResourcePathInner(resourcePathValue, pathSections.slice(index));
         }
       } else {
@@ -106,7 +115,7 @@ export class ResourceUtils {
   }
 
   private isPrimitive(value: any) {
-    return typeof (value) === "boolean" || typeof (value) === "string";
+    return typeof value === 'boolean' || typeof value === 'string';
   }
 
   /**
@@ -116,10 +125,11 @@ export class ResourceUtils {
   getAllReferencesFromResource(resource: any): string[] {
     const stringifiedResource = JSON.stringify(resource);
     const referenceJsonString = '"reference":';
-    let references = [];
+    const references = [];
     let cursor = stringifiedResource.indexOf(referenceJsonString, 0);
     while (cursor > -1) {
-      const referenceStart = stringifiedResource.indexOf(referenceJsonString, cursor) + referenceJsonString.length;
+      const referenceStart =
+        stringifiedResource.indexOf(referenceJsonString, cursor) + referenceJsonString.length;
       const referenceEnd = stringifiedResource.indexOf('"', referenceStart + 1);
       const reference = stringifiedResource.substring(referenceStart, referenceEnd);
       // this means the reference ends started reading from start again
@@ -131,4 +141,4 @@ export class ResourceUtils {
     }
     return references;
   }
-}
+}

package/src/library/constants.ts

@@ -1,27 +1,27 @@
 export enum SORT_ORDER {
-    ASCENDING,
-    DESCENDING
+  ASCENDING,
+  DESCENDING,
 }
 
 export enum PATCH_DATATYPE {
-    CODE = "valueCode",
-    DATE = "valueDate",
-    DATE_TIME = "valueDateTime",
-    BOOLEAN = "valueBoolean",
-    CODEABLE_CONCEPT = "valueCodeableConcept",
-    CODING = "valueCoding",
-    IDENTIFIER = "valueIdentifier",
-    HUMAN_NAME = "valueHumanName",
-    STRING = "valueString",
-    ADDRESS = "valueAddress",
-    REFERENCE = "valueReference"
+  CODE = 'valueCode',
+  DATE = 'valueDate',
+  DATE_TIME = 'valueDateTime',
+  BOOLEAN = 'valueBoolean',
+  CODEABLE_CONCEPT = 'valueCodeableConcept',
+  CODING = 'valueCoding',
+  IDENTIFIER = 'valueIdentifier',
+  HUMAN_NAME = 'valueHumanName',
+  STRING = 'valueString',
+  ADDRESS = 'valueAddress',
+  REFERENCE = 'valueReference',
 }
 
 export interface PatchAddValueParams {
-    value: any;
-    valueDataType: PATCH_DATATYPE;
+  value: any;
+  valueDataType: PATCH_DATATYPE;
 }
 
 export interface PatchAddBackboneElementParams extends PatchAddValueParams {
-    backBoneElementProperty: string;
-}
+  backBoneElementProperty: string;
+}

package/src/library/dataTypes.ts

@@ -1,12 +1,12 @@
-import { fhirR5 } from "..";
-import * as DSTU2 from "../FHIR-DSTU2";
-import * as fhirR3 from "../FHIR-R3";
-import { Coding as r4Coding } from "../FHIR-R4/classes/coding";
-import { Extension as r4Extension } from "../FHIR-R4/classes/extension";
-import { Identifier as r4Identifier } from "../FHIR-R4/classes/identifier";
+import { fhirR5 } from '..';
+import * as DSTU2 from '../FHIR-DSTU2';
+import * as fhirR3 from '../FHIR-R3';
+import { Coding as r4Coding } from '../FHIR-R4/classes/coding';
+import { Extension as r4Extension } from '../FHIR-R4/classes/extension';
+import { Identifier as r4Identifier } from '../FHIR-R4/classes/identifier';
 
 export type Identifier = r4Identifier & fhirR3.Identifier & DSTU2.Identifier & fhirR5.Identifier;
 export type IdentifierKeys = keyof Identifier;
 export type Extension = r4Extension & fhirR3.Extension & DSTU2.Extension & fhirR5.Extension;
 export type Coding = r4Coding & fhirR3.Coding & DSTU2.Coding & fhirR5.Coding;
-export type CodingKeys = keyof Coding;
+export type CodingKeys = keyof Coding;

package/tsconfig.json

@@ -6,12 +6,35 @@
     "outDir": "./dist",
     "lib": [
       "es2017"
-    ]
+    ],
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    /* Strict Type-Checking Options */
+    "strict": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "strictBindCallApply": true,
+    "strictPropertyInitialization": false,  // Disabled for FHIR DTOs with optional properties
+    "noImplicitThis": true,
+    "alwaysStrict": true,
+    /* Additional Checks */
+    "noUnusedLocals": false,  // Disabled due to auto-generated FHIR classes
+    "noUnusedParameters": false,  // Disabled due to auto-generated FHIR classes
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true  // Adds undefined to index signatures for safety
   },
   "include": [
     "src/**/*"
   ],
   "exclude": [
     "node_modules"
-  ]
+  ],
+  "ts-node": {
+    "compilerOptions": {
+      "module": "commonjs"
+    }
+  }
 }