@beechcms/api 0.4.1 → 0.4.3

package/src/public/public-read.ts

@@ -1,119 +1,34 @@
-import { resolvePolicies, EntryNotFoundError } from '@beechcms/core'
-import type { Seed, ISeedRegistry } from '@beechcms/core'
 import type { Context } from 'hono'
 import { cleanStr } from '../shared/query-utils'
 import { checkPublicOperation } from './access-policy'
-import { publicProblem } from './problem-details'
-import { buildPublicListMeta, buildPublicSingleMeta } from './response-builder'
-import {
-  parseLatestCount,
-  parsePublicFilter,
-  parsePublicPagination,
-  toEngineFilters,
-} from './query-builder'
+import { publicProblem, internalErrorDetail } from './problem-details'
+import { resolveEdgeCache, withCachedResponse } from './cache-utils'
+import { readSingleEntry } from './read-single'
+import { readListEntries } from './read-list'
 import { AppEnv } from '../types'
 
-function buildSeedNotFoundMessage(seed: string, seedRegistry: ISeedRegistry): string {
-  const available = seedRegistry.all().map(s => s.slug).join(', ')
-  return `The content type '${seed}' does not exist. Available types: ${available}.`
-}
-
-/** Applies public/visibility policies for the Public API. */
-function applyPublicPolicies(data: Record<string, unknown>, seed: Seed): Record<string, unknown> {
-  const result: Record<string, unknown> = {}
-  
-  // System fields are mapped to top-level for public API
-  const system = ['id', 'slug', 'status', 'created_at', 'updated_at']
-  for (const key of system) {
-    if (key in data) result[key] = data[key]
-  }
-
-  for (const branch of seed.branches) {
-    const value = data[branch.alias]
-    const { public: isPublic, visibility } = resolvePolicies(branch)
-    if (!isPublic) continue
-    if (visibility === 'hidden') continue
-    if (visibility === 'masked') {
-      result[branch.alias] = typeof value === 'string' && value.length > 0 ? '••••••••' : null
-    } else {
-      result[branch.alias] = value
-    }
-  }
-  return result
-}
-
-function toFlatPublicEntry(data: Record<string, unknown>, seed: Seed, fieldsParam?: string): Record<string, unknown> {
-  const aliasData = applyPublicPolicies(data, seed)
-  const requestedFields = (fieldsParam ?? '').split(',').map((f) => f.trim()).filter(Boolean)
-  
-  if (requestedFields.length === 0) return aliasData
-  
-  const filteredData: Record<string, unknown> = {}
-  for (const field of requestedFields) {
-    if (field in aliasData) filteredData[field] = aliasData[field]
-  }
-  
-  // Always include basic identity fields if they exist in filtered data or if requested
-  const identity = ['id', 'slug']
-  for (const key of identity) {
-    if (key in aliasData && !filteredData[key]) filteredData[key] = aliasData[key]
-  }
-  
-  return filteredData
-}
-
-function withCache(
-  cache: Cache | undefined,
-  executionCtx: { waitUntil: (p: Promise<unknown>) => void } | undefined,
-  cacheKey: Request,
-  response: Response
-): Response {
-  if (cache && executionCtx) {
-    const cloned = response.clone()
-    const headers = new Headers(cloned.headers)
-    headers.set('Cache-Control', 'public, max-age=60')
-    executionCtx.waitUntil(cache.put(cacheKey, new Response(cloned.body, { status: cloned.status, headers })))
-  }
-  return response
-}
-
-function buildInternalErrorMessage(context: Context<AppEnv>, error: unknown): string {
-  if (context.env.ENV !== 'production' && error instanceof Error) return error.message
-  return 'An unexpected error occurred.'
-}
-
 export async function publicReadHandler(context: Context<AppEnv>) {
   const seedSlug = context.req.param('seed') ?? ''
   const seed = context.get('getSeed')(seedSlug)
   if (!seed) {
+    const available = context.get('seedRegistry').all().map(s => s.slug).join(', ')
     return publicProblem(context, {
-      type: 'seed-not-found', 
-      title: 'Seed Not Found', 
+      type: 'seed-not-found',
+      title: 'Seed Not Found',
       status: 404,
-      detail: buildSeedNotFoundMessage(seedSlug, context.get('seedRegistry')),
+      detail: `The content type '${seedSlug}' does not exist. Available types: ${available}.`,
     })
   }
-  
+
   const access = checkPublicOperation(seed, 'read')
   if (!access.ok) {
-    return publicProblem(context, { 
-      type: 'operation-not-allowed', 
-      title: access.error.error, 
-      status: 403, 
-      detail: access.error.message 
-    })
+    return publicProblem(context, { type: 'operation-not-allowed', title: access.error.error, status: 403, detail: access.error.message })
   }
 
-  let cache: Cache | undefined
-  let executionCtx: { waitUntil: (p: Promise<unknown>) => void } | undefined
-  try {
-    cache = caches.default
-    executionCtx = context.executionCtx as typeof executionCtx
-  } catch {}
-
+  const edgeCache = resolveEdgeCache(context)
   const cacheKey = context.req.raw
-  if (cache) {
-    const hit = await cache.match(cacheKey)
+  if (edgeCache) {
+    const hit = await edgeCache.cache.match(cacheKey)
     if (hit) return hit
   }
 
@@ -125,92 +40,20 @@ export async function publicReadHandler(context: Context<AppEnv>) {
 
   try {
     if (id || slug) {
-      try {
-        const entry = id 
-          ? await repository.findById(seed, id)
-          : await repository.findBySlug(seed, slug!)
-        
-        if (publishedOnly && entry.status !== 'published') {
-          return publicProblem(context, { 
-            type: 'entry-not-found', 
-            title: 'Not Found', 
-            status: 404, 
-            detail: `Entry '${id || slug}' not found or not published.` 
-          })
-        }
-
-        return withCache(cache, executionCtx, cacheKey,
-          context.json({ 
-            data: toFlatPublicEntry(entry, seed, query.fields), 
-            meta: buildPublicSingleMeta(seedSlug) 
-          }, 200)
-        )
-      } catch (error) {
-        if (error instanceof EntryNotFoundError) {
-          return publicProblem(context, { 
-            type: 'entry-not-found', 
-            title: 'Not Found', 
-            status: 404, 
-            detail: `Entry '${id || slug}' not found for content type '${seedSlug}'.` 
-          })
-        }
-        throw error
+      const result = await readSingleEntry({ seed, seedSlug, repository, id, slug, publishedOnly, fieldsParam: query.fields })
+      if (!result.ok) {
+        return publicProblem(context, { type: 'entry-not-found', title: 'Not Found', status: 404, detail: result.detail })
       }
+      return withCachedResponse(edgeCache, cacheKey, context.json({ data: result.data, meta: result.meta }, 200))
     }
 
-    const parsedFilter = parsePublicFilter(query.filter)
-    const allMode = cleanStr(query.all)?.toLowerCase() === 'true'
-    const latestMode = cleanStr(query.latest) !== null
-    const latestCount = latestMode ? parseLatestCount(query.latest ?? '') : null
-    const pagination = allMode ? { page: 1, limit: 100 } : parsePublicPagination(query)
-    const offset = (pagination.page - 1) * pagination.limit
-    const search = cleanStr(query.search) ?? ''
-
-    const engineFilters = toEngineFilters(seed, parsedFilter)
-    const sortBy = cleanStr(query.orderBy) ?? 'created_at'
-    const sortDir = (cleanStr(query.orderDir) ?? 'desc').toLowerCase() === 'asc' ? 'ASC' : 'DESC'
-
-    const { items, total } = await repository.findMany(seed, {
-      filters: engineFilters,
-      search: search || undefined,
-      status: publishedOnly ? 'published' : null,
-      pagination: { 
-        limit: latestMode ? (latestCount ?? 10) : pagination.limit, 
-        offset: latestMode ? 0 : offset 
-      },
-      orderBy: latestMode ? { column: 'created_at', dir: 'DESC' } : { column: sortBy, dir: sortDir }
-    })
-
-    const data = items.map((item) => toFlatPublicEntry(item, seed, query.fields))
-
-    if (latestMode) {
-      return withCache(cache, executionCtx, cacheKey,
-        context.json({ data, meta: { total, returned: data.length, seed: seedSlug } }, 200)
-      )
-    }
-
-    return withCache(cache, executionCtx, cacheKey,
-      context.json({
-        data,
-        meta: buildPublicListMeta({ 
-          total, 
-          page: pagination.page, 
-          limit: latestMode ? (latestCount ?? 10) : pagination.limit, 
-          returned: data.length, 
-          seed: seedSlug 
-        }),
-      }, 200)
-    )
+    const result = await readListEntries({ seed, seedSlug, repository, query, publishedOnly })
+    return withCachedResponse(edgeCache, cacheKey, context.json(result, 200))
   } catch (error) {
     if (error instanceof Error && error.message.startsWith('Invalid filter:')) {
       return publicProblem(context, { type: 'invalid-filter', title: 'Bad Request', status: 400, detail: error.message })
     }
     console.error('Public read error:', error)
-    return publicProblem(context, { 
-      type: 'internal-server-error', 
-      title: 'Internal Server Error', 
-      status: 500, 
-      detail: buildInternalErrorMessage(context, error) 
-    })
+    return publicProblem(context, { type: 'internal-server-error', title: 'Internal Server Error', status: 500, detail: internalErrorDetail(context.env, error) })
   }
 }

package/src/public/read-list.ts

@@ -0,0 +1,50 @@
+import type { Seed, ContentRepository } from '@beechcms/core'
+import { cleanStr } from '../shared/query-utils'
+import { toFlatPublicEntry } from './entry-projection'
+import { buildPublicListMeta } from './response-builder'
+import { parsePublicFilter, parsePublicPagination, parseLatestCount, toEngineFilters } from './query-builder'
+
+type ReadListInput = {
+  seed: Seed
+  seedSlug: string
+  repository: ContentRepository
+  query: Record<string, string | undefined>
+  publishedOnly: boolean
+}
+
+export async function readListEntries(input: ReadListInput) {
+  const { seed, seedSlug, repository, query, publishedOnly } = input
+
+  const parsedFilter = parsePublicFilter(query.filter)
+  const allMode = cleanStr(query.all)?.toLowerCase() === 'true'
+  const latestMode = cleanStr(query.latest) !== null
+  const latestCount = latestMode ? parseLatestCount(query.latest ?? '') : null
+  const pagination = allMode ? { page: 1, limit: 100 } : parsePublicPagination(query)
+  const offset = (pagination.page - 1) * pagination.limit
+  const search = cleanStr(query.search) ?? ''
+  const engineFilters = toEngineFilters(seed, parsedFilter)
+  const sortBy = cleanStr(query.orderBy) ?? 'created_at'
+  const sortDir = (cleanStr(query.orderDir) ?? 'desc').toLowerCase() === 'asc' ? 'ASC' : 'DESC'
+
+  const { items, total } = await repository.findMany(seed, {
+    filters: engineFilters,
+    search: search || undefined,
+    status: publishedOnly ? 'published' : null,
+    pagination: {
+      limit: latestMode ? (latestCount ?? 10) : pagination.limit,
+      offset: latestMode ? 0 : offset,
+    },
+    orderBy: latestMode ? { column: 'created_at', dir: 'DESC' } : { column: sortBy, dir: sortDir },
+  })
+
+  const data = items.map(item => toFlatPublicEntry(item, seed, query.fields))
+
+  if (latestMode) {
+    return { data, meta: { total, returned: data.length, seed: seedSlug } }
+  }
+
+  return {
+    data,
+    meta: buildPublicListMeta({ total, page: pagination.page, limit: pagination.limit, returned: data.length, seed: seedSlug }),
+  }
+}

package/src/public/read-single.ts

@@ -0,0 +1,44 @@
+import { EntryNotFoundError } from '@beechcms/core'
+import type { Seed, ContentRepository } from '@beechcms/core'
+import { toFlatPublicEntry } from './entry-projection'
+import { buildPublicSingleMeta } from './response-builder'
+
+type ReadSingleInput = {
+  seed: Seed
+  seedSlug: string
+  repository: ContentRepository
+  id: string | null
+  slug: string | null
+  publishedOnly: boolean
+  fieldsParam?: string
+}
+
+export type ReadSingleResult =
+  | { ok: true; data: Record<string, unknown>; meta: { seed: string } }
+  | { ok: false; detail: string }
+
+export async function readSingleEntry(input: ReadSingleInput): Promise<ReadSingleResult> {
+  const { seed, seedSlug, repository, id, slug, publishedOnly, fieldsParam } = input
+  const label = id ?? slug!
+
+  try {
+    const entry = id
+      ? await repository.findById(seed, id)
+      : await repository.findBySlug(seed, slug!)
+
+    if (publishedOnly && entry.status !== 'published') {
+      return { ok: false, detail: `Entry '${label}' not found or not published.` }
+    }
+
+    return {
+      ok: true,
+      data: toFlatPublicEntry(entry, seed, fieldsParam),
+      meta: buildPublicSingleMeta(seedSlug),
+    }
+  } catch (error) {
+    if (error instanceof EntryNotFoundError) {
+      return { ok: false, detail: `Entry '${label}' not found for content type '${seedSlug}'.` }
+    }
+    throw error
+  }
+}

package/src/shared/automations.repository.d1.ts

@@ -0,0 +1,146 @@
+import type {
+  IAutomationRepository,
+  Automation,
+  AutomationAction,
+  AutomationTrigger,
+  AutomationTriggerEvent,
+  CreateAutomationInput,
+  UpdateAutomationInput,
+  WhenNode,
+} from '@beechcms/core'
+
+interface AutomationRow {
+  id: string
+  seed_slug: string
+  name: string
+  enabled: number
+  triggers: string
+  trigger_conditions: string | null
+  actions: string
+  created_at: number
+  updated_at: number
+}
+
+export class D1AutomationRepository implements IAutomationRepository {
+  constructor(private readonly db: D1Database) {}
+
+  async findActive(seedSlug: string, event: AutomationTriggerEvent): Promise<Automation[]> {
+    const result = seedSlug === '*'
+      ? await this.db
+          .prepare(
+            `SELECT DISTINCT a.* FROM automations a, json_each(a.triggers) t
+             WHERE a.enabled = 1 AND json_extract(t.value, '$.event') = ?`,
+          )
+          .bind(event)
+          .all<AutomationRow>()
+      : await this.db
+          .prepare(
+            `SELECT DISTINCT a.* FROM automations a, json_each(a.triggers) t
+             WHERE a.seed_slug = ? AND a.enabled = 1 AND json_extract(t.value, '$.event') = ?`,
+          )
+          .bind(seedSlug, event)
+          .all<AutomationRow>()
+    return (result.results ?? []).map(rowToAutomation)
+  }
+
+  async list(seedSlug: string): Promise<Automation[]> {
+    const result = await this.db
+      .prepare(`SELECT * FROM automations WHERE seed_slug = ? ORDER BY created_at DESC`)
+      .bind(seedSlug)
+      .all<AutomationRow>()
+    return (result.results ?? []).map(rowToAutomation)
+  }
+
+  async findById(id: string): Promise<Automation | null> {
+    const row = await this.db
+      .prepare(`SELECT * FROM automations WHERE id = ?`)
+      .bind(id)
+      .first<AutomationRow>()
+    return row ? rowToAutomation(row) : null
+  }
+
+  async create(input: CreateAutomationInput): Promise<string> {
+    const id = crypto.randomUUID()
+    const now = Math.floor(Date.now() / 1000)
+    await this.db
+      .prepare(
+        `INSERT INTO automations
+           (id, seed_slug, name, enabled, triggers, trigger_conditions, actions, created_at, updated_at)
+         VALUES (?, ?, ?, 1, ?, ?, ?, ?, ?)`,
+      )
+      .bind(
+        id,
+        input.seed_slug,
+        input.name,
+        JSON.stringify(input.triggers),
+        input.trigger_conditions ? JSON.stringify(input.trigger_conditions) : null,
+        JSON.stringify(input.actions),
+        now,
+        now,
+      )
+      .run()
+    return id
+  }
+
+  async update(id: string, input: UpdateAutomationInput): Promise<void> {
+    const now = Math.floor(Date.now() / 1000)
+    const fields: string[] = []
+    const values: unknown[] = []
+
+    const map: Record<string, unknown> = {
+      seed_slug: input.seed_slug,
+      name: input.name,
+      triggers: input.triggers !== undefined ? JSON.stringify(input.triggers) : undefined,
+      trigger_conditions:
+        input.trigger_conditions !== undefined
+          ? input.trigger_conditions === null
+            ? null
+            : JSON.stringify(input.trigger_conditions)
+          : undefined,
+      actions: input.actions !== undefined ? JSON.stringify(input.actions) : undefined,
+    }
+
+    for (const [column, value] of Object.entries(map)) {
+      if (value !== undefined) {
+        fields.push(`${column} = ?`)
+        values.push(value)
+      }
+    }
+
+    if (fields.length === 0) return
+
+    values.push(now, id)
+    await this.db
+      .prepare(`UPDATE automations SET ${fields.join(', ')}, updated_at = ? WHERE id = ?`)
+      .bind(...values)
+      .run()
+  }
+
+  async toggle(id: string, enabled: boolean): Promise<void> {
+    const now = Math.floor(Date.now() / 1000)
+    await this.db
+      .prepare(`UPDATE automations SET enabled = ?, updated_at = ? WHERE id = ?`)
+      .bind(enabled ? 1 : 0, now, id)
+      .run()
+  }
+
+  async delete(id: string): Promise<void> {
+    await this.db.prepare(`DELETE FROM automations WHERE id = ?`).bind(id).run()
+  }
+}
+
+function rowToAutomation(row: AutomationRow): Automation {
+  return {
+    id: row.id,
+    seed_slug: row.seed_slug,
+    name: row.name,
+    enabled: row.enabled === 1,
+    triggers: JSON.parse(row.triggers) as AutomationTrigger[],
+    trigger_conditions: row.trigger_conditions
+      ? (JSON.parse(row.trigger_conditions) as WhenNode)
+      : null,
+    actions: JSON.parse(row.actions) as AutomationAction[],
+    created_at: row.created_at,
+    updated_at: row.updated_at,
+  }
+}

package/src/shared/d1-content-scan.repository.test.ts

@@ -0,0 +1,76 @@
+import { describe, it, expect, vi } from 'vitest'
+import type { Seed } from '@beechcms/core'
+import { D1ContentScanRepository } from './d1-content-scan.repository'
+
+function makeMockDb(allResults: unknown[] = []) {
+  const allMock = vi.fn().mockResolvedValue({ results: allResults })
+  const prepareMock = vi.fn(() => ({ all: allMock }))
+  return { db: { prepare: prepareMock } as any, prepareMock, allMock }
+}
+
+describe('D1ContentScanRepository', () => {
+  it('returns empty set if seeds list is empty', async () => {
+    const { db, prepareMock } = makeMockDb()
+    const repo = new D1ContentScanRepository(db)
+    const result = await repo.getReferencedMediaKeys([])
+    expect(result.size).toBe(0)
+    expect(prepareMock).not.toHaveBeenCalled()
+  })
+
+  it('skips seeds with no file branches', async () => {
+    const { db, prepareMock } = makeMockDb()
+    const repo = new D1ContentScanRepository(db)
+    const seedWithoutFile: Seed = {
+      slug: 'posts',
+      label: 'Post',
+      displayNameAlias: 'title',
+      branches: [
+        { alias: 'title', type: 'text', label: 'Title' },
+      ],
+    }
+    const result = await repo.getReferencedMediaKeys([seedWithoutFile])
+    expect(result.size).toBe(0)
+    expect(prepareMock).not.toHaveBeenCalled()
+  })
+
+  it('extracts referenced media keys from file columns', async () => {
+    const mockResults = [
+      { cover: '/api/media/image1.jpg', gallery: '/api/media/img2.png /api/media/img3%20spaced.jpg' },
+      { cover: null, gallery: 'no-media-here' },
+    ]
+    const { db, prepareMock } = makeMockDb(mockResults)
+    const repo = new D1ContentScanRepository(db)
+    const seedWithFiles: Seed = {
+      slug: 'articles',
+      label: 'Article',
+      displayNameAlias: 'title',
+      branches: [
+        { alias: 'title', type: 'text', label: 'Title' },
+        { alias: 'cover', type: 'file', label: 'Cover' },
+        { alias: 'gallery', type: 'file', label: 'Gallery' },
+      ],
+    }
+
+    const result = await repo.getReferencedMediaKeys([seedWithFiles])
+    expect(prepareMock).toHaveBeenCalledWith('SELECT cover, gallery FROM content_articles')
+    expect(result).toEqual(new Set(['image1.jpg', 'img2.png', 'img3 spaced.jpg']))
+  })
+
+  it('handles null or missing results gracefully', async () => {
+    const allMock = vi.fn().mockResolvedValue({ results: null })
+    const prepareMock = vi.fn(() => ({ all: allMock }))
+    const db = { prepare: prepareMock } as any
+    const repo = new D1ContentScanRepository(db)
+    const seedWithFiles: Seed = {
+      slug: 'articles',
+      label: 'Article',
+      displayNameAlias: 'title',
+      branches: [
+        { alias: 'cover', type: 'file', label: 'Cover' },
+      ],
+    }
+
+    const result = await repo.getReferencedMediaKeys([seedWithFiles])
+    expect(result.size).toBe(0)
+  })
+})

package/src/shared/execution-context-scheduler.ts

@@ -0,0 +1,9 @@
+import type { IScheduler } from '@beechcms/core'
+
+export class ExecutionContextScheduler implements IScheduler {
+  constructor(private readonly ctx: ExecutionContext) {}
+
+  waitUntil(promise: Promise<unknown>): void {
+    this.ctx.waitUntil(promise)
+  }
+}

package/src/shared/storage-utils.ts

@@ -12,13 +12,13 @@ export async function getBucketSize(client: S3Client, bucketName: string): Promi
 
   try {
     while (isTruncatedFlag) {
-      const command = new ListObjectsV2Command({
+      const command: ListObjectsV2Command = new ListObjectsV2Command({
         Bucket: bucketName,
         ContinuationToken: continuationToken,
       })
 
-      const response = (await client.send(command)) as ListObjectsV2CommandOutput
-      
+      const response: ListObjectsV2CommandOutput = await client.send(command)
+
       if (response.Contents) {
         for (const obj of response.Contents) {
           totalSize += obj.Size ?? 0

package/src/types.ts

@@ -1,5 +1,5 @@
 /// <reference types="@cloudflare/workers-types" />
-import type { Seed, ContentRepository, IdempotencyRepository, BeechBucket, MediaRepository, SystemStatsRepository, IHashProvider, ITokenService, IUserRepository, ISessionRepository, IPasswordResetTokenRepository, IActivityLogger, IActivityLogRepository, INotificationRepository, INotificationService, IWidgetRepository, ISearchRepository, IAnalyticsRepository, IContentScanRepository, ISeedRegistry, IClock, IIdGenerator } from '@beechcms/core'
+import type { Seed, ContentRepository, IdempotencyRepository, BeechBucket, MediaRepository, SystemStatsRepository, IHashProvider, ITokenService, IUserRepository, ISessionRepository, IPasswordResetTokenRepository, IActivityLogger, IActivityLogRepository, INotificationRepository, INotificationService, IWidgetRepository, ISearchRepository, IAnalyticsRepository, IContentScanRepository, ISeedRegistry, IClock, IIdGenerator, IAutomationRunner, IAutomationRepository, IScheduler } from '@beechcms/core'
 import type { IRateLimiterRegistry } from './middleware/rate-limit.middleware'
 
 export interface Env {
@@ -23,6 +23,7 @@ export interface Env {
   MEDIA_BASE_URL?: string
   MEDIA_CDN_URL?: string
   RESEND_API_KEY?: string
+  EMAIL_API_KEY?: string
   APP_URL?: string
   EMAIL_FROM?: string
   FORGOT_PASSWORD_RATE_LIMITER?: RateLimit
@@ -58,6 +59,9 @@ export interface Variables {
   contentScanRepository: IContentScanRepository
   clock: IClock
   idGenerator: IIdGenerator
+  automationRepository: IAutomationRepository
+  automationRunner: IAutomationRunner
+  scheduler: IScheduler
 }
 
 export type AppEnv = { Bindings: Env; Variables: Variables }

package/src/upload.ts

@@ -158,7 +158,7 @@ uploadRoutes.post('/upload', async (c) => {
 uploadRoutes.delete('/upload/:key', async (c) => {
   const key = c.req.param('key')
   if (!key) return c.json({ error: 'Missing key' }, 400)
-  
+
   await deleteR2Objects(c, [decodeURIComponent(key)])
   return c.json({ success: true }, 200)
 })
@@ -178,9 +178,10 @@ export async function serveMediaHandler(c: any): Promise<Response> {
     const headers = new Headers()
     headers.set('Content-Type', object.contentType ?? 'application/octet-stream')
     headers.set('Cache-Control', 'public, max-age=31536000, immutable')
-    
+
     return new Response(object.body, { status: 200, headers })
   } catch (err) {
+    console.error(`[serveMediaHandler] Error serving file ${key}:`, err)
     return new Response('Internal error', { status: 500 })
   }
 }