speckle-server/packages/server/modules/workspaces/services/join.ts

import { FindEmailsByUserId } from '@/modules/core/domain/userEmails/operations'
import { EventBus } from '@/modules/shared/services/eventBus'
import {
  EnsureValidWorkspaceRoleSeat,
  GetWorkspaceWithDomains,
  UpsertWorkspaceRole
} from '@/modules/workspaces/domain/operations'
import {
  WorkspaceJoinNotAllowedError,
  WorkspaceNotDiscoverableError,
  WorkspaceNotJoinableError
} from '@/modules/workspaces/errors/workspace'
import { WorkspaceEvents } from '@/modules/workspacesCore/domain/events'
import { Roles } from '@speckle/shared'

export const joinWorkspaceFactory =
  ({
    getUserEmails,
    getWorkspaceWithDomains,
    upsertWorkspaceRole,
    emitWorkspaceEvent,
    ensureValidWorkspaceRoleSeat
  }: {
    getUserEmails: FindEmailsByUserId
    getWorkspaceWithDomains: GetWorkspaceWithDomains
    upsertWorkspaceRole: UpsertWorkspaceRole
    emitWorkspaceEvent: EventBus['emit']
    ensureValidWorkspaceRoleSeat: EnsureValidWorkspaceRoleSeat
  }) =>
  async ({ userId, workspaceId }: { userId: string; workspaceId: string }) => {
    const userEmails = await getUserEmails({ userId })
    const workspace = await getWorkspaceWithDomains({ id: workspaceId })
    if (!workspace?.discoverabilityEnabled) throw new WorkspaceNotDiscoverableError()

    const workspaceDomains = workspace.domains.filter((domain) => domain.verified)

    if (!workspaceDomains.length) throw new WorkspaceNotJoinableError()

    const matchingEmail = userEmails.find((userEmail) => {
      if (!userEmail.verified) return false
      return workspaceDomains
        .map((domain) => domain.domain)
        .includes(userEmail.email.split('@')[1])
    })

    if (!matchingEmail) throw new WorkspaceJoinNotAllowedError()

    const role = Roles.Workspace.Member

    await upsertWorkspaceRole({ userId, workspaceId, role, createdAt: new Date() })
    await ensureValidWorkspaceRoleSeat({
      userId,
      workspaceId,
      role,
      updatedByUserId: userId
    })

    await emitWorkspaceEvent({
      eventName: WorkspaceEvents.JoinedFromDiscovery,
      payload: { userId, workspaceId, role }
    })
    await emitWorkspaceEvent({
      eventName: WorkspaceEvents.RoleUpdated,
      payload: {
        acl: { userId, workspaceId, role },
        updatedByUserId: userId
      }
    })
  }