refactor: break up vault services (#2364)

2023-07-24 07:46:20 -05:00
parent f2d089ab24
commit 3281ac9d37
50 changed files with 763 additions and 633 deletions
--- a/packages/services/src/Domain/SharedVaults/PendingSharedVaultInviteRecord.ts
+++ b/packages/services/src/Domain/SharedVaults/PendingSharedVaultInviteRecord.ts
@@ -1,8 +0,0 @@
-import { AsymmetricMessageSharedVaultInvite } from '@standardnotes/models'
-import { SharedVaultInviteServerHash } from '@standardnotes/responses'
-
-export type PendingSharedVaultInviteRecord = {
-  invite: SharedVaultInviteServerHash
-  message: AsymmetricMessageSharedVaultInvite
-  trusted: boolean
-}
--- a/packages/services/src/Domain/SharedVaults/SharedVaultService.spec.ts
+++ b/packages/services/src/Domain/SharedVaults/SharedVaultService.spec.ts
@@ -1,24 +1,15 @@
+import { IsVaultAdmin } from './../VaultUser/UseCase/IsVaultAdmin'
 import { EncryptionProviderInterface } from './../Encryption/EncryptionProviderInterface'
-import { GetVaultUsers } from './UseCase/GetVaultUsers'
-import { RemoveVaultMember } from './UseCase/RemoveSharedVaultMember'
 import { DeleteSharedVault } from './UseCase/DeleteSharedVault'
 import { ConvertToSharedVault } from './UseCase/ConvertToSharedVault'
 import { ShareContactWithVault } from './UseCase/ShareContactWithVault'
 import { DeleteThirdPartyVault } from './UseCase/DeleteExternalSharedVault'
-import { LeaveVault } from './UseCase/LeaveSharedVault'
-import { InviteToVault } from './UseCase/InviteToVault'
-import { AcceptVaultInvite } from './UseCase/AcceptVaultInvite'
-import { GetVaultContacts } from './UseCase/GetVaultContacts'
-import { GetAllContacts } from './../Contacts/UseCase/GetAllContacts'
 import { FindContact } from './../Contacts/UseCase/FindContact'
-import { GetUntrustedPayload } from './../AsymmetricMessage/UseCase/GetUntrustedPayload'
-import { GetTrustedPayload } from './../AsymmetricMessage/UseCase/GetTrustedPayload'
 import { SendVaultDataChangedMessage } from './UseCase/SendVaultDataChangedMessage'
 import { NotifyVaultUsersOfKeyRotation } from './UseCase/NotifyVaultUsersOfKeyRotation'
 import { HandleKeyPairChange } from './../Contacts/UseCase/HandleKeyPairChange'
 import { CreateSharedVault } from './UseCase/CreateSharedVault'
 import { GetVault } from './../Vaults/UseCase/GetVault'
-import { SharedVaultInvitesServer } from '@standardnotes/api'
 import { SharedVaultService } from './SharedVaultService'
 import { SyncServiceInterface } from '../Sync/SyncServiceInterface'
 import { ItemManagerInterface } from '../Item/ItemManagerInterface'
@@ -40,56 +31,37 @@ describe('SharedVaultService', () => {
    const encryption = {} as jest.Mocked<EncryptionProviderInterface>
    const session = {} as jest.Mocked<SessionsClientInterface>
    const vaults = {} as jest.Mocked<VaultServiceInterface>
-    const invitesServer = {} as jest.Mocked<SharedVaultInvitesServer>
    const getVault = {} as jest.Mocked<GetVault>
    const createSharedVaultUseCase = {} as jest.Mocked<CreateSharedVault>
    const handleKeyPairChange = {} as jest.Mocked<HandleKeyPairChange>
    const notifyVaultUsersOfKeyRotation = {} as jest.Mocked<NotifyVaultUsersOfKeyRotation>
    const sendVaultDataChangeMessage = {} as jest.Mocked<SendVaultDataChangedMessage>
-    const getTrustedPayload = {} as jest.Mocked<GetTrustedPayload>
-    const getUntrustedPayload = {} as jest.Mocked<GetUntrustedPayload>
    const findContact = {} as jest.Mocked<FindContact>
-    const getAllContacts = {} as jest.Mocked<GetAllContacts>
-    const getVaultContacts = {} as jest.Mocked<GetVaultContacts>
-    const acceptVaultInvite = {} as jest.Mocked<AcceptVaultInvite>
-    const inviteToVault = {} as jest.Mocked<InviteToVault>
-    const leaveVault = {} as jest.Mocked<LeaveVault>
    const deleteThirdPartyVault = {} as jest.Mocked<DeleteThirdPartyVault>
    const shareContactWithVault = {} as jest.Mocked<ShareContactWithVault>
    const convertToSharedVault = {} as jest.Mocked<ConvertToSharedVault>
    const deleteSharedVaultUseCase = {} as jest.Mocked<DeleteSharedVault>
-    const removeVaultMember = {} as jest.Mocked<RemoveVaultMember>
-    const getSharedVaultUsersUseCase = {} as jest.Mocked<GetVaultUsers>
+    const isVaultAdmin = {} as jest.Mocked<IsVaultAdmin>

    const eventBus = {} as jest.Mocked<InternalEventBusInterface>
    eventBus.addEventHandler = jest.fn()

    service = new SharedVaultService(
-      sync,
      items,
      encryption,
      session,
      vaults,
-      invitesServer,
      getVault,
      createSharedVaultUseCase,
      handleKeyPairChange,
      notifyVaultUsersOfKeyRotation,
      sendVaultDataChangeMessage,
-      getTrustedPayload,
-      getUntrustedPayload,
      findContact,
-      getAllContacts,
-      getVaultContacts,
-      acceptVaultInvite,
-      inviteToVault,
-      leaveVault,
      deleteThirdPartyVault,
      shareContactWithVault,
      convertToSharedVault,
      deleteSharedVaultUseCase,
-      removeVaultMember,
-      getSharedVaultUsersUseCase,
+      isVaultAdmin,
      eventBus,
    )
  })
--- a/packages/services/src/Domain/SharedVaults/SharedVaultService.ts
+++ b/packages/services/src/Domain/SharedVaults/SharedVaultService.ts
@@ -1,114 +1,70 @@
 import { UserKeyPairChangedEventData } from './../Session/UserKeyPairChangedEventData'
-import { InviteToVault } from './UseCase/InviteToVault'
-import {
-  ClientDisplayableError,
-  SharedVaultInviteServerHash,
-  isErrorResponse,
-  SharedVaultUserServerHash,
-  isClientDisplayableError,
-  SharedVaultPermission,
-  UserEventType,
-} from '@standardnotes/responses'
-import { SharedVaultInvitesServer } from '@standardnotes/api'
+import { ClientDisplayableError, UserEventType } from '@standardnotes/responses'
 import {
  DecryptedItemInterface,
  PayloadEmitSource,
  TrustedContactInterface,
  SharedVaultListingInterface,
  VaultListingInterface,
-  AsymmetricMessageSharedVaultInvite,
  KeySystemRootKeyStorageMode,
 } from '@standardnotes/models'
 import { SharedVaultServiceInterface } from './SharedVaultServiceInterface'
 import { SharedVaultServiceEvent, SharedVaultServiceEventPayload } from './SharedVaultServiceEvent'
-import { GetVaultUsers } from './UseCase/GetVaultUsers'
-import { RemoveVaultMember } from './UseCase/RemoveSharedVaultMember'
 import { AbstractService } from '../Service/AbstractService'
 import { InternalEventHandlerInterface } from '../Internal/InternalEventHandlerInterface'
-import { SyncServiceInterface } from '../Sync/SyncServiceInterface'
 import { ItemManagerInterface } from '../Item/ItemManagerInterface'
 import { SessionsClientInterface } from '../Session/SessionsClientInterface'
 import { InternalEventBusInterface } from '../Internal/InternalEventBusInterface'
-import { SyncEvent, SyncEventReceivedSharedVaultInvitesData } from '../Event/SyncEvent'
+import { SyncEvent } from '../Event/SyncEvent'
 import { SessionEvent } from '../Session/SessionEvent'
 import { InternalEventInterface } from '../Internal/InternalEventInterface'
-import { LeaveVault } from './UseCase/LeaveSharedVault'
 import { VaultServiceInterface } from '../Vaults/VaultServiceInterface'
 import { UserEventServiceEvent, UserEventServiceEventPayload } from '../UserEvent/UserEventServiceEvent'
 import { DeleteThirdPartyVault } from './UseCase/DeleteExternalSharedVault'
 import { DeleteSharedVault } from './UseCase/DeleteSharedVault'
 import { VaultServiceEvent, VaultServiceEventPayload } from '../Vaults/VaultServiceEvent'
-import { AcceptVaultInvite } from './UseCase/AcceptVaultInvite'
-import { GetTrustedPayload } from '../AsymmetricMessage/UseCase/GetTrustedPayload'
-import { PendingSharedVaultInviteRecord } from './PendingSharedVaultInviteRecord'
-import { GetUntrustedPayload } from '../AsymmetricMessage/UseCase/GetUntrustedPayload'
 import { ShareContactWithVault } from './UseCase/ShareContactWithVault'
-import { GetVaultContacts } from './UseCase/GetVaultContacts'
 import { NotifyVaultUsersOfKeyRotation } from './UseCase/NotifyVaultUsersOfKeyRotation'
 import { CreateSharedVault } from './UseCase/CreateSharedVault'
 import { SendVaultDataChangedMessage } from './UseCase/SendVaultDataChangedMessage'
 import { ConvertToSharedVault } from './UseCase/ConvertToSharedVault'
 import { GetVault } from '../Vaults/UseCase/GetVault'
-import { ContentType, Result } from '@standardnotes/domain-core'
+import { ContentType } from '@standardnotes/domain-core'
 import { HandleKeyPairChange } from '../Contacts/UseCase/HandleKeyPairChange'
 import { FindContact } from '../Contacts/UseCase/FindContact'
-import { GetAllContacts } from '../Contacts/UseCase/GetAllContacts'
 import { EncryptionProviderInterface } from '../Encryption/EncryptionProviderInterface'
+import { IsVaultAdmin } from '../VaultUser/UseCase/IsVaultAdmin'

 export class SharedVaultService
  extends AbstractService<SharedVaultServiceEvent, SharedVaultServiceEventPayload>
  implements SharedVaultServiceInterface, InternalEventHandlerInterface
 {
-  private pendingInvites: Record<string, PendingSharedVaultInviteRecord> = {}
-
  constructor(
-    private sync: SyncServiceInterface,
    private items: ItemManagerInterface,
    private encryption: EncryptionProviderInterface,
    private session: SessionsClientInterface,
    private vaults: VaultServiceInterface,
-    private invitesServer: SharedVaultInvitesServer,
-    private getVault: GetVault,
-    private createSharedVaultUseCase: CreateSharedVault,
-    private handleKeyPairChange: HandleKeyPairChange,
-    private notifyVaultUsersOfKeyRotation: NotifyVaultUsersOfKeyRotation,
-    private sendVaultDataChangeMessage: SendVaultDataChangedMessage,
-    private getTrustedPayload: GetTrustedPayload,
-    private getUntrustedPayload: GetUntrustedPayload,
-    private findContact: FindContact,
-    private getAllContacts: GetAllContacts,
-    private getVaultContacts: GetVaultContacts,
-    private acceptVaultInvite: AcceptVaultInvite,
-    private inviteToVault: InviteToVault,
-    private leaveVault: LeaveVault,
-    private deleteThirdPartyVault: DeleteThirdPartyVault,
-    private shareContactWithVault: ShareContactWithVault,
-    private convertToSharedVault: ConvertToSharedVault,
-    private deleteSharedVaultUseCase: DeleteSharedVault,
-    private removeVaultMember: RemoveVaultMember,
-    private getSharedVaultUsersUseCase: GetVaultUsers,
+    private _getVault: GetVault,
+    private _createSharedVaultUseCase: CreateSharedVault,
+    private _handleKeyPairChange: HandleKeyPairChange,
+    private _notifyVaultUsersOfKeyRotation: NotifyVaultUsersOfKeyRotation,
+    private _sendVaultDataChangeMessage: SendVaultDataChangedMessage,
+    private _findContact: FindContact,
+    private _deleteThirdPartyVault: DeleteThirdPartyVault,
+    private _shareContactWithVault: ShareContactWithVault,
+    private _convertToSharedVault: ConvertToSharedVault,
+    private _deleteSharedVaultUseCase: DeleteSharedVault,
+    private _isVaultAdmin: IsVaultAdmin,
    eventBus: InternalEventBusInterface,
  ) {
    super(eventBus)

-    eventBus.addEventHandler(this, SessionEvent.UserKeyPairChanged)
-    eventBus.addEventHandler(this, UserEventServiceEvent.UserEventReceived)
-    eventBus.addEventHandler(this, VaultServiceEvent.VaultRootKeyRotated)
-
    this.eventDisposers.push(
-      items.addObserver<TrustedContactInterface>(
-        ContentType.TYPES.TrustedContact,
-        async ({ changed, inserted, source }) => {
-          await this.reprocessCachedInvitesTrustStatusAfterTrustedContactsChange()
-
-          if (source === PayloadEmitSource.LocalChanged && inserted.length > 0) {
-            void this.handleCreationOfNewTrustedContacts(inserted)
-          }
-          if (source === PayloadEmitSource.LocalChanged && changed.length > 0) {
-            void this.handleTrustedContactsChange(changed)
-          }
-        },
-      ),
+      items.addObserver<TrustedContactInterface>(ContentType.TYPES.TrustedContact, async ({ changed, source }) => {
+        if (source === PayloadEmitSource.LocalChanged && changed.length > 0) {
+          void this.handleTrustedContactsChange(changed)
+        }
+      }),
    )

    this.eventDisposers.push(
@@ -120,54 +76,88 @@ export class SharedVaultService
    )
  }

+  override deinit(): void {
+    super.deinit()
+    ;(this.items as unknown) = undefined
+    ;(this.encryption as unknown) = undefined
+    ;(this.session as unknown) = undefined
+    ;(this.vaults as unknown) = undefined
+    ;(this._getVault as unknown) = undefined
+    ;(this._createSharedVaultUseCase as unknown) = undefined
+    ;(this._handleKeyPairChange as unknown) = undefined
+    ;(this._notifyVaultUsersOfKeyRotation as unknown) = undefined
+    ;(this._sendVaultDataChangeMessage as unknown) = undefined
+    ;(this._findContact as unknown) = undefined
+    ;(this._deleteThirdPartyVault as unknown) = undefined
+    ;(this._shareContactWithVault as unknown) = undefined
+    ;(this._convertToSharedVault as unknown) = undefined
+    ;(this._deleteSharedVaultUseCase as unknown) = undefined
+    ;(this._isVaultAdmin as unknown) = undefined
+  }
+
  async handleEvent(event: InternalEventInterface): Promise<void> {
-    if (event.type === SessionEvent.UserKeyPairChanged) {
-      void this.invitesServer.deleteAllInboundInvites()
-
-      const eventData = event.payload as UserKeyPairChangedEventData
-
-      void this.handleKeyPairChange.execute({
-        newKeys: eventData.current,
-        previousKeys: eventData.previous,
-      })
-    } else if (event.type === UserEventServiceEvent.UserEventReceived) {
-      await this.handleUserEvent(event.payload as UserEventServiceEventPayload)
-    } else if (event.type === VaultServiceEvent.VaultRootKeyRotated) {
-      const payload = event.payload as VaultServiceEventPayload[VaultServiceEvent.VaultRootKeyRotated]
-      await this.handleVaultRootKeyRotatedEvent(payload.vault)
-    } else if (event.type === SyncEvent.ReceivedSharedVaultInvites) {
-      await this.processInboundInvites(event.payload as SyncEventReceivedSharedVaultInvitesData)
-    } else if (event.type === SyncEvent.ReceivedRemoteSharedVaults) {
-      void this.notifyCollaborationStatusChanged()
+    switch (event.type) {
+      case SessionEvent.UserKeyPairChanged: {
+        const eventData = event.payload as UserKeyPairChangedEventData
+        void this._handleKeyPairChange.execute({
+          newKeys: eventData.current,
+          previousKeys: eventData.previous,
+        })
+        break
+      }
+      case UserEventServiceEvent.UserEventReceived:
+        await this.handleUserEvent(event.payload as UserEventServiceEventPayload)
+        break
+      case VaultServiceEvent.VaultRootKeyRotated: {
+        const payload = event.payload as VaultServiceEventPayload[VaultServiceEvent.VaultRootKeyRotated]
+        await this.handleVaultRootKeyRotatedEvent(payload.vault)
+        break
+      }
+      case SyncEvent.ReceivedRemoteSharedVaults:
+        void this.notifyEventSync(SharedVaultServiceEvent.SharedVaultStatusChanged)
+        break
    }
  }

  private async handleUserEvent(event: UserEventServiceEventPayload): Promise<void> {
-    if (event.eventPayload.eventType === UserEventType.RemovedFromSharedVault) {
-      const vault = this.getVault.execute<SharedVaultListingInterface>({
-        sharedVaultUuid: event.eventPayload.sharedVaultUuid,
-      })
-      if (!vault.isFailed()) {
-        await this.deleteThirdPartyVault.execute(vault.getValue())
+    switch (event.eventPayload.eventType) {
+      case UserEventType.RemovedFromSharedVault: {
+        const vault = this._getVault.execute<SharedVaultListingInterface>({
+          sharedVaultUuid: event.eventPayload.sharedVaultUuid,
+        })
+        if (!vault.isFailed()) {
+          await this._deleteThirdPartyVault.execute(vault.getValue())
+        }
+        break
      }
-    } else if (event.eventPayload.eventType === UserEventType.SharedVaultItemRemoved) {
-      const item = this.items.findItem(event.eventPayload.itemUuid)
-      if (item) {
-        this.items.removeItemsLocally([item])
+      case UserEventType.SharedVaultItemRemoved: {
+        const item = this.items.findItem(event.eventPayload.itemUuid)
+        if (item) {
+          this.items.removeItemsLocally([item])
+        }
+        break
      }
    }
  }

+  private isCurrentUserVaultOwner(sharedVault: SharedVaultListingInterface): boolean {
+    if (!sharedVault.sharing.ownerUserUuid) {
+      throw new Error(`Shared vault ${sharedVault.sharing.sharedVaultUuid} does not have an owner user uuid`)
+    }
+
+    return sharedVault.sharing.ownerUserUuid === this.session.userUuid
+  }
+
  private async handleVaultRootKeyRotatedEvent(vault: VaultListingInterface): Promise<void> {
    if (!vault.isSharedVaultListing()) {
      return
    }

-    if (!this.isCurrentUserSharedVaultOwner(vault)) {
+    if (!this.isCurrentUserVaultOwner(vault)) {
      return
    }

-    await this.notifyVaultUsersOfKeyRotation.execute({
+    await this._notifyVaultUsersOfKeyRotation.execute({
      sharedVault: vault,
      senderUuid: this.session.getSureUser().uuid,
      keys: {
@@ -183,7 +173,7 @@ export class SharedVaultService
    userInputtedPassword: string | undefined
    storagePreference?: KeySystemRootKeyStorageMode
  }): Promise<VaultListingInterface | ClientDisplayableError> {
-    return this.createSharedVaultUseCase.execute({
+    return this._createSharedVaultUseCase.execute({
      vaultName: dto.name,
      vaultDescription: dto.description,
      userInputtedPassword: dto.userInputtedPassword,
@@ -194,11 +184,7 @@ export class SharedVaultService
  async convertVaultToSharedVault(
    vault: VaultListingInterface,
  ): Promise<SharedVaultListingInterface | ClientDisplayableError> {
-    return this.convertToSharedVault.execute({ vault })
-  }
-
-  public getCachedPendingInviteRecords(): PendingSharedVaultInviteRecord[] {
-    return Object.values(this.pendingInvites)
+    return this._convertToSharedVault.execute({ vault })
  }

  private getAllSharedVaults(): SharedVaultListingInterface[] {
@@ -206,38 +192,6 @@ export class SharedVaultService
    return vaults as SharedVaultListingInterface[]
  }

-  private findSharedVault(sharedVaultUuid: string): SharedVaultListingInterface | undefined {
-    const result = this.getVault.execute<SharedVaultListingInterface>({ sharedVaultUuid })
-    if (result.isFailed()) {
-      return undefined
-    }
-
-    return result.getValue()
-  }
-
-  public isCurrentUserSharedVaultAdmin(sharedVault: SharedVaultListingInterface): boolean {
-    if (!sharedVault.sharing.ownerUserUuid) {
-      throw new Error(`Shared vault ${sharedVault.sharing.sharedVaultUuid} does not have an owner user uuid`)
-    }
-    return sharedVault.sharing.ownerUserUuid === this.session.userUuid
-  }
-
-  public isCurrentUserSharedVaultOwner(sharedVault: SharedVaultListingInterface): boolean {
-    if (!sharedVault.sharing.ownerUserUuid) {
-      throw new Error(`Shared vault ${sharedVault.sharing.sharedVaultUuid} does not have an owner user uuid`)
-    }
-    return sharedVault.sharing.ownerUserUuid === this.session.userUuid
-  }
-
-  public isSharedVaultUserSharedVaultOwner(user: SharedVaultUserServerHash): boolean {
-    const vault = this.findSharedVault(user.shared_vault_uuid)
-    return vault != undefined && vault.sharing.ownerUserUuid === user.user_uuid
-  }
-
-  private async handleCreationOfNewTrustedContacts(_contacts: TrustedContactInterface[]): Promise<void> {
-    await this.downloadInboundInvites()
-  }
-
  private async handleTrustedContactsChange(contacts: TrustedContactInterface[]): Promise<void> {
    for (const contact of contacts) {
      if (contact.isMe) {
@@ -254,7 +208,7 @@ export class SharedVaultService
        continue
      }

-      await this.sendVaultDataChangeMessage.execute({
+      await this._sendVaultDataChangeMessage.execute({
        vault,
        senderUuid: this.session.getSureUser().uuid,
        keys: {
@@ -265,220 +219,8 @@ export class SharedVaultService
    }
  }

-  public async downloadInboundInvites(): Promise<ClientDisplayableError | SharedVaultInviteServerHash[]> {
-    const response = await this.invitesServer.getInboundUserInvites()
-
-    if (isErrorResponse(response)) {
-      return ClientDisplayableError.FromString(`Failed to get inbound user invites ${response}`)
-    }
-
-    this.pendingInvites = {}
-
-    await this.processInboundInvites(response.data.invites)
-
-    return response.data.invites
-  }
-
-  public async getOutboundInvites(
-    sharedVault?: SharedVaultListingInterface,
-  ): Promise<SharedVaultInviteServerHash[] | ClientDisplayableError> {
-    const response = await this.invitesServer.getOutboundUserInvites()
-
-    if (isErrorResponse(response)) {
-      return ClientDisplayableError.FromString(`Failed to get outbound user invites ${response}`)
-    }
-
-    if (sharedVault) {
-      return response.data.invites.filter((invite) => invite.shared_vault_uuid === sharedVault.sharing.sharedVaultUuid)
-    }
-
-    return response.data.invites
-  }
-
-  public async deleteInvite(invite: SharedVaultInviteServerHash): Promise<ClientDisplayableError | void> {
-    const response = await this.invitesServer.deleteInvite({
-      sharedVaultUuid: invite.shared_vault_uuid,
-      inviteUuid: invite.uuid,
-    })
-
-    if (isErrorResponse(response)) {
-      return ClientDisplayableError.FromString(`Failed to delete invite ${response}`)
-    }
-
-    delete this.pendingInvites[invite.uuid]
-  }
-
  public async deleteSharedVault(sharedVault: SharedVaultListingInterface): Promise<ClientDisplayableError | void> {
-    return this.deleteSharedVaultUseCase.execute({ sharedVault })
-  }
-
-  private async reprocessCachedInvitesTrustStatusAfterTrustedContactsChange(): Promise<void> {
-    const cachedInvites = this.getCachedPendingInviteRecords().map((record) => record.invite)
-
-    await this.processInboundInvites(cachedInvites)
-  }
-
-  private async processInboundInvites(invites: SharedVaultInviteServerHash[]): Promise<void> {
-    if (invites.length === 0) {
-      return
-    }
-
-    for (const invite of invites) {
-      const sender = this.findContact.execute({ userUuid: invite.sender_uuid })
-      if (!sender.isFailed()) {
-        const trustedMessage = this.getTrustedPayload.execute<AsymmetricMessageSharedVaultInvite>({
-          message: invite,
-          privateKey: this.encryption.getKeyPair().privateKey,
-          sender: sender.getValue(),
-        })
-
-        if (!trustedMessage.isFailed()) {
-          this.pendingInvites[invite.uuid] = {
-            invite,
-            message: trustedMessage.getValue(),
-            trusted: true,
-          }
-
-          continue
-        }
-      }
-
-      const untrustedMessage = this.getUntrustedPayload.execute<AsymmetricMessageSharedVaultInvite>({
-        message: invite,
-        privateKey: this.encryption.getKeyPair().privateKey,
-      })
-
-      if (!untrustedMessage.isFailed()) {
-        this.pendingInvites[invite.uuid] = {
-          invite,
-          message: untrustedMessage.getValue(),
-          trusted: false,
-        }
-      }
-    }
-
-    await this.notifyCollaborationStatusChanged()
-  }
-
-  private async notifyCollaborationStatusChanged(): Promise<void> {
-    await this.notifyEventSync(SharedVaultServiceEvent.SharedVaultStatusChanged)
-  }
-
-  async acceptPendingSharedVaultInvite(pendingInvite: PendingSharedVaultInviteRecord): Promise<void> {
-    if (!pendingInvite.trusted) {
-      throw new Error('Cannot accept untrusted invite')
-    }
-
-    await this.acceptVaultInvite.execute({ invite: pendingInvite.invite, message: pendingInvite.message })
-
-    delete this.pendingInvites[pendingInvite.invite.uuid]
-
-    void this.sync.sync()
-
-    await this.decryptErroredItemsAfterInviteAccept()
-
-    await this.sync.syncSharedVaultsFromScratch([pendingInvite.invite.shared_vault_uuid])
-  }
-
-  private async decryptErroredItemsAfterInviteAccept(): Promise<void> {
-    await this.encryption.decryptErroredPayloads()
-  }
-
-  public async getInvitableContactsForSharedVault(
-    sharedVault: SharedVaultListingInterface,
-  ): Promise<TrustedContactInterface[]> {
-    const users = await this.getSharedVaultUsers(sharedVault)
-    if (!users) {
-      return []
-    }
-
-    const contacts = this.getAllContacts.execute()
-    if (contacts.isFailed()) {
-      return []
-    }
-    return contacts.getValue().filter((contact) => {
-      const isContactAlreadyInVault = users.some((user) => user.user_uuid === contact.contactUuid)
-      return !isContactAlreadyInVault
-    })
-  }
-
-  private async getSharedVaultContacts(sharedVault: SharedVaultListingInterface): Promise<TrustedContactInterface[]> {
-    const contacts = await this.getVaultContacts.execute(sharedVault.sharing.sharedVaultUuid)
-    if (contacts.isFailed()) {
-      return []
-    }
-
-    return contacts.getValue()
-  }
-
-  async inviteContactToSharedVault(
-    sharedVault: SharedVaultListingInterface,
-    contact: TrustedContactInterface,
-    permissions: SharedVaultPermission,
-  ): Promise<Result<SharedVaultInviteServerHash>> {
-    const sharedVaultContacts = await this.getSharedVaultContacts(sharedVault)
-
-    const result = await this.inviteToVault.execute({
-      keys: {
-        encryption: this.encryption.getKeyPair(),
-        signing: this.encryption.getSigningKeyPair(),
-      },
-      senderUuid: this.session.getSureUser().uuid,
-      sharedVault,
-      recipient: contact,
-      sharedVaultContacts,
-      permissions,
-    })
-
-    void this.notifyCollaborationStatusChanged()
-
-    await this.sync.sync()
-
-    return result
-  }
-
-  async removeUserFromSharedVault(
-    sharedVault: SharedVaultListingInterface,
-    userUuid: string,
-  ): Promise<ClientDisplayableError | void> {
-    if (!this.isCurrentUserSharedVaultAdmin(sharedVault)) {
-      throw new Error('Only vault admins can remove users')
-    }
-
-    if (this.vaults.isVaultLocked(sharedVault)) {
-      throw new Error('Cannot remove user from locked vault')
-    }
-
-    const result = await this.removeVaultMember.execute({
-      sharedVaultUuid: sharedVault.sharing.sharedVaultUuid,
-      userUuid,
-    })
-    if (isClientDisplayableError(result)) {
-      return result
-    }
-
-    void this.notifyCollaborationStatusChanged()
-
-    await this.vaults.rotateVaultRootKey(sharedVault)
-  }
-
-  async leaveSharedVault(sharedVault: SharedVaultListingInterface): Promise<ClientDisplayableError | void> {
-    const result = await this.leaveVault.execute({
-      sharedVault: sharedVault,
-      userUuid: this.session.getSureUser().uuid,
-    })
-
-    if (isClientDisplayableError(result)) {
-      return result
-    }
-
-    void this.notifyCollaborationStatusChanged()
-  }
-
-  async getSharedVaultUsers(
-    sharedVault: SharedVaultListingInterface,
-  ): Promise<SharedVaultUserServerHash[] | undefined> {
-    return this.getSharedVaultUsersUseCase.execute({ sharedVaultUuid: sharedVault.sharing.sharedVaultUuid })
+    return this._deleteSharedVaultUseCase.execute({ sharedVault })
  }

  async shareContactWithVaults(contact: TrustedContactInterface): Promise<void> {
@@ -486,10 +228,17 @@ export class SharedVaultService
      throw new Error('Cannot share self contact')
    }

-    const ownedVaults = this.getAllSharedVaults().filter(this.isCurrentUserSharedVaultAdmin.bind(this))
+    const ownedVaults = this.getAllSharedVaults().filter((vault) => {
+      return this._isVaultAdmin
+        .execute({
+          sharedVault: vault,
+          userUuid: this.session.userUuid,
+        })
+        .getValue()
+    })

    for (const vault of ownedVaults) {
-      await this.shareContactWithVault.execute({
+      await this._shareContactWithVault.execute({
        keys: {
          encryption: this.encryption.getKeyPair(),
          signing: this.encryption.getSigningKeyPair(),
@@ -506,7 +255,7 @@ export class SharedVaultService
      return undefined
    }

-    const contact = this.findContact.execute({ userUuid: item.last_edited_by_uuid })
+    const contact = this._findContact.execute({ userUuid: item.last_edited_by_uuid })

    return contact.isFailed() ? undefined : contact.getValue()
  }
@@ -516,37 +265,8 @@ export class SharedVaultService
      return undefined
    }

-    const contact = this.findContact.execute({ userUuid: item.user_uuid })
+    const contact = this._findContact.execute({ userUuid: item.user_uuid })

    return contact.isFailed() ? undefined : contact.getValue()
  }
-
-  override deinit(): void {
-    super.deinit()
-    ;(this.sync as unknown) = undefined
-    ;(this.items as unknown) = undefined
-    ;(this.encryption as unknown) = undefined
-    ;(this.session as unknown) = undefined
-    ;(this.vaults as unknown) = undefined
-    ;(this.invitesServer as unknown) = undefined
-    ;(this.getVault as unknown) = undefined
-    ;(this.createSharedVaultUseCase as unknown) = undefined
-    ;(this.handleKeyPairChange as unknown) = undefined
-    ;(this.notifyVaultUsersOfKeyRotation as unknown) = undefined
-    ;(this.sendVaultDataChangeMessage as unknown) = undefined
-    ;(this.getTrustedPayload as unknown) = undefined
-    ;(this.getUntrustedPayload as unknown) = undefined
-    ;(this.findContact as unknown) = undefined
-    ;(this.getAllContacts as unknown) = undefined
-    ;(this.getVaultContacts as unknown) = undefined
-    ;(this.acceptVaultInvite as unknown) = undefined
-    ;(this.inviteToVault as unknown) = undefined
-    ;(this.leaveVault as unknown) = undefined
-    ;(this.deleteThirdPartyVault as unknown) = undefined
-    ;(this.shareContactWithVault as unknown) = undefined
-    ;(this.convertToSharedVault as unknown) = undefined
-    ;(this.deleteSharedVaultUseCase as unknown) = undefined
-    ;(this.removeVaultMember as unknown) = undefined
-    ;(this.getSharedVaultUsersUseCase as unknown) = undefined
-  }
 }
--- a/packages/services/src/Domain/SharedVaults/SharedVaultServiceInterface.ts
+++ b/packages/services/src/Domain/SharedVaults/SharedVaultServiceInterface.ts
@@ -1,9 +1,4 @@
-import {
-  ClientDisplayableError,
-  SharedVaultInviteServerHash,
-  SharedVaultUserServerHash,
-  SharedVaultPermission,
-} from '@standardnotes/responses'
+import { ClientDisplayableError } from '@standardnotes/responses'
 import {
  DecryptedItemInterface,
  TrustedContactInterface,
@@ -13,8 +8,6 @@ import {
 } from '@standardnotes/models'
 import { AbstractService } from '../Service/AbstractService'
 import { SharedVaultServiceEvent, SharedVaultServiceEventPayload } from './SharedVaultServiceEvent'
-import { PendingSharedVaultInviteRecord } from './PendingSharedVaultInviteRecord'
-import { Result } from '@standardnotes/domain-core'

 export interface SharedVaultServiceInterface
  extends AbstractService<SharedVaultServiceEvent, SharedVaultServiceEventPayload> {
@@ -25,32 +18,8 @@ export interface SharedVaultServiceInterface
    storagePreference?: KeySystemRootKeyStorageMode
  }): Promise<VaultListingInterface | ClientDisplayableError>
  deleteSharedVault(sharedVault: SharedVaultListingInterface): Promise<ClientDisplayableError | void>
-
  convertVaultToSharedVault(vault: VaultListingInterface): Promise<SharedVaultListingInterface | ClientDisplayableError>

-  inviteContactToSharedVault(
-    sharedVault: SharedVaultListingInterface,
-    contact: TrustedContactInterface,
-    permissions: SharedVaultPermission,
-  ): Promise<Result<SharedVaultInviteServerHash>>
-  removeUserFromSharedVault(
-    sharedVault: SharedVaultListingInterface,
-    userUuid: string,
-  ): Promise<ClientDisplayableError | void>
-  leaveSharedVault(sharedVault: SharedVaultListingInterface): Promise<ClientDisplayableError | void>
-  getSharedVaultUsers(sharedVault: SharedVaultListingInterface): Promise<SharedVaultUserServerHash[] | undefined>
-  isSharedVaultUserSharedVaultOwner(user: SharedVaultUserServerHash): boolean
-  isCurrentUserSharedVaultAdmin(sharedVault: SharedVaultListingInterface): boolean
-
  getItemLastEditedBy(item: DecryptedItemInterface): TrustedContactInterface | undefined
  getItemSharedBy(item: DecryptedItemInterface): TrustedContactInterface | undefined
-
-  downloadInboundInvites(): Promise<ClientDisplayableError | SharedVaultInviteServerHash[]>
-  getOutboundInvites(
-    sharedVault?: SharedVaultListingInterface,
-  ): Promise<SharedVaultInviteServerHash[] | ClientDisplayableError>
-  acceptPendingSharedVaultInvite(pendingInvite: PendingSharedVaultInviteRecord): Promise<void>
-  getCachedPendingInviteRecords(): PendingSharedVaultInviteRecord[]
-  getInvitableContactsForSharedVault(sharedVault: SharedVaultListingInterface): Promise<TrustedContactInterface[]>
-  deleteInvite(invite: SharedVaultInviteServerHash): Promise<ClientDisplayableError | void>
 }
--- a/packages/services/src/Domain/SharedVaults/UseCase/AcceptVaultInvite.ts
+++ b/packages/services/src/Domain/SharedVaults/UseCase/AcceptVaultInvite.ts
@@ -1,23 +0,0 @@
-import { AsymmetricMessageSharedVaultInvite } from '@standardnotes/models'
-import { SharedVaultInvitesServerInterface } from '@standardnotes/api'
-import { SharedVaultInviteServerHash } from '@standardnotes/responses'
-import { ProcessAcceptedVaultInvite } from '../../AsymmetricMessage/UseCase/ProcessAcceptedVaultInvite'
-
-export class AcceptVaultInvite {
-  constructor(
-    private inviteServer: SharedVaultInvitesServerInterface,
-    private processInvite: ProcessAcceptedVaultInvite,
-  ) {}
-
-  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({
-      sharedVaultUuid: dto.invite.shared_vault_uuid,
-      inviteUuid: dto.invite.uuid,
-    })
-  }
-}
--- a/packages/services/src/Domain/SharedVaults/UseCase/GetVaultContacts.ts
+++ b/packages/services/src/Domain/SharedVaults/UseCase/GetVaultContacts.ts
@@ -1,23 +0,0 @@
-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)
-  }
-}
--- a/packages/services/src/Domain/SharedVaults/UseCase/GetVaultUsers.ts
+++ b/packages/services/src/Domain/SharedVaults/UseCase/GetVaultUsers.ts
@@ -1,16 +0,0 @@
-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
-  }
-}
--- a/packages/services/src/Domain/SharedVaults/UseCase/InviteToVault.ts
+++ b/packages/services/src/Domain/SharedVaults/UseCase/InviteToVault.ts
@@ -1,135 +0,0 @@
-import { SharedVaultInviteServerHash, SharedVaultPermission } from '@standardnotes/responses'
-import {
-  TrustedContactInterface,
-  SharedVaultListingInterface,
-  AsymmetricMessagePayloadType,
-  VaultInviteDelegatedContact,
-} from '@standardnotes/models'
-import { SendVaultInvite } from './SendVaultInvite'
-import { PkcKeyPair } from '@standardnotes/sncrypto-common'
-import { EncryptMessage } from '../../Encryption/UseCase/Asymmetric/EncryptMessage'
-import { Result, UseCaseInterface } from '@standardnotes/domain-core'
-import { ShareContactWithVault } from './ShareContactWithVault'
-import { KeySystemKeyManagerInterface } from '../../KeySystem/KeySystemKeyManagerInterface'
-
-export class InviteToVault implements UseCaseInterface<SharedVaultInviteServerHash> {
-  constructor(
-    private keyManager: KeySystemKeyManagerInterface,
-    private encryptMessage: EncryptMessage,
-    private sendInvite: SendVaultInvite,
-    private shareContact: ShareContactWithVault,
-  ) {}
-
-  async execute(params: {
-    keys: {
-      encryption: PkcKeyPair
-      signing: PkcKeyPair
-    }
-    senderUuid: string
-    sharedVault: SharedVaultListingInterface
-    sharedVaultContacts: TrustedContactInterface[]
-    recipient: TrustedContactInterface
-    permissions: SharedVaultPermission
-  }): Promise<Result<SharedVaultInviteServerHash>> {
-    const createInviteResult = await this.inviteContact(params)
-
-    if (createInviteResult.isFailed()) {
-      return createInviteResult
-    }
-
-    await this.shareContactWithOtherVaultMembers({
-      contact: params.recipient,
-      senderUuid: params.senderUuid,
-      keys: params.keys,
-      sharedVault: params.sharedVault,
-    })
-
-    return createInviteResult
-  }
-
-  private async shareContactWithOtherVaultMembers(params: {
-    contact: TrustedContactInterface
-    senderUuid: string
-    keys: {
-      encryption: PkcKeyPair
-      signing: PkcKeyPair
-    }
-    sharedVault: SharedVaultListingInterface
-  }): Promise<Result<void>> {
-    const result = await this.shareContact.execute({
-      keys: params.keys,
-      senderUserUuid: params.senderUuid,
-      sharedVault: params.sharedVault,
-      contactToShare: params.contact,
-    })
-
-    return result
-  }
-
-  private async inviteContact(params: {
-    keys: {
-      encryption: PkcKeyPair
-      signing: PkcKeyPair
-    }
-    sharedVault: SharedVaultListingInterface
-    sharedVaultContacts: TrustedContactInterface[]
-    recipient: TrustedContactInterface
-    permissions: SharedVaultPermission
-  }): Promise<Result<SharedVaultInviteServerHash>> {
-    const keySystemRootKey = this.keyManager.getPrimaryKeySystemRootKey(params.sharedVault.systemIdentifier)
-    if (!keySystemRootKey) {
-      return Result.fail('Cannot invite contact; key system root key not found')
-    }
-
-    const meContact = params.sharedVaultContacts.find((contact) => contact.isMe)
-    if (!meContact) {
-      return Result.fail('Cannot invite contact; me contact not found')
-    }
-
-    const meContactContent: VaultInviteDelegatedContact = {
-      name: undefined,
-      contactUuid: meContact.contactUuid,
-      publicKeySet: meContact.publicKeySet,
-    }
-
-    const delegatedContacts: VaultInviteDelegatedContact[] = params.sharedVaultContacts
-      .filter((contact) => !contact.isMe && contact.contactUuid !== params.recipient.contactUuid)
-      .map((contact) => {
-        return {
-          name: contact.name,
-          contactUuid: contact.contactUuid,
-          publicKeySet: contact.publicKeySet,
-        }
-      })
-
-    const encryptedMessage = this.encryptMessage.execute({
-      message: {
-        type: AsymmetricMessagePayloadType.SharedVaultInvite,
-        data: {
-          recipientUuid: params.recipient.contactUuid,
-          rootKey: keySystemRootKey.content,
-          trustedContacts: [meContactContent, ...delegatedContacts],
-          metadata: {
-            name: params.sharedVault.name,
-            description: params.sharedVault.description,
-          },
-        },
-      },
-      keys: params.keys,
-      recipientPublicKey: params.recipient.publicKeySet.encryption,
-    })
-
-    if (encryptedMessage.isFailed()) {
-      return Result.fail(encryptedMessage.getError())
-    }
-
-    const createInviteResult = await this.sendInvite.execute({
-      sharedVaultUuid: params.sharedVault.sharing.sharedVaultUuid,
-      recipientUuid: params.recipient.contactUuid,
-      encryptedMessage: encryptedMessage.getValue(),
-      permissions: params.permissions,
-    })
-
-    return createInviteResult
-  }
-}
--- a/packages/services/src/Domain/SharedVaults/UseCase/LeaveSharedVault.ts
+++ b/packages/services/src/Domain/SharedVaults/UseCase/LeaveSharedVault.ts
@@ -1,34 +0,0 @@
-import { ClientDisplayableError, isErrorResponse } from '@standardnotes/responses'
-import { SharedVaultUsersServerInterface } from '@standardnotes/api'
-import { DeleteThirdPartyVault } from './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)
-  }
-}
--- a/packages/services/src/Domain/SharedVaults/UseCase/NotifyVaultUsersOfKeyRotation.ts
+++ b/packages/services/src/Domain/SharedVaults/UseCase/NotifyVaultUsersOfKeyRotation.ts
@@ -4,8 +4,8 @@ import { SharedVaultInviteServerHash, isErrorResponse } from '@standardnotes/res
 import { SendVaultKeyChangedMessage } from './SendVaultKeyChangedMessage'
 import { PkcKeyPair } from '@standardnotes/sncrypto-common'
 import { Result, UseCaseInterface } from '@standardnotes/domain-core'
-import { InviteToVault } from './InviteToVault'
-import { GetVaultContacts } from './GetVaultContacts'
+import { InviteToVault } from '../../VaultInvite/UseCase/InviteToVault'
+import { GetVaultContacts } from '../../VaultUser/UseCase/GetVaultContacts'
 import { DecryptOwnMessage } from '../../Encryption/UseCase/Asymmetric/DecryptOwnMessage'
 import { FindContact } from '../../Contacts/UseCase/FindContact'

--- a/packages/services/src/Domain/SharedVaults/UseCase/RemoveSharedVaultMember.ts
+++ b/packages/services/src/Domain/SharedVaults/UseCase/RemoveSharedVaultMember.ts
@@ -1,17 +0,0 @@
-import { ClientDisplayableError, isErrorResponse } from '@standardnotes/responses'
-import { SharedVaultUsersServerInterface } from '@standardnotes/api'
-
-export class RemoveVaultMember {
-  constructor(private vaultUserServer: SharedVaultUsersServerInterface) {}
-
-  async execute(params: { sharedVaultUuid: string; userUuid: string }): Promise<ClientDisplayableError | void> {
-    const response = await this.vaultUserServer.deleteSharedVaultUser({
-      sharedVaultUuid: params.sharedVaultUuid,
-      userUuid: params.userUuid,
-    })
-
-    if (isErrorResponse(response)) {
-      return ClientDisplayableError.FromNetworkError(response)
-    }
-  }
-}
--- a/packages/services/src/Domain/SharedVaults/UseCase/ReuploadAllInvites.ts
+++ b/packages/services/src/Domain/SharedVaults/UseCase/ReuploadAllInvites.ts
@@ -1,86 +0,0 @@
-import { SharedVaultInviteServerHash, isErrorResponse } from '@standardnotes/responses'
-import { SharedVaultInvitesServerInterface } from '@standardnotes/api'
-import { PkcKeyPair } from '@standardnotes/sncrypto-common'
-import { Result, UseCaseInterface } from '@standardnotes/domain-core'
-import { ReuploadInvite } from './ReuploadInvite'
-import { FindContact } from '../../Contacts/UseCase/FindContact'
-
-type ReuploadAllInvitesDTO = {
-  keys: {
-    encryption: PkcKeyPair
-    signing: PkcKeyPair
-  }
-  previousKeys?: {
-    encryption: PkcKeyPair
-    signing: PkcKeyPair
-  }
-}
-
-export class ReuploadAllInvites implements UseCaseInterface<void> {
-  constructor(
-    private reuploadInvite: ReuploadInvite,
-    private findContact: FindContact,
-    private inviteServer: SharedVaultInvitesServerInterface,
-  ) {}
-
-  async execute(params: ReuploadAllInvitesDTO): Promise<Result<void>> {
-    const invites = await this.getExistingInvites()
-    if (invites.isFailed()) {
-      return invites
-    }
-
-    const deleteResult = await this.deleteExistingInvites()
-    if (deleteResult.isFailed()) {
-      return deleteResult
-    }
-
-    const errors: string[] = []
-
-    for (const invite of invites.getValue()) {
-      const recipient = this.findContact.execute({ userUuid: invite.user_uuid })
-      if (recipient.isFailed()) {
-        errors.push(`Contact not found for invite ${invite.user_uuid}`)
-        continue
-      }
-
-      const result = await this.reuploadInvite.execute({
-        keys: params.keys,
-        previousKeys: params.previousKeys,
-        recipient: recipient.getValue(),
-        previousInvite: invite,
-      })
-
-      if (result.isFailed()) {
-        errors.push(result.getError())
-      }
-    }
-
-    if (errors.length > 0) {
-      return Result.fail(errors.join(', '))
-    }
-
-    return Result.ok()
-  }
-
-  private async getExistingInvites(): Promise<Result<SharedVaultInviteServerHash[]>> {
-    const response = await this.inviteServer.getOutboundUserInvites()
-
-    if (isErrorResponse(response)) {
-      return Result.fail(`Failed to get outbound user invites ${response}`)
-    }
-
-    const invites = response.data.invites
-
-    return Result.ok(invites)
-  }
-
-  private async deleteExistingInvites(): Promise<Result<void>> {
-    const response = await this.inviteServer.deleteAllOutboundInvites()
-
-    if (isErrorResponse(response)) {
-      return Result.fail(`Failed to delete existing invites ${response}`)
-    }
-
-    return Result.ok()
-  }
-}
--- a/packages/services/src/Domain/SharedVaults/UseCase/ReuploadInvite.ts
+++ b/packages/services/src/Domain/SharedVaults/UseCase/ReuploadInvite.ts
@@ -1,57 +0,0 @@
-import { DecryptOwnMessage } from './../../Encryption/UseCase/Asymmetric/DecryptOwnMessage'
-import { AsymmetricMessageSharedVaultInvite, TrustedContactInterface } from '@standardnotes/models'
-import { SharedVaultInviteServerHash } from '@standardnotes/responses'
-import { PkcKeyPair } from '@standardnotes/sncrypto-common'
-import { Result, UseCaseInterface } from '@standardnotes/domain-core'
-import { SendVaultInvite } from './SendVaultInvite'
-import { EncryptMessage } from '../../Encryption/UseCase/Asymmetric/EncryptMessage'
-
-export class ReuploadInvite implements UseCaseInterface<void> {
-  constructor(
-    private decryptOwnMessage: DecryptOwnMessage<AsymmetricMessageSharedVaultInvite>,
-    private sendInvite: SendVaultInvite,
-    private encryptMessage: EncryptMessage,
-  ) {}
-
-  async execute(params: {
-    keys: {
-      encryption: PkcKeyPair
-      signing: PkcKeyPair
-    }
-    previousKeys?: {
-      encryption: PkcKeyPair
-      signing: PkcKeyPair
-    }
-    recipient: TrustedContactInterface
-    previousInvite: SharedVaultInviteServerHash
-  }): Promise<Result<SharedVaultInviteServerHash>> {
-    const decryptedPreviousInvite = this.decryptOwnMessage.execute({
-      message: params.previousInvite.encrypted_message,
-      privateKey: params.previousKeys?.encryption.privateKey ?? params.keys.encryption.privateKey,
-      recipientPublicKey: params.recipient.publicKeySet.encryption,
-    })
-
-    if (decryptedPreviousInvite.isFailed()) {
-      return Result.fail(decryptedPreviousInvite.getError())
-    }
-
-    const encryptedMessage = this.encryptMessage.execute({
-      message: decryptedPreviousInvite.getValue(),
-      keys: params.keys,
-      recipientPublicKey: params.recipient.publicKeySet.encryption,
-    })
-
-    if (encryptedMessage.isFailed()) {
-      return Result.fail(encryptedMessage.getError())
-    }
-
-    const createInviteResult = await this.sendInvite.execute({
-      sharedVaultUuid: params.previousInvite.shared_vault_uuid,
-      recipientUuid: params.recipient.contactUuid,
-      encryptedMessage: encryptedMessage.getValue(),
-      permissions: params.previousInvite.permissions,
-    })
-
-    return createInviteResult
-  }
-}
--- a/packages/services/src/Domain/SharedVaults/UseCase/ReuploadVaultInvites.ts
+++ b/packages/services/src/Domain/SharedVaults/UseCase/ReuploadVaultInvites.ts
@@ -1,86 +0,0 @@
-import { SharedVaultListingInterface } from '@standardnotes/models'
-import { SharedVaultInviteServerHash, isErrorResponse } from '@standardnotes/responses'
-import { SharedVaultInvitesServerInterface } from '@standardnotes/api'
-import { PkcKeyPair } from '@standardnotes/sncrypto-common'
-import { Result, UseCaseInterface } from '@standardnotes/domain-core'
-import { ReuploadInvite } from './ReuploadInvite'
-import { FindContact } from '../../Contacts/UseCase/FindContact'
-
-type ReuploadVaultInvitesDTO = {
-  sharedVault: SharedVaultListingInterface
-  senderUuid: string
-  keys: {
-    encryption: PkcKeyPair
-    signing: PkcKeyPair
-  }
-}
-
-export class ReuploadVaultInvites implements UseCaseInterface<void> {
-  constructor(
-    private reuploadInvite: ReuploadInvite,
-    private findContact: FindContact,
-    private inviteServer: SharedVaultInvitesServerInterface,
-  ) {}
-
-  async execute(params: ReuploadVaultInvitesDTO): Promise<Result<void>> {
-    const existingInvites = await this.getExistingInvites(params.sharedVault.sharing.sharedVaultUuid)
-    if (existingInvites.isFailed()) {
-      return existingInvites
-    }
-
-    const deleteResult = await this.deleteExistingInvites(params.sharedVault.sharing.sharedVaultUuid)
-    if (deleteResult.isFailed()) {
-      return deleteResult
-    }
-
-    const errors: string[] = []
-
-    for (const invite of existingInvites.getValue()) {
-      const recipient = this.findContact.execute({ userUuid: invite.user_uuid })
-      if (recipient.isFailed()) {
-        errors.push(`Contact not found for invite ${invite.user_uuid}`)
-        continue
-      }
-
-      const result = await this.reuploadInvite.execute({
-        keys: params.keys,
-        recipient: recipient.getValue(),
-        previousInvite: invite,
-      })
-
-      if (result.isFailed()) {
-        errors.push(result.getError())
-      }
-    }
-
-    if (errors.length > 0) {
-      return Result.fail(errors.join(', '))
-    }
-
-    return Result.ok()
-  }
-
-  private async getExistingInvites(sharedVaultUuid: string): Promise<Result<SharedVaultInviteServerHash[]>> {
-    const response = await this.inviteServer.getOutboundUserInvites()
-
-    if (isErrorResponse(response)) {
-      return Result.fail(`Failed to get outbound user invites ${response}`)
-    }
-
-    const invites = response.data.invites
-
-    return Result.ok(invites.filter((invite) => invite.shared_vault_uuid === sharedVaultUuid))
-  }
-
-  private async deleteExistingInvites(sharedVaultUuid: string): Promise<Result<void>> {
-    const response = await this.inviteServer.deleteAllSharedVaultInvites({
-      sharedVaultUuid: sharedVaultUuid,
-    })
-
-    if (isErrorResponse(response)) {
-      return Result.fail(`Failed to delete existing invites ${response}`)
-    }
-
-    return Result.ok()
-  }
-}
--- a/packages/services/src/Domain/SharedVaults/UseCase/SendVaultDataChangedMessage.ts
+++ b/packages/services/src/Domain/SharedVaults/UseCase/SendVaultDataChangedMessage.ts
@@ -5,7 +5,7 @@ import {
  TrustedContactInterface,
 } from '@standardnotes/models'
 import { AsymmetricMessageServerHash } from '@standardnotes/responses'
-import { GetVaultUsers } from './GetVaultUsers'
+import { GetVaultUsers } from '../../VaultUser/UseCase/GetVaultUsers'
 import { PkcKeyPair } from '@standardnotes/sncrypto-common'
 import { SendMessage } from '../../AsymmetricMessage/UseCase/SendMessage'
 import { EncryptMessage } from '../../Encryption/UseCase/Asymmetric/EncryptMessage'
--- a/packages/services/src/Domain/SharedVaults/UseCase/SendVaultInvite.ts
+++ b/packages/services/src/Domain/SharedVaults/UseCase/SendVaultInvite.ts
@@ -1,32 +0,0 @@
-import {
-  SharedVaultInviteServerHash,
-  isErrorResponse,
-  SharedVaultPermission,
-  getErrorFromErrorResponse,
-} from '@standardnotes/responses'
-import { SharedVaultInvitesServerInterface } from '@standardnotes/api'
-import { Result, UseCaseInterface } from '@standardnotes/domain-core'
-
-export class SendVaultInvite implements UseCaseInterface<SharedVaultInviteServerHash> {
-  constructor(private vaultInvitesServer: SharedVaultInvitesServerInterface) {}
-
-  async execute(params: {
-    sharedVaultUuid: string
-    recipientUuid: string
-    encryptedMessage: string
-    permissions: SharedVaultPermission
-  }): Promise<Result<SharedVaultInviteServerHash>> {
-    const response = await this.vaultInvitesServer.createInvite({
-      sharedVaultUuid: params.sharedVaultUuid,
-      recipientUuid: params.recipientUuid,
-      encryptedMessage: params.encryptedMessage,
-      permissions: params.permissions,
-    })
-
-    if (isErrorResponse(response)) {
-      return Result.fail(getErrorFromErrorResponse(response).message)
-    }
-
-    return Result.ok(response.data.invite)
-  }
-}
--- a/packages/services/src/Domain/SharedVaults/UseCase/SendVaultKeyChangedMessage.ts
+++ b/packages/services/src/Domain/SharedVaults/UseCase/SendVaultKeyChangedMessage.ts
@@ -5,7 +5,7 @@ import {
  TrustedContactInterface,
 } from '@standardnotes/models'
 import { AsymmetricMessageServerHash } from '@standardnotes/responses'
-import { GetVaultUsers } from './GetVaultUsers'
+import { GetVaultUsers } from '../../VaultUser/UseCase/GetVaultUsers'
 import { PkcKeyPair } from '@standardnotes/sncrypto-common'
 import { SendMessage } from '../../AsymmetricMessage/UseCase/SendMessage'
 import { EncryptMessage } from '../../Encryption/UseCase/Asymmetric/EncryptMessage'
--- a/packages/services/src/Domain/SharedVaults/UseCase/ShareContactWithVault.ts
+++ b/packages/services/src/Domain/SharedVaults/UseCase/ShareContactWithVault.ts
@@ -8,7 +8,7 @@ import { SendMessage } from '../../AsymmetricMessage/UseCase/SendMessage'
 import { EncryptMessage } from '../../Encryption/UseCase/Asymmetric/EncryptMessage'
 import { Result, UseCaseInterface } from '@standardnotes/domain-core'
 import { FindContact } from '../../Contacts/UseCase/FindContact'
-import { GetVaultUsers } from './GetVaultUsers'
+import { GetVaultUsers } from '../../VaultUser/UseCase/GetVaultUsers'

 export class ShareContactWithVault implements UseCaseInterface<void> {
  constructor(
--- a/packages/services/src/Domain/SharedVaults/UseCase/UpdateSharedVaultInvite.ts
+++ b/packages/services/src/Domain/SharedVaults/UseCase/UpdateSharedVaultInvite.ts
@@ -1,31 +0,0 @@
-import {
-  ClientDisplayableError,
-  SharedVaultInviteServerHash,
-  isErrorResponse,
-  SharedVaultPermission,
-} from '@standardnotes/responses'
-import { SharedVaultInvitesServerInterface } from '@standardnotes/api'
-
-export class UpdateSharedVaultInviteUseCase {
-  constructor(private vaultInvitesServer: SharedVaultInvitesServerInterface) {}
-
-  async execute(params: {
-    sharedVaultUuid: string
-    inviteUuid: string
-    encryptedMessage: string
-    permissions: SharedVaultPermission
-  }): Promise<SharedVaultInviteServerHash | ClientDisplayableError> {
-    const response = await this.vaultInvitesServer.updateInvite({
-      sharedVaultUuid: params.sharedVaultUuid,
-      inviteUuid: params.inviteUuid,
-      encryptedMessage: params.encryptedMessage,
-      permissions: params.permissions,
-    })
-
-    if (isErrorResponse(response)) {
-      return ClientDisplayableError.FromNetworkError(response)
-    }
-
-    return response.data.invite
-  }
-}