refactor: key rotation (#2383)

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

@@ -6,12 +6,12 @@ import { Result, UseCaseInterface } from '@standardnotes/domain-core'
 
 export class GetVaultContacts implements UseCaseInterface<TrustedContactInterface[]> {
   constructor(
-    private findContact: FindContact,
-    private getVaultUsers: GetVaultUsers,
+    private _findContact: FindContact,
+    private _getVaultUsers: GetVaultUsers,
   ) {}
 
   async execute(dto: { sharedVaultUuid: string; readFromCache: boolean }): Promise<Result<TrustedContactInterface[]>> {
-    const users = await this.getVaultUsers.execute({
+    const users = await this._getVaultUsers.execute({
       sharedVaultUuid: dto.sharedVaultUuid,
       readFromCache: dto.readFromCache,
     })
@@ -21,7 +21,7 @@ export class GetVaultContacts implements UseCaseInterface<TrustedContactInterfac
 
     const contacts = users
       .getValue()
-      .map((user) => this.findContact.execute({ userUuid: user.user_uuid }))
+      .map((user) => this._findContact.execute({ userUuid: user.user_uuid }))
       .map((result) => (result.isFailed() ? undefined : result.getValue()))
       .filter(isNotUndefined)
 

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

@@ -1,12 +1,17 @@
+import { UserServiceInterface } from './../../User/UserServiceInterface'
 import { Result, SyncUseCaseInterface } from '@standardnotes/domain-core'
 import { SharedVaultListingInterface } from '@standardnotes/models'
 
 export class IsVaultOwner implements SyncUseCaseInterface<boolean> {
-  execute(dto: { sharedVault: SharedVaultListingInterface; userUuid: string }): Result<boolean> {
+  constructor(private users: UserServiceInterface) {}
+
+  execute(dto: { sharedVault: SharedVaultListingInterface }): 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)
+    const user = this.users.sureUser
+
+    return Result.ok(dto.sharedVault.sharing.ownerUserUuid === user.uuid)
   }
 }

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

@@ -1,3 +1,4 @@
+import { UserServiceInterface } from './../../User/UserServiceInterface'
 import { ClientDisplayableError, isErrorResponse } from '@standardnotes/responses'
 import { SharedVaultUsersServerInterface } from '@standardnotes/api'
 import { DeleteThirdPartyVault } from '../../SharedVaults/UseCase/DeleteExternalSharedVault'
@@ -6,15 +7,13 @@ import { SharedVaultListingInterface } from '@standardnotes/models'
 
 export class LeaveVault {
   constructor(
+    private users: UserServiceInterface,
     private vaultUserServer: SharedVaultUsersServerInterface,
     private items: ItemManagerInterface,
-    private deleteThirdPartyVault: DeleteThirdPartyVault,
+    private _deleteThirdPartyVault: DeleteThirdPartyVault,
   ) {}
 
-  async execute(params: {
-    sharedVault: SharedVaultListingInterface
-    userUuid: string
-  }): Promise<ClientDisplayableError | void> {
+  async execute(params: { sharedVault: SharedVaultListingInterface }): 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}`)
@@ -22,13 +21,13 @@ export class LeaveVault {
 
     const response = await this.vaultUserServer.deleteSharedVaultUser({
       sharedVaultUuid: latestVaultListing.sharing.sharedVaultUuid,
-      userUuid: params.userUuid,
+      userUuid: this.users.sureUser.uuid,
     })
 
     if (isErrorResponse(response)) {
       return ClientDisplayableError.FromString(`Failed to leave vault ${JSON.stringify(response)}`)
     }
 
-    await this.deleteThirdPartyVault.execute(latestVaultListing)
+    await this._deleteThirdPartyVault.execute(latestVaultListing)
   }
 }