oro-sdk 3.4.0 → 3.6.1

package/package.json

@@ -1,61 +1,61 @@
 {
-  "version": "3.4.0",
-  "main": "dist/index.js",
-  "typings": "dist/index.d.ts",
-  "files": [
-    "dist",
-    "src"
-  ],
-  "engines": {
-    "node": ">=10",
-    "npm": ">=6.14.13"
-  },
-  "scripts": {
-    "link:watch": "npm link && tsdx watch",
-    "link:watch:apis": "npm link oro-sdk-apis && npm link && tsdx watch",
-    "start": "tsdx watch",
-    "build": "tsdx build",
-    "test": "tsdx test",
-    "lint": "tsdx lint",
-    "prepare": "tsdx build",
-    "size": "size-limit",
-    "analyze": "size-limit --why",
-    "package": "tsdx build && npm publish",
-    "pretty": "prettier --config ../../.prettierrc.yaml --write './src/**/*.{ts,js,json,md}' && prettier --write './*.md'"
-  },
-  "name": "oro-sdk",
-  "author": "Antoine Jaouën <antoine@orohealth.me>",
-  "module": "dist/oro-sdk.esm.js",
-  "description": "This package is intended to be run in browser only. It contains everything needed to interact with backend services, especially the vault",
-  "size-limit": [
-    {
-      "path": "dist/oro-sdk.cjs.production.min.js",
-      "limit": "10 KB"
+    "version": "3.6.1",
+    "main": "dist/index.js",
+    "typings": "dist/index.d.ts",
+    "files": [
+        "dist",
+        "src"
+    ],
+    "engines": {
+        "node": ">=10",
+        "npm": ">=6.14.13"
     },
-    {
-      "path": "dist/oro-sdk.esm.js",
-      "limit": "10 KB"
+    "scripts": {
+        "link:watch": "npm link && tsdx watch",
+        "link:watch:apis": "npm link oro-sdk-apis && npm link && tsdx watch",
+        "start": "tsdx watch",
+        "build": "tsdx build",
+        "test": "tsdx test",
+        "lint": "tsdx lint",
+        "prepare": "tsdx build",
+        "size": "size-limit",
+        "analyze": "size-limit --why",
+        "package": "tsdx build && npm publish",
+        "pretty": "prettier --config ../../.prettierrc.yaml --write './src/**/*.{ts,js,json,md}' && prettier --write './*.md'"
+    },
+    "name": "oro-sdk",
+    "author": "Antoine Jaouën <antoine@orohealth.me>",
+    "module": "dist/oro-sdk.esm.js",
+    "description": "This package is intended to be run in browser only. It contains everything needed to interact with backend services, especially the vault",
+    "size-limit": [
+        {
+            "path": "dist/oro-sdk.cjs.production.min.js",
+            "limit": "10 KB"
+        },
+        {
+            "path": "dist/oro-sdk.esm.js",
+            "limit": "10 KB"
+        }
+    ],
+    "devDependencies": {
+        "@size-limit/preset-small-lib": "^4.10.2",
+        "@types/jest": "^27.4.1",
+        "@types/uuid": "^8.3.0",
+        "prettier": "^2.5.1",
+        "prettier-plugin-svelte": "^2.3.0",
+        "size-limit": "^4.10.2",
+        "tsdx": "^0.14.1",
+        "tslib": "^2.2.0",
+        "typescript": "^4.2.4"
+    },
+    "dependencies": {
+        "axios": "^0.21.4",
+        "axios-auth-refresh": "^3.2.1",
+        "form-data": "^4.0.0",
+        "formdata-node": "^4.3.1",
+        "idb-keyval": "^5.0.6",
+        "oro-sdk-apis": "1.41.0",
+        "oro-toolbox": "0.0.6",
+        "uuid": "^8.3.2"
     }
-  ],
-  "devDependencies": {
-    "@size-limit/preset-small-lib": "^4.10.2",
-    "@types/jest": "^27.4.1",
-    "@types/uuid": "^8.3.0",
-    "prettier": "^2.5.1",
-    "prettier-plugin-svelte": "^2.3.0",
-    "size-limit": "^4.10.2",
-    "tsdx": "^0.14.1",
-    "tslib": "^2.2.0",
-    "typescript": "^4.2.4"
-  },
-  "dependencies": {
-    "axios": "^0.21.4",
-    "axios-auth-refresh": "^3.2.1",
-    "form-data": "^4.0.0",
-    "formdata-node": "^4.3.1",
-    "idb-keyval": "^5.0.6",
-    "oro-sdk-apis": "1.40.0",
-    "oro-toolbox": "0.0.6",
-    "uuid": "^8.3.2"
-  }
-}
+}

package/src/client.ts

@@ -83,7 +83,7 @@ export class OroClient {
         public workflowClient: WorkflowService,
         public diagnosisClient: DiagnosisService,
         private authenticationCallback?: (err: Error) => void
-    ) { }
+    ) {}
 
     /**
      * clears the vaultIndex and cached metadata grants
@@ -280,6 +280,7 @@ export class OroClient {
      * @param consult
      * @param workflow
      * @param recoveryQA
+     * @param indexSearch create search index for the consultation if true
      * @returns
      */
     public async registerPatient(
@@ -289,10 +290,11 @@ export class OroClient {
         recoveryQA?: {
             recoverySecurityQuestions: string[]
             recoverySecurityAnswers: string[]
-        }
+        },
+        indexSearch: boolean = true
     ): Promise<RegisterPatientOutput> {
         if (!this.rsa) throw IncompleteAuthentication
-        return registerPatient(patientUuid, consult, workflow, this, this.toolbox.uuid(), recoveryQA)
+        return registerPatient(patientUuid, consult, workflow, this, this.toolbox.uuid(), recoveryQA, indexSearch)
     }
 
     /**
@@ -391,18 +393,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
                 //// DEPRECATED : REMOVE ME : BEGIN ///////////////////////////////////////////
@@ -424,18 +426,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
                 //// DEPRECATED : REMOVE ME : END ///////////////////////////////////////////
@@ -785,14 +787,15 @@ export class OroClient {
 
         // if there is a filter to apply, then the grant can be retrieved from the vault index, otherwise, all grants are fetched
         // Note: will work only if the filter being applied is exclusively a consult id
-        const grantsByConsultLockbox = filter ? (
-            await this.vaultClient.vaultIndexGet([IndexKey.ConsultationLockbox], [filter.consultationId])
-                .then((res) => res[IndexKey.ConsultationLockbox])
-                .catch((e) => {
-                    console.error(e)
-                    return []
-                })
-        ) : undefined
+        const grantsByConsultLockbox = filter
+            ? await this.vaultClient
+                  .vaultIndexGet([IndexKey.ConsultationLockbox], [filter.consultationId])
+                  .then((res) => res[IndexKey.ConsultationLockbox])
+                  .catch((e) => {
+                      console.error(e)
+                      return []
+                  })
+            : undefined
         const decryptedConsults = decryptConsultLockboxGrants(grantsByConsultLockbox ?? [], this.rsa)
         if (decryptedConsults.length > 0) {
             console.info('[sdk:index] Grants found in user`s constant time secure index')

package/src/helpers/patient-registration.ts

@@ -27,7 +27,7 @@ import {
     identificationToPersonalInformations,
     OroClient,
     RegisterPatientOutput,
-    toActualObject
+    toActualObject,
 } from '..'
 
 const MAX_RETRIES = 15
@@ -50,6 +50,7 @@ const MAX_RETRIES = 15
  * @param oroClient
  * @param masterKey
  * @param recoveryQA
+ * @param indexSearch create search index for the consultation if true
  * @returns the successful registration
  */
 export async function registerPatient(
@@ -61,7 +62,8 @@ export async function registerPatient(
     recoveryQA?: {
         recoverySecurityQuestions: string[]
         recoverySecurityAnswers: string[]
-    }
+    },
+    indexSearch: boolean = true
 ): Promise<RegisterPatientOutput> {
     let consult: Consult | undefined = undefined
     let lockboxUuid: Uuid | undefined = undefined
@@ -95,8 +97,7 @@ export async function registerPatient(
             // Creating lockbox
             if (!lockboxUuid) lockboxUuid = await getOrCreatePatientLockbox(oroClient)
 
-            if (!identity)
-                identity = await oroClient.guardClient.identityGet(patientUuid)
+            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)
@@ -131,14 +132,16 @@ 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(`[SDK: registration] Error while adding to the practitioner's index ${practitioner.uuid}`, err)
+                    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)
                 })
             })
 
