refactor: break up vault services (#2364)

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

@@ -0,0 +1,23 @@
+import { GetVaultUsers } from './GetVaultUsers'
+import { TrustedContactInterface } from '@standardnotes/models'
+import { isNotUndefined } from '@standardnotes/utils'
+import { FindContact } from '../../Contacts/UseCase/FindContact'
+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) {
+      return Result.fail('Failed to get vault users')
+    }
+
+    const contacts = users
+      .map((user) => this.findContact.execute({ userUuid: user.user_uuid }))
+      .map((result) => (result.isFailed() ? undefined : result.getValue()))
+      .filter(isNotUndefined)
+
+    return Result.ok(contacts)
+  }
+}

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

@@ -0,0 +1,16 @@
+import { SharedVaultUserServerHash, isErrorResponse } from '@standardnotes/responses'
+import { SharedVaultUsersServerInterface } from '@standardnotes/api'
+
+export class GetVaultUsers {
+  constructor(private vaultUsersServer: SharedVaultUsersServerInterface) {}
+
+  async execute(params: { sharedVaultUuid: string }): Promise<SharedVaultUserServerHash[] | undefined> {
+    const response = await this.vaultUsersServer.getSharedVaultUsers({ sharedVaultUuid: params.sharedVaultUuid })
+
+    if (isErrorResponse(response)) {
+      return undefined
+    }
+
+    return response.data.users
+  }
+}

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

@@ -0,0 +1,12 @@
+import { Result, SyncUseCaseInterface } from '@standardnotes/domain-core'
+import { SharedVaultListingInterface } from '@standardnotes/models'
+
+export class IsVaultAdmin 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`)
+    }
+
+    return Result.ok(dto.sharedVault.sharing.ownerUserUuid === dto.userUuid)
+  }
+}

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

@@ -0,0 +1,34 @@
+import { ClientDisplayableError, isErrorResponse } from '@standardnotes/responses'
+import { SharedVaultUsersServerInterface } from '@standardnotes/api'
+import { DeleteThirdPartyVault } from '../../SharedVaults/UseCase/DeleteExternalSharedVault'
+import { ItemManagerInterface } from '../../Item/ItemManagerInterface'
+import { SharedVaultListingInterface } from '@standardnotes/models'
+
+export class LeaveVault {
+  constructor(
+    private vaultUserServer: SharedVaultUsersServerInterface,
+    private items: ItemManagerInterface,
+    private deleteThirdPartyVault: DeleteThirdPartyVault,
+  ) {}
+
+  async execute(params: {
+    sharedVault: SharedVaultListingInterface
+    userUuid: string
+  }): Promise<ClientDisplayableError | void> {
+    const latestVaultListing = this.items.findItem<SharedVaultListingInterface>(params.sharedVault.uuid)
+    if (!latestVaultListing) {
+      throw new Error(`LeaveVaultUseCase: Could not find vault ${params.sharedVault.uuid}`)
+    }
+
+    const response = await this.vaultUserServer.deleteSharedVaultUser({
+      sharedVaultUuid: latestVaultListing.sharing.sharedVaultUuid,
+      userUuid: params.userUuid,
+    })
+
+    if (isErrorResponse(response)) {
+      return ClientDisplayableError.FromString(`Failed to leave vault ${JSON.stringify(response)}`)
+    }
+
+    await this.deleteThirdPartyVault.execute(latestVaultListing)
+  }
+}

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

@@ -0,0 +1,20 @@
+import { getErrorFromErrorResponse, isErrorResponse } from '@standardnotes/responses'
+import { SharedVaultUsersServerInterface } from '@standardnotes/api'
+import { Result, UseCaseInterface } from '@standardnotes/domain-core'
+
+export class RemoveVaultMember implements UseCaseInterface<void> {
+  constructor(private vaultUserServer: SharedVaultUsersServerInterface) {}
+
+  async execute(params: { sharedVaultUuid: string; userUuid: string }): Promise<Result<void>> {
+    const response = await this.vaultUserServer.deleteSharedVaultUser({
+      sharedVaultUuid: params.sharedVaultUuid,
+      userUuid: params.userUuid,
+    })
+
+    if (isErrorResponse(response)) {
+      return Result.fail(getErrorFromErrorResponse(response).message)
+    }
+
+    return Result.ok()
+  }
+}