feat(api): add accepting invites to workspace

packages/api/src/Domain/Client/Workspace/WorkspaceApiOperations.ts

@@ -1,4 +1,5 @@
 export enum WorkspaceApiOperations {
   Creating,
   Inviting,
+  Accepting,
 }

packages/api/src/Domain/Client/Workspace/WorkspaceApiService.spec.ts

@@ -1,6 +1,7 @@
 import { WorkspaceType } from '@standardnotes/common'
-import { WorkspaceInvitationResponse } from '../../Response'
 import { WorkspaceCreationResponse } from '../../Response/Workspace/WorkspaceCreationResponse'
+import { WorkspaceInvitationAcceptingResponse } from '../../Response/Workspace/WorkspaceInvitationAcceptingResponse'
+import { WorkspaceInvitationResponse } from '../../Response/Workspace/WorkspaceInvitationResponse'
 import { WorkspaceServerInterface } from '../../Server/Workspace/WorkspaceServerInterface'
 
 import { WorkspaceApiOperations } from './WorkspaceApiOperations'
@@ -19,6 +20,9 @@ describe('WorkspaceApiService', () => {
     workspaceServer.inviteToWorkspace = jest.fn().mockReturnValue({
       data: { uuid: 'i-1-2-3' },
     } as jest.Mocked<WorkspaceInvitationResponse>)
+    workspaceServer.acceptInvite = jest.fn().mockReturnValue({
+      data: { success: true },
+    } as jest.Mocked<WorkspaceInvitationAcceptingResponse>)
   })
 
   it('should create a workspace', async () => {
@@ -136,4 +140,66 @@ describe('WorkspaceApiService', () => {
 
     expect(error).not.toBeNull()
   })
+
+  it('should accept invite to a workspace', async () => {
+    const response = await createService().acceptInvite({
+      userUuid: 'u-1-2-3',
+      inviteUuid: 'i-1-2-3',
+      publicKey: 'foo',
+      encryptedPrivateKey: 'bar',
+    })
+
+    expect(response).toEqual({
+      data: {
+        success: true,
+      },
+    })
+    expect(workspaceServer.acceptInvite).toHaveBeenCalledWith({
+      userUuid: 'u-1-2-3',
+      inviteUuid: 'i-1-2-3',
+      publicKey: 'foo',
+      encryptedPrivateKey: 'bar',
+    })
+  })
+
+  it('should not accept invite to a workspace if it is already accepting', async () => {
+    const service = createService()
+    Object.defineProperty(service, 'operationsInProgress', {
+      get: () => new Map([[WorkspaceApiOperations.Accepting, true]]),
+    })
+
+    let error = null
+    try {
+      await service.acceptInvite({
+        userUuid: 'u-1-2-3',
+        inviteUuid: 'i-1-2-3',
+        publicKey: 'foo',
+        encryptedPrivateKey: 'bar',
+      })
+    } catch (caughtError) {
+      error = caughtError
+    }
+
+    expect(error).not.toBeNull()
+  })
+
+  it('should not accept invite to a workspace if the server fails', async () => {
+    workspaceServer.acceptInvite = jest.fn().mockImplementation(() => {
+      throw new Error('Oops')
+    })
+
+    let error = null
+    try {
+      await createService().acceptInvite({
+        userUuid: 'u-1-2-3',
+        inviteUuid: 'i-1-2-3',
+        publicKey: 'foo',
+        encryptedPrivateKey: 'bar',
+      })
+    } catch (caughtError) {
+      error = caughtError
+    }
+
+    expect(error).not.toBeNull()
+  })
 })

packages/api/src/Domain/Client/Workspace/WorkspaceApiService.ts

@@ -3,13 +3,13 @@ import { Uuid, WorkspaceType } from '@standardnotes/common'
 import { ErrorMessage } from '../../Error/ErrorMessage'
 import { ApiCallError } from '../../Error/ApiCallError'
 import { WorkspaceCreationResponse } from '../../Response/Workspace/WorkspaceCreationResponse'
+import { WorkspaceInvitationAcceptingResponse } from '../../Response/Workspace/WorkspaceInvitationAcceptingResponse'
+import { WorkspaceInvitationResponse } from '../../Response/Workspace/WorkspaceInvitationResponse'
 import { WorkspaceServerInterface } from '../../Server/Workspace/WorkspaceServerInterface'
 
 import { WorkspaceApiServiceInterface } from './WorkspaceApiServiceInterface'
 import { WorkspaceApiOperations } from './WorkspaceApiOperations'
 
