feat(workspace): add inviting to workspace

packages/workspace/src/Domain/UseCase/CreateWorkspace/CreateWorkspace.spec.ts

@@ -6,14 +6,19 @@ import { WorkspaceRepositoryInterface } from '../../Workspace/WorkspaceRepositor
 import { WorkspaceUserRepositoryInterface } from '../../Workspace/WorkspaceUserRepositoryInterface'
 
 import { CreateWorkspace } from './CreateWorkspace'
+import { TimerInterface } from '@standardnotes/time'
 
 describe('CreateWorkspace', () => {
   let workspaceRepository: WorkspaceRepositoryInterface
   let workspaceUserRepository: WorkspaceUserRepositoryInterface
+  let timer: TimerInterface
 
-  const createUseCase = () => new CreateWorkspace(workspaceRepository, workspaceUserRepository)
+  const createUseCase = () => new CreateWorkspace(workspaceRepository, workspaceUserRepository, timer)
 
   beforeEach(() => {
+    timer = {} as jest.Mocked<TimerInterface>
+    timer.getTimestampInMicroseconds = jest.fn().mockReturnValue(1)
+
     workspaceRepository = {} as jest.Mocked<WorkspaceRepositoryInterface>
     workspaceRepository.save = jest.fn().mockImplementation((workspace) => {
       return {
@@ -39,6 +44,8 @@ describe('CreateWorkspace', () => {
     expect(workspaceRepository.save).toHaveBeenCalledWith({
       name: 'A Team',
       type: 'root',
+      createdAt: 1,
+      updatedAt: 1,
     })
     expect(workspaceUserRepository.save).toHaveBeenCalledWith({
       accessLevel: 'owner',
@@ -48,6 +55,8 @@ describe('CreateWorkspace', () => {
       status: 'active',
       userUuid: '1-2-3',
       workspaceUuid: 'w-1-2-3',
+      createdAt: 1,
+      updatedAt: 1,
     })
   })
 
@@ -59,12 +68,16 @@ describe('CreateWorkspace', () => {
 
     expect(workspaceRepository.save).toHaveBeenCalledWith({
       type: 'private',
+      createdAt: 1,
+      updatedAt: 1,
     })
     expect(workspaceUserRepository.save).toHaveBeenCalledWith({
       accessLevel: 'owner',
       status: 'active',
       userUuid: '1-2-3',
       workspaceUuid: 'w-1-2-3',
+      createdAt: 1,
+      updatedAt: 1,
     })
   })
 })

packages/workspace/src/Domain/UseCase/CreateWorkspace/CreateWorkspace.ts

@@ -1,3 +1,4 @@
+import { TimerInterface } from '@standardnotes/time'
 import { inject, injectable } from 'inversify'
 
 import TYPES from '../../../Bootstrap/Types'
@@ -17,6 +18,7 @@ export class CreateWorkspace implements UseCaseInterface {
   constructor(
     @inject(TYPES.WorkspaceRepository) private workspaceRepository: WorkspaceRepositoryInterface,
     @inject(TYPES.WorkspaceUserRepository) private workspaceUserRepository: WorkspaceUserRepositoryInterface,
+    @inject(TYPES.Timer) private timer: TimerInterface,
   ) {}
 
   async execute(dto: CreateWorkspaceDTO): Promise<CreateWorkspaceResponse> {
@@ -25,6 +27,9 @@ export class CreateWorkspace implements UseCaseInterface {
       workspace.name = dto.name
     }
     workspace.type = dto.type
+    const timestamp = this.timer.getTimestampInMicroseconds()
+    workspace.createdAt = timestamp
+    workspace.updatedAt = timestamp
 
     workspace = await this.workspaceRepository.save(workspace)
 
@@ -42,6 +47,8 @@ export class CreateWorkspace implements UseCaseInterface {
     ownerAssociation.status = WorkspaceUserStatus.Active
     ownerAssociation.userUuid = dto.ownerUuid
     ownerAssociation.workspaceUuid = workspace.uuid
+    ownerAssociation.createdAt = timestamp
+    ownerAssociation.updatedAt = timestamp
 
     await this.workspaceUserRepository.save(ownerAssociation)
 

packages/workspace/src/Domain/UseCase/InviteToWorkspace/InviteToWorkspace.spec.ts

@@ -0,0 +1,45 @@
+import 'reflect-metadata'
+import { TimerInterface } from '@standardnotes/time'
+
+import { WorkspaceInviteRepositoryInterface } from '../../Invite/WorkspaceInviteRepositoryInterface'
+
+import { InviteToWorkspace } from './InviteToWorkspace'
+
+describe('InviteToWorkspace', () => {
+  let workspaceInviteRepository: WorkspaceInviteRepositoryInterface
+  let timer: TimerInterface
+
+  const createUseCase = () => new InviteToWorkspace(workspaceInviteRepository, timer)
+
+  beforeEach(() => {
+    workspaceInviteRepository = {} as jest.Mocked<WorkspaceInviteRepositoryInterface>
+    workspaceInviteRepository.save = jest.fn().mockImplementation((invite) => {
+      return {
+        ...invite,
+        uuid: 'i-1-2-3',
+      }
+    })
+
+    timer = {} as jest.Mocked<TimerInterface>
+    timer.getTimestampInMicroseconds = jest.fn().mockReturnValue(1)
+  })
+
+  it('should create an invite', async () => {
+    const result = await createUseCase().execute({
+      inviteeEmail: '[email protected]',
+      inviterUuid: 'u-1-2-3',
+      workspaceUuid: 'w-1-2-3',
+    })
+
+    expect(result).toEqual({ uuid: 'i-1-2-3' })
+
+    expect(workspaceInviteRepository.save).toHaveBeenCalledWith({
+      inviterUuid: 'u-1-2-3',
+      inviteeEmail: '[email protected]',
+      workspaceUuid: 'w-1-2-3',
+      status: 'created',
+      createdAt: 1,
+      updatedAt: 1,
+    })
+  })
+})

packages/workspace/src/Domain/UseCase/InviteToWorkspace/InviteToWorkspace.ts

@@ -0,0 +1,37 @@
+import { TimerInterface } from '@standardnotes/time'
+import { inject, injectable } from 'inversify'
+
+import TYPES from '../../../Bootstrap/Types'
+import { WorkspaceInvite } from '../../Invite/WorkspaceInvite'
+import { WorkspaceInviteRepositoryInterface } from '../../Invite/WorkspaceInviteRepositoryInterface'
+import { WorkspaceInviteStatus } from '../../Invite/WorkspaceInviteStatus'
+
+import { UseCaseInterface } from '../UseCaseInterface'
+import { InviteToWorkspaceDTO } from './InviteToWorkspaceDTO'
+import { InviteToWorkspaceResponse } from './InviteToWorkspaceResponse'
+
+@injectable()
+export class InviteToWorkspace implements UseCaseInterface {
+  constructor(
+    @inject(TYPES.WorkspaceInviteRepository) private workspaceInviteRepository: WorkspaceInviteRepositoryInterface,
+    @inject(TYPES.Timer) private timer: TimerInterface,
+  ) {}
+
+  async execute(dto: InviteToWorkspaceDTO): Promise<InviteToWorkspaceResponse> {
+    let invite = new WorkspaceInvite()
+    invite.inviterUuid = dto.inviterUuid
+    invite.inviteeEmail = dto.inviteeEmail
+    invite.workspaceUuid = dto.workspaceUuid
+    invite.status = WorkspaceInviteStatus.Created
+
+    const timestamp = this.timer.getTimestampInMicroseconds()
+    invite.createdAt = timestamp
+    invite.updatedAt = timestamp
+
+    invite = await this.workspaceInviteRepository.save(invite)
+
+    return {
+      uuid: invite.uuid,
+    }
+  }
+}

packages/workspace/src/Domain/UseCase/InviteToWorkspace/InviteToWorkspaceDTO.ts

@@ -0,0 +1,7 @@
+import { Uuid } from '@standardnotes/common'
+
+export type InviteToWorkspaceDTO = {
+  workspaceUuid: Uuid
+  inviterUuid: Uuid
+  inviteeEmail: string
+}

packages/workspace/src/Domain/UseCase/InviteToWorkspace/InviteToWorkspaceResponse.ts

@@ -0,0 +1,3 @@
+export type InviteToWorkspaceResponse = {
+  uuid: string
+}