tests: vaults (#2365)

* tests: signature tests

* tests: asymmetric

* feat: delete contact use case

* chore: lint

* chore: lint

packages/services/src/Domain/VaultUser/UseCase/GetVaultContacts.ts

@@ -7,13 +7,17 @@ import { Result, UseCaseInterface } from '@standardnotes/domain-core'
 export class GetVaultContacts implements UseCaseInterface<TrustedContactInterface[]> {
   constructor(private findContact: FindContact, private getVaultUsers: GetVaultUsers) {}
 
-  async execute(sharedVaultUuid: string): Promise<Result<TrustedContactInterface[]>> {
-    const users = await this.getVaultUsers.execute({ sharedVaultUuid })
-    if (!users) {
+  async execute(dto: { sharedVaultUuid: string; readFromCache: boolean }): Promise<Result<TrustedContactInterface[]>> {
+    const users = await this.getVaultUsers.execute({
+      sharedVaultUuid: dto.sharedVaultUuid,
+      readFromCache: dto.readFromCache,
+    })
+    if (users.isFailed()) {
       return Result.fail('Failed to get vault users')
     }
 
     const contacts = users
+      .getValue()
       .map((user) => this.findContact.execute({ userUuid: user.user_uuid }))
       .map((result) => (result.isFailed() ? undefined : result.getValue()))
       .filter(isNotUndefined)

packages/services/src/Domain/VaultUser/UseCase/GetVaultUsers.ts

@@ -1,16 +1,31 @@
-import { SharedVaultUserServerHash, isErrorResponse } from '@standardnotes/responses'
+import { VaultUserCache } from './../VaultUserCache'
+import { SharedVaultUserServerHash, getErrorFromErrorResponse, isErrorResponse } from '@standardnotes/responses'
 import { SharedVaultUsersServerInterface } from '@standardnotes/api'
+import { Result, UseCaseInterface } from '@standardnotes/domain-core'
 
-export class GetVaultUsers {
-  constructor(private vaultUsersServer: SharedVaultUsersServerInterface) {}
+export class GetVaultUsers implements UseCaseInterface<SharedVaultUserServerHash[]> {
+  constructor(private vaultUsersServer: SharedVaultUsersServerInterface, private cache: VaultUserCache) {}
+
+  async execute(params: {
+    sharedVaultUuid: string
+    readFromCache: boolean
+  }): Promise<Result<SharedVaultUserServerHash[]>> {
+    if (params.readFromCache) {
+      const cachedUsers = this.cache.get(params.sharedVaultUuid)
+
+      if (cachedUsers) {
+        return Result.ok(cachedUsers)
+      }
+    }
 
-  async execute(params: { sharedVaultUuid: string }): Promise<SharedVaultUserServerHash[] | undefined> {
     const response = await this.vaultUsersServer.getSharedVaultUsers({ sharedVaultUuid: params.sharedVaultUuid })
 
     if (isErrorResponse(response)) {
-      return undefined
+      return Result.fail(getErrorFromErrorResponse(response).message)
     }
 
-    return response.data.users
+    this.cache.set(params.sharedVaultUuid, response.data.users)
+
+    return Result.ok(response.data.users)
   }
 }

packages/services/src/Domain/VaultUser/UseCase/IsVaultOwner.ts

@@ -1,7 +1,7 @@
 import { Result, SyncUseCaseInterface } from '@standardnotes/domain-core'
 import { SharedVaultListingInterface } from '@standardnotes/models'
 
-export class IsVaultAdmin implements SyncUseCaseInterface<boolean> {
+export class IsVaultOwner implements SyncUseCaseInterface<boolean> {
   execute(dto: { sharedVault: SharedVaultListingInterface; userUuid: string }): Result<boolean> {
     if (!dto.sharedVault.sharing.ownerUserUuid) {
       throw new Error(`Shared vault ${dto.sharedVault.sharing.sharedVaultUuid} does not have an owner user uuid`)

packages/services/src/Domain/VaultUser/VaultUserCache.ts

@@ -0,0 +1,15 @@
+import { SharedVaultUserServerHash } from '@standardnotes/responses'
+
+type SharedVaultUuid = string
+
+export class VaultUserCache {
+  private cache = new Map<SharedVaultUuid, SharedVaultUserServerHash[]>()
+
+  public get(sharedVaultUuid: SharedVaultUuid): SharedVaultUserServerHash[] | undefined {
+    return this.cache.get(sharedVaultUuid)
+  }
+
+  public set(sharedVaultUuid: SharedVaultUuid, users: SharedVaultUserServerHash[]): void {
+    this.cache.set(sharedVaultUuid, users)
+  }
+}

packages/services/src/Domain/VaultUser/VaultUserService.ts

@@ -11,7 +11,7 @@ import { ClientDisplayableError, SharedVaultUserServerHash, isClientDisplayableE
 import { AbstractService } from './../Service/AbstractService'
 import { VaultUserServiceEvent } from './VaultUserServiceEvent'
 import { Result } from '@standardnotes/domain-core'
-import { IsVaultAdmin } from './UseCase/IsVaultAdmin'
+import { IsVaultOwner } from './UseCase/IsVaultOwner'
 
 export class VaultUserService extends AbstractService<VaultUserServiceEvent> implements VaultUserServiceInterface {
   constructor(
@@ -19,7 +19,7 @@ export class VaultUserService extends AbstractService<VaultUserServiceEvent> imp
     private vaults: VaultServiceInterface,
     private _getVaultUsers: GetVaultUsers,
     private _removeVaultMember: RemoveVaultMember,
-    private _isVaultAdmin: IsVaultAdmin,
+    private _isVaultOwner: IsVaultOwner,
     private _getVault: GetVault,
     private _leaveVault: LeaveVault,
     eventBus: InternalEventBusInterface,
@@ -33,7 +33,7 @@ export class VaultUserService extends AbstractService<VaultUserServiceEvent> imp
     ;(this.vaults as unknown) = undefined
     ;(this._getVaultUsers as unknown) = undefined
     ;(this._removeVaultMember as unknown) = undefined
-    ;(this._isVaultAdmin as unknown) = undefined
+    ;(this._isVaultOwner as unknown) = undefined
     ;(this._getVault as unknown) = undefined
     ;(this._leaveVault as unknown) = undefined
   }
@@ -41,11 +41,19 @@ export class VaultUserService extends AbstractService<VaultUserServiceEvent> imp
   public async getSharedVaultUsers(
     sharedVault: SharedVaultListingInterface,
   ): Promise<SharedVaultUserServerHash[] | undefined> {
-    return this._getVaultUsers.execute({ sharedVaultUuid: sharedVault.sharing.sharedVaultUuid })
+    const result = await this._getVaultUsers.execute({
+      sharedVaultUuid: sharedVault.sharing.sharedVaultUuid,
+      readFromCache: false,
+    })
+    if (result.isFailed()) {
+      return undefined
+    }
+
+    return result.getValue()
   }
 
   public isCurrentUserSharedVaultAdmin(sharedVault: SharedVaultListingInterface): boolean {
-    return this._isVaultAdmin
+    return this._isVaultOwner
       .execute({
         sharedVault,
         userUuid: this.session.userUuid,