bunderstack 0.17.0-beta.2 → 0.17.0-beta.4

package/src/storage/operations.ts

@@ -1,398 +0,0 @@
-import { randomUUID } from 'node:crypto'
-import { extname } from 'node:path'
-
-import type { AccessContext, OperationRule } from '../access'
-import type { AnyDb } from '../dialect'
-import type { BucketStorageRegistry } from './registry'
-
-import { checkAccess } from '../access'
-import { BunderstackError } from '../errors'
-import { deleteFileWithDerivatives } from './delete'
-import {
-  deleteFileMetaRow,
-  fileMatchesScope,
-  getFileMeta,
-  insertPendingFile,
-  insertReadyFile,
-  markFileReady,
-  scopeToJson,
-  sumReadySize,
-  type FileMetaRow,
-} from './file-meta'
-import { parseTransformSpec, transformHash, transformImage } from './thumbnails'
-
-export interface StorageExecutionContext {
-  request: Request
-  user: AccessContext['user']
-  session: { activeOrganizationId: string | null }
-}
-
-export interface StorageOperationsOptions {
-  registry: BucketStorageRegistry
-  db: AnyDb
-  presignExpiresSec?: number
-}
-
-export type PrepareUploadResult =
-  | { mode: 'proxy'; uploadUrl: string }
-  | {
-      mode: 'presign'
-      fileId: string
-      uploadUrl: string
-      method: 'PUT'
-      confirmUrl: string
-    }
-
-export type StorageDownload =
-  | { kind: 'redirect'; status: 302; url: string }
-  | {
-      kind: 'body'
-      status: number
-      body: ConstructorParameters<typeof Response>[0]
-      headers: Headers
-    }
-
-const FILE_OWNER_COLUMN = 'ownerId'
-
-function matchMime(type: string, accept?: string[]): boolean {
-  if (!accept || accept.length === 0) return true
-  if (!type) return false
-  return accept.some(
-    (pattern) =>
-      pattern === type ||
-      (pattern.endsWith('/*') && type.startsWith(pattern.slice(0, -1))),
-  )
-}
-
-function accessContext(
-  context: StorageExecutionContext,
-  extra: { row?: FileMetaRow; body?: Record<string, unknown> } = {},
-): AccessContext {
-  return {
-    request: context.request,
-    user: context.user,
-    session: context.session,
-    row: extra.row,
-    body: extra.body,
-  }
-}
-
-async function gate(rule: OperationRule, context: AccessContext) {
-  const result = await checkAccess(rule, context, FILE_OWNER_COLUMN)
-  if (!result.allowed) {
-    throw new BunderstackError(
-      result.status === 401 ? 'UNAUTHORIZED' : 'FORBIDDEN',
-      result.status === 401 ? 'Authentication required' : 'Forbidden',
-    )
-  }
-}
-
-function notFound(message = 'Not found'): never {
-  throw new BunderstackError('NOT_FOUND', message)
-}
-
-function sanitizeFilename(name: string): string {
-  return name.replace(/["\\\r\n]/g, '')
-}
-
-async function quotaExceeded(
-  db: AnyDb,
-  bucket: string,
-  quota: { perUserBytes?: number; perScopeBytes?: number },
-  ownerId: string | undefined,
-  scopeJson: string | null,
-  incoming: number,
-): Promise<boolean> {
-  if (quota.perUserBytes !== undefined && ownerId !== undefined) {
-    const current = await sumReadySize(db, { bucket, ownerId })
-    if (current + incoming > quota.perUserBytes) return true
-  }
-  if (quota.perScopeBytes !== undefined && scopeJson != null) {
-    const current = await sumReadySize(db, { bucket, scopeJson })
-    if (current + incoming > quota.perScopeBytes) return true
-  }
-  return false
-}
-
-export function createStorageOperations(options: StorageOperationsOptions) {
-  const { registry, db } = options
-  const presignExpiresSec = options.presignExpiresSec ?? 60
-
-  const bucketEntry = (name: string) => {
-    const entry = registry.get(name)
-    if (!entry) notFound('Unknown bucket')
-    return entry
-  }
-
-  return {
-    async prepareUpload(
-      bucketName: string,
-      body: { filename?: string; contentType?: string },
-      context: StorageExecutionContext,
-    ): Promise<PrepareUploadResult> {
-      const { bucket, adapter } = bucketEntry(bucketName)
-      const ctx = accessContext(context, { body })
-      await gate(bucket.access.create, ctx)
-
-      if (!adapter.presignPut) {
-        return { mode: 'proxy', uploadUrl: `/api/files/${bucket.name}` }
-      }
-
-      const scopeJson = scopeToJson(bucket.writeScope?.(ctx))
-      if (
-        bucket.quota &&
-        (await quotaExceeded(
-          db,
-          bucket.name,
-          bucket.quota,
-          context.user?.id,
-          scopeJson,
-          bucket.upload?.maxSizeBytes ?? 0,
-        ))
-      ) {
-        throw new BunderstackError('PAYLOAD_TOO_LARGE', 'Quota exceeded')
-      }
-
-      const fileId = `${bucket.name}/${randomUUID()}${extname(body.filename ?? '')}`
-      await insertPendingFile(db, {
-        fileId,
-        bucket: bucket.name,
-        ownerId: context.user?.id ?? null,
-        scopeJson,
-        filename: body.filename ?? null,
-        contentType: body.contentType ?? null,
-      })
-      const uploadUrl = await adapter.presignPut(fileId, {
-        contentType: body.contentType,
-        expiresIn: presignExpiresSec,
-      })
-      const id = fileId.slice(`${bucket.name}/`.length)
-      return {
-        mode: 'presign',
-        fileId,
-        uploadUrl,
-        method: 'PUT',
-        confirmUrl: `/api/files/${bucket.name}/${id}/confirm`,
-      }
-    },
-
-    async upload(
-      bucketName: string,
-      file: File,
-      context: StorageExecutionContext,
-    ) {
-      const { bucket, adapter } = bucketEntry(bucketName)
-      const ctx = accessContext(context)
-      await gate(bucket.access.create, ctx)
-
-      if (!matchMime(file.type, bucket.upload?.accept)) {
-        throw new BunderstackError(
-          'BAD_REQUEST',
-          `Content type ${file.type || '(none)'} not allowed`,
-        )
-      }
-      if (
-        bucket.upload?.maxSizeBytes !== undefined &&
-        file.size > bucket.upload.maxSizeBytes
-      ) {
-        throw new BunderstackError('PAYLOAD_TOO_LARGE', 'File too large')
-      }
-
-      const scopeJson = scopeToJson(bucket.readScope?.(ctx))
-      if (
-        bucket.quota &&
-        (await quotaExceeded(
-          db,
-          bucket.name,
-          bucket.quota,
-          context.user?.id,
-          scopeJson,
-          file.size,
-        ))
-      ) {
-        throw new BunderstackError('PAYLOAD_TOO_LARGE', 'Quota exceeded')
-      }
-
-      const fileId = `${bucket.name}/${randomUUID()}${extname(file.name)}`
-      await adapter.upload(fileId, await file.arrayBuffer(), file.type)
-      await insertReadyFile(db, {
-        fileId,
-        bucket: bucket.name,
-        ownerId: context.user?.id ?? null,
-        scopeJson,
-        filename: file.name || null,
-        contentType: file.type || null,
-        size: file.size,
-      })
-      const id = fileId.slice(`${bucket.name}/`.length)
-      return {
-        status: 201 as const,
-        fileId,
-        url: `/api/files/${bucket.name}/${id}`,
-      }
-    },
-
-    async confirmUpload(
-      bucketName: string,
-      id: string,
-      context: StorageExecutionContext,
-    ) {
-      const { bucket, adapter } = bucketEntry(bucketName)
-      const fileId = `${bucketName}/${id}`
-      const row = await getFileMeta(db, fileId)
-      if (!row || row.bucket !== bucketName) notFound()
-      if (row.ownerId != null && row.ownerId !== (context.user?.id ?? null)) {
-        throw new BunderstackError('FORBIDDEN', 'Forbidden')
-      }
-
-      const result = { fileId, url: `/api/files/${bucketName}/${id}` }
-      if (row.status === 'ready') return result
-
-      const info = await adapter.stat?.(fileId)
-      if (!info) notFound()
-
-      const rejectUpload = async (message: string, validation = false) => {
-        await adapter.delete(fileId)
-        await deleteFileMetaRow(db, fileId)
-        throw new BunderstackError(
-          validation ? 'BAD_REQUEST' : 'PAYLOAD_TOO_LARGE',
-          message,
-        )
-      }
-      if (
-        bucket.upload?.maxSizeBytes !== undefined &&
-        info.size > bucket.upload.maxSizeBytes
-      ) {
-        await rejectUpload('File too large')
-      }
-      if (!matchMime(info.contentType, bucket.upload?.accept)) {
-        await rejectUpload(
-          `Content type ${info.contentType || '(none)'} not allowed`,
-          true,
-        )
-      }
-      if (
-        bucket.quota &&
-        (await quotaExceeded(
-          db,
-          bucket.name,
-          bucket.quota,
-          row.ownerId ?? undefined,
-          row.scopeJson,
-          info.size,
-        ))
-      ) {
-        await rejectUpload('Quota exceeded')
-      }
-
-      await markFileReady(db, fileId, info)
-      return result
-    },
-
-    async download(
-      bucketName: string,
-      id: string,
-      query: Record<string, string>,
-      context: StorageExecutionContext,
-    ): Promise<StorageDownload> {
-      const { bucket, adapter } = bucketEntry(bucketName)
-      const fileId = `${bucketName}/${id}`
-      const row = await getFileMeta(db, fileId)
-      if (!row || row.status !== 'ready' || row.bucket !== bucketName) notFound()
-
-      const ctx = accessContext(context, { row })
-      await gate(bucket.access.get, ctx)
-      if (!fileMatchesScope(row, bucket.readScope?.(ctx))) notFound()
-
-      const spec = parseTransformSpec(query)
-      if (spec) {
-        if (!bucket.transforms) {
-          throw new BunderstackError(
-            'BAD_REQUEST',
-            'Transforms not enabled for this bucket',
-          )
-        }
-        const ext = spec.format ? `.${spec.format}` : extname(fileId) || '.jpg'
-        const cacheKey = `${fileId}__transforms/${transformHash(spec)}${ext}`
-        if (await adapter.exists(cacheKey)) {
-          const cached = await adapter.get(cacheKey)
-          const headers = new Headers(cached.headers)
-          headers.set('Cache-Control', 'public, max-age=31536000')
-          return {
-            kind: 'body',
-            status: cached.status,
-            body: cached.body,
-            headers,
-          }
-        }
-
-        const original = await adapter.get(fileId)
-        if (original.status === 404) notFound()
-        const transformed = await transformImage(
-          Buffer.from(await original.arrayBuffer()),
-          spec,
-        )
-        const contentType = spec.format
-          ? `image/${spec.format}`
-          : (original.headers.get('Content-Type') ?? 'image/jpeg')
-        const body = Uint8Array.from(transformed).buffer
-        await adapter.upload(cacheKey, body, contentType)
-        return {
-          kind: 'body',
-          status: 200,
-          body,
-          headers: new Headers({
-            'Content-Type': contentType,
-            'Cache-Control': 'public, max-age=31536000',
-          }),
-        }
-      }
-
-      if (bucket.visibility === 'public' && adapter.publicUrlFor) {
-        const url = adapter.publicUrlFor(fileId)
-        if (url) return { kind: 'redirect', status: 302, url }
-      }
-      if (bucket.visibility === 'private' && adapter.presignGet) {
-        return {
-          kind: 'redirect',
-          status: 302,
-          url: await adapter.presignGet(fileId, {
-            expiresIn: presignExpiresSec,
-          }),
-        }
-      }
-
-      const response = await adapter.get(fileId)
-      const headers = new Headers(response.headers)
-      if (response.status !== 404 && row.filename) {
-        headers.set(
-          'Content-Disposition',
-          `inline; filename="${sanitizeFilename(row.filename)}"`,
-        )
-      }
-      return {
-        kind: 'body',
-        status: response.status,
-        body: response.body,
-        headers,
-      }
-    },
-
-    async delete(
-      bucketName: string,
-      id: string,
-      context: StorageExecutionContext,
-    ): Promise<void> {
-      const { bucket, adapter } = bucketEntry(bucketName)
-      const fileId = `${bucketName}/${id}`
-      const row = await getFileMeta(db, fileId)
-      if (!row || row.bucket !== bucketName) notFound()
-      const ctx = accessContext(context, { row })
-      await gate(bucket.access.delete, ctx)
-      if (!fileMatchesScope(row, bucket.readScope?.(ctx))) notFound()
-      await deleteFileWithDerivatives(adapter, db, fileId)
-    },
-  }
-}
-
-export type StorageOperations = ReturnType<typeof createStorageOperations>

package/src/storage/registry.ts

@@ -1,40 +0,0 @@
-// src/storage/registry.ts
-import type {
-  ResolvedBackend,
-  ResolvedBucket,
-  ResolvedStorageBuckets,
-} from './buckets'
-import type { StorageAdapter } from './index'
-
-import { LocalStorageAdapter } from './local'
-import { S3StorageAdapter } from './s3'
-
-export interface BucketStorage {
-  bucket: ResolvedBucket
-  adapter: StorageAdapter
-}
-export type BucketStorageRegistry = Map<string, BucketStorage>
-
-export function createAdapter(backend: ResolvedBackend): StorageAdapter {
-  if (backend.type === 'local') {
-    return new LocalStorageAdapter(backend.path)
-  }
-  return new S3StorageAdapter({
-    bucket: backend.bucket,
-    region: backend.region,
-    accessKeyId: backend.accessKeyId,
-    secretAccessKey: backend.secretAccessKey,
-    endpoint: backend.endpoint,
-    publicUrl: backend.publicUrl,
-  })
-}
-
-export function createBucketStorages(
-  resolved: ResolvedStorageBuckets,
-): BucketStorageRegistry {
-  const registry: BucketStorageRegistry = new Map()
-  for (const [name, bucket] of resolved.buckets) {
-    registry.set(name, { bucket, adapter: createAdapter(bucket.backend) })
-  }
-  return registry
-}

package/src/storage/s3.ts

@@ -1,99 +0,0 @@
-// src/storage/s3.ts
-import type {
-  PresignGetOptions,
-  PresignPutOptions,
-  StorageAdapter,
-} from './index'
-
-interface S3Config {
-  bucket: string
-  region: string
-  accessKeyId: string
-  secretAccessKey: string
-  endpoint?: string
-  publicUrl?: string
-}
-
-export class S3StorageAdapter implements StorageAdapter {
-  private client: InstanceType<typeof Bun.S3Client>
-  private readonly publicUrl?: string
-
-  constructor(cfg: S3Config) {
-    this.client = new Bun.S3Client({
-      bucket: cfg.bucket,
-      region: cfg.region,
-      accessKeyId: cfg.accessKeyId,
-      secretAccessKey: cfg.secretAccessKey,
-      ...(cfg.endpoint && { endpoint: cfg.endpoint }),
-    })
-    this.publicUrl = cfg.publicUrl
-  }
-
-  async upload(
-    fileId: string,
-    data: Blob | ArrayBuffer,
-    contentType: string,
-  ): Promise<void> {
-    const bytes = data instanceof Blob ? await data.arrayBuffer() : data
-    await this.client.write(fileId, bytes, { type: contentType })
-  }
-
-  async get(fileId: string): Promise<Response> {
-    // `stat` (a HEAD, same cost as `exists`) is the only way to learn the
-    // stored Content-Type: a lazily-constructed `client.file(key)` reports
-    // `type: ""` — it never stats, and unlike `Bun.file` it does not guess
-    // from the extension either.
-    const info = await this.stat(fileId)
-    if (!info) return new Response('Not found', { status: 404 })
-    const file = this.client.file(fileId)
-    return new Response(file.stream(), {
-      headers: {
-        'Content-Type': info.contentType || 'application/octet-stream',
-      },
-    })
-  }
-
-  async delete(fileId: string): Promise<void> {
-    await this.client.delete(fileId)
-  }
-
-  async exists(fileId: string): Promise<boolean> {
-    return this.client.exists(fileId)
-  }
-
-  async presignPut(key: string, opts: PresignPutOptions): Promise<string> {
-    return this.client.presign(key, {
-      method: 'PUT',
-      expiresIn: opts.expiresIn,
-      ...(opts.contentType && { type: opts.contentType }),
-    })
-  }
-
-  async presignGet(key: string, opts: PresignGetOptions): Promise<string> {
-    return this.client.presign(key, {
-      method: 'GET',
-      expiresIn: opts.expiresIn,
-    })
-  }
-
-  async stat(
-    key: string,
-  ): Promise<{ size: number; contentType: string } | null> {
-    try {
-      const s = await this.client.stat(key)
-      return { size: s.size, contentType: s.type }
-    } catch {
-      return null
-    }
-  }
-
-  publicUrlFor(key: string): string | undefined {
-    if (!this.publicUrl) return undefined
-    return `${this.publicUrl.replace(/\/$/, '')}/${key}`
-  }
-
-  async list(prefix: string): Promise<string[]> {
-    const res = await this.client.list({ prefix })
-    return res.contents?.map((c) => c.key) ?? []
-  }
-}

package/src/storage/sweep.ts

@@ -1,25 +0,0 @@
-// src/storage/sweep.ts
-import type { AnyDb } from '../dialect'
-import type { BucketStorageRegistry } from './registry'
-
-import { deleteFileMetaRow, listStalePendingFiles } from './file-meta'
-
-/**
- * Reap stale `pending` file-meta rows (two-phase uploads that never confirmed)
- * older than `olderThanMs`. For each, best-effort delete the object (it may
- * never have landed) then remove the meta row. Returns the number reaped.
- */
-export async function sweepOrphans(
-  registry: BucketStorageRegistry,
-  db: AnyDb,
-  olderThanMs: number,
-): Promise<number> {
-  const cutoff = Date.now() - olderThanMs
-  const rows = await listStalePendingFiles(db, cutoff)
-  for (const row of rows) {
-    const adapter = registry.get(row.bucket)?.adapter
-    await adapter?.delete(row.fileId).catch(() => {})
-    await deleteFileMetaRow(db, row.fileId)
-  }
-  return rows.length
-}

package/src/storage/thumbnails.ts

@@ -1,65 +0,0 @@
-import { createHash } from 'node:crypto'
-
-export interface TransformSpec {
-  w?: number
-  h?: number
-  fit?: 'fill' | 'inside'
-  format?: 'webp' | 'jpeg' | 'png' | 'avif'
-  quality?: number
-}
-
-export async function transformImage(
-  input: Buffer,
-  spec: TransformSpec,
-): Promise<Buffer> {
-  let img = new Bun.Image(input)
-
-  if (spec.w !== undefined && spec.h !== undefined) {
-    img = img.resize(spec.w, spec.h, { fit: spec.fit ?? 'fill' })
-  } else if (spec.w !== undefined) {
-    img = img.resize(spec.w)
-  } else if (spec.h !== undefined) {
-    img = img.resize(0, spec.h)
-  }
-
-  const q = spec.quality
-  switch (spec.format) {
-    case 'webp':
-      return img.webp({ quality: q }).buffer()
-    case 'png':
-      return img.png().buffer()
-    case 'avif':
-      return img.avif({ quality: q }).buffer()
-    default:
-      return img.jpeg({ quality: q }).buffer()
-  }
-}
-
-export function transformHash(spec: TransformSpec): string {
-  return createHash('sha256')
-    .update(JSON.stringify(spec))
-    .digest('hex')
-    .slice(0, 16)
-}
-
-export function parseTransformSpec(
-  query: Record<string, string>,
-): TransformSpec | null {
-  const { w, h, fit, format, quality } = query
-  if (!w && !h && !fit && !format && !quality) return null
-
-  const spec: TransformSpec = {}
-  if (w) spec.w = Number(w)
-  if (h) spec.h = Number(h)
-  if (fit === 'fill' || fit === 'inside') spec.fit = fit
-  if (
-    format === 'webp' ||
-    format === 'jpeg' ||
-    format === 'png' ||
-    format === 'avif'
-  ) {
-    spec.format = format
-  }
-  if (quality) spec.quality = Math.min(100, Math.max(1, Number(quality)))
-  return spec
-}

package/src/testing.ts

@@ -1,31 +0,0 @@
-// src/testing.ts — test utilities for Bunderstack applications.
-
-export type AuthSessionResolverLike = {
-  api: {
-    getSession: (opts: { headers: Headers }) => Promise<unknown>
-  }
-}
-
-export type BunderstackAppLike = {
-  auth: unknown
-}
-
-/**
- * Mock the auth session resolver on a Bunderstack app instance for unit testing.
- */
-export function mockAuthSession<
-  TUser extends { id: string; email: string; name?: string; role?: string },
->(
-  app: BunderstackAppLike,
-  resolver: (opts: { headers: Headers }) => Promise<{
-    user: TUser
-    session?: { activeOrganizationId?: string | null } | null
-  } | null>,
-): void {
-  const auth = app.auth as unknown as AuthSessionResolverLike
-  if (auth?.api) {
-    auth.api.getSession = resolver as unknown as (opts: {
-      headers: Headers
-    }) => Promise<unknown>
-  }
-}