Skip to content

AI-native design editor. Open-source Figma alternative.

8.3 KB
Raw Blame
import { computed, ref, shallowRef } from 'vue'

import { CloudAPIError } from '@open-pencil/cloud/client'
import type { WorkspaceMembers, WorkspaceRole } from '@open-pencil/cloud/contract'

import { homeLocation } from '@/app/home/location'

import { findCloudServer, showCloudServerOnHome } from '../servers/store'
import { cloudAPIClient, cloudConnection, refreshCloudConnection } from '../sessions/connection'

/** Why a workspace change did not go through, in terms the dialogs explain. */
export type WorkspaceFailure =
  | 'not-empty'
  | 'cleanup-pending'
  | 'already-member'
  | 'last-admin'
  | 'forbidden'
  | 'not-found'
  | 'unavailable'

function failureOf(error: unknown): WorkspaceFailure {
  if (!(error instanceof CloudAPIError)) return 'unavailable'
  if (error.code === 'not_empty') return 'not-empty'
  if (error.code === 'cleanup_pending') return 'cleanup-pending'
  if (error.code === 'already_member') return 'already-member'
  if (error.code === 'last_admin') return 'last-admin'
  if (error.status === 403) return 'forbidden'
  if (error.status === 404) return 'not-found'
  return 'unavailable'
}

function serverClient(serverId: string) {
  const server = findCloudServer(serverId)
  const discovery = server ? cloudConnection(server.id).discovery : null
  if (!server || !discovery) return null
  return { server, client: cloudAPIClient(server, discovery) }
}

// New workspace

export const newWorkspaceOpen = ref(false)
export const newWorkspaceServerId = ref<string | null>(null)
export const newWorkspaceBusy = ref(false)
export const newWorkspaceFailure = ref<WorkspaceFailure | null>(null)

export function openNewWorkspace(serverId: string): void {
  newWorkspaceServerId.value = serverId
  newWorkspaceFailure.value = null
  newWorkspaceBusy.value = false
  newWorkspaceOpen.value = true
}

/** Creates a workspace the person administers, and shows it on Home. */
export async function createWorkspace(name: string): Promise<void> {
  const target = newWorkspaceServerId.value ? serverClient(newWorkspaceServerId.value) : null
  if (!target || newWorkspaceBusy.value) return
  newWorkspaceBusy.value = true
  newWorkspaceFailure.value = null
  try {
    const workspace = await target.client.createWorkspace(name)
    await refreshCloudConnection(target.server)
    showCloudServerOnHome(target.server.id)
    homeLocation.value = { kind: 'workspace', id: workspace.id }
    newWorkspaceOpen.value = false
  } catch (error) {
    newWorkspaceFailure.value = failureOf(error)
  } finally {
    newWorkspaceBusy.value = false
  }
}

// Members

type MembersTarget = { serverId: string; workspaceId: string }
/** An invitation just sent and the link it carries. */
export type SentInvitation = { invitationId: string; link: string }

export const membersOpen = ref(false)
const membersTarget = shallowRef<MembersTarget | null>(null)
export const workspaceMembers = shallowRef<WorkspaceMembers | null>(null)
export const membersLoading = ref(false)
export const membersBusy = ref(false)
export const membersFailure = ref<WorkspaceFailure | null>(null)
/** The invitation just sent, whose link to pass on when the server sends no email. */
export const lastInvitation = ref<SentInvitation | null>(null)
/** The invitation last sent again and its new link, so its row can say so and offer the link. */
export const lastResent = ref<SentInvitation | null>(null)

/** The workspace the dialog manages, as the server last listed it to this person. */
export const membersWorkspace = computed(() => {
  const target = membersTarget.value
  if (!target) return null
  const workspace = cloudConnection(target.serverId).workspaces.find(
    (entry) => entry.id === target.workspaceId
  )
  return workspace ?? null
})

export const membersSelf = computed(() => {
  const target = membersTarget.value
  return target ? (cloudConnection(target.serverId).account?.id ?? null) : null
})

async function reload(): Promise<void> {
  const target = membersTarget.value
  const context = target ? serverClient(target.serverId) : null
  if (!target || !context) return
  try {
    workspaceMembers.value = await context.client.listWorkspaceMembers(target.workspaceId)
  } catch (error) {
    membersFailure.value = failureOf(error)
  }
}

