Skip to content

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

3.0 KB
Raw Blame
import type { CreateWorkspaceInput, WorkspaceSummary } from '#cloud/contract'
import type { CloudDatabase } from '#cloud/server/db'
import {
  findWorkspace,
  insertWorkspace,
  insertWorkspaceMember,
  listWorkspaces
} from '#cloud/server/workspaces/repository'
import type { Kysely } from 'kysely'

export class WorkspaceSlugConflictError extends Error {
  constructor(readonly slug: string) {
    super(`Workspace slug is already in use: ${slug}`)
    this.name = 'WorkspaceSlugConflictError'
  }
}

function fallbackSlug(name: string): string {
  const normalized = name
    .toLowerCase()
    .normalize('NFKD')
    .replace(/[\u0300-\u036f]/g, '')
    .replace(/[^a-z0-9]+/g, '-')
    .replace(/^-|-$/g, '')
    .slice(0, 48)
  return normalized.length >= 3 ? normalized : 'workspace'
}

function generatedSlug(name: string): string {
  return `${fallbackSlug(name)}-${crypto.randomUUID().slice(0, 8)}`
}

function personalWorkspaceName(name: string): string {
  const first = name.trim().split(/\s+/)[0]
  return first ? `${first}’s workspace` : 'Personal workspace'
}

export function createWorkspaceService(database: Kysely<CloudDatabase>) {
  return {
    list(userId: string): Promise<WorkspaceSummary[]> {
      return listWorkspaces(database, userId)
    },

    get(userId: string, workspaceId: string): Promise<WorkspaceSummary | undefined> {
      return findWorkspace(database, userId, workspaceId)
    },

    async create(userId: string, input: CreateWorkspaceInput): Promise<WorkspaceSummary> {
      const workspaceId = crypto.randomUUID()
      const slug = input.slug ?? generatedSlug(input.name)
      await database.transaction().execute(async (transaction) => {
        const inserted = await insertWorkspace(transaction, userId, {
          ...input,
          id: workspaceId,
          slug
        })
        if (!inserted) throw new WorkspaceSlugConflictError(slug)
        await insertWorkspaceMember(transaction, workspaceId, userId, 'admin')
      })
      const workspace = await findWorkspace(database, userId, workspaceId)
      if (!workspace) throw new Error('Created workspace could not be read')
      return workspace
    },

    /**
     * Gives an active account with no workspace one of its own, so it has somewhere to save. The
     * slug is fixed per person, so concurrent calls make one workspace and later calls none.
     */
    async ensurePersonal(user: { userId: string; name: string }): Promise<void> {
      if ((await listWorkspaces(database, user.userId)).length > 0) return
      const workspaceId = crypto.randomUUID()
      await database.transaction().execute(async (transaction) => {
        const inserted = await insertWorkspace(transaction, user.userId, {
          id: workspaceId,
          name: personalWorkspaceName(user.name),
          slug: `personal-${user.userId}`
        })
        if (inserted) await insertWorkspaceMember(transaction, workspaceId, user.userId, 'admin')
      })
    }
  }
}

export type WorkspaceService = ReturnType<typeof createWorkspaceService>