oro-sdk 2.1.4-dev1.0 → 2.2.1

package/src/client.ts

@@ -1,24 +1,20 @@
-import * as OroToolbox from 'oro-toolbox'
-import { CryptoRSA } from 'oro-toolbox'
-import { registerPatient, sessionStorePrivateKeyName, decryptGrants, decryptConsultLockboxGrants} from './helpers'
 import {
-    AssociatedLockboxNotFound,
     AuthTokenRequest,
     Consult,
     ConsultRequest,
+    ConsultService,
     DataCreateResponse,
+    DiagnosisService,
     Document,
     DocumentType,
     EncryptedIndexEntry,
     EncryptedVaultIndex,
     Grant,
+    GuardService,
     IdentityCreateRequest,
     IdentityResponse,
-    IncompleteAuthentication,
-    IndexBuildError,
     IndexConsultLockbox,
     IndexKey,
-    LocalEncryptedData,
     LocalizedData,
     LockboxDataRequest,
     LockboxGrantRequest,
@@ -27,34 +23,37 @@ import {
     Meta,
     Metadata,
     MetadataCategory,
-    MissingGrant,
-    MissingLockbox,
-    MissingLockboxOwner,
     PersonalMeta,
     PopulatedWorkflowData,
     Practice,
+    PracticeService,
     PreferenceMeta,
-    RecoveryData,
     RecoveryMeta,
-    RegisterPatientOutput,
     SecretShard,
+    TellerService,
     TokenData,
     TosAndCpAcceptanceRequest,
-    UserPreference,
     Uuid,
     VaultIndex,
-    WorkflowData,
-} from './models'
-import { filterGrantsWithLockboxMetadata, buildLegacyVaultIndex } from './sdk-revision'
-import {
-    ConsultService,
-    DiagnosisService,
-    GuardService,
-    PracticeService,
-    TellerService,
     VaultService,
+    WorkflowData,
     WorkflowService,
-} from './services'
+} from 'oro-sdk-apis'
+import * as OroToolbox from 'oro-toolbox'
+import { CryptoRSA } from 'oro-toolbox'
+import { decryptConsultLockboxGrants, decryptGrants, registerPatient, sessionStorePrivateKeyName } from './helpers'
+import {
+    AssociatedLockboxNotFound,
+    IncompleteAuthentication,
+    LocalEncryptedData,
+    MissingGrant,
+    MissingLockbox,
+    MissingLockboxOwner,
+    RecoveryData,
+    RegisterPatientOutput,
+    UserPreference,
+} from './models'
+import { buildLegacyVaultIndex, filterGrantsWithLockboxMetadata } from './sdk-revision'
 
 export class OroClient {
     private rsa?: CryptoRSA
@@ -84,13 +83,13 @@ export class OroClient {
         private authenticationCallback?: (err: Error) => void
     ) {}
 
-    /** 
+    /**
      * clears the vaultIndex and cached metadata grants
-    */
+     */
     public async cleanIndex() {
         this.vaultIndex = undefined
         this.cachedMetadataGrants = {}
-        this.cachedManifest = {}    
+        this.cachedManifest = {}
     }
 
     /**
@@ -115,16 +114,10 @@ export class OroClient {
         this.rsa = new CryptoRSA()
         const privateKey = this.rsa.private()
 
-        const symmetricEncryptor = this.toolbox.CryptoChaCha.fromPassphrase(
-            password
-        )
-        const recoveryPassword = symmetricEncryptor.bytesEncryptToBase64Payload(
-            privateKey
-        )
+        const symmetricEncryptor = this.toolbox.CryptoChaCha.fromPassphrase(password)
+        const recoveryPassword = symmetricEncryptor.bytesEncryptToBase64Payload(privateKey)
 
-        const hashedPassword = this.toolbox.hashStringToBase64(
-            this.toolbox.hashStringToBase64(password)
-        )
+        const hashedPassword = this.toolbox.hashStringToBase64(this.toolbox.hashStringToBase64(password))
 
         const signupRequest: IdentityCreateRequest = {
             practiceUuid: practice.uuid,
@@ -141,9 +134,7 @@ export class OroClient {
 
         if (identity.recoveryLogin) {
             //Ensure we can recover from a page reload
-            let symetricEncryptor = this.toolbox.CryptoChaCha.fromPassphrase(
-                identity.recoveryLogin
-            )
+            let symetricEncryptor = this.toolbox.CryptoChaCha.fromPassphrase(identity.recoveryLogin)
             sessionStorage.setItem(
                 sessionStorePrivateKeyName(identity.id),
                 symetricEncryptor.bytesEncryptToBase64Payload(privateKey)
@@ -176,15 +167,8 @@ export class OroClient {
      * @param otp
      * @returns the user identity
      */
-    public async signIn(
-        practiceUuid: Uuid,
-        email: string,
-        password: string,
-        otp?: string
-    ): Promise<IdentityResponse> {
-        const hashedPassword = this.toolbox.hashStringToBase64(
-            this.toolbox.hashStringToBase64(password)
-        )
+    public async signIn(practiceUuid: Uuid, email: string, password: string, otp?: string): Promise<IdentityResponse> {
+        const hashedPassword = this.toolbox.hashStringToBase64(this.toolbox.hashStringToBase64(password))
         const tokenRequest: AuthTokenRequest = {
             practiceUuid,
             email: email.toLowerCase(),
@@ -206,20 +190,13 @@ export class OroClient {
      */
     public async resumeSession() {
         const id = (await this.guardClient.whoAmI()).sub
-        const recoveryPayload = sessionStorage.getItem(
-            sessionStorePrivateKeyName(id)
-        )
-        const recoveryKey = (await this.guardClient.identityGet(id))
-            .recoveryLogin
+        const recoveryPayload = sessionStorage.getItem(sessionStorePrivateKeyName(id))
+        const recoveryKey = (await this.guardClient.identityGet(id)).recoveryLogin
 
         if (!recoveryKey || !recoveryPayload) throw IncompleteAuthentication
 
-        const symmetricDecryptor = this.toolbox.CryptoChaCha.fromPassphrase(
-            recoveryKey
-        )
-        let privateKey = symmetricDecryptor.base64PayloadDecryptToBytes(
-            recoveryPayload
-        )
+        const symmetricDecryptor = this.toolbox.CryptoChaCha.fromPassphrase(recoveryKey)
+        let privateKey = symmetricDecryptor.base64PayloadDecryptToBytes(recoveryPayload)
         this.rsa = this.toolbox.CryptoRSA.fromKey(privateKey)
     }
 
@@ -242,9 +219,7 @@ export class OroClient {
         const chaChaKey = new this.toolbox.CryptoChaCha()
 
         const encryptedData = chaChaKey.jsonEncryptToBase64Payload(value)
-        const encryptedKey = this.toolbox.encodeToBase64(
-            this.rsa.encryptToBytes(chaChaKey.key())
-        )
+        const encryptedKey = this.toolbox.encodeToBase64(this.rsa.encryptToBytes(chaChaKey.key()))
 
         return { encryptedData, encryptedKey }
     }
@@ -256,10 +231,7 @@ export class OroClient {
      * @throws IncompleteAuthentication if rsa is not set
      * @calls authenticationCallback if rsa is not set
      */
-    public localDecryptJsonPayload({
-        encryptedKey,
-        encryptedData,
-    }: LocalEncryptedData): any {
+    public localDecryptJsonPayload({ encryptedKey, encryptedData }: LocalEncryptedData): any {
         if (!this.rsa) {
             if (this.authenticationCallback) {
                 this.authenticationCallback(new IncompleteAuthentication())
@@ -269,9 +241,7 @@ export class OroClient {
         }
 
         const chaChaKey = this.rsa.base64DecryptToBytes(encryptedKey)
-        const decryptedData = this.toolbox.CryptoChaCha.fromKey(
-            chaChaKey
-        ).base64PayloadDecryptToJson(encryptedData)
+        const decryptedData = this.toolbox.CryptoChaCha.fromKey(chaChaKey).base64PayloadDecryptToJson(encryptedData)
 
         return decryptedData
     }
@@ -316,14 +286,7 @@ export class OroClient {
         }
     ): 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)
     }
 
     /**
@@ -337,8 +300,7 @@ export class OroClient {
      * @returns the latest vault index
      */
     public async buildVaultIndex(forceRefresh: boolean = false) {
-        if (!this.vaultIndex || forceRefresh)
-            await buildLegacyVaultIndex(this)
+        if (!this.vaultIndex || forceRefresh) await buildLegacyVaultIndex(this)
     }
 
     /**
@@ -373,8 +335,7 @@ export class OroClient {
                                     return {
                                         ...consult,
                                         grant: {
-                                            lockboxOwnerUuid:
-                                                grant.lockboxOwnerUuid,
+                                            lockboxOwnerUuid: grant.lockboxOwnerUuid,
                                             lockboxUuid: grant.lockboxUuid,
                                         },
                                     }
@@ -405,9 +366,7 @@ export class OroClient {
 
         let rsaPub: Uint8Array
         if (indexOwnerUuid) {
-            let base64IndexOwnerPubKey = (
-                await this.guardClient.identityGet(indexOwnerUuid)
-            ).publicKey
+            let base64IndexOwnerPubKey = (await this.guardClient.identityGet(indexOwnerUuid)).publicKey
             rsaPub = this.toolbox.decodeFromBase64(base64IndexOwnerPubKey)
         } else {
             rsaPub = this.rsa.public()
@@ -419,9 +378,7 @@ export class OroClient {
             let key = keyString as keyof VaultIndex
             switch (key) {
                 case IndexKey.ConsultationLockbox:
-                    encryptedIndex[key] = (entries[
-                        key
-                    ] as IndexConsultLockbox[])
+                    encryptedIndex[key] = (entries[key] as IndexConsultLockbox[])
                         .map((e) => ({
                             ...e,
                             uniqueHash: e.consultationId,
@@ -444,9 +401,7 @@ export class OroClient {
                     break
                 //// DEPRECATED : REMOVE ME : BEGIN ///////////////////////////////////////////
                 case IndexKey.Consultation:
-                    encryptedIndex[key] = (entries[
-                        key
-                    ] as IndexConsultLockbox[])
+                    encryptedIndex[key] = (entries[key] as IndexConsultLockbox[])
                         .map((e) => ({
                             ...e,
                             uniqueHash: this.toolbox.hashStringToBase64(
@@ -459,9 +414,7 @@ export class OroClient {
                         .filter(
                             (e) =>
                                 !this.vaultIndex ||
-                                !this.vaultIndex[IndexKey.Consultation]?.find(
-                                    (v) => v.uniqueHash === e.uniqueHash
-                                )
+                                !this.vaultIndex[IndexKey.Consultation]?.find((v) => v.uniqueHash === e.uniqueHash)
                         )
                         .map(
                             (e: IndexConsultLockbox) =>
@@ -506,10 +459,7 @@ export class OroClient {
 
         // the data of the snapshot should not contain the `IndexEntry` data
         // (will create conflicts while updating)
-        let encryptedIndexEntry = CryptoRSA.jsonWithPubEncryptToBase64(
-            cleanedIndex,
-            rsaPub
-        )
+        let encryptedIndexEntry = CryptoRSA.jsonWithPubEncryptToBase64(cleanedIndex, rsaPub)
 
         // The encryptedIndexEntry can have the uuid and timstamp (for updating)
         let encryptedIndex: EncryptedIndexEntry = {
@@ -527,36 +477,19 @@ export class OroClient {
      * @param lockboxUuid
      * @param lockboxOwnerUuid the lockbox owner (ignored if lockbox is owned by self)
      */
-    public async grantLockbox(
-        granteeUuid: Uuid,
-        lockboxUuid: Uuid,
-        lockboxOwnerUuid?: Uuid
-    ) {
+    public async grantLockbox(granteeUuid: Uuid, lockboxUuid: Uuid, lockboxOwnerUuid?: Uuid) {
         if (!this.rsa) throw IncompleteAuthentication
 
-        let secret = (
-            await this.getCachedSecretCryptor(lockboxUuid, lockboxOwnerUuid)
-        ).key()
-        let base64GranteePublicKey = (
-            await this.guardClient.identityGet(granteeUuid)
-        ).publicKey
-        let granteePublicKey = this.toolbox.decodeFromBase64(
-            base64GranteePublicKey
-        )
+        let secret = (await this.getCachedSecretCryptor(lockboxUuid, lockboxOwnerUuid)).key()
+        let base64GranteePublicKey = (await this.guardClient.identityGet(granteeUuid)).publicKey
+        let granteePublicKey = this.toolbox.decodeFromBase64(base64GranteePublicKey)
 
-        let granteeEncryptedSecret = CryptoRSA.bytesWithPubEncryptToBase64(
-            secret,
-            granteePublicKey
-        )
+        let granteeEncryptedSecret = CryptoRSA.bytesWithPubEncryptToBase64(secret, granteePublicKey)
         let request: LockboxGrantRequest = {
             encryptedSecret: granteeEncryptedSecret,
             granteeUuid: granteeUuid,
         }
-        await this.vaultClient.lockboxGrant(
-            lockboxUuid,
-            request,
-            lockboxOwnerUuid
-        )
+        await this.vaultClient.lockboxGrant(lockboxUuid, request, lockboxOwnerUuid)
     }
 
     /**
@@ -578,17 +511,12 @@ export class OroClient {
     ): Promise<DataCreateResponse> {
         if (!this.rsa) throw IncompleteAuthentication
 
-        let symmetricEncryptor = await this.getCachedSecretCryptor(
-            lockboxUuid,
-            lockboxOwnerUuid
-        )
+        let symmetricEncryptor = await this.getCachedSecretCryptor(lockboxUuid, lockboxOwnerUuid)
 
-        let encryptedData = symmetricEncryptor.jsonEncryptToBase64Payload(
-            message
-        )
-        let encryptedPrivateMeta = symmetricEncryptor.jsonEncryptToBase64Payload(
-            { author: (await this.guardClient.whoAmI()).sub }
-        )
+        let encryptedData = symmetricEncryptor.jsonEncryptToBase64Payload(message)
+        let encryptedPrivateMeta = symmetricEncryptor.jsonEncryptToBase64Payload({
+            author: (await this.guardClient.whoAmI()).sub,
+        })
 
         let meta = {
             consultationId,
@@ -603,12 +531,7 @@ export class OroClient {
             privateMetadata: encryptedPrivateMeta,
         }
 
-        return this.tellerClient.lockboxDataStore(
-            lockboxUuid,
-            request,
-            lockboxOwnerUuid,
-            previousDataUuid
-        )
+        return this.tellerClient.lockboxDataStore(lockboxUuid, request, lockboxOwnerUuid, previousDataUuid)
     }
 
     /**
@@ -630,21 +553,14 @@ export class OroClient {
     ): Promise<DataCreateResponse> {
         if (!this.rsa) throw IncompleteAuthentication
 
-        let symmetricEncryptor = await this.getCachedSecretCryptor(
-            lockboxUuid,
-            lockboxOwnerUuid
-        )
-        let encryptedData = symmetricEncryptor.bytesEncryptToBase64Payload(
-            new Uint8Array(await data.arrayBuffer())
-        )
-        let encryptedPrivateMeta = symmetricEncryptor.jsonEncryptToBase64Payload(
-            {
-                author: (await this.guardClient.whoAmI()).sub,
-                fileName: data.name,
-                lastModified: data.lastModified,
-                size: data.size,
-            }
-        )
+        let symmetricEncryptor = await this.getCachedSecretCryptor(lockboxUuid, lockboxOwnerUuid)
+        let encryptedData = symmetricEncryptor.bytesEncryptToBase64Payload(new Uint8Array(await data.arrayBuffer()))
+        let encryptedPrivateMeta = symmetricEncryptor.jsonEncryptToBase64Payload({
+            author: (await this.guardClient.whoAmI()).sub,
+            fileName: data.name,
+            lastModified: data.lastModified,
+            size: data.size,
+        })
 
         let meta = {
             consultationId,
@@ -659,12 +575,7 @@ export class OroClient {
             privateMetadata: encryptedPrivateMeta,
         }
 
-        return this.tellerClient.lockboxDataStore(
-            lockboxUuid,
-            request,
-            lockboxOwnerUuid,
-            previousDataUuid
-        )
+        return this.tellerClient.lockboxDataStore(lockboxUuid, request, lockboxOwnerUuid, previousDataUuid)
     }
 
     /**
@@ -727,14 +638,9 @@ export class OroClient {
     ): Promise<DataCreateResponse> {
         if (!this.rsa) throw IncompleteAuthentication
 
-        let symmetricEncryptor = await this.getCachedSecretCryptor(
-            lockboxUuid,
-            lockboxOwnerUuid
-        )
+        let symmetricEncryptor = await this.getCachedSecretCryptor(lockboxUuid, lockboxOwnerUuid)
         let encryptedData = symmetricEncryptor.jsonEncryptToBase64Payload(data)
-        let encryptedPrivateMeta = symmetricEncryptor.jsonEncryptToBase64Payload(
-            privateMeta
-        )
+        let encryptedPrivateMeta = symmetricEncryptor.jsonEncryptToBase64Payload(privateMeta)
 
         let request: LockboxDataRequest = {
             data: encryptedData,
@@ -742,12 +648,7 @@ export class OroClient {
             privateMetadata: encryptedPrivateMeta,
         }
 
-        return this.tellerClient.lockboxDataStore(
-            lockboxUuid,
-            request,
-            lockboxOwnerUuid,
-            previousDataUuid
-        )
+        return this.tellerClient.lockboxDataStore(lockboxUuid, request, lockboxOwnerUuid, previousDataUuid)
     }
 
     /**
@@ -766,14 +667,9 @@ export class OroClient {
         privateMetadata: Metadata,
         forceReplace: boolean = false
     ): Promise<Uuid> {
-        let manifest = await this.vaultClient.lockboxManifestGet(
-            lockboxUuid,
-            publicMetadata
-        )
+        let manifest = await this.vaultClient.lockboxManifestGet(lockboxUuid, publicMetadata)
         if (!forceReplace && manifest.length > 0) {
-            console.log(
-                `The data for ${JSON.stringify(publicMetadata)} already exist`
-            )
+            console.log(`The data for ${JSON.stringify(publicMetadata)} already exist`)
             return manifest[0].dataUuid
         } else
             return (
@@ -783,16 +679,9 @@ 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
                 ).catch((err) => {
-                    console.error(
-                        `Error while upserting data ${JSON.stringify(
-                            publicMetadata
-                        )} data`,
-                        err
-                    )
+                    console.error(`Error while upserting data ${JSON.stringify(publicMetadata)} data`, err)
                     throw err
                 })
             ).dataUuid
@@ -818,14 +707,9 @@ export class OroClient {
         previousDataUuid?: Uuid
     ): Promise<DataCreateResponse> {
         if (!this.rsa) throw IncompleteAuthentication
-        let symmetricEncryptor = await this.getCachedSecretCryptor(
-            lockboxUuid,
-            lockboxOwnerUuid
-        )
+        let symmetricEncryptor = await this.getCachedSecretCryptor(lockboxUuid, lockboxOwnerUuid)
         let encryptedData = symmetricEncryptor.bytesEncryptToBase64Payload(data)
-        let encryptedPrivateMeta = symmetricEncryptor.jsonEncryptToBase64Payload(
-            privateMeta
-        )
+        let encryptedPrivateMeta = symmetricEncryptor.jsonEncryptToBase64Payload(privateMeta)
 
         let request: LockboxDataRequest = {
             data: encryptedData,
@@ -833,12 +717,7 @@ export class OroClient {
             privateMetadata: encryptedPrivateMeta,
         }
 
-        return this.tellerClient.lockboxDataStore(
-            lockboxUuid,
-            request,
-            lockboxOwnerUuid,
-            previousDataUuid
-        )
+        return this.tellerClient.lockboxDataStore(lockboxUuid, request, lockboxOwnerUuid, previousDataUuid)
     }
 
     /**
@@ -852,25 +731,15 @@ export class OroClient {
      * @param lockboxOwnerUuid the lockbox owner (ignored if lockbox is owned by self)
      * @returns the data specified by the generic type <T>
      */
-    public async getJsonData<T = any>(
-        lockboxUuid: Uuid,
-        dataUuid: Uuid,
-        lockboxOwnerUuid?: Uuid
-    ): Promise<T> {
+    public async getJsonData<T = any>(lockboxUuid: Uuid, dataUuid: Uuid, lockboxOwnerUuid?: Uuid): Promise<T> {
         if (!this.rsa) throw IncompleteAuthentication
 
         let [encryptedPayload, symmetricDecryptor] = await Promise.all([
-            this.vaultClient.lockboxDataGet(
-                lockboxUuid,
-                dataUuid,
-                lockboxOwnerUuid
-            ),
+            this.vaultClient.lockboxDataGet(lockboxUuid, dataUuid, lockboxOwnerUuid),
             this.getCachedSecretCryptor(lockboxUuid, lockboxOwnerUuid),
         ])
 
-        return symmetricDecryptor.base64PayloadDecryptToJson(
-            encryptedPayload.data
-        )
+        return symmetricDecryptor.base64PayloadDecryptToJson(encryptedPayload.data)
     }
     /**
      * @description Fetches and decrypts the lockbox data with the cached shared secret.
@@ -879,25 +748,15 @@ export class OroClient {
      * @param lockboxOwnerUuid the lockbox owner (ignored if lockbox is owned by self)
      * @returns the bytes data
      */
-    public async getBytesData(
-        lockboxUuid: Uuid,
-        dataUuid: Uuid,
-        lockboxOwnerUuid?: Uuid
-    ): Promise<Uint8Array> {
+    public async getBytesData(lockboxUuid: Uuid, dataUuid: Uuid, lockboxOwnerUuid?: Uuid): Promise<Uint8Array> {
         if (!this.rsa) throw IncompleteAuthentication
 
         let [encryptedPayload, symmetricDecryptor] = await Promise.all([
-            this.vaultClient.lockboxDataGet(
-                lockboxUuid,
-                dataUuid,
-                lockboxOwnerUuid
-            ),
+            this.vaultClient.lockboxDataGet(lockboxUuid, dataUuid, lockboxOwnerUuid),
             this.getCachedSecretCryptor(lockboxUuid, lockboxOwnerUuid),
         ])
 
-        return symmetricDecryptor.base64PayloadDecryptToBytes(
-            encryptedPayload.data
-        )
+        return symmetricDecryptor.base64PayloadDecryptToBytes(encryptedPayload.data)
     }
 
     /**
@@ -910,21 +769,19 @@ export class OroClient {
      * @param filter: the consultationId in which the grant exists
      * @returns decrypted lockboxes granted to user
      */
-    public async getGrants(
-        filter?: { consultationId: Uuid },
-        forceRefresh: boolean = false
-    ): Promise<Grant[]> {
+    public async getGrants(filter?: { consultationId: Uuid }, forceRefresh: boolean = false): Promise<Grant[]> {
         if (!this.rsa) throw IncompleteAuthentication
 
         let filterString = JSON.stringify(filter)
         // retrieves cached grants
         // Note: if filters is set to empty, it will be stored in the `undefined` key
-        if (!forceRefresh && this.cachedMetadataGrants[filterString])
-            return this.cachedMetadataGrants[filterString]
+        if (!forceRefresh && this.cachedMetadataGrants[filterString]) return this.cachedMetadataGrants[filterString]
 
         // retrieves the consult lockbox from the vault directly if it exists
         // Note: will work only if the filter being applied is exclusively a consult id
-        const grantsByConsultLockbox = (await this.vaultClient.vaultIndexGet([IndexKey.ConsultationLockbox], [filter?.consultationId!]))[IndexKey.ConsultationLockbox] 
+        const grantsByConsultLockbox = (
+            await this.vaultClient.vaultIndexGet([IndexKey.ConsultationLockbox], [filter?.consultationId!])
+        )[IndexKey.ConsultationLockbox]
         const decryptedConsults = decryptConsultLockboxGrants(grantsByConsultLockbox ?? [], this.rsa)
         if (decryptedConsults.length > 0) {
             console.info('[sdk:index] Grants found in user`s constant time secure index')
@@ -935,12 +792,7 @@ export class OroClient {
         let encryptedGrants
         // if there are no grants with the applied filter from index, attempt for naive filter with backwards compatibility
         if (filter) {
-            encryptedGrants = await filterGrantsWithLockboxMetadata(
-                this, 
-                filter,
-                this.vaultIndex,
-                forceRefresh
-            )
+            encryptedGrants = await filterGrantsWithLockboxMetadata(this, filter, this.vaultIndex, forceRefresh)
         } else {
             encryptedGrants = (await this.vaultClient.grantsGet()).grants
         }
@@ -958,22 +810,12 @@ export class OroClient {
      * @param lockboxOwnerUuid the lockbox owner (ignored if lockbox is owned by self)
      * @returns
      */
-    async getCachedSecretCryptor(
-        lockboxUuid: string,
-        lockboxOwnerUuid?: string
-    ): Promise<OroToolbox.CryptoChaCha> {
+    async getCachedSecretCryptor(lockboxUuid: string, lockboxOwnerUuid?: string): Promise<OroToolbox.CryptoChaCha> {
         if (!this.rsa) throw IncompleteAuthentication
 
-        let index = this.secrets.findIndex(
-            (secret) => secret.lockboxUuid === lockboxUuid
-        )
+        let index = this.secrets.findIndex((secret) => secret.lockboxUuid === lockboxUuid)
         if (index === -1) {
-            let encryptedSecret = (
-                await this.vaultClient.lockboxSecretGet(
-                    lockboxUuid,
-                    lockboxOwnerUuid
-                )
-            ).sharedSecret
+            let encryptedSecret = (await this.vaultClient.lockboxSecretGet(lockboxUuid, lockboxOwnerUuid)).sharedSecret
 
             let secret = this.rsa.base64DecryptToBytes(encryptedSecret)
             let cryptor = this.toolbox.CryptoChaCha.fromKey(secret)
@@ -995,17 +837,10 @@ export class OroClient {
      */
     public async getPersonalInformationsFromConsultId(
         consultationId: Uuid,
-        category:
-            | MetadataCategory.Personal
-            | MetadataCategory.ChildPersonal
-            | MetadataCategory.OtherPersonal,
+        category: MetadataCategory.Personal | MetadataCategory.ChildPersonal | MetadataCategory.OtherPersonal,
         forceRefresh = false
     ): Promise<LocalizedData<PopulatedWorkflowData>[]> {
-        return this.getMetaCategoryFromConsultId(
-            consultationId,
-            category,
-            forceRefresh
-        )
+        return this.getMetaCategoryFromConsultId(consultationId, category, forceRefresh)
     }
 
     /**
@@ -1020,11 +855,7 @@ export class OroClient {
         consultationId: Uuid,
         forceRefresh = false
     ): Promise<LocalizedData<PopulatedWorkflowData>[]> {
-        return this.getMetaCategoryFromConsultId(
-            consultationId,
-            MetadataCategory.Medical,
-            forceRefresh
-        )
+        return this.getMetaCategoryFromConsultId(consultationId, MetadataCategory.Medical, forceRefresh)
     }
 
     private async getMetaCategoryFromConsultId(
@@ -1069,10 +900,7 @@ export class OroClient {
                         lockboxOwnerUuid: grant.lockboxOwnerUuid,
                         lockboxUuid: grant.lockboxUuid!,
                         dataUuid: entry.dataUuid,
-                        data: await this.getJsonData<PopulatedWorkflowData>(
-                            grant.lockboxUuid!,
-                            entry.dataUuid
-                        ),
+                        data: await this.getJsonData<PopulatedWorkflowData>(grant.lockboxUuid!, entry.dataUuid),
                     }
                 })
             )
@@ -1086,12 +914,8 @@ export class OroClient {
      * @param userId The user Id
      * @returns the personal data
      */
-    public async getPersonalInformations(
-        userId: Uuid
-    ): Promise<LocalizedData<PopulatedWorkflowData>> {
-        const grant = (await this.getGrants()).find(
-            (lockbox) => lockbox.lockboxOwnerUuid === userId
-        )
+    public async getPersonalInformations(userId: Uuid): Promise<LocalizedData<PopulatedWorkflowData>> {
+        const grant = (await this.getGrants()).find((lockbox) => lockbox.lockboxOwnerUuid === userId)
 
         if (!grant) {
             throw MissingGrant
@@ -1119,10 +943,7 @@ export class OroClient {
             lockboxOwnerUuid,
             lockboxUuid,
             dataUuid: identificationDataUuid,
-            data: await this.getJsonData<PopulatedWorkflowData>(
-                lockboxUuid,
-                identificationDataUuid
-            ),
+            data: await this.getJsonData<PopulatedWorkflowData>(lockboxUuid, identificationDataUuid),
         }
     }
 
@@ -1132,9 +953,7 @@ export class OroClient {
      * @param consultationId The consultationId
      * @returns the grant
      */
-    public async getGrantFromConsultId(
-        consultationId: Uuid
-    ): Promise<Grant | undefined> {
+    public async getGrantFromConsultId(consultationId: Uuid): Promise<Grant | undefined> {
         let grants = await this.getGrants({ consultationId })
 
         if (grants.length === 0) {
@@ -1149,9 +968,7 @@ export class OroClient {
      * @param consultationId The consultation Id
      * @returns the identity
      */
-    public async getIdentityFromConsultId(
-        consultationId: Uuid
-    ): Promise<IdentityResponse | undefined> {
+    public async getIdentityFromConsultId(consultationId: Uuid): Promise<IdentityResponse | undefined> {
         const grant = await this.getGrantFromConsultId(consultationId)
 
         if (grant && grant.lockboxOwnerUuid) {
@@ -1184,34 +1001,26 @@ export class OroClient {
             expandPrivateMetadata,
             lockboxOwnerUuid,
         })
-        if (!forceRefresh && this.cachedManifest[manifestKey])
-            return this.cachedManifest[manifestKey]
-
-        return this.vaultClient
-            .lockboxManifestGet(lockboxUuid, filter, lockboxOwnerUuid)
-            .then((manifest) => {
-                return Promise.all(
-                    manifest.map(async (entry) => {
-                        if (
-                            expandPrivateMetadata &&
-                            entry.metadata.privateMetadata
-                        ) {
-                            let privateMeta = await this.getJsonData<Metadata>(
-                                lockboxUuid!,
-                                entry.metadata.privateMetadata,
-                                lockboxOwnerUuid
-                            )
-                            entry.metadata = {
-                                ...entry.metadata,
-                                ...privateMeta,
-                            }
+        if (!forceRefresh && this.cachedManifest[manifestKey]) return this.cachedManifest[manifestKey]
+
+        return this.vaultClient.lockboxManifestGet(lockboxUuid, filter, lockboxOwnerUuid).then((manifest) => {
+            return Promise.all(
+                manifest.map(async (entry) => {
+                    if (expandPrivateMetadata && entry.metadata.privateMetadata) {
+                        let privateMeta = await this.getJsonData<Metadata>(
+                            lockboxUuid!,
+                            entry.metadata.privateMetadata,
+                            lockboxOwnerUuid
+                        )
+                        entry.metadata = {
+                            ...entry.metadata,
+                            ...privateMeta,
                         }
-                        return entry
-                    })
-                ).then(
-                    (manifest) => (this.cachedManifest[manifestKey] = manifest)
-                )
-            })
+                    }
+                    return entry
+                })
+            ).then((manifest) => (this.cachedManifest[manifestKey] = manifest))
+        })
     }
 
     /**
@@ -1285,10 +1094,7 @@ export class OroClient {
      * @param grant The grant
      * @returns the user preference
      */
-    public async getDataFromGrant<T = any>(
-        grant: Grant,
-        filter: Metadata
-    ): Promise<LocalizedData<T>> {
+    public async getDataFromGrant<T = any>(grant: Grant, filter: Metadata): Promise<LocalizedData<T>> {
         const { lockboxUuid, lockboxOwnerUuid } = grant
 
         if (!lockboxUuid) throw MissingLockbox
@@ -1308,10 +1114,7 @@ export class OroClient {
             lockboxOwnerUuid,
             lockboxUuid,
             dataUuid: identificationDataUuid,
-            data: await this.getJsonData<T>(
-                lockboxUuid,
-                identificationDataUuid
-            ),
+            data: await this.getJsonData<T>(lockboxUuid, identificationDataUuid),
         }
     }
 
@@ -1320,9 +1123,7 @@ export class OroClient {
      * @param consultationId The related consultationId
      * @returns the user preference
      */
-    public async getUserPreferenceFromConsultId(
-        consultationId: string
-    ): Promise<LocalizedData<UserPreference>> {
+    public async getUserPreferenceFromConsultId(consultationId: string): Promise<LocalizedData<UserPreference>> {
         const grant = await this.getGrantFromConsultId(consultationId)
 
         if (!grant) throw MissingGrant
@@ -1338,12 +1139,8 @@ export class OroClient {
      * @param identity The identity to use
      * @returns the user preference
      */
-    public async getUserPreference(
-        identity: IdentityResponse
-    ): Promise<LocalizedData<UserPreference>> {
-        const grant = (await this.getGrants()).find(
-            (lockbox) => lockbox.lockboxOwnerUuid === identity.id
-        )
+    public async getUserPreference(identity: IdentityResponse): Promise<LocalizedData<UserPreference>> {
+        const grant = (await this.getGrants()).find((lockbox) => lockbox.lockboxOwnerUuid === identity.id)
 
         if (!grant) throw MissingGrant
 
@@ -1358,9 +1155,7 @@ export class OroClient {
      * @param consultationId The related consultationId
      * @returns the user preference
      */
-    public async getRecoveryDataFromConsultId(
-        consultationId: string
-    ): Promise<LocalizedData<RecoveryData>> {
+    public async getRecoveryDataFromConsultId(consultationId: string): Promise<LocalizedData<RecoveryData>> {
         const grant = await this.getGrantFromConsultId(consultationId)
 
         if (!grant) throw MissingGrant
@@ -1376,12 +1171,8 @@ export class OroClient {
      * @param identity The identity to use
      * @returns the user preference
      */
-    public async getRecoveryData(
-        identity: IdentityResponse
-    ): Promise<LocalizedData<RecoveryData>> {
-        const grant = (await this.getGrants()).find(
-            (lockbox) => lockbox.lockboxOwnerUuid === identity.id
-        )
+    public async getRecoveryData(identity: IdentityResponse): Promise<LocalizedData<RecoveryData>> {
+        const grant = (await this.getGrants()).find((lockbox) => lockbox.lockboxOwnerUuid === identity.id)
 
         if (!grant) throw MissingGrant
 
@@ -1401,10 +1192,7 @@ export class OroClient {
      *  @param practiceUuid the uuid of the practice to look consult into
      * @returns the list of consults
      */
-    public async getAssignedConsultations(
-        practiceUuid: Uuid,
-        forceRefresh: boolean = false
-    ): Promise<Consult[]> {
+    public async getAssignedConsultations(practiceUuid: Uuid, forceRefresh: boolean = false): Promise<Consult[]> {
         return Promise.all(
             (await this.getGrants(undefined, forceRefresh)).map((grant) =>
                 this.getLockboxManifest(
@@ -1420,10 +1208,7 @@ export class OroClient {
                     Promise.all(
                         manifest.map(
                             async (entry) =>
-                                await this.consultClient.getConsultByUUID(
-                                    entry.metadata.consultationId,
-                                    practiceUuid
-                                )
+                                await this.consultClient.getConsultByUUID(entry.metadata.consultationId, practiceUuid)
                         )
                     ).then((promise) => promise.flat())
                 )
@@ -1456,19 +1241,13 @@ export class OroClient {
             )
         )
             .flat()
-            .map(
-                (metadata: { consultationId: string }) =>
-                    metadata.consultationId
-            )
+            .map((metadata: { consultationId: string }) => metadata.consultationId)
 
         if (consultationsInLockbox.length == 0) return []
 
         return await Promise.all(
             consultationsInLockbox.map(async (consultId: string) => {
-                return await this.consultClient.getConsultByUUID(
-                    consultId,
-                    practiceUuid
-                )
+                return await this.consultClient.getConsultByUUID(consultId, practiceUuid)
             })
         )
     }
@@ -1518,9 +1297,7 @@ export class OroClient {
      * @param consultationId
      * @returns
      */
-    public async getPatientPrescriptionsList(
-        consultationId: Uuid
-    ): Promise<Document[]> {
+    public async getPatientPrescriptionsList(consultationId: Uuid): Promise<Document[]> {
         return this.getPatientDocumentsList(
             {
                 category: MetadataCategory.Consultation,
@@ -1536,9 +1313,7 @@ export class OroClient {
      * @param consultationId
      * @returns
      */
-    public async getPatientResultsList(
-        consultationId: Uuid
-    ): Promise<Document[]> {
+    public async getPatientResultsList(consultationId: Uuid): Promise<Document[]> {
         return this.getPatientDocumentsList(
             {
                 category: MetadataCategory.Consultation,
@@ -1554,9 +1329,7 @@ export class OroClient {
      * @param consultationId
      * @returns Document[] corresponding to the patient treatment plan options
      */
-    public async getPatientTreatmentPlans(
-        consultationId: Uuid
-    ): Promise<Document[]> {
+    public async getPatientTreatmentPlans(consultationId: Uuid): Promise<Document[]> {
         return this.getPatientDocumentsList(
             {
                 category: MetadataCategory.Consultation,
@@ -1573,10 +1346,7 @@ export class OroClient {
      * @param treatmentPlanId
      * @returns
      */
-    public async getPatientTreatmentPlanByUuid(
-        consultationId: Uuid,
-        treatmentPlanId: Uuid
-    ): Promise<Document[]> {
+    public async getPatientTreatmentPlanByUuid(consultationId: Uuid, treatmentPlanId: Uuid): Promise<Document[]> {
         return this.getPatientDocumentsList(
             {
                 category: MetadataCategory.Consultation,
@@ -1613,16 +1383,13 @@ export class OroClient {
                         true
                     ).then((manifest) =>
                         Promise.all(
-                            manifest.map(
-                                async (entry): Promise<Document> => {
-                                    return {
-                                        lockboxOwnerUuid:
-                                            grant.lockboxOwnerUuid,
-                                        lockboxUuid: grant.lockboxUuid!,
-                                        ...entry,
-                                    }
+                            manifest.map(async (entry): Promise<Document> => {
+                                return {
+                                    lockboxOwnerUuid: grant.lockboxOwnerUuid,
+                                    lockboxUuid: grant.lockboxUuid!,
+                                    ...entry,
                                 }
-                            )
+                            })
                         )
                     )
                 )
@@ -1648,34 +1415,23 @@ export class OroClient {
         recoverySecurityAnswers: string[],
         threshold: number
     ) {
-        let shards: SecretShard[] = (await this.guardClient.identityGet(id))
-            .recoverySecurityQuestions
+        let shards: SecretShard[] = (await this.guardClient.identityGet(id)).recoverySecurityQuestions
         let answeredShards = shards
             .filter((shard: any) => {
                 // filters all answered security questions
-                let indexOfQuestion = recoverySecurityQuestions.indexOf(
-                    shard.securityQuestion
-                )
+                let indexOfQuestion = recoverySecurityQuestions.indexOf(shard.securityQuestion)
                 if (indexOfQuestion === -1) return false
-                return (
-                    recoverySecurityAnswers[indexOfQuestion] &&
-                    recoverySecurityAnswers[indexOfQuestion] != ''
-                )
+                return recoverySecurityAnswers[indexOfQuestion] && recoverySecurityAnswers[indexOfQuestion] != ''
             })
             .map((item: any) => {
                 // appends the security answer to the answered shards
-                let index = recoverySecurityQuestions.indexOf(
-                    item.securityQuestion
-                )
+                let index = recoverySecurityQuestions.indexOf(item.securityQuestion)
                 item.securityAnswer = recoverySecurityAnswers[index]
                 return item
             })
         try {
             // reconstructs the key from the answered security answers
-            let privateKey = this.toolbox.reconstructSecret(
-                answeredShards,
-                threshold
-            )
+            let privateKey = this.toolbox.reconstructSecret(answeredShards, threshold)
             this.rsa = this.toolbox.CryptoRSA.fromKey(privateKey)
         } catch (e) {
             console.error(e)
@@ -1692,18 +1448,12 @@ export class OroClient {
         let identity = await this.guardClient.identityGet(id)
 
         let recoveryPayload = identity.recoveryPassword
-        let symmetricDecryptor = this.toolbox.CryptoChaCha.fromPassphrase(
-            password
-        )
-        let privateKey = symmetricDecryptor.base64PayloadDecryptToBytes(
-            recoveryPayload
-        )
+        let symmetricDecryptor = this.toolbox.CryptoChaCha.fromPassphrase(password)
+        let privateKey = symmetricDecryptor.base64PayloadDecryptToBytes(recoveryPayload)
 
         if (identity.recoveryLogin) {
             //Ensure we can recover from a page reload
-            let symetricEncryptor = this.toolbox.CryptoChaCha.fromPassphrase(
-                identity.recoveryLogin
-            )
+            let symetricEncryptor = this.toolbox.CryptoChaCha.fromPassphrase(identity.recoveryLogin)
             sessionStorage.setItem(
                 sessionStorePrivateKeyName(id),
                 symetricEncryptor.bytesEncryptToBase64Payload(privateKey)
@@ -1720,14 +1470,9 @@ export class OroClient {
      * @param masterKey
      */
     public async recoverPrivateKeyFromMasterKey(id: Uuid, masterKey: string) {
-        let recoveryPayload = (await this.guardClient.identityGet(id))
-            .recoveryMasterKey
-        let symmetricDecryptor = this.toolbox.CryptoChaCha.fromPassphrase(
-            masterKey
-        )
-        let privateKey = symmetricDecryptor.base64PayloadDecryptToBytes(
-            recoveryPayload
-        )
+        let recoveryPayload = (await this.guardClient.identityGet(id)).recoveryMasterKey
+        let symmetricDecryptor = this.toolbox.CryptoChaCha.fromPassphrase(masterKey)
+        let privateKey = symmetricDecryptor.base64PayloadDecryptToBytes(recoveryPayload)
         this.rsa = this.toolbox.CryptoRSA.fromKey(privateKey)
     }
 
@@ -1770,28 +1515,16 @@ export class OroClient {
      * @param newPassword
      * @param oldPassword
      */
-    public async updatePassword(
-        id: Uuid,
-        newPassword: string,
-        oldPassword?: string
-    ) {
+    public async updatePassword(id: Uuid, newPassword: string, oldPassword?: string) {
         if (!this.rsa) throw IncompleteAuthentication
 
-        let symmetricEncryptor = this.toolbox.CryptoChaCha.fromPassphrase(
-            newPassword
-        )
-        let passwordPayload = symmetricEncryptor.bytesEncryptToBase64Payload(
-            this.rsa.private()
-        )
+        let symmetricEncryptor = this.toolbox.CryptoChaCha.fromPassphrase(newPassword)
+        let passwordPayload = symmetricEncryptor.bytesEncryptToBase64Payload(this.rsa.private())
         if (oldPassword) {
-            oldPassword = this.toolbox.hashStringToBase64(
-                this.toolbox.hashStringToBase64(oldPassword)
-            )
+            oldPassword = this.toolbox.hashStringToBase64(this.toolbox.hashStringToBase64(oldPassword))
         }
 
-        newPassword = this.toolbox.hashStringToBase64(
-            this.toolbox.hashStringToBase64(newPassword)
-        )
+        newPassword = this.toolbox.hashStringToBase64(this.toolbox.hashStringToBase64(newPassword))
 
         let updateRequest = {
             password: {
@@ -1815,17 +1548,10 @@ export class OroClient {
     async updateMasterKey(id: Uuid, masterKey: string, lockboxUuid: Uuid) {
         if (!this.rsa) throw IncompleteAuthentication
 
-        let symmetricEncryptor = this.toolbox.CryptoChaCha.fromPassphrase(
-            masterKey
-        )
-        let masterKeyPayload = symmetricEncryptor.bytesEncryptToBase64Payload(
-            this.rsa.private()
-        )
+        let symmetricEncryptor = this.toolbox.CryptoChaCha.fromPassphrase(masterKey)
+        let masterKeyPayload = symmetricEncryptor.bytesEncryptToBase64Payload(this.rsa.private())
         let updateRequest = { recoveryMasterKey: masterKeyPayload }
-        const updatedIdentity = await this.guardClient.identityUpdate(
-            id,
-            updateRequest
-        )
+        const updatedIdentity = await this.guardClient.identityUpdate(id, updateRequest)
 
         await this.getOrInsertJsonData<RecoveryMeta>(
             lockboxUuid,