chore: fix handling failures upon shared vault invite accepting

packages/services/src/Domain/VaultInvite/UseCase/AcceptVaultInvite.ts

@@ -1,9 +1,11 @@
 import { AsymmetricMessageSharedVaultInvite } from '@standardnotes/models'
 import { SharedVaultInvitesServerInterface } from '@standardnotes/api'
-import { SharedVaultInviteServerHash } from '@standardnotes/responses'
+import { SharedVaultInviteServerHash, getErrorFromErrorResponse, isErrorResponse } from '@standardnotes/responses'
+import { Result, UseCaseInterface } from '@standardnotes/domain-core'
+
 import { ProcessAcceptedVaultInvite } from '../../AsymmetricMessage/UseCase/ProcessAcceptedVaultInvite'
 
-export class AcceptVaultInvite {
+export class AcceptVaultInvite implements UseCaseInterface<void> {
   constructor(
     private inviteServer: SharedVaultInvitesServerInterface,
     private processInvite: ProcessAcceptedVaultInvite,
@@ -12,12 +14,17 @@ export class AcceptVaultInvite {
   async execute(dto: {
     invite: SharedVaultInviteServerHash
     message: AsymmetricMessageSharedVaultInvite
-  }): Promise<void> {
-    await this.processInvite.execute(dto.message, dto.invite.shared_vault_uuid, dto.invite.sender_uuid)
-
-    await this.inviteServer.acceptInvite({
+  }): Promise<Result<void>> {
+    const acceptResponse = await this.inviteServer.acceptInvite({
       sharedVaultUuid: dto.invite.shared_vault_uuid,
       inviteUuid: dto.invite.uuid,
     })
+    if (isErrorResponse(acceptResponse)) {
+      return Result.fail(`Could not accept vault invitation: ${getErrorFromErrorResponse(acceptResponse).message}`)
+    }
+
+    await this.processInvite.execute(dto.message, dto.invite.shared_vault_uuid, dto.invite.sender_uuid)
+
+    return Result.ok()
   }
 }

packages/services/src/Domain/VaultInvite/VaultInviteService.ts

@@ -135,12 +135,18 @@ export class VaultInviteService
     return response.data.invites
   }
 
-  public async acceptInvite(pendingInvite: InviteRecord): Promise<void> {
+  public async acceptInvite(pendingInvite: InviteRecord): Promise<Result<void>> {
     if (!pendingInvite.trusted) {
-      throw new Error('Cannot accept untrusted invite')
+      return Result.fail('Cannot accept untrusted invite')
     }
 
-    await this._acceptVaultInvite.execute({ invite: pendingInvite.invite, message: pendingInvite.message })
+    const acceptResult = await this._acceptVaultInvite.execute({
+      invite: pendingInvite.invite,
+      message: pendingInvite.message,
+    })
+    if (acceptResult.isFailed()) {
+      return Result.fail(acceptResult.getError())
+    }
 
     delete this.pendingInvites[pendingInvite.invite.uuid]
 
@@ -149,6 +155,8 @@ export class VaultInviteService
     await this._decryptErroredPayloads.execute()
 
     await this.sync.syncSharedVaultsFromScratch([pendingInvite.invite.shared_vault_uuid])
+
+    return Result.ok()
   }
 
   public async getInvitableContactsForSharedVault(

packages/services/src/Domain/VaultInvite/VaultInviteServiceInterface.ts

@@ -18,5 +18,5 @@ export interface VaultInviteServiceInterface extends ApplicationServiceInterface
   getOutboundInvites(
     sharedVault?: SharedVaultListingInterface,
   ): Promise<SharedVaultInviteServerHash[] | ClientDisplayableError>
-  acceptInvite(pendingInvite: InviteRecord): Promise<void>
+  acceptInvite(pendingInvite: InviteRecord): Promise<Result<void>>
 }

packages/web/src/javascripts/Components/Preferences/Panes/Vaults/Invites/InviteItem.tsx

@@ -23,7 +23,10 @@ const InviteItem = ({ inviteRecord }: Props) => {
   }, [])
 
   const acceptInvite = useCallback(async () => {
-    await application.vaultInvites.acceptInvite(inviteRecord)
+    const result = await application.vaultInvites.acceptInvite(inviteRecord)
+    if (result.isFailed()) {
+      await application.alerts.alert(result.getError())
+    }
   }, [application, inviteRecord])
 
   const closeAddContactModal = () => setIsAddContactModalOpen(false)