feat(api): add inviting to workspace

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

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

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

@@ -1,4 +1,5 @@
 import { WorkspaceType } from '@standardnotes/common'
+import { WorkspaceInvitationResponse } from '../../Response'
 import { WorkspaceCreationResponse } from '../../Response/Workspace/WorkspaceCreationResponse'
 import { WorkspaceServerInterface } from '../../Server/Workspace/WorkspaceServerInterface'
 
@@ -15,6 +16,9 @@ describe('WorkspaceApiService', () => {
     workspaceServer.createWorkspace = jest.fn().mockReturnValue({
       data: { uuid: '1-2-3' },
     } as jest.Mocked<WorkspaceCreationResponse>)
+    workspaceServer.inviteToWorkspace = jest.fn().mockReturnValue({
+      data: { uuid: 'i-1-2-3' },
+    } as jest.Mocked<WorkspaceInvitationResponse>)
   })
 
   it('should create a workspace', async () => {
@@ -77,4 +81,58 @@ describe('WorkspaceApiService', () => {
 
     expect(error).not.toBeNull()
   })
+
+  it('should invite to a workspace', async () => {
+    const response = await createService().inviteToWorkspace({
+      workspaceUuid: 'w-1-2-3',
+      inviteeEmail: 'test@test.te'
+    })
+
+    expect(response).toEqual({
+      data: {
+        uuid: 'i-1-2-3',
+      },
+    })
+    expect(workspaceServer.inviteToWorkspace).toHaveBeenCalledWith({
+      workspaceUuid: 'w-1-2-3',
+      inviteeEmail: 'test@test.te'
+    })
+  })
+
+  it('should not invite to a workspace if it is already inviting', async () => {
+    const service = createService()
+    Object.defineProperty(service, 'operationsInProgress', {
+      get: () => new Map([[WorkspaceApiOperations.Inviting, true]]),
+    })
+
+    let error = null
+    try {
+      await service.inviteToWorkspace({
+        workspaceUuid: 'w-1-2-3',
+        inviteeEmail: 'test@test.te'
+      })
+    } catch (caughtError) {
+      error = caughtError
+    }
+
+    expect(error).not.toBeNull()
+  })
+
+  it('should not invite to a workspace if the server fails', async () => {
+    workspaceServer.inviteToWorkspace = jest.fn().mockImplementation(() => {
+      throw new Error('Oops')
+    })
+
+    let error = null
+    try {
+      await createService().inviteToWorkspace({
+        workspaceUuid: 'w-1-2-3',
+        inviteeEmail: 'test@test.te'
+      })
+    } catch (caughtError) {
+      error = caughtError
+    }
+
+    expect(error).not.toBeNull()
+  })
 })

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

@@ -1,3 +1,5 @@
+import { Uuid, WorkspaceType } from '@standardnotes/common'
+
 import { ErrorMessage } from '../../Error/ErrorMessage'
 import { ApiCallError } from '../../Error/ApiCallError'
 import { WorkspaceCreationResponse } from '../../Response/Workspace/WorkspaceCreationResponse'
@@ -6,7 +8,7 @@ import { WorkspaceServerInterface } from '../../Server/Workspace/WorkspaceServer
 import { WorkspaceApiServiceInterface } from './WorkspaceApiServiceInterface'
 import { WorkspaceApiOperations } from './WorkspaceApiOperations'
 
-import { WorkspaceType } from '@standardnotes/common'
+import { WorkspaceInvitationResponse } from '../../Response'
 
 export class WorkspaceApiService implements WorkspaceApiServiceInterface {
   private operationsInProgress: Map<WorkspaceApiOperations, boolean>
@@ -15,6 +17,27 @@ 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)
+    }
+
+    this.operationsInProgress.set(WorkspaceApiOperations.Inviting, true)
+
+    try {
+      const response = await this.workspaceServer.inviteToWorkspace({
+        inviteeEmail: dto.inviteeEmail,
+        workspaceUuid: dto.workspaceUuid,
+      })
+
+      this.operationsInProgress.set(WorkspaceApiOperations.Inviting, false)
+
+      return response
+    } catch (error) {
+      throw new ApiCallError(ErrorMessage.GenericFail)
+    }
+  }
+
   async createWorkspace(dto: {
     workspaceType: WorkspaceType,
     encryptedWorkspaceKey?: string

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

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