-
             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
@@ -146,13 +149,19 @@ export async function registerPatient(
                 else errorsThrown.push(err)
             })
 
-            await storePatientData(consult.uuid, consultRequest.isoLanguageRequired, lockboxUuid, workflow, oroClient).catch((err) => {
+            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 && !identity?.recoveryMasterKey) {
-                // generate and store recovery payload and updates the identity 
+                // 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)
@@ -166,7 +175,7 @@ export async function registerPatient(
             }
 
             if (recoveryQA && !identity?.recoverySecurityQuestions)
-                // Patient security question recovery threshold is 2 answers and updates the identity 
+                // Patient security question recovery threshold is 2 answers and updates the identity
                 identity = await oroClient
                     .updateSecurityQuestions(
                         patientUuid,
@@ -184,15 +193,19 @@ export async function registerPatient(
 
             await Promise.all([...grantPromises, ...consultIndexPromises])
 
-            // TODO: uncomment when search is deployed in prod
-            // await buildConsultSearchIndex(consult, workflow, oroClient).catch((err) => {
-            //     console.error('[SDK: registration] personal information not found or another error occured during search indexing', err)
-            //     if(retry <= 1) return       // this statement is to avoid failing the registration due to the failure in search indexing the consult, this practically implements a soft retry
-            //     errorsThrown.push(err)
-            // })
 
-            if (errorsThrown.length > 0)
-                throw errorsThrown
+            if(indexSearch) {
+                await buildConsultSearchIndex(consult, workflow, oroClient).catch((err) => {
+                    console.error(
+                        '[SDK: registration] personal information not found or another error occured during search indexing',
+                        err
+                    )
+                    if (retry <= 1) return // this statement is to avoid failing the registration due to the failure in search indexing the consult, this practically implements a soft retry
+                    errorsThrown.push(err)
+                })
+            }
+
+            if (errorsThrown.length > 0) throw errorsThrown
 
             // Deem the consultation as ready
             await oroClient.consultClient.updateConsultByUUID(consult.uuid, {
@@ -417,14 +430,14 @@ export async function extractAndStorePersonalWorkflowData(
  * @param workflow
  */
 export async function extractPersonalInfoFromWorkflowData(workflow: WorkflowData): Promise<{
-    personalInfoPopulatedWfData: PopulatedWorkflowData,
-    childPersonalInfoPopulatedWfData: PopulatedWorkflowData,
-    otherPersonalInfoPopulatedWfData: PopulatedWorkflowData,
+    personalInfoPopulatedWfData: PopulatedWorkflowData
+    childPersonalInfoPopulatedWfData: PopulatedWorkflowData
+    otherPersonalInfoPopulatedWfData: PopulatedWorkflowData
 }> {
     return Promise.all([
         getWorkflowDataByCategory(workflow, MetadataCategory.Personal),
         getWorkflowDataByCategory(workflow, MetadataCategory.ChildPersonal),
-        getWorkflowDataByCategory(workflow, MetadataCategory.OtherPersonal)
+        getWorkflowDataByCategory(workflow, MetadataCategory.OtherPersonal),
     ]).then(([personalInfoPopulatedWfData, childPersonalInfoPopulatedWfData, otherPersonalInfoPopulatedWfData]) => {
         return {
             personalInfoPopulatedWfData,
@@ -442,17 +455,14 @@ export async function extractPersonalInfoFromWorkflowData(workflow: WorkflowData
  */
 export async function buildConsultSearchIndex(consult: Consult, workflow: WorkflowData, oroClient: OroClient) {
     let terms: Terms = [
-        <Term> {
+        <Term>{
             kind: 'consult-shortid',
-            value: consult.shortId
-        }
+            value: consult.shortId,
+        },
     ]
 
-    const {
-        personalInfoPopulatedWfData,
-        childPersonalInfoPopulatedWfData,
-        otherPersonalInfoPopulatedWfData
-    } = await extractPersonalInfoFromWorkflowData(workflow)
+    const { personalInfoPopulatedWfData, childPersonalInfoPopulatedWfData, otherPersonalInfoPopulatedWfData } =
+        await extractPersonalInfoFromWorkflowData(workflow)
 
     const personalInfo = identificationToPersonalInformations(
         toActualObject(personalInfoPopulatedWfData),
@@ -467,32 +477,41 @@ export async function buildConsultSearchIndex(consult: Consult, workflow: Workfl
         MetadataCategory.OtherPersonal
     )
 
-    terms.push(<Term>{
-        kind: 'first-name',
-        value: personalInfo.firstname,
-    }, <Term> {
-        kind: 'last-name',
-        value: personalInfo.name
-    })
-
-    if(childPersonalInfo.firstname && childPersonalInfo.name) {
-        terms.push(<Term>{
+    terms.push(
+        <Term>{
             kind: 'first-name',
-            value: childPersonalInfo.firstname,
-        }, <Term> {
+            value: personalInfo.firstname,
+        },
+        <Term>{
             kind: 'last-name',
-            value: childPersonalInfo.name
-        })
+            value: personalInfo.name,
+        }
+    )
+
+    if (childPersonalInfo.firstname && childPersonalInfo.name) {
+        terms.push(
+            <Term>{
+                kind: 'first-name',
+                value: childPersonalInfo.firstname,
+            },
+            <Term>{
+                kind: 'last-name',
+                value: childPersonalInfo.name,
+            }
+        )
     }
 
-    if(otherPersonalInfo.firstname && otherPersonalInfo.name) {
-        terms.push(<Term>{
-            kind: 'first-name',
-            value: otherPersonalInfo.firstname,
-        }, <Term> {
-            kind: 'last-name',
-            value: otherPersonalInfo.name
-        })
+    if (otherPersonalInfo.firstname && otherPersonalInfo.name) {
+        terms.push(
+            <Term>{
+                kind: 'first-name',
+                value: otherPersonalInfo.firstname,
+            },
+            <Term>{
+                kind: 'last-name',
+                value: otherPersonalInfo.name,
+            }
+        )
     }
 
     await oroClient.searchClient.index(consult.uuid, terms)