Skip to content

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

6.9 KB
Raw Blame
import {
  parseCreateWorkspace,
  parseCreateWorkspaceInvitation,
  parseUpdateWorkspace,
  parseUpdateWorkspaceMember
} from '#cloud/contract'
import type { CloudActor } from '#cloud/server/auth'
import type { CloudDatabase } from '#cloud/server/db'
import {
  CLOUD_RATE_LIMITS,
  createRouteRateLimiter,
  routeParamResource,
  createResourceRateLimiter
} from '#cloud/server/rate-limit'
import {
  validatedJSON,
  workspaceInvitationParams,
  workspaceMemberParams,
  workspaceParams
} from '#cloud/server/validation'
import {
  WorkspaceAlreadyMemberError,
  WorkspaceForbiddenError,
  WorkspaceLastAdminError,
  WorkspaceNotEmptyError,
  WorkspaceNotFoundError,
  type WorkspaceMemberService
} from '#cloud/server/workspaces/members'
import type { WorkspaceService } from '#cloud/server/workspaces/service'
import { WorkspaceSlugConflictError } from '#cloud/server/workspaces/service'
import { Hono, type Context } from 'hono'
import type { Kysely } from 'kysely'

export type WorkspaceRouteEnvironment = {
  Variables: {
    actor: CloudActor
  }
}

/** Runs a membership action, answering its domain errors with their HTTP codes. */
async function memberRoute<T>(context: Context, action: () => Promise<T>): Promise<T | Response> {
  try {
    return await action()
  } catch (error) {
    if (error instanceof WorkspaceNotFoundError) {
      return context.json({ error: { code: 'not_found' as const } }, 404)
    }
    if (error instanceof WorkspaceForbiddenError) {
      return context.json({ error: { code: 'forbidden' as const } }, 403)
    }
    if (error instanceof WorkspaceLastAdminError) {
      return context.json({ error: { code: 'last_admin' as const } }, 409)
    }
    if (error instanceof WorkspaceNotEmptyError) {
      const code = error.reason === 'documents' ? 'not_empty' : 'cleanup_pending'
      return context.json({ error: { code } }, 409)
    }
    if (error instanceof WorkspaceAlreadyMemberError) {
      return context.json({ error: { code: 'already_member' as const } }, 409)
    }
    throw error
  }
}

export function createWorkspaceRoutes(
  service: WorkspaceService,
  members: WorkspaceMemberService,
  rateLimit?: { database: Kysely<CloudDatabase>; secret: string }
) {
  const router = new Hono<WorkspaceRouteEnvironment>()
  if (rateLimit) {
    router.use(
      '/',
      createRouteRateLimiter(
        rateLimit.database,
        rateLimit.secret,
        CLOUD_RATE_LIMITS.workspaceCreation,
        (context) => context.req.method !== 'POST'
      )
    )
    // Resending mails the invitation again, so it counts against the same budget as sending.
    router.use(
      '/:workspaceId/invitations/:invitationId/resend',
      createResourceRateLimiter(
        rateLimit.database,
        rateLimit.secret,
        CLOUD_RATE_LIMITS.invitationMutation,
        routeParamResource('workspaceId'),
        () => false
      )
    )
    router.use(
      '/:workspaceId/invitations',
      createResourceRateLimiter(
        rateLimit.database,
        rateLimit.secret,
        CLOUD_RATE_LIMITS.invitationMutation,
        routeParamResource('workspaceId'),
        (context) => context.req.method !== 'POST'
      )
    )
  }
  return router
    .get('/', async (context) => {
      const workspaces = await service.list(context.get('actor').userId)
      return context.json({ workspaces })
    })
    .post('/', validatedJSON(parseCreateWorkspace), async (context) => {
      try {
        const workspace = await service.create(
          context.get('actor').userId,
          context.req.valid('json')
        )
        return context.json({ workspace }, 201)
      } catch (error) {
        if (error instanceof WorkspaceSlugConflictError) {
          return context.json({ error: { code: 'slug_conflict' as const } }, 409)
        }
        throw error
      }
    })
    .get('/:workspaceId', workspaceParams, async (context) => {
      const workspace = await service.get(
        context.get('actor').userId,
        context.req.valid('param').workspaceId
      )
      if (!workspace) return context.json({ error: { code: 'not_found' as const } }, 404)
      return context.json({ workspace })
    })
    .patch('/:workspaceId', workspaceParams, validatedJSON(parseUpdateWorkspace), (context) =>
      memberRoute(context, async () =>
        context.json({
          workspace: await members.rename(
            context.get('actor').userId,
            context.req.valid('param').workspaceId,
            context.req.valid('json').name
          )
        })
      )
    )
    .delete('/:workspaceId', workspaceParams, (context) =>
      memberRoute(context, async () => {
        await members.delete(context.get('actor').userId, context.req.valid('param').workspaceId)
        return context.body(null, 204)
      })
    )
    .get('/:workspaceId/members', workspaceParams, (context) =>
      memberRoute(context, async () =>
        context.json(
          await members.list(context.get('actor').userId, context.req.valid('param').workspaceId)
        )
      )
    )
    .post(
      '/:workspaceId/invitations',
      workspaceParams,
      validatedJSON(parseCreateWorkspaceInvitation),
      (context) =>
        memberRoute(context, async () =>
          context.json(
            await members.invite(
              context.get('actor').userId,
              context.req.valid('param').workspaceId,
              context.req.valid('json')
            ),
            201
          )
        )
    )
    .post('/:workspaceId/invitations/:invitationId/resend', workspaceInvitationParams, (context) =>
      memberRoute(context, async () =>
        context.json(
          await members.resendInvitation(
            context.get('actor').userId,
            context.req.valid('param').workspaceId,
            context.req.valid('param').invitationId
          )
        )
      )
    )
    .delete('/:workspaceId/invitations/:invitationId', workspaceInvitationParams, (context) =>
      memberRoute(context, async () => {
        await members.revokeInvitation(
          context.get('actor').userId,
          context.req.valid('param').workspaceId,
          context.req.valid('param').invitationId
        )
        return context.body(null, 204)
      })
    )
    .patch(
      '/:workspaceId/members/:userId',
      workspaceMemberParams,
      validatedJSON(parseUpdateWorkspaceMember),
      (context) =>
        memberRoute(context, async () => {
          await members.updateRole(
            context.get('actor').userId,
            context.req.valid('param').workspaceId,
            context.req.valid('param').userId,
            context.req.valid('json').role
          )
          return context.body(null, 204)
        })
    )
    .delete('/:workspaceId/members/:userId', workspaceMemberParams, (context) =>
      memberRoute(context, async () => {
        await members.remove(
          context.get('actor').userId,
          context.req.valid('param').workspaceId,
          context.req.valid('param').userId
        )
        return context.body(null, 204)
      })
    )
}