oro-sdk 5.0.2 → 5.2.0

package/package.json

@@ -1,5 +1,5 @@
 {
-    "version": "5.0.2",
+    "version": "5.2.0",
     "main": "dist/index.js",
     "typings": "dist/index.d.ts",
     "files": [
@@ -55,7 +55,7 @@
         "form-data": "^4.0.0",
         "formdata-node": "^4.3.1",
         "idb-keyval": "^5.0.6",
-        "oro-sdk-apis": "3.0.1",
+        "oro-sdk-apis": "3.1.0",
         "oro-toolbox": "0.0.6",
         "uuid": "^8.3.2"
     }

package/src/client.ts

@@ -88,7 +88,7 @@ export class OroClient {
         public workflowClient: WorkflowService,
         public diagnosisClient: DiagnosisService,
         private authenticationCallback?: (err: Error) => void
-    ) { }
+    ) {}
 
     /**
      * clears the vaultIndex and cached metadata grants
@@ -300,7 +300,16 @@ export class OroClient {
         onProgress?: (progress: number, descriptionKey: string) => void
     ): Promise<RegisterPatientOutput> {
         if (!this.rsa) throw IncompleteAuthentication
-        return registerPatient(patientUuid, consult, workflow, this, this.toolbox.uuid(), recoveryQA, indexSearch, onProgress)
+        return registerPatient(
+            patientUuid,
+            consult,
+            workflow,
+            this,
+            this.toolbox.uuid(),
+            recoveryQA,
+            indexSearch,
+            onProgress
+        )
     }
 
     /**
@@ -377,18 +386,18 @@ export class OroClient {
                         }))
                         .map(
                             (e: IndexConsultLockbox) =>
-                            ({
-                                uuid: e.uuid,
-                                timestamp: e.timestamp,
-                                uniqueHash: e.uniqueHash,
-                                encryptedIndexEntry: CryptoRSA.jsonWithPubEncryptToBase64(
-                                    {
-                                        consultationId: e.consultationId,
-                                        grant: e.grant,
-                                    },
-                                    rsaPub
-                                ),
-                            } as EncryptedIndexEntry)
+                                ({
+                                    uuid: e.uuid,
+                                    timestamp: e.timestamp,
+                                    uniqueHash: e.uniqueHash,
+                                    encryptedIndexEntry: CryptoRSA.jsonWithPubEncryptToBase64(
+                                        {
+                                            consultationId: e.consultationId,
+                                            grant: e.grant,
+                                        },
+                                        rsaPub
+                                    ),
+                                } as EncryptedIndexEntry)
                         )
                     break
             }
@@ -513,6 +522,7 @@ export class OroClient {
      * @param category the category for the attachment data
      * @param lockboxOwnerUuid the lockbox owner (ignored if lockbox is owned by self)
      * @param previousDataUuid if it's a revision of existing file, specify the previous data uuid
+     * @param withNotification if the insertion of data requires notification
      * @returns the data uuid
      */
     public async createConsultationAttachmentData(
@@ -521,7 +531,8 @@ export class OroClient {
         consultationId: string,
         documentType: DocumentType,
         lockboxOwnerUuid?: Uuid,
-        previousDataUuid?: Uuid
+        previousDataUuid?: Uuid,
+        withNotification: boolean = false
     ): Promise<DataCreateResponse> {
         if (!this.rsa) throw IncompleteAuthentication
 
@@ -539,7 +550,8 @@ export class OroClient {
                 fileName: data.name,
             },
             lockboxOwnerUuid,
-            previousDataUuid
+            previousDataUuid,
+            withNotification
         )
     }
 
