Skip to content

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

20.7 KB
Raw Blame
import type {
  CommitImageUploadsInput,
  CommitUploadInput,
  CreateDocumentInput,
  CreateUploadInput,
  DocumentDownload,
  DocumentSummary,
  ImageUploadOffer,
  RequestImageUploadsInput,
  SharedDocument
} from '#cloud/contract'
import { createUploadCleanupService } from '#cloud/server/cleanup'
import type { CloudDatabase } from '#cloud/server/db'
import {
  canDeleteDocument,
  canEditDocument,
  resolveDocumentAccess
} from '#cloud/server/documents/access'
import {
  DocumentConflictError,
  DocumentForbiddenError,
  DocumentNotFoundError,
  UploadInvalidError
} from '#cloud/server/documents/errors'
import {
  createDocumentImages,
  currentImageUsage,
  documentImageLinks,
  revisionImageDownloads
} from '#cloud/server/documents/images'
import { writableDocument } from '#cloud/server/documents/limits'
import {
  findDocument,
  insertDocument,
  listDocuments,
  listSharedDocuments,
  workspaceRole
} from '#cloud/server/documents/repository'
import { documentSummary, getDocumentSummaryRow } from '#cloud/server/documents/summary'
import type { CreateDocumentUploadResult } from '#cloud/server/documents/types'
import { announceVersions, recordCheckpoint } from '#cloud/server/documents/versions/checkpoint'
import type { ObjectStore, StoredObject } from '#cloud/server/objects'
import type { CloudPolicy } from '#cloud/server/policy/policy'
import { createStorageQuotaService } from '#cloud/server/quota'
import { isUndefined, limitAsync, omitBy, uniq, uniqBy } from 'es-toolkit'
import type { Kysely, Transaction } from 'kysely'

const DOWNLOAD_LIFETIME_MS = 5 * 60 * 1000
const UPLOAD_LIFETIME_MS = 15 * 60 * 1000
/** How many of a save's images are checked and landed at once. */
const IMAGE_COMMIT_CONCURRENCY = 8
const WRITABLE_ROLES = new Set(['admin', 'editor'])

export type DocumentServiceOptions = {
  policy?: CloudPolicy
  technicalMaximumUploadBytes?: number
  /** Called once a save adds a checkpoint to the document's history. */
  onVersionsChanged?: (documentId: string) => void
}

/** Whether the stored object is the file the upload declared, which the commit names again. */
function matchesUpload(
  stored: { checksum: string; byteSize: number; contentType: string },
  upload: { checksum: string; byteSize: number | string | bigint; contentType: string }
): boolean {
  return (
    stored.checksum === upload.checksum &&
    stored.byteSize === Number(upload.byteSize) &&
    stored.contentType === upload.contentType
  )
}