export async function openWorkspaceMembers(serverId: string, workspaceId: string): Promise<void> {
  membersTarget.value = { serverId, workspaceId }
  workspaceMembers.value = null
  membersFailure.value = null
  lastInvitation.value = null
  lastResent.value = null
  membersOpen.value = true
  membersLoading.value = true
  await reload()
  membersLoading.value = false
}

/** Runs one change to the workspace, then lists it again; false when it was refused. */
async function change(
  action: (context: {
    client: ReturnType<typeof cloudAPIClient>
    workspaceId: string
  }) => Promise<void>
): Promise<boolean> {
  const target = membersTarget.value
  const context = target ? serverClient(target.serverId) : null
  if (!target || !context || membersBusy.value) return false
  membersBusy.value = true
  membersFailure.value = null
  try {
    await action({ client: context.client, workspaceId: target.workspaceId })
    await reload()
    return true
  } catch (error) {
    membersFailure.value = failureOf(error)
    return false
  } finally {
    membersBusy.value = false
  }
}

export function inviteToWorkspace(email: string, role: WorkspaceRole): Promise<boolean> {
  return change(async ({ client, workspaceId }) => {
    const created = await client.inviteToWorkspace(workspaceId, { email, role })
    lastInvitation.value = { invitationId: created.invitation.id, link: created.acceptanceURL }
  })
}

/** Sends an invitation again under a new link; the one sent before stops working. */
export function resendWorkspaceInvitation(invitationId: string): Promise<boolean> {
  return change(async ({ client, workspaceId }) => {
    const resent = await client.resendWorkspaceInvitation(workspaceId, invitationId)
    lastResent.value = { invitationId: resent.invitation.id, link: resent.acceptanceURL }
    // Its earlier link no longer works, so the note under the invite form goes with it.
    if (lastInvitation.value?.invitationId === invitationId) lastInvitation.value = null
  })
}

export function revokeWorkspaceInvitation(invitationId: string): Promise<boolean> {
  return change(({ client, workspaceId }) =>
    client.revokeWorkspaceInvitation(workspaceId, invitationId)
  )
}

export function changeWorkspaceRole(userId: string, role: WorkspaceRole): Promise<boolean> {
  return change(({ client, workspaceId }) =>
    client.updateWorkspaceMember(workspaceId, userId, role)
  )
}

export function removeWorkspaceMember(userId: string): Promise<boolean> {
  return change(({ client, workspaceId }) => client.removeWorkspaceMember(workspaceId, userId))
}

export async function renameWorkspace(name: string): Promise<boolean> {
  const target = membersTarget.value
  const renamed = await change(async ({ client, workspaceId }) => {
    await client.renameWorkspace(workspaceId, name)
  })
  const context = target ? serverClient(target.serverId) : null
  if (renamed && context) await refreshCloudConnection(context.server)
  return renamed
}

/** Deletes an empty workspace; Home goes back to Recent once it is gone. */
export async function deleteWorkspace(): Promise<void> {
  const target = membersTarget.value
  const context = target ? serverClient(target.serverId) : null
  if (!target || !context || membersBusy.value) return
  membersBusy.value = true
  membersFailure.value = null
  try {
    await context.client.deleteWorkspace(target.workspaceId)
    membersOpen.value = false
    await refreshCloudConnection(context.server)
  } catch (error) {
    membersFailure.value = failureOf(error)
  } finally {
    membersBusy.value = false
  }
}

/** Leaves the workspace; Home goes back to Recent once it is gone. */
export async function leaveWorkspace(): Promise<void> {
  const target = membersTarget.value
  const self = membersSelf.value
  const context = target ? serverClient(target.serverId) : null
  if (!target || !self || !context || membersBusy.value) return
  membersBusy.value = true
  membersFailure.value = null
  try {
    await context.client.removeWorkspaceMember(target.workspaceId, self)
    membersOpen.value = false
    await refreshCloudConnection(context.server)
  } catch (error) {
    membersFailure.value = failureOf(error)
  } finally {
    membersBusy.value = false
  }
}