@@ -552,15 +564,17 @@ export class OroClient {
      * @param privateMeta the metadata that will be secured in the vault
      * @param lockboxOwnerUuid the lockbox owner (ignored if lockbox is owned by self)
      * @param previousDataUuid if it's a revision of existing data, specify the previous data uuid
+     * @param withNotification if the insertion of data requires notification
      * @returns the data uuid
      */
-    public async createJsonData<T = Meta>(
+    public async createJsonData<T extends Metadata>(
         lockboxUuid: Uuid,
         data: any,
         meta?: T,
         privateMeta?: { [val: string]: any },
         lockboxOwnerUuid?: Uuid,
-        previousDataUuid?: Uuid
+        previousDataUuid?: Uuid,
+        withNotification: boolean = false
     ): Promise<DataCreateResponse> {
         if (!this.rsa) throw IncompleteAuthentication
 
@@ -573,8 +587,9 @@ export class OroClient {
             publicMetadata: meta,
             privateMetadata: encryptedPrivateMeta,
         }
-
-        return this.tellerClient.lockboxDataStore(lockboxUuid, request, lockboxOwnerUuid, previousDataUuid)
+        if (withNotification)
+            return this.tellerClient.lockboxDataStore(lockboxUuid, request, lockboxOwnerUuid, previousDataUuid)
+        else return this.vaultClient.lockboxDataStore(lockboxUuid, request, lockboxOwnerUuid, previousDataUuid)
     }
 
     /**
@@ -584,14 +599,16 @@ export class OroClient {
      * @param publicMetadata the public Metadata
      * @param privateMetadata the private Metadata
      * @param forceReplace set true when the insertion of data requires to replace the data when it exists already
+     * @param withNotification if the insertion of data requires notification
      * @returns the data uuid
      */
-    public async getOrInsertJsonData<M = Metadata>(
+    public async getOrInsertJsonData<M extends Metadata>(
         lockboxUuid: Uuid,
         data: any,
         publicMetadata: M,
         privateMetadata: Metadata,
-        forceReplace: boolean = false
+        forceReplace: boolean = false,
+        withNotification: boolean = false
     ): Promise<Uuid> {
         let manifest = await this.vaultClient.lockboxManifestGet(lockboxUuid, publicMetadata)
         if (!forceReplace && manifest.length > 0) {
@@ -605,7 +622,8 @@ export class OroClient {
                     publicMetadata,
                     privateMetadata,
                     undefined,
-                    forceReplace && manifest.length > 0 ? manifest[0].dataUuid : undefined // if forceReplace and data already exist, then replace data. Otherwise insert it
+                    forceReplace && manifest.length > 0 ? manifest[0].dataUuid : undefined, // if forceReplace and data already exist, then replace data. Otherwise insert it
+                    withNotification
                 ).catch((err) => {
                     console.error(`Error while upserting data ${JSON.stringify(publicMetadata)} data`, err)
                     throw err
@@ -622,15 +640,17 @@ export class OroClient {
      * @param privateMeta the metadata that will be secured in the vault
      * @param lockboxOwnerUuid the lockbox owner (ignored if lockbox is owned by self)
      * @param previousDataUuid if it's a revision of existing data, specify the previous data uuid
+     * @param withNotification if the insertion of data requires notification
      * @returns the data uuid
      */
-    public async createBytesData<T = Meta>(
+    public async createBytesData<T extends Metadata>(
         lockboxUuid: Uuid,
         data: Uint8Array,
         meta: T,
         privateMeta: { [val: string]: any },
         lockboxOwnerUuid?: Uuid,
-        previousDataUuid?: Uuid
+        previousDataUuid?: Uuid,
+        withNotification: boolean = false
     ): Promise<DataCreateResponse> {
         if (!this.rsa) throw IncompleteAuthentication
         let symmetricEncryptor = await this.getCachedSecretCryptor(lockboxUuid, lockboxOwnerUuid)
@@ -642,8 +662,9 @@ export class OroClient {
             publicMetadata: meta,
             privateMetadata: encryptedPrivateMeta,
         }
-
-        return this.tellerClient.lockboxDataStore(lockboxUuid, request, lockboxOwnerUuid, previousDataUuid)
+        if (withNotification)
+            return this.tellerClient.lockboxDataStore(lockboxUuid, request, lockboxOwnerUuid, previousDataUuid)
+        else return this.vaultClient.lockboxDataStore(lockboxUuid, request, lockboxOwnerUuid, previousDataUuid)
     }
 
     /**
@@ -704,10 +725,13 @@ export class OroClient {
 
         // We're using the account role to determine the way a grant is accessed
         let currentAccountRole = await this.getAccountRole()
-        if (currentAccountRole.length === 1 && currentAccountRole[0] === OtherRoleType.User)
-            return []
+        if (currentAccountRole.length === 1 && currentAccountRole[0] === OtherRoleType.User) return []
 
-        if ([OtherRoleType.Patient, OtherRoleType.User].every(requiredRole => currentAccountRole.includes(requiredRole))) {
+        if (
+            [OtherRoleType.Patient, OtherRoleType.User].every((requiredRole) =>
+                currentAccountRole.includes(requiredRole)
+            )
+        ) {
             let encryptedGrants
             // if there are no grants with the applied filter from index, attempt for naive filter with backwards compatibility
             if (filter) {
@@ -722,8 +746,7 @@ export class OroClient {
             return decryptedGrants
         }
         // if not a patient, then a practitioner is trying to retrieve a grant, it **Must** contain a filter, otherwise too many grants are possible
-        if (!filter)
-            throw MissingGrantFilter
+        if (!filter) throw MissingGrantFilter
         // Note: will work only if the filter being applied is exclusively a consult id
         const grantsByConsultLockbox = await this.vaultClient
             .vaultIndexGet([IndexKey.ConsultationLockbox], [filter.consultationId])
@@ -746,7 +769,7 @@ export class OroClient {
 
     /**
      * Fetches the role of the account that is logged in
-     * 
+     *
      * @returns the role based scopes defined by the whoami
      */
     async getAccountRole(): Promise<RoleBasedScopes[]> {
@@ -1515,4 +1538,4 @@ export class OroClient {
 
         return updatedIdentity
     }
-}
+}

package/src/helpers/patient-registration.ts

@@ -65,7 +65,11 @@ export async function registerPatient(
         recoverySecurityAnswers: string[]
     },
     indexSearch: boolean = true,
-    onProgress?: (progress: number, descriptionKey: string, extraInfo?: { storedImagesNum?: number, totalImagesNum?: number }) => void
+    onProgress?: (
+        progress: number,
+        descriptionKey: string,
+        extraInfo?: { storedImagesNum?: number; totalImagesNum?: number }
+    ) => void
 ): Promise<RegisterPatientOutput> {
     let consult: Consult | undefined = undefined
     let lockboxUuid: Uuid | undefined = undefined
@@ -80,8 +84,7 @@ export async function registerPatient(
         try {
             currentStep = 0
 
-            if (onProgress) onProgress((currentStep++)/stepsTotalNum, 'retrieve_practitioners')
-
+            if (onProgress) onProgress(currentStep++ / stepsTotalNum, 'retrieve_practitioners')
 
             // Wait a bit each retry (we also want the first one to wait)
             await new Promise((resolve) => setTimeout(resolve, 2000))
@@ -99,14 +102,14 @@ export async function registerPatient(
                 })
 
             // Creating consult
-            if (onProgress) onProgress((currentStep++)/stepsTotalNum, 'create_consult')
+            if (onProgress) onProgress(currentStep++ / stepsTotalNum, 'create_consult')
 
             if (!consult) {
                 consult = await getOrCreatePatientConsultationUuid(consultRequest, oroClient)
             }
 
             // Creating lockbox
-            if (onProgress) onProgress((currentStep++)/stepsTotalNum, 'create_lockbox')
+            if (onProgress) onProgress(currentStep++ / stepsTotalNum, 'create_lockbox')
 
             if (!lockboxUuid) lockboxUuid = await getOrCreatePatientLockbox(oroClient)
 
@@ -119,7 +122,7 @@ export async function registerPatient(
             })
 
             // Patient Grant to practice
-            if (onProgress) onProgress((currentStep++)/stepsTotalNum, 'grant_patient')
+            if (onProgress) onProgress(currentStep++ / stepsTotalNum, 'grant_patient')
 
             let grantPromises = practitioners
                 .filter((practitioner) => practitioner.uuid !== practitionerAdmin)
@@ -162,11 +165,13 @@ export async function registerPatient(
                 lockboxUuid,
                 workflow,
                 oroClient,
-                onProgress? {
-                    onProgress,
-                    currentStep,
-                    stepsTotalNum
-                } : undefined
+                onProgress
+                    ? {
+                          onProgress,
+                          currentStep,
+                          stepsTotalNum,
+                      }
+                    : undefined
             ).catch((err) => {
                 console.error('[SDK: registration] Some errors happened during image upload', err)
                 // Acceptable to continue as images can be requested during the consultation, but we should still retry until the last retry remains
@@ -175,7 +180,7 @@ export async function registerPatient(
             })
             ++currentStep
 
-            if (onProgress) onProgress((currentStep++)/stepsTotalNum, 'store_patient_data')
+            if (onProgress) onProgress(currentStep++ / stepsTotalNum, 'store_patient_data')
 
             await storePatientData(
                 consult.uuid,
@@ -188,7 +193,7 @@ export async function registerPatient(
                 errorsThrown.push(err)
             })
 
-            if (onProgress) onProgress((currentStep++)/stepsTotalNum, 'set_masterkey')
+            if (onProgress) onProgress(currentStep++ / stepsTotalNum, 'set_masterkey')
 
             if (masterKey && !identity?.recoveryMasterKey) {
                 // generate and store recovery payload and updates the identity
@@ -204,7 +209,7 @@ export async function registerPatient(
                 masterKey = undefined
             }
 
-            if (onProgress) onProgress((currentStep++)/stepsTotalNum, 'set_security_questions')
+            if (onProgress) onProgress(currentStep++ / stepsTotalNum, 'set_security_questions')
 
             if (recoveryQA && !identity?.recoverySecurityQuestions)
                 // Patient security question recovery threshold is 2 answers and updates the identity
@@ -225,8 +230,7 @@ export async function registerPatient(
 
             await Promise.all([...grantPromises, ...consultIndexPromises])
 
-
-            if (onProgress) onProgress((currentStep++)/stepsTotalNum, 'search_indexing')
+            if (onProgress) onProgress(currentStep++ / stepsTotalNum, 'search_indexing')
 
             if (indexSearch) {
                 await buildConsultSearchIndex(consult, workflow, oroClient).catch((err) => {
@@ -247,7 +251,7 @@ export async function registerPatient(
             })
 
             // if we got through the complete flow, the registration succeeded
-            if (onProgress) onProgress((currentStep++)/stepsTotalNum, 'success')
+            if (onProgress) onProgress(currentStep++ / stepsTotalNum, 'success')
 
             break
         } catch (err) {
@@ -306,11 +310,10 @@ async function getOrCreatePatientLockbox(oroClient: OroClient): Promise<Uuid> {
         console.log('The grant has already been created, skipping lockbox create step')
         return grants[0].lockboxUuid!
     } else {
-        let lockboxResponse =
-            await oroClient.vaultClient.lockboxCreate().catch((err) => {
-                console.error('Error while creating lockbox', err)
-                throw err
-            })
+        let lockboxResponse = await oroClient.vaultClient.lockboxCreate().catch((err) => {
+            console.error('Error while creating lockbox', err)
+            throw err
+        })
         // Since the creation of a lockbox will change the scope of a user, we will force refresh the tokens
         let tokens = await oroClient.guardClient.authRefresh()
         await oroClient.guardClient.setTokens({ accessToken: tokens.accessToken, refreshToken: tokens.refreshToken })
@@ -358,7 +361,9 @@ async function storePatientData(
                     documentType: DocumentType.PopulatedWorkflowData,
                     consultationId, // TODO: deprecated. Will finally only be in privateMetadata
                 },
-                { consultationId }
+                { consultationId },
+                false,
+                true // the only data that needs to include an email notification
             )
         ),
         getWorkflowDataByCategory(workflow, MetadataCategory.Medical).then((data) =>
@@ -412,9 +417,13 @@ async function storeImageAliases(
     workflow: WorkflowData,
     oroClient: OroClient,
     progress?: {
-        currentStep: number;
-        stepsTotalNum: number;
-        onProgress: (progress: number, descriptionKey: string, extraInfo?: { storedImagesNum?: number; totalImagesNum?: number }) => void;
+        currentStep: number
+        stepsTotalNum: number
+        onProgress: (
+            progress: number,
+            descriptionKey: string,
+            extraInfo?: { storedImagesNum?: number; totalImagesNum?: number }
+        ) => void
     }
 ): Promise<(Uuid | void)[]> {
     const images = await getImagesFromIndexDb((await filterTriggeredAnsweredWithKind(workflow, 'images-alias')).flat())
@@ -428,33 +437,44 @@ async function storeImageAliases(
     let storedImagesNum = 0
     let totalImagesNum = nonNullImages.length
     if (progress)
-        progress.onProgress(progress.currentStep/progress.stepsTotalNum, 'store_images', {storedImagesNum, totalImagesNum})
+        progress.onProgress(progress.currentStep / progress.stepsTotalNum, 'store_images', {
+            storedImagesNum,
+            totalImagesNum,
+        })
 
     let promises = nonNullImages.map((image) => {
-        return oroClient.getOrInsertJsonData<ConsultationImageMeta>(
-            lockboxUuid,
-            image,
-            {
-                category: MetadataCategory.Consultation,
-                documentType: DocumentType.ImageAlias,
-                consultationId,
-                idbId: image.idbId as string,
-            },
-            {}
-        ).then(() => {
-            if (progress) {
-                ++storedImagesNum
-                let progressStepValue = Math.round((((progress.currentStep + 1)/progress.stepsTotalNum) - (progress.currentStep/progress.stepsTotalNum)) * 100) / 100
-                progress.onProgress(
-                    (progress.currentStep/progress.stepsTotalNum) + (progressStepValue * (storedImagesNum/totalImagesNum)),
-                    'store_images',
-                    {
-                        storedImagesNum,
-                        totalImagesNum
-                    })
-            }
-
-        })
+        return oroClient
+            .getOrInsertJsonData<ConsultationImageMeta>(
+                lockboxUuid,
+                image,
+                {
+                    category: MetadataCategory.Consultation,
+                    documentType: DocumentType.ImageAlias,
+                    consultationId,
+                    idbId: image.idbId as string,
+                },
+                {}
+            )
+            .then(() => {
+                if (progress) {
+                    ++storedImagesNum
+                    let progressStepValue =
+                        Math.round(
+                            ((progress.currentStep + 1) / progress.stepsTotalNum -
+                                progress.currentStep / progress.stepsTotalNum) *
+                                100
+                        ) / 100
+                    progress.onProgress(
+                        progress.currentStep / progress.stepsTotalNum +
+                            progressStepValue * (storedImagesNum / totalImagesNum),
+                        'store_images',
+                        {
+                            storedImagesNum,
+                            totalImagesNum,
+                        }
+                    )
+                }
+            })
     })
     return Promise.all(promises)
 }
@@ -580,4 +600,4 @@ export async function buildConsultSearchIndex(consult: Consult, workflow: Workfl
     }
 
     await oroClient.searchClient.index(consult.uuid, terms)
-}
+}