oro-sdk 2.10.2 → 2.12.1

package/package.json

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

package/src/helpers/patient-registration.ts

@@ -4,6 +4,7 @@ import {
     ConsultationMeta,
     ConsultRequest,
     DocumentType,
+    IdentityResponse,
     IndexKey,
     MedicalMeta,
     MedicalStatus,
@@ -26,6 +27,26 @@ import {
 
 const MAX_RETRIES = 15
 
+/**
+ * Completes a registration for a user retrying the complete flow a maximum of 15 times
+ *
+ * @description The order of importance when registering:
+ * Creates a consultation if none exist
+ * Retrieves or create's a lockbox if none exist
+ * Grants the lockbox (if new) to all practitioners in the practice
+ * Stores or fetches the patient data (without images)
+ * Indexes the lockbox to the consult for all practitioners (done after inserting since index can be rebuilt from grants)
+ * Stores the image data - done last since the majority of failure cases occur here
+ * Creates the recovery payloads if they don't exist
+ *
+ * @param patientUuid
+ * @param consultRequest
+ * @param workflow
+ * @param oroClient
+ * @param masterKey
+ * @param recoveryQA
+ * @returns the successful registration
+ */
 export async function registerPatient(
     patientUuid: Uuid,
     consultRequest: ConsultRequest,
@@ -41,7 +62,8 @@ export async function registerPatient(
     let lockboxUuid: Uuid | undefined = undefined
     let practitionerAdmin: Uuid | undefined = undefined
     let retry = MAX_RETRIES
-    let isExistingPatient = false
+    let identity: IdentityResponse | undefined = undefined
+    let errorsThrown: Error[] = []
 
     for (; retry > 0; retry--) {
         try {
@@ -68,14 +90,13 @@ export async function registerPatient(
             // Creating lockbox
             if (!lockboxUuid) lockboxUuid = await getOrCreatePatientLockbox(oroClient)
 
-            isExistingPatient = await patientConsultExists(consult, lockboxUuid, oroClient).catch((err) => {
-                console.error(`Error when retrieving existing consults ${err}`)
-                return false
-            })
+            if (!identity)
+                identity = await oroClient.guardClient.identityGet(patientUuid)
+
             await oroClient.grantLockbox(practitionerAdmin, lockboxUuid).catch((err) => {
                 console.error(`Error while granting lockbox to practitioner admin ${practitionerAdmin}`, err)
                 // if we cannot grant to the admin, then the registration will fail
-                throw err
+                errorsThrown.push(err)
             })
 
             // Patient Grant to practice
@@ -84,16 +105,13 @@ export async function registerPatient(
                 .map(async (practitioner) => {
                     return oroClient.grantLockbox(practitioner.uuid, lockboxUuid!).catch((err) => {
                         console.error(`Error while granting lockbox to practitioner`, err)
-                        // Acceptable to continue as admin has already been granted, but we should still try to retry
+                        // Acceptable to continue as admin has already been granted, but we should still retry until the last retry remains
                         if (retry <= 1) return
-                        else throw err
+                        errorsThrown.push(err)
                     })
                 })
 
-            await storePatientData(consult.uuid, consultRequest.isoLanguageRequired, lockboxUuid, workflow, oroClient)
-
-            // the index will identify in which lockbox a consultation live
-            let consultIndex: VaultIndex = {
+            const consultIndex: VaultIndex = {
                 [IndexKey.ConsultationLockbox]: [
                     {
                         grant: {
@@ -105,53 +123,46 @@ export async function registerPatient(
                 ],
             }
 
+            // the index will identify in which lockbox a consultation resides
             let consultIndexPromises = practitioners.map(async (practitioner) => {
                 return oroClient.vaultIndexAdd(consultIndex, practitioner.uuid).catch((err) => {
-                    console.error(`Error while adding to the practitioner's index ${practitioner.uuid}`, err)
-                    /// it's acceptable to continue registration
-                    return
+                    console.error(`[SDK: registration] Error while adding to the practitioner's index ${practitioner.uuid}`, err)
+                    // Acceptable to continue as the index can be rebuilt, but we should still retry until the last retry remains
+                    if (retry <= 1) return
+                    else errorsThrown.push(err)
                 })
             })
 
-            //DEPRECATED: REMOVE ME : BEGIN /////////////////////////////////////////
 
-            let deprecatedConsultIndex: VaultIndex = {
-                [IndexKey.Consultation]: [
-                    {
-                        grant: {
-                            lockboxUuid,
-                            lockboxOwnerUuid: patientUuid,
-                        },
-                        consultationId: consult.uuid,
-                    },
-                ],
-            }
-
-            let deprecatedConsultIndexPromises = practitioners.map(async (practitioner) => {
-                return oroClient.vaultIndexAdd(deprecatedConsultIndex, practitioner.uuid).catch((err) => {
-                    console.error(`Error while adding to the practitioner's index ${practitioner.uuid}`, err)
-                    /// it's acceptable to continue registration
-                    return
-                })
+            await storeImageAliases(consult.uuid, lockboxUuid, workflow, oroClient).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
+                if (retry <= 1) return
+                else errorsThrown.push(err)
             })
 
-            //DEPRECATED: REMOVE ME : END /////////////////////////////////////////
+            await storePatientData(consult.uuid, consultRequest.isoLanguageRequired, lockboxUuid, workflow, oroClient).catch((err) => {
+                console.error('[SDK: registration] Some errors happened during patient data upload', err)
+                errorsThrown.push(err)
+            })
 
-            if (masterKey && !isExistingPatient) {
-                // generate and store recovery payload
-                await oroClient.updateMasterKey(patientUuid, masterKey, lockboxUuid).catch((err) => {
-                    console.error(`Error while updating master key`, err)
-                    /// it's acceptable to continue registration
-                    return
+            if (masterKey && !identity?.recoveryMasterKey) {
+                // generate and store recovery payload and updates the identity 
+                identity = await oroClient.updateMasterKey(patientUuid, masterKey, lockboxUuid).catch((err) => {
+                    console.error(`[SDK: registration] Error while updating master key`, err)
+                    /// it's acceptable to continue registration (return old identity)
+                    if (retry <= 1) return
+                    errorsThrown.push(err)
+                    return identity
                 })
             } else {
                 // we did not set the master key so we do not return it
                 masterKey = undefined
             }
 
-            if (recoveryQA && !isExistingPatient)
-                // Patient security question recovery threshold is 2 answers
-                await oroClient
+            if (recoveryQA && !identity?.recoverySecurityQuestions)
+                // Patient security question recovery threshold is 2 answers and updates the identity 
+                identity = await oroClient
                     .updateSecurityQuestions(
                         patientUuid,
                         recoveryQA.recoverySecurityQuestions,
@@ -159,12 +170,17 @@ export async function registerPatient(
                         2
                     )
                     .catch((err) => {
-                        console.error(`Error while updating security questions`, err)
-                        /// it's acceptable to continue registration
-                        return
+                        console.error(`[SDK: registration] Error while updating security questions`, err)
+                        /// it's acceptable to continue registration (return old identity)
+                        if (retry <= 1) return
+                        errorsThrown.push(err)
+                        return identity
                     })
 
-            await Promise.all([...grantPromises, ...consultIndexPromises, ...deprecatedConsultIndexPromises])
+            await Promise.all([...grantPromises, ...consultIndexPromises])
+
+            if (errorsThrown.length > 0)
+                throw errorsThrown
 
             // Deem the consultation as ready
             await oroClient.consultClient.updateConsultByUUID(consult.uuid, {
@@ -174,13 +190,14 @@ export async function registerPatient(
             // if we got through the complete flow, the registration succeeded
             break
         } catch (err) {
-            console.error(`Error occured during registration, retrying... Retries remaining: ${retry}`)
+            console.error(`[SDK] Error occured during registration: ${err}, retrying... Retries remaining: ${retry}`)
+            errorsThrown = []
             continue
         }
     }
 
     if (retry <= 0) {
-        console.error('registration failed: MAX_RETRIES reached')
+        console.error('[SDK] registration failed: MAX_RETRIES reached')
         throw 'RegistrationFailed'
     }
 
@@ -193,28 +210,6 @@ export async function registerPatient(
     }
 }
 
-/**
- * Returns whether the consultation creation is for an existing patient (ignores data from the current consultation)
- *
- * @param currentConsultation
- */
-async function patientConsultExists(
-    currentConsultation: Consult,
-    lockboxUuid: Uuid,
-    oroClient: OroClient
-): Promise<boolean> {
-    let publicMetadata: ConsultationMeta = {
-        category: MetadataCategory.Consultation,
-        documentType: DocumentType.PopulatedWorkflowData,
-    }
-    let manifest = await oroClient.vaultClient.lockboxMetadataGet(lockboxUuid, ['consultationId'], [], publicMetadata)
-    return (
-        manifest[0].findIndex(
-            (v: { consultationId: Uuid }) => v.consultationId != null && v.consultationId !== currentConsultation.uuid
-        ) !== -1
-    )
-}
-
 /**
  * Creates a consultation if one has not been created and fails to be retrieved by the payment intent
  * @param consult
@@ -276,9 +271,6 @@ async function storePatientData(
 ): Promise<(Uuid | void)[]> {
     // Create and store registration data
     return Promise.all([
-        storeImageAliases(consultationId, lockboxUuid, workflow, oroClient).catch((err) => {
-            console.error('[SDK] Some errors happened during image upload', err)
-        }),
         // Storing Raw data first
         oroClient.getOrInsertJsonData<RawConsultationMeta>(
             lockboxUuid,