export function createDocumentService(
  database: Kysely<CloudDatabase>,
  objects: ObjectStore,
  options: DocumentServiceOptions = {}
) {
  const cleanup = createUploadCleanupService(database, objects)
  const quota = createStorageQuotaService(database)
  const images = createDocumentImages(database, objects, quota)

  /**
   * Makes a committed upload the document's current revision, unless it already was, and records
   * the checkpoint the save adds, if any. Whether the history gained one.
   */
  async function landRevision(
    transaction: Transaction<CloudDatabase>,
    {
      userId,
      uploadId,
      upload,
      stored,
      revisionId,
      storageObjectId,
      images: revisionImages,
      name,
      kind
    }: {
      userId: string
      uploadId: string
      upload: {
        documentId: string
        workspaceId: string
        baseRevisionId: string | null
        objectKey: string
      }
      stored: { checksum: string; byteSize: number; contentType: string }
      revisionId: string
      storageObjectId: string
      images: CommitUploadInput['images']
      name: CommitUploadInput['name']
      kind: CommitUploadInput['kind']
    }
  ): Promise<boolean> {
    const lockedUpload = await transaction
      .selectFrom('upload')
      .select('status')
      .where('id', '=', uploadId)
      .forUpdate()
      .executeTakeFirstOrThrow()
    if (lockedUpload.status === 'committed') return false
    if (lockedUpload.status !== 'finalizing') throw new UploadInvalidError()
    const document = await transaction
      .selectFrom('document')
      .select(['currentRevisionId'])
      .where('id', '=', upload.documentId)
      .forUpdate()
      .executeTakeFirstOrThrow()
    if (document.currentRevisionId !== upload.baseRevisionId) {
      throw new DocumentConflictError()
    }
    await transaction
      .insertInto('storageObject')
      .values({
        id: storageObjectId,
        objectKey: upload.objectKey,
        checksum: stored.checksum,
        byteSize: stored.byteSize,
        contentType: stored.contentType
      })
      .execute()
    await transaction
      .insertInto('documentRevision')
      .values({
        id: revisionId,
        documentId: upload.documentId,
        parentRevisionId: upload.baseRevisionId,
        storageObjectId,
        createdBy: userId
      })
      .execute()
    const attached = await images.attachInTransaction(transaction, {
      workspaceId: upload.workspaceId,
      revisionId,
      images: revisionImages
    })
    if (!attached) throw new UploadInvalidError()
    await transaction
      .updateTable('document')
      .set({
        // A revision may also retitle its document, or say the file it holds is a board.
        ...omitBy({ name, kind }, isUndefined),
        currentRevisionId: revisionId,
        version: (expression) => expression('version', '+', 1)
      })
      .where('id', '=', upload.documentId)
      .execute()
    const checkpointed = await recordCheckpoint(transaction, {
      documentId: upload.documentId,
      previousRevisionId: document.currentRevisionId,
      revisionId,
      userId,
      now: new Date()
    })
    await transaction
      .updateTable('upload')
      .set({ status: 'committed', finalizationStartedAt: null })
      .where('id', '=', uploadId)
      .execute()
    await quota.commitInTransaction(transaction, uploadId)
    return checkpointed
  }

  /** Links for images a live room names, by checksum. */
  async function imageLinksOf(documentId: string, checksums: string[]) {
    const expiresAt = new Date(Date.now() + DOWNLOAD_LIFETIME_MS)
    return {
      images: await documentImageLinks(database, objects, { documentId, checksums, expiresAt })
    }
  }

  async function createDownload(documentId: string): Promise<DocumentDownload> {
    const row = await getDocumentSummaryRow(database, documentId)
    if (!row?.currentRevisionId) throw new DocumentNotFoundError()
    const document: DocumentSummary = documentSummary(row)
    const revision = await database
      .selectFrom('documentRevision')
      .innerJoin('storageObject', 'storageObject.id', 'documentRevision.storageObjectId')
      .select([
        'documentRevision.id as revisionId',
        'storageObject.objectKey',
        'storageObject.byteSize',
        'storageObject.checksum',
        'storageObject.contentType'
      ])
      .where('documentRevision.id', '=', document.currentRevisionId)
      .where('documentRevision.documentId', '=', documentId)
      .executeTakeFirst()
    if (!revision) throw new DocumentNotFoundError()
    const expiresAt = new Date(Date.now() + DOWNLOAD_LIFETIME_MS)
    return {
      document,
      revisionId: revision.revisionId,
      byteSize: Number(revision.byteSize),
      checksum: revision.checksum,
      contentType: revision.contentType,
      download: await objects.createDownload({ key: revision.objectKey, expiresAt }),
      images: await revisionImageDownloads(database, objects, revision.revisionId, expiresAt)
    }
  }

  /** What committing an upload reads of it and its document. */
  function selectUploads() {
    return database
      .selectFrom('upload')
      .innerJoin('document', 'document.id', 'upload.documentId')
      .select([
        'upload.id',
        'upload.documentId',
        'upload.kind',
        'document.workspaceId',
        'upload.baseRevisionId',
        'upload.objectKey',
        'upload.checksum',
        'upload.byteSize',
        'upload.contentType',
        'upload.multipartUploadId',
        'upload.status',
        'upload.expiresAt'
      ])
  }
  type UploadRow = Awaited<ReturnType<ReturnType<typeof selectUploads>['executeTakeFirstOrThrow']>>

  /**
   * Claims a pending upload, completes it when it came in parts, checks the store holds the file
   * it declared, and lands it with `land`. An upload that fails goes back to pending, so its
   * commit can be tried again.
   */
  async function finalizeUpload<T>(
    upload: UploadRow,
    multipart: CommitUploadInput['multipart'],
    land: (stored: StoredObject) => Promise<T>
  ): Promise<T> {
    if (upload.status !== 'pending' || new Date(upload.expiresAt).getTime() <= Date.now()) {
      throw new UploadInvalidError()
    }
    const claimed = await database
      .updateTable('upload')
      .set({ status: 'finalizing', finalizationStartedAt: new Date() })
      .where('id', '=', upload.id)
      .where('status', '=', 'pending')
      .returning('id')
      .executeTakeFirst()
    if (!claimed) throw new UploadInvalidError()
    try {
      if (multipart) {
        if (
          !objects.capabilities.multipartUpload ||
          multipart.uploadId !== upload.multipartUploadId
        ) {
          throw new UploadInvalidError()
        }
        await objects.completeUpload({
          key: upload.objectKey,
          uploadId: multipart.uploadId,
          parts: multipart.parts
        })
      }
      const stored = await objects.head(upload.objectKey)
      if (!stored || !matchesUpload(stored, upload)) throw new UploadInvalidError()
      return await land(stored)
    } catch (error) {
      await database
        .updateTable('upload')
        .set({ status: 'pending', finalizationStartedAt: null })
        .where('id', '=', upload.id)
        .where('status', '=', 'finalizing')
        .execute()
      throw error
    }
  }

  function landImage(upload: UploadRow, stored: StoredObject): Promise<void> {
    return database.transaction().execute((transaction) =>
      images.landInTransaction(transaction, {
        uploadId: upload.id,
        workspaceId: upload.workspaceId,
        objectKey: upload.objectKey,
        stored
      })
    )
  }

  async function commitUpload(
    userId: string,
    uploadId: string,
    input: CommitUploadInput
  ): Promise<DocumentSummary> {
    const upload = await selectUploads()
      .where('upload.id', '=', uploadId)
      .where('upload.createdBy', '=', userId)
      .executeTakeFirst()
    if (!upload) throw new DocumentNotFoundError()
    const access = await resolveDocumentAccess(database, userId, upload.documentId)
    if (!access) throw new DocumentNotFoundError()
    if (!canEditDocument(access)) throw new DocumentForbiddenError()
    if (input.checksum !== upload.checksum) throw new UploadInvalidError()
    if (upload.status !== 'committed') {
      const checkpointed =
        upload.kind === 'image'
          ? await finalizeUpload(upload, input.multipart, (stored) =>
              landImage(upload, stored).then(() => false)
            )
          : await finalizeUpload(upload, input.multipart, (stored) =>
              database.transaction().execute((transaction) =>
                landRevision(transaction, {
                  userId,
                  uploadId,
                  upload,
                  stored,
                  revisionId: crypto.randomUUID(),
                  storageObjectId: crypto.randomUUID(),
                  images: input.images,
                  name: input.name,
                  kind: input.kind
                })
              )
            )
      if (checkpointed) announceVersions(options.onVersionsChanged, upload.documentId)
    }
    const document = await findDocument(database, userId, upload.documentId)
    if (!document) throw new DocumentNotFoundError()
    return document
  }

  return {
    async cleanupExpiredUploads(now = new Date()): Promise<number> {
      const result = await cleanup.cleanupExpiredUploads({
        batchSize: 100,
        leaseDurationMs: 5 * 60 * 1000,
        now
      })
      if (result.failed > 0) throw new Error('One or more expired uploads could not be cleaned')
      return result.cleaned
    },

    list(userId: string, workspaceId: string): Promise<DocumentSummary[] | undefined> {
      return listDocuments(database, userId, workspaceId)
    },

    listShared(userId: string): Promise<SharedDocument[]> {
      return listSharedDocuments(database, userId)
    },

    async usage(userId: string, workspaceId: string) {
      const role = await workspaceRole(database, userId, workspaceId)
      if (!role) throw new DocumentNotFoundError()
      const result = await database
        .selectFrom('document')
        .leftJoin('documentRevision', 'documentRevision.id', 'document.currentRevisionId')
        .leftJoin('storageObject', 'storageObject.id', 'documentRevision.storageObjectId')
        .select((expression) => [
          expression.fn.count('document.id').as('documentCount'),
          expression.fn.count('storageObject.id').as('objectCount'),
          expression.fn
            .coalesce(expression.fn.sum('storageObject.byteSize'), expression.val(0))
            .as('bytesUsed')
        ])
        .where('document.workspaceId', '=', workspaceId)
        .where('document.deletedAt', 'is', null)
        .executeTakeFirstOrThrow()
      const shared = await currentImageUsage(database, workspaceId)
      return {
        bytesUsed: Number(result.bytesUsed) + shared.bytesUsed,
        objectCount: Number(result.objectCount) + shared.objectCount,
        documentCount: Number(result.documentCount)
      }
    },

    async access(userId: string, documentId: string) {
      const access = await resolveDocumentAccess(database, userId, documentId)
      if (!access) throw new DocumentNotFoundError()
      return access
    },

    async downloadShared(documentId: string): Promise<DocumentDownload> {
      return createDownload(documentId)
    },

    /** Links for images a live room names, for someone who may view the document. */
    async imageLinks(userId: string, documentId: string, checksums: string[]) {
      const access = await resolveDocumentAccess(database, userId, documentId)
      if (!access) throw new DocumentNotFoundError()
      return imageLinksOf(documentId, checksums)
    },

    /** Links for images a live room names, for a guest a share already let in. */
    imageLinksShared(documentId: string, checksums: string[]) {
      return imageLinksOf(documentId, checksums)
    },

    async download(userId: string, documentId: string): Promise<DocumentDownload> {
      const access = await resolveDocumentAccess(database, userId, documentId)
      if (!access) throw new DocumentNotFoundError()
      return createDownload(documentId)
    },

    async remove(userId: string, documentId: string): Promise<void> {
      const access = await resolveDocumentAccess(database, userId, documentId)
      if (!access) throw new DocumentNotFoundError()
      if (!canEditDocument(access) || !(await canDeleteDocument(database, userId, documentId))) {
        throw new DocumentForbiddenError()
      }
      await database
        .updateTable('document')
        .set({ deletedAt: new Date() })
        .where('id', '=', documentId)
        .where('deletedAt', 'is', null)
        .execute()
    },

    async create(
      userId: string,
      workspaceId: string,
      input: CreateDocumentInput
    ): Promise<DocumentSummary> {
      const role = await workspaceRole(database, userId, workspaceId)
      if (!role) throw new DocumentNotFoundError()
      if (!WRITABLE_ROLES.has(role)) throw new DocumentForbiddenError()
      const documentId = input.id ?? crypto.randomUUID()
      await insertDocument(database, {
        id: documentId,
        workspaceId,
        name: input.name,
        kind: input.kind,
        createdBy: userId
      })
      const document = await findDocument(database, userId, documentId)
      if (!document) throw new DocumentNotFoundError()
      return document
    },

    async createUpload(
      userId: string,
      documentId: string,
      input: CreateUploadInput
    ): Promise<CreateDocumentUploadResult> {
      const { document, maximumFileBytes, maximumStorageBytes } = await writableDocument(
        database,
        options,
        userId,
        documentId
      )
      if (document.currentRevisionId !== input.baseRevisionId) throw new DocumentConflictError()
      if (input.byteSize > maximumFileBytes) throw new UploadInvalidError()
      const uploadId = crypto.randomUUID()
      const objectKey = `documents/${document.workspaceId}/${documentId}/uploads/${uploadId}.fig`
      const expiresAt = new Date(Date.now() + UPLOAD_LIFETIME_MS)
      await database.transaction().execute(async (transaction) => {
        await transaction
          .insertInto('upload')
          .values({
            id: uploadId,
            documentId,
            baseRevisionId: input.baseRevisionId,
            objectKey,
            checksum: input.checksum,
            byteSize: input.byteSize,
            contentType: input.contentType,
            multipartUploadId: null,
            status: 'pending',
            finalizationStartedAt: null,
            createdBy: userId,
            expiresAt
          })
          .execute()
        await quota.reserveInTransaction(transaction, {
          workspaceId: document.workspaceId,
          uploadId,
          bytes: input.byteSize,
          expiresAt,
          maximumBytes: maximumStorageBytes
        })
      })
      let objectUpload
      try {
        objectUpload = await objects.createUpload({
          key: objectKey,
          byteSize: input.byteSize,
          checksum: input.checksum,
          contentType: input.contentType,
          expiresAt
        })
      } catch (error) {
        await quota.release(uploadId)
        await database
          .updateTable('upload')
          .set({ status: 'abandoned' })
          .where('id', '=', uploadId)
          .execute()
        throw error
      }
      if (objectUpload.kind === 'multipart') {
        await database
          .updateTable('upload')
          .set({ multipartUploadId: objectUpload.uploadId })
          .where('id', '=', uploadId)
          .execute()
      }
      return { id: uploadId, upload: objectUpload }
    },

    /** Uploads for the images a save of the document will name that its workspace lacks. */
    async requestImageUploads(
      userId: string,
      documentId: string,
      input: RequestImageUploadsInput
    ): Promise<{ uploads: ImageUploadOffer[] }> {
      const { document, maximumFileBytes, maximumStorageBytes } = await writableDocument(
        database,
        options,
        userId,
        documentId
      )
      if (input.images.some((image) => image.byteSize > maximumFileBytes)) {
        throw new UploadInvalidError()
      }
      return {
        uploads: await images.requestUploads({
          userId,
          documentId,
          workspaceId: document.workspaceId,
          images: input.images,
          expiresAt: new Date(Date.now() + UPLOAD_LIFETIME_MS),
          maximumBytes: maximumStorageBytes
        })
      }
    },
    commitUpload,

    /**
     * Commits the image uploads a save asked for in one request, however many there are: each
     * must be an image upload this person made for the document.
     */
    async commitImageUploads(
      userId: string,
      documentId: string,
      uploads: CommitImageUploadsInput['uploads']
    ): Promise<void> {
      const access = await resolveDocumentAccess(database, userId, documentId)
      if (!access) throw new DocumentNotFoundError()
      if (!canEditDocument(access)) throw new DocumentForbiddenError()
      const ids = uniq(uploads.map((upload) => upload.uploadId))
      const rows = new Map(
        (
          await selectUploads()
            .where('upload.id', 'in', ids)
            .where('upload.documentId', '=', documentId)
            .where('upload.createdBy', '=', userId)
            .execute()
        ).map((row) => [row.id, row])
      )
      if (rows.size !== ids.length || [...rows.values()].some((row) => row.kind !== 'image')) {
        throw new UploadInvalidError()
      }
      for (const commit of uploads) {
        if (rows.get(commit.uploadId)?.checksum !== commit.checksum) throw new UploadInvalidError()
      }
      // Each image is its own object, so a few are checked and landed at once, each once however
      // often the request names it.
      const land = limitAsync(
        (upload: UploadRow, multipart: CommitUploadInput['multipart']) =>
          finalizeUpload(upload, multipart, (stored) => landImage(upload, stored)),
        IMAGE_COMMIT_CONCURRENCY
      )
      await Promise.all(
        uniqBy(uploads, (commit) => commit.uploadId).map(async (commit) => {
          const upload = rows.get(commit.uploadId)
          if (!upload) throw new UploadInvalidError()
          if (upload.status !== 'committed') await land(upload, commit.multipart)
        })
      )
    }
  }
}

export type DocumentService = ReturnType<typeof createDocumentService>