Skip to content

Self-hosted personal gallery application with online photo management and albums, supporting Live/Motion Photos, EXIF parsing, geolocation recognition, and an explore map.

3.4 KB
Raw Blame
import { randomUUID } from 'node:crypto'
import type {
  DirectUploadSetup,
  StorageProvider,
} from '../services/storage/interfaces'
import type { UploadPlan } from '#shared/types/upload'
import { createChunkUpload } from './chunk-upload'
import { logUpload } from './upload-log'

export const directUploads = new Map<
  string,
  {
    owner: string
    key: string
    setup: Extract<DirectUploadSetup, { mode: 'multipart' }>
    busy: boolean
    cancelled: boolean
    completed: boolean
    touched: number
  }
>()

export async function abortDirectUpload(id: string) {
  const session = directUploads.get(id)
  if (!session) return
  session.cancelled = true
  if (session.busy) return
  if (!session.completed) await session.setup.abort()
  directUploads.delete(id)
  logUpload('multipart.session.removed', {
    sessionId: id,
    key: session.key,
    completed: session.completed,
  })
}

export async function prepareUpload(
  owner: string,
  key: string,
  size: number | undefined,
  contentType: string,
  provider: StorageProvider,
  chunked: boolean,
): Promise<UploadPlan> {
  logUpload('prepare.started', {
    provider: provider.config?.provider,
    owner,
    key,
    size,
    chunked,
  })
  if (
    provider.prepareDirectUpload &&
    typeof size === 'number' &&
    Number.isSafeInteger(size) &&
    size > 0
  ) {
    const setup = await provider.prepareDirectUpload(key, size, contentType)
    if (setup?.mode === 'single' || setup?.mode === 'range') {
      logUpload('prepare.direct', {
        provider: provider.config?.provider,
        key,
        size,
        mode: setup.mode,
        partSize: setup.mode === 'range' ? setup.partSize : undefined,
      })
      return setup
    }
    if (setup?.mode === 'multipart') {
      const id = randomUUID()
      directUploads.set(id, {
        owner,
        key,
        setup,
        busy: false,
        cancelled: false,
        completed: false,
        touched: Date.now(),
      })
      logUpload('multipart.session.created', {
        sessionId: id,
        provider: provider.config?.provider,
        owner,
        key,
        size,
        partSize: setup.partSize,
        partCount: setup.partUrls.length,
      })
      return {
        mode: 'multipart',
        url: `/api/photos/multipart/${id}`,
        partSize: setup.partSize,
        partUrls: setup.partUrls,
      }
    }
  }
  if (provider.getSignedUrl) {
    logUpload('prepare.single', {
      provider: provider.config?.provider,
      key,
      size,
    })
    return {
      mode: 'single',
      url: await provider.getSignedUrl(key, 3600, { contentType }),
    }
  }
  if (chunked && provider.config?.provider === 'local') {
    if (typeof size !== 'number') throw new Error('Invalid file size')
    return {
      mode: 'chunks',
      url: await createChunkUpload(owner, key, size, contentType, provider),
    }
  }
  return {
    mode: 'single',
    url: `/api/photos/upload?key=${encodeURIComponent(key)}`,
  }
}

const cleanup = setInterval(() => {
  for (const [id, session] of directUploads) {
    if (!session.busy && Date.now() - session.touched > 60 * 60_000) {
      logUpload('multipart.session.expired', {
        sessionId: id,
        key: session.key,
        completed: session.completed,
      })
      void abortDirectUpload(id).catch((error) =>
        logUpload(
          'multipart.cleanup.failed',
          { sessionId: id, key: session.key },
          error,
        ),
      )
    }
  }
}, 60_000)
cleanup.unref()