Skip to content

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

7.9 KB
Raw Blame
import {
  parseCommitImageUploads,
  parseCommitUpload,
  parseCreateDocument,
  parseCreateUpload,
  parseRequestImageLinks,
  parseRequestImageUploads
} from '#cloud/contract'
import type { CloudActor } from '#cloud/server/auth'
import type { CloudDatabase } from '#cloud/server/db'
import {
  DocumentConflictError,
  DocumentForbiddenError,
  DocumentNotFoundError,
  UploadInvalidError
} from '#cloud/server/documents/errors'
import type { DocumentService } from '#cloud/server/documents/service'
import { StorageQuotaExceededError } from '#cloud/server/quota'
import {
  CLOUD_RATE_LIMITS,
  routeParamResource,
  createResourceRateLimiter
} from '#cloud/server/rate-limit'
import {
  documentParams,
  uploadParams,
  validatedJSON,
  workspaceParams
} from '#cloud/server/validation'
import { Hono, type Context } from 'hono'
import type { Kysely } from 'kysely'

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

/** The response a document domain error stands for, or null for any other error. */
export function documentDomainError(context: Context, error: unknown): Response | null {
  if (error instanceof DocumentNotFoundError) {
    return context.json({ error: { code: 'not_found' as const } }, 404)
  }
  if (error instanceof DocumentForbiddenError) {
    return context.json({ error: { code: 'forbidden' as const } }, 403)
  }
  if (error instanceof DocumentConflictError) {
    return context.json({ error: { code: 'revision_conflict' as const } }, 409)
  }
  if (error instanceof StorageQuotaExceededError) {
    return context.json({ error: { code: 'storage_quota_exceeded' as const } }, 409)
  }
  if (error instanceof UploadInvalidError) {
    return context.json({ error: { code: 'invalid_upload' as const } }, 422)
  }
  return null
}

/** Answers with what `respond` gives, or with the response a document domain error stands for. */
async function documentResponse<T extends Response>(
  context: Context,
  respond: () => Promise<T>
): Promise<T | Response> {
  try {
    return await respond()
  } catch (error) {
    const response = documentDomainError(context, error)
    if (response) return response
    throw error
  }
}

export function createDocumentRoutes(
  service: DocumentService,
  rateLimit?: { database: Kysely<CloudDatabase>; secret: string }
) {
  const router = new Hono<DocumentRouteEnvironment>()
  if (rateLimit) {
    router.use(
      '/workspaces/:workspaceId/documents',
      createResourceRateLimiter(
        rateLimit.database,
        rateLimit.secret,
        CLOUD_RATE_LIMITS.documentCreation,
        routeParamResource('workspaceId'),
        (context) => context.req.method !== 'POST'
      )
    )
    router.use(
      '/documents/:documentId/images',
      createResourceRateLimiter(
        rateLimit.database,
        rateLimit.secret,
        CLOUD_RATE_LIMITS.uploadCreation,
        routeParamResource('documentId'),
        (context) => context.req.method !== 'POST'
      )
    )
    router.use(
      '/documents/:documentId/uploads',
      createResourceRateLimiter(
        rateLimit.database,
        rateLimit.secret,
        CLOUD_RATE_LIMITS.uploadCreation,
        routeParamResource('documentId'),
        (context) => context.req.method !== 'POST'
      )
    )
  }
  return router
    .get('/shared-documents', async (context) =>
      context.json({ documents: await service.listShared(context.get('actor').userId) })
    )
    .get('/workspaces/:workspaceId/documents', workspaceParams, async (context) => {
      const documents = await service.list(
        context.get('actor').userId,
        context.req.valid('param').workspaceId
      )
      if (!documents) return context.json({ error: { code: 'not_found' as const } }, 404)
      return context.json({ documents })
    })
    .get('/workspaces/:workspaceId/usage', workspaceParams, async (context) => {
      try {
        return context.json({
          usage: await service.usage(
            context.get('actor').userId,
            context.req.valid('param').workspaceId
          )
        })
      } catch (error) {
        const response = documentDomainError(context, error)
        if (response) return response
        throw error
      }
    })
    .post(
      '/workspaces/:workspaceId/documents',
      workspaceParams,
      validatedJSON(parseCreateDocument),
      async (context) => {
        try {
          const document = await service.create(
            context.get('actor').userId,
            context.req.valid('param').workspaceId,
            context.req.valid('json')
          )
          return context.json({ document }, 201)
        } catch (error) {
          const response = documentDomainError(context, error)
          if (response) return response
          throw error
        }
      }
    )
    .delete('/documents/:documentId', documentParams, async (context) => {
      try {
        await service.remove(context.get('actor').userId, context.req.valid('param').documentId)
        return context.body(null, 204)
      } catch (error) {
        const response = documentDomainError(context, error)
        if (response) return response
        throw error
      }
    })
    .get('/documents/:documentId/access', documentParams, (context) =>
      documentResponse(context, async () =>
        context.json({
          access: await service.access(
            context.get('actor').userId,
            context.req.valid('param').documentId
          )
        })
      )
    )
    .get('/documents/:documentId', documentParams, (context) =>
      documentResponse(context, async () =>
        context.json({
          document: await service.download(
            context.get('actor').userId,
            context.req.valid('param').documentId
          )
        })
      )
    )
    .post(
      '/documents/:documentId/uploads',
      documentParams,
      validatedJSON(parseCreateUpload),
      (context) =>
        documentResponse(context, async () =>
          context.json(
            await service.createUpload(
              context.get('actor').userId,
              context.req.valid('param').documentId,
              context.req.valid('json')
            ),
            201
          )
        )
    )
    .post(
      '/documents/:documentId/images/commit',
      documentParams,
      validatedJSON(parseCommitImageUploads),
      (context) =>
        documentResponse(context, async () => {
          await service.commitImageUploads(
            context.get('actor').userId,
            context.req.valid('param').documentId,
            context.req.valid('json').uploads
          )
          return context.body(null, 204)
        })
    )
    .post(
      '/documents/:documentId/images/links',
      documentParams,
      validatedJSON(parseRequestImageLinks),
      (context) =>
        documentResponse(context, async () =>
          context.json(
            await service.imageLinks(
              context.get('actor').userId,
              context.req.valid('param').documentId,
              context.req.valid('json').checksums
            )
          )
        )
    )
    .post(
      '/documents/:documentId/images',
      documentParams,
      validatedJSON(parseRequestImageUploads),
      (context) =>
        documentResponse(context, async () =>
          context.json(
            await service.requestImageUploads(
              context.get('actor').userId,
              context.req.valid('param').documentId,
              context.req.valid('json')
            ),
            201
          )
        )
    )
    .post(
      '/uploads/:uploadId/commit',
      uploadParams,
      validatedJSON(parseCommitUpload),
      async (context) => {
        try {
          const document = await service.commitUpload(
            context.get('actor').userId,
            context.req.valid('param').uploadId,
            context.req.valid('json')
          )
          return context.json({ document })
        } catch (error) {
          const response = documentDomainError(context, error)
          if (response) return response
          throw error
        }
      }
    )
}