-import { WorkspaceInvitationResponse } from '../../Response'
-
 export class WorkspaceApiService implements WorkspaceApiServiceInterface {
   private operationsInProgress: Map<WorkspaceApiOperations, boolean>
 
@@ -17,12 +17,32 @@ export class WorkspaceApiService implements WorkspaceApiServiceInterface {
     this.operationsInProgress = new Map()
   }
 
-  async inviteToWorkspace(dto: { inviteeEmail: string; workspaceUuid: Uuid }): Promise<WorkspaceInvitationResponse> {
-    if (this.operationsInProgress.get(WorkspaceApiOperations.Inviting)) {
-      throw new ApiCallError(ErrorMessage.GenericInProgress)
-    }
+  async acceptInvite(dto: {
+    inviteUuid: string
+    userUuid: string
+    publicKey: string
+    encryptedPrivateKey: string
+  }): Promise<WorkspaceInvitationAcceptingResponse> {
+    this.lockOperation(WorkspaceApiOperations.Accepting)
 
-    this.operationsInProgress.set(WorkspaceApiOperations.Inviting, true)
+    try {
+      const response = await this.workspaceServer.acceptInvite({
+        encryptedPrivateKey: dto.encryptedPrivateKey,
+        publicKey: dto.publicKey,
+        inviteUuid: dto.inviteUuid,
+        userUuid: dto.userUuid,
+      })
+
+      this.unlockOperation(WorkspaceApiOperations.Accepting)
+
+      return response
+    } catch (error) {
+      throw new ApiCallError(ErrorMessage.GenericFail)
+    }
+  }
+
+  async inviteToWorkspace(dto: { inviteeEmail: string; workspaceUuid: Uuid }): Promise<WorkspaceInvitationResponse> {
+    this.lockOperation(WorkspaceApiOperations.Inviting)
 
     try {
       const response = await this.workspaceServer.inviteToWorkspace({
@@ -30,7 +50,7 @@ export class WorkspaceApiService implements WorkspaceApiServiceInterface {
         workspaceUuid: dto.workspaceUuid,
       })
 
-      this.operationsInProgress.set(WorkspaceApiOperations.Inviting, false)
+      this.unlockOperation(WorkspaceApiOperations.Inviting)
 
       return response
     } catch (error) {
@@ -45,11 +65,7 @@ export class WorkspaceApiService implements WorkspaceApiServiceInterface {
     publicKey?: string
     workspaceName?: string
   }): Promise<WorkspaceCreationResponse> {
-    if (this.operationsInProgress.get(WorkspaceApiOperations.Creating)) {
-      throw new ApiCallError(ErrorMessage.GenericInProgress)
-    }
-
-    this.operationsInProgress.set(WorkspaceApiOperations.Creating, true)
+    this.lockOperation(WorkspaceApiOperations.Creating)
 
     try {
       const response = await this.workspaceServer.createWorkspace({
@@ -60,11 +76,23 @@ export class WorkspaceApiService implements WorkspaceApiServiceInterface {
         workspaceName: dto.workspaceName,
       })
 
-      this.operationsInProgress.set(WorkspaceApiOperations.Creating, false)
+      this.unlockOperation(WorkspaceApiOperations.Creating)
 
       return response
     } catch (error) {
       throw new ApiCallError(ErrorMessage.GenericFail)
     }
   }
+
+  private lockOperation(operation: WorkspaceApiOperations): void {
+    if (this.operationsInProgress.get(operation)) {
+      throw new ApiCallError(ErrorMessage.GenericInProgress)
+    }
+
+    this.operationsInProgress.set(operation, true)
+  }
+
+  private unlockOperation(operation: WorkspaceApiOperations): void {
+    this.operationsInProgress.set(operation, false)
+  }
 }

packages/api/src/Domain/Client/Workspace/WorkspaceApiServiceInterface.ts

@@ -1,6 +1,8 @@
 import { Uuid, WorkspaceType } from '@standardnotes/common'
 
-import { WorkspaceCreationResponse, WorkspaceInvitationResponse } from '../../Response'
+import { WorkspaceCreationResponse } from '../../Response/Workspace/WorkspaceCreationResponse'
+import { WorkspaceInvitationAcceptingResponse } from '../../Response/Workspace/WorkspaceInvitationAcceptingResponse'
+import { WorkspaceInvitationResponse } from '../../Response/Workspace/WorkspaceInvitationResponse'
 
 export interface WorkspaceApiServiceInterface {
   createWorkspace(dto: {
@@ -11,4 +13,10 @@ export interface WorkspaceApiServiceInterface {
     workspaceName?: string
   }): Promise<WorkspaceCreationResponse>
   inviteToWorkspace(dto: { inviteeEmail: string; workspaceUuid: Uuid }): Promise<WorkspaceInvitationResponse>
+  acceptInvite(dto: {
+    inviteUuid: Uuid
+    userUuid: Uuid
+    publicKey: string
+    encryptedPrivateKey: string
+  }): Promise<WorkspaceInvitationAcceptingResponse>
 }