@beechcms/api 0.4.0-preview.1 → 0.4.0-preview.11

package/src/public/public-edit.ts

@@ -1,33 +1,20 @@
-import { isValidContentStatus, resolvePolicies } from '@beechcms/core'
+import { isValidContentStatus, resolvePolicies, EntryNotFoundError } from '@beechcms/core'
 import type { Seed } from '@beechcms/core'
 import type { Context } from 'hono'
 import { cleanStr } from '../shared/query-utils'
-import { rowToApiData, buildUpdateBindings } from '../shared/content-utils'
 import { checkPublicOperation } from './access-policy'
 import { publicProblem } from './problem-details'
 import { slugify } from './slug-utils'
 import { sanitizePublicPayload } from './sanitize'
 import { createNotification } from '../shared/notification-service'
-
-type Bindings = {
-  DB: D1Database
-  PUBLIC_READ_API_KEY?: string
-  PUBLIC_WRITE_API_KEY?: string
-  ENV?: string
-}
-
-type Variables = {
-  jwtPayload: { sub: string; email?: string }
-  getSeed: (slug: string) => Seed | null
-  seedRegistry: Record<string, Seed>
-}
+import { AppEnv } from '../types'
 
 const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
-type PublicCtx = Context<{ Bindings: Bindings; Variables: Variables }>
+type PublicCtx = Context<AppEnv>
 type ResolveResult<T> = { ok: true; value: T } | { ok: false; response: Response }
 
-function errorMessage(c: PublicCtx, err: unknown): string {
-  if (c.env.ENV !== 'production' && err instanceof Error) return err.message
+function errorMessage(context: PublicCtx, error: unknown): string {
+  if (context.env.ENV !== 'production' && error instanceof Error) return error.message
   return 'An unexpected error occurred.'
 }
 
@@ -45,48 +32,47 @@ function removeNullishFields(data: Record<string, unknown>): Record<string, unkn
   return next
 }
 
-function parseBody(c: PublicCtx): Promise<ResolveResult<Record<string, unknown>>> {
-  return c.req.json<unknown>()
+function parseBody(context: PublicCtx): Promise<ResolveResult<Record<string, unknown>>> {
+  return context.req.json<unknown>()
     .then((parsed) => ({ ok: true, value: asRecord(parsed) ?? {} }) as const)
     .catch(() => ({
       ok: false,
-      response: publicProblem(c, { type: 'invalid-json-body', title: 'Bad Request', status: 400, detail: 'Invalid JSON body' }),
+      response: publicProblem(context, { type: 'invalid-json-body', title: 'Bad Request', status: 400, detail: 'Invalid JSON body' }),
     }))
 }
 
-function resolveSlug(c: PublicCtx, body: Record<string, unknown>, currentSlug: string): ResolveResult<{ slugRequested: boolean; nextSlug: string }> {
+function resolveSlug(context: PublicCtx, body: Record<string, unknown>, currentSlug: string): ResolveResult<{ slugRequested: boolean; nextSlug: string }> {
   const slugRequested = Object.hasOwn(body, 'slug')
   if (!slugRequested) return { ok: true, value: { slugRequested, nextSlug: currentSlug } }
   const requestedSlug = cleanStr(body.slug)
   if (!requestedSlug) {
-    return { ok: false, response: publicProblem(c, { type: 'invalid-slug', title: 'Bad Request', status: 400, detail: "Field 'slug' must be a non-empty string" }) }
+    return { ok: false, response: publicProblem(context, { type: 'invalid-slug', title: 'Bad Request', status: 400, detail: "Field 'slug' must be a non-empty string" }) }
   }
   return { ok: true, value: { slugRequested, nextSlug: slugify(requestedSlug) } }
 }
 
-function resolveStatus(c: PublicCtx, body: Record<string, unknown>, currentStatus: string): ResolveResult<string> {
+function resolveStatus(context: PublicCtx, body: Record<string, unknown>, currentStatus: string): ResolveResult<string> {
   if (!Object.hasOwn(body, 'status')) return { ok: true, value: currentStatus }
   const statusValue = body.status
   if (!isValidContentStatus(statusValue)) {
-    return { ok: false, response: publicProblem(c, { type: 'invalid-status', title: 'Bad Request', status: 400, detail: 'Invalid status. Allowed values are: draft, review, published' }) }
+    return { ok: false, response: publicProblem(context, { type: 'invalid-status', title: 'Bad Request', status: 400, detail: 'Invalid status. Allowed values are: draft, review, published' }) }
   }
-  return { ok: true, value: statusValue }
+  return { ok: true, value: statusValue as string }
 }
 
 function resolveData(
-  c: PublicCtx,
+  context: PublicCtx,
   seed: Seed,
-  body: Record<string, unknown>,
-  currentRow: Record<string, unknown>
+  body: Record<string, unknown>
 ): ResolveResult<Record<string, unknown>> {
   if (!Object.hasOwn(body, 'data')) {
-    // No data update — return empty patch (caller keeps existing columns)
+    // No data update — return empty patch
     return { ok: true, value: {} }
   }
 
   const rawData = asRecord(body.data)
   if (!rawData) {
-    return { ok: false, response: publicProblem(c, { type: 'invalid-data-object', title: 'Bad Request', status: 400, detail: "Field 'data' must be an object when provided" }) }
+    return { ok: false, response: publicProblem(context, { type: 'invalid-data-object', title: 'Bad Request', status: 400, detail: "Field 'data' must be an object when provided" }) }
   }
 
   const sensitiveAliases = Object.keys(rawData).filter((alias) => {
@@ -94,90 +80,79 @@ function resolveData(
     return branch != null && resolvePolicies(branch).privacy !== 'plain'
   })
   if (sensitiveAliases.length > 0) {
-    return { ok: false, response: publicProblem(c, { type: 'sensitive-field-edit', title: 'Unprocessable Entity', status: 422, detail: `Cannot edit sensitive fields: ${sensitiveAliases.join(', ')}` }) }
+    return { ok: false, response: publicProblem(context, { type: 'sensitive-field-edit', title: 'Unprocessable Entity', status: 422, detail: `Cannot edit sensitive fields: ${sensitiveAliases.join(', ')}` }) }
   }
 
   const sanitized = sanitizePublicPayload(seed, rawData, { allowNull: true, operation: 'update', requireAtLeastOneValidField: true, enforceRequiredFields: true })
   if (!sanitized.ok) {
     if (sanitized.status === 422) {
-      return { ok: false, response: publicProblem(c, { type: sanitized.code, title: 'Unprocessable Entity', status: 422, detail: sanitized.message }) }
+      return { ok: false, response: publicProblem(context, { type: sanitized.code, title: 'Unprocessable Entity', status: 422, detail: sanitized.message }) }
     }
-    return { ok: false, response: publicProblem(c, { type: sanitized.code, title: 'Bad Request', status: 400, detail: sanitized.message, errors: sanitized.details }) }
+    return { ok: false, response: publicProblem(context, { type: sanitized.code, title: 'Bad Request', status: 400, detail: sanitized.message, errors: sanitized.details }) }
   }
 
-  // Merge: current columns + patch, remove nulls
-  const currentAliasData = rowToApiData(seed, currentRow)
-  const merged = removeNullishFields({ ...currentAliasData, ...sanitized.data })
-  return { ok: true, value: merged }
+  return { ok: true, value: removeNullishFields(sanitized.data) }
 }
 
-export async function publicEditHandler(c: PublicCtx) {
-  const seedSlug = c.req.param('seed') ?? ''
-  const id = c.req.param('id') ?? ''
-  const seed = c.get('getSeed')(seedSlug)
+export async function publicEditHandler(context: PublicCtx) {
+  const seedSlug = context.req.param('seed') ?? ''
+  const id = context.req.param('id') ?? ''
+  const seed = context.get('getSeed')(seedSlug)
   if (!seed) {
-    return publicProblem(c, { type: 'seed-not-found', title: 'Seed Not Found', status: 404, detail: `The content type '${seedSlug}' does not exist.` })
+    return publicProblem(context, { type: 'seed-not-found', title: 'Seed Not Found', status: 404, detail: `The content type '${seedSlug}' does not exist.` })
   }
   const access = checkPublicOperation(seed, 'edit')
   if (!access.ok) {
-    return publicProblem(c, { 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 })
   }
 
   if (!UUID_REGEX.test(id)) {
-    return publicProblem(c, { type: 'invalid-entry-id', title: 'Bad Request', status: 400, detail: 'Invalid entry ID format' })
+    return publicProblem(context, { type: 'invalid-entry-id', title: 'Bad Request', status: 400, detail: 'Invalid entry ID format' })
   }
 
-  const table = `content_${seedSlug}`
+  const repository = context.get('repository')
 
   try {
-    const { DB } = c.env
-    const currentRow = await DB.prepare(`SELECT * FROM ${table} WHERE id = ? LIMIT 1`)
-      .bind(id)
-      .first<Record<string, unknown>>()
-
-    if (!currentRow) {
-      return publicProblem(c, { type: 'entry-not-found', title: 'Not Found', status: 404, detail: `Entry '${id}' not found for content type '${seedSlug}'.` })
-    }
+    const entry = await repository.findById(seed, id)
 
-    const bodyResult = await parseBody(c)
+    const bodyResult = await parseBody(context)
     if (!bodyResult.ok) return bodyResult.response
 
-    const slugResult = resolveSlug(c, bodyResult.value, (currentRow.slug as string) ?? '')
+    const slugResult = resolveSlug(context, bodyResult.value, (entry.slug as string) ?? '')
     if (!slugResult.ok) return slugResult.response
 
-    const statusResult = resolveStatus(c, bodyResult.value, (currentRow.status as string) ?? 'draft')
+    const statusResult = resolveStatus(context, bodyResult.value, (entry.status as string) ?? 'draft')
     if (!statusResult.ok) return statusResult.response
 
-    const dataResult = resolveData(c, seed, bodyResult.value, currentRow)
+    const dataResult = resolveData(context, seed, bodyResult.value)
     if (!dataResult.ok) return dataResult.response
 
-    if (slugResult.value.slugRequested) {
-      const slugExisting = await DB.prepare(`SELECT id FROM ${table} WHERE slug = ? AND id != ? LIMIT 1`)
-        .bind(slugResult.value.nextSlug, id)
-        .first<{ id: string }>()
-
-      if (slugExisting) {
-        return publicProblem(c, { type: 'slug-conflict', title: 'Conflict', status: 409, detail: `An entry with slug '${slugResult.value.nextSlug}' already exists for content type '${seedSlug}'.` })
+    if (slugResult.value.slugRequested && slugResult.value.nextSlug !== entry.slug) {
+      const exists = await repository.existsSlug(seed, slugResult.value.nextSlug, id)
+      if (exists) {
+        return publicProblem(context, { type: 'slug-conflict', title: 'Conflict', status: 409, detail: `An entry with slug '${slugResult.value.nextSlug}' already exists for content type '${seedSlug}'.` })
       }
     }
 
-    const now = Math.floor(Date.now() / 1000)
-    const { setClause, bindings } = buildUpdateBindings(seed, dataResult.value)
-    const systemSet = `slug = ?, status = ?, updated_at = ?`
-    const fullSet = setClause ? `${systemSet}, ${setClause}` : systemSet
+    const updateData = { ...dataResult.value }
+    if (slugResult.value.slugRequested) {
+      (updateData as any).slug = slugResult.value.nextSlug
+    }
 
-    await DB.prepare(`UPDATE ${table} SET ${fullSet} WHERE id = ?`)
-      .bind(slugResult.value.nextSlug, statusResult.value, now, ...bindings, id)
-      .run()
+    await repository.update(seed, id, updateData, statusResult.value)
 
-    await createNotification(c, {
+    await createNotification(context, {
       title: `${seed.label}: Modifica`,
       message: `L'entry "${slugResult.value.nextSlug}" è stata modificata via API pubblica.`,
       type: 'info',
     })
 
-    return c.json({ success: true, id, slug: slugResult.value.nextSlug }, 200)
-  } catch (err) {
-    return publicProblem(c, { type: 'internal-server-error', title: 'Internal Server Error', status: 500, detail: errorMessage(c, err) })
+    return context.json({ success: true, id, slug: slugResult.value.nextSlug }, 200)
+  } catch (error) {
+    if (error instanceof EntryNotFoundError) {
+      return publicProblem(context, { type: 'entry-not-found', title: 'Not Found', status: 404, detail: `Entry '${id}' not found for content type '${seedSlug}'.` })
+    }
+    console.error('Public edit error:', error)
+    return publicProblem(context, { type: 'internal-server-error', title: 'Internal Server Error', status: 500, detail: errorMessage(context, error) })
   }
 }

package/src/public/public-read.ts

@@ -1,31 +1,17 @@
-import { resolvePolicies } from '@beechcms/core'
+import { resolvePolicies, EntryNotFoundError } from '@beechcms/core'
 import type { Seed } from '@beechcms/core'
 import type { Context } from 'hono'
 import { cleanStr } from '../shared/query-utils'
-import { rowToApiData } from '../shared/content-utils'
 import { checkPublicOperation } from './access-policy'
 import { publicProblem } from './problem-details'
 import { buildPublicListMeta, buildPublicSingleMeta } from './response-builder'
 import {
-  buildPublicFilterWhereClause,
   parseLatestCount,
   parsePublicFilter,
   parsePublicPagination,
+  toEngineFilters,
 } from './query-builder'
-
-type Bindings = {
-  DB: D1Database
-  PUBLIC_READ_API_KEY?: string
-  PUBLIC_WRITE_API_KEY?: string
-  PUBLIC_PUBLISHED_ONLY?: string
-  ENV?: string
-}
-
-type Variables = {
-  jwtPayload: { sub: string; email?: string }
-  getSeed: (slug: string) => Seed | null
-  seedRegistry: Record<string, Seed>
-}
+import { AppEnv } from '../types'
 
 function buildSeedNotFoundMessage(seed: string, seedRegistry: Record<string, Seed>): string {
   const available = Object.keys(seedRegistry).join(', ')
@@ -33,10 +19,17 @@ function buildSeedNotFoundMessage(seed: string, seedRegistry: Record<string, See
 }
 
 /** Applica policy public/visibility per la Public API. */
-function applyPublicPolicies(aliasData: Record<string, unknown>, seed: Seed): Record<string, unknown> {
+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 = aliasData[branch.alias]
+    const value = data[branch.alias]
     const { public: isPublic, visibility } = resolvePolicies(branch)
     if (!isPublic) continue
     if (visibility === 'hidden') continue
@@ -49,22 +42,24 @@ function applyPublicPolicies(aliasData: Record<string, unknown>, seed: Seed): Re
   return result
 }
 
-function toFlatPublicEntry(row: Record<string, unknown>, seed: Seed, fieldsParam?: string): Record<string, unknown> {
-  const aliasData = applyPublicPolicies(rowToApiData(seed, row), seed)
-  const base: Record<string, unknown> = {
-    id: row.id,
-    slug: row.slug,
-    status: row.status,
-    created_at: row.created_at,
-    updated_at: row.updated_at,
-  }
+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 { ...base, ...aliasData }
+  
+  if (requestedFields.length === 0) return aliasData
+  
   const filteredData: Record<string, unknown> = {}
   for (const field of requestedFields) {
     if (field in aliasData) filteredData[field] = aliasData[field]
   }
-  return { ...base, ...filteredData }
+  
+  // 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(
@@ -82,74 +77,85 @@ function withCache(
   return response
 }
 
-function buildInternalErrorMessage(c: Context<{ Bindings: Bindings; Variables: Variables }>, err: unknown): string {
-  if (c.env.ENV !== 'production' && err instanceof Error) return err.message
+function buildInternalErrorMessage(context: Context<AppEnv>, error: unknown): string {
+  if (context.env.ENV !== 'production' && error instanceof Error) return error.message
   return 'An unexpected error occurred.'
 }
 
-function buildOrderSql(seed: Seed, query: Record<string, string | undefined>, hasLatest: boolean): string {
-  if (hasLatest) return 'ORDER BY created_at DESC'
-  const orderBy = cleanStr(query.orderBy) ?? ''
-  const orderDir = (cleanStr(query.orderDir) ?? 'desc').toLowerCase()
-  if (orderBy === 'created_at' || orderBy === 'updated_at') {
-    return `ORDER BY ${orderBy} ${orderDir === 'asc' ? 'ASC' : 'DESC'}`
-  }
-  // Branch column — always a real column in v0.4.0
-  const branch = seed.branches.find((b) => b.alias === orderBy)
-  if (branch) {
-    const dir = orderDir === 'asc' ? 'ASC' : 'DESC'
-    return `ORDER BY ${branch.alias} ${dir} NULLS LAST`
-  }
-  return 'ORDER BY created_at DESC'
-}
-
-export async function publicReadHandler(c: Context<{ Bindings: Bindings; Variables: Variables }>) {
-  const seedSlug = c.req.param('seed') ?? ''
-  const seed = c.get('getSeed')(seedSlug)
+export async function publicReadHandler(context: Context<AppEnv>) {
+  const seedSlug = context.req.param('seed') ?? ''
+  const seed = context.get('getSeed')(seedSlug)
   if (!seed) {
-    return publicProblem(c, {
-      type: 'seed-not-found', title: 'Seed Not Found', status: 404,
-      detail: buildSeedNotFoundMessage(seedSlug, c.get('seedRegistry')),
+    return publicProblem(context, {
+      type: 'seed-not-found', 
+      title: 'Seed Not Found', 
+      status: 404,
+      detail: buildSeedNotFoundMessage(seedSlug, context.get('seedRegistry')),
     })
   }
+  
   const access = checkPublicOperation(seed, 'read')
   if (!access.ok) {
-    return publicProblem(c, { 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 = c.executionCtx as typeof executionCtx
+    executionCtx = context.executionCtx as typeof executionCtx
   } catch {}
 
-  const cacheKey = c.req.raw
+  const cacheKey = context.req.raw
   if (cache) {
     const hit = await cache.match(cacheKey)
     if (hit) return hit
   }
 
-  const query = c.req.query()
+  const query = context.req.query()
   const id = cleanStr(query.id)
-  const table = `content_${seedSlug}`
-  const publishedOnly = c.env.PUBLIC_PUBLISHED_ONLY !== 'false'
+  const slug = cleanStr(query.slug)
+  const publishedOnly = context.env.PUBLIC_PUBLISHED_ONLY !== 'false'
+  const repository = context.get('repository')
 
   try {
-    const { DB } = c.env
-
-    if (id) {
-      const row = await DB.prepare(
-        `SELECT * FROM ${table} WHERE id = ? ${publishedOnly ? "AND status = 'published'" : ''} LIMIT 1`
-      ).bind(id).first<Record<string, unknown>>()
-
-      if (!row) {
-        return publicProblem(c, { type: 'entry-not-found', title: 'Not Found', status: 404, detail: `Entry '${id}' not found for content type '${seedSlug}'.` })
+    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
       }
-
-      return withCache(cache, executionCtx, cacheKey,
-        c.json({ data: toFlatPublicEntry(row, seed, query.fields), meta: buildPublicSingleMeta(seedSlug) }, 200)
-      )
     }
 
     const parsedFilter = parsePublicFilter(query.filter)
@@ -160,58 +166,51 @@ export async function publicReadHandler(c: Context<{ Bindings: Bindings; Variabl
     const offset = (pagination.page - 1) * pagination.limit
     const search = cleanStr(query.search) ?? ''
 
-    const whereParts: string[] = []
-    const whereBindings: Array<string | number> = []
-    if (publishedOnly) whereParts.push("status = 'published'")
-
-    if (search) {
-      // Search against slug and text/richtext columns
-      const searchableBranches = seed.branches.filter((b) => ['text', 'richtext'].includes(b.type))
-      const term = `%${search}%`
-      const searchExprs = ['slug LIKE ?', ...searchableBranches.map((b) => `${b.alias} LIKE ?`)]
-      whereParts.push(`(${searchExprs.join(' OR ')})`)
-      whereBindings.push(term, ...searchableBranches.map(() => term))
-    }
-
-    const filterClause = buildPublicFilterWhereClause(seed, parsedFilter)
-    if (filterClause.clause) {
-      whereParts.push(`(${filterClause.clause})`)
-      whereBindings.push(...filterClause.bindings)
-    }
-
-    const whereSql = whereParts.length > 0 ? `WHERE ${whereParts.join(' AND ')}` : ''
-    const countRow = await DB.prepare(`SELECT COUNT(*) as total FROM ${table} ${whereSql}`)
-      .bind(...whereBindings)
-      .first<{ total: number }>()
-    const total = countRow?.total ?? 0
-
-    const orderSql = buildOrderSql(seed, query, latestMode)
-    const effectiveLimit = latestMode ? (latestCount ?? 10) : pagination.limit
-    const effectiveOffset = latestMode ? 0 : offset
-
-    const rowsResult = await DB.prepare(`SELECT * FROM ${table} ${whereSql} ${orderSql} LIMIT ? OFFSET ?`)
-      .bind(...whereBindings, effectiveLimit, effectiveOffset)
-      .all<Record<string, unknown>>()
+    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 rows = rowsResult.results ?? []
-    const data = rows.map((row) => toFlatPublicEntry(row, seed, query.fields))
+    const data = items.map((item) => toFlatPublicEntry(item, seed, query.fields))
 
     if (latestMode) {
       return withCache(cache, executionCtx, cacheKey,
-        c.json({ data, meta: { total, returned: data.length, seed: seedSlug } }, 200)
+        context.json({ data, meta: { total, returned: data.length, seed: seedSlug } }, 200)
       )
     }
 
     return withCache(cache, executionCtx, cacheKey,
-      c.json({
+      context.json({
         data,
-        meta: buildPublicListMeta({ total, page: pagination.page, limit: effectiveLimit, returned: data.length, seed: seedSlug }),
+        meta: buildPublicListMeta({ 
+          total, 
+          page: pagination.page, 
+          limit: latestMode ? (latestCount ?? 10) : pagination.limit, 
+          returned: data.length, 
+          seed: seedSlug 
+        }),
       }, 200)
     )
-  } catch (err) {
-    if (err instanceof Error && err.message.startsWith('Invalid filter:')) {
-      return publicProblem(c, { type: 'invalid-filter', title: 'Bad Request', status: 400, detail: err.message })
+  } 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 })
     }
-    return publicProblem(c, { type: 'internal-server-error', title: 'Internal Server Error', status: 500, detail: buildInternalErrorMessage(c, err) })
+    console.error('Public read error:', error)
+    return publicProblem(context, { 
+      type: 'internal-server-error', 
+      title: 'Internal Server Error', 
+      status: 500, 
+      detail: buildInternalErrorMessage(context, error) 
+    })
   }
 }