@beechcms/api 0.6.0-preview.1 → 0.6.0-preview.3

package/src/public/problem-details.ts

@@ -1,124 +0,0 @@
-// SPDX-License-Identifier: BUSL-1.1
-// Copyright (c) 2024–2026 Flavio De Musso. All rights reserved.
-// See LICENSE in the repository root for license terms.
-
-import type { Context } from 'hono'
-
-// ──────────────────────────────────────────────────────────────────────────────
-// FK / SQLite error detection
-// ──────────────────────────────────────────────────────────────────────────────
-
-type FkViolationKind = 'relation-in-use' | 'relation-target-not-found' | 'foreign-key-violation'
-
-function isFkError(error: unknown): boolean {
-  if (!(error instanceof Error)) return false
-  // D1 surfaces the error in .message
-  if (/FOREIGN KEY constraint failed/i.test(error.message)) return true
-  // Some runtimes expose cause.code
-  const cause = (error as { cause?: { code?: string } }).cause
-  if (cause?.code === 'SQLITE_CONSTRAINT_FOREIGNKEY') return true
-  return false
-}
-
-/**
- * Classify a SQLite FK error by HTTP method.
- * - DELETE  → the referenced row is still used → relation-in-use
- * - POST/PUT/PATCH → referenced parent does not exist → relation-target-not-found
- * - anything else → generic foreign-key-violation
- */
-function classifyFkError(method: string): FkViolationKind {
-  const m = method.toUpperCase()
-  if (m === 'DELETE') return 'relation-in-use'
-  if (m === 'POST' || m === 'PUT' || m === 'PATCH') return 'relation-target-not-found'
-  return 'foreign-key-violation'
-}
-
-const FK_PROBLEM: Record<FkViolationKind, { title: string; status: 409 | 422; detail: string }> = {
-  'relation-in-use': {
-    title: 'Relation In Use',
-    status: 409,
-    detail: 'The record cannot be deleted because it is referenced by one or more related entries.',
-  },
-  'relation-target-not-found': {
-    title: 'Relation Target Not Found',
-    status: 422,
-    detail: 'The provided relation id does not match any existing record in the referenced collection.',
-  },
-  'foreign-key-violation': {
-    title: 'Foreign Key Violation',
-    status: 409,
-    detail: 'The operation violates a referential integrity constraint.',
-  },
-}
-
-/**
- * Returns a Problem+JSON response when the error is a SQLite FK violation,
- * or null when the error is unrelated (let the caller handle it).
- *
- * @param c       Hono context
- * @param error   The caught error
- * @param method  HTTP method of the current request (e.g. 'DELETE', 'POST')
- */
-export function fkProblemOrNull(c: Context, error: unknown, method: string): Response | null {
-  if (!isFkError(error)) return null
-  const kind = classifyFkError(method)
-  const meta = FK_PROBLEM[kind]
-  return publicProblem(c, {
-    type: `https://beechcms.dev/problems/${kind}`,
-    title: meta.title,
-    status: meta.status,
-    detail: meta.detail,
-  })
-}
-
-export interface PublicProblemDetailItem {
-  field: string
-  expected: string
-  received: string
-  message: string
-}
-
-type PublicProblemInput = {
-  type: string
-  title: string
-  status: 400 | 401 | 403 | 404 | 405 | 409 | 422 | 429 | 500 | 501
-  detail: string
-  errors?: PublicProblemDetailItem[]
-}
-
-/**
- * TODO: UPDATE DOMAIN ONCE REGISTERED
- * Currently uses 'beechcms.dev' as a placeholder. 
- * When a real domain is registered for BeechCMS, update the URL below 
- * to point to the official API error documentation (RFC 9457).
- */
-function normalizeProblemType(type: string): string {
-  if (type.startsWith('http://') || type.startsWith('https://')) {
-    return type
-  }
-  return `https://beechcms.dev/problems/${type}`
-}
-
-export function internalErrorDetail(env: { ENV?: string }, error: unknown): string {
-  if (env.ENV !== 'production' && error instanceof Error) return error.message
-  return 'An unexpected error occurred.'
-}
-
-/**
- * Restituisce errori API in formato Problem Details (RFC 9457).
- */
-export function publicProblem(c: Context, input: PublicProblemInput): Response {
-  const body: Record<string, unknown> = {
-    type: normalizeProblemType(input.type),
-    title: input.title,
-    status: input.status,
-    detail: input.detail,
-    instance: c.req.path,
-  }
-  if (input.errors && input.errors.length > 0) {
-    body.errors = input.errors
-  }
-  return c.json(body, input.status, {
-    'Content-Type': 'application/problem+json',
-  })
-}

package/src/public/public-add.ts

@@ -1,114 +0,0 @@
-// SPDX-License-Identifier: BUSL-1.1
-// Copyright (c) 2024–2026 Flavio De Musso. All rights reserved.
-// See LICENSE in the repository root for license terms.
-
-import { isValidContentStatus, SlugConflictError } from '@beechcms/core'
-import type { Context } from 'hono'
-import { cleanStr } from '../shared/query-utils'
-import { checkPublicOperation } from './access-policy'
-import { publicProblem, internalErrorDetail } from './problem-details'
-import { generateEntrySlug, slugify } from './slug-utils'
-import { sanitizePublicPayload } from './sanitize'
-import { parseIdempotencyKey, buildRequestFingerprint } from './idempotency'
-import { AppEnv } from '../types'
-
-function asRecord(value: unknown): Record<string, unknown> | null {
-  return value !== null && typeof value === 'object' && !Array.isArray(value)
-    ? (value as Record<string, unknown>)
-    : null
-}
-
-function pickSlug(body: Record<string, unknown>, sanitizedData: Record<string, unknown>): string {
-  const explicit = cleanStr(body.slug)
-  if (explicit) return slugify(explicit)
-  return generateEntrySlug({ title: sanitizedData.title, name: sanitizedData.name })
-}
-
-export async function publicAddHandler(context: Context<AppEnv>) {
-  const seedSlug = context.req.param('seed') ?? ''
-  const seed = context.get('getSeed')(seedSlug)
-  if (!seed) {
-    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, 'add')
-  if (!access.ok) {
-    return publicProblem(context, { type: 'operation-not-allowed', title: access.error.error, status: 403, detail: access.error.message })
-  }
-
-  let body: Record<string, unknown>
-  try {
-    const parsed = await context.req.json<unknown>()
-    body = asRecord(parsed) ?? {}
-  } catch {
-    return publicProblem(context, { type: 'invalid-json-body', title: 'Bad Request', status: 400, detail: 'Invalid JSON body' })
-  }
-
-  const rawData = asRecord(body.data)
-  if (!rawData || Object.keys(rawData).length === 0) {
-    return publicProblem(context, { type: 'invalid-data-object', title: 'Bad Request', status: 400, detail: "Field 'data' is required and must be a non-empty object" })
-  }
-
-  const statusValue = body.status ?? 'draft'
-  if (!isValidContentStatus(statusValue)) {
-    return publicProblem(context, { type: 'invalid-status', title: 'Bad Request', status: 400, detail: 'Invalid status. Allowed values are: draft, review, published' })
-  }
-
-  const sanitized = sanitizePublicPayload(seed, rawData, { operation: 'create', allowNull: false, requireAtLeastOneValidField: true, enforceRequiredFields: true })
-  if (!sanitized.ok) {
-    if (sanitized.status === 422) {
-      return publicProblem(context, { type: sanitized.code, title: 'Unprocessable Entity', status: 422, detail: sanitized.message })
-    }
-    return publicProblem(context, { type: sanitized.code, title: 'Bad Request', status: 400, detail: sanitized.message, errors: sanitized.details })
-  }
-
-  const idempotencyKey = parseIdempotencyKey(context.req.header('Idempotency-Key'))
-  const finalSlug = pickSlug(body, sanitized.data) || context.get('idGenerator').uuid().slice(0, 8)
-  const repository = context.get('repository')
-  const idempotencyRepository = context.get('idempotencyRepository')
-
-  try {
-    const now = Math.floor(Date.now() / 1000)
-    const fingerprint = await buildRequestFingerprint({ seedSlug, statusValue, slug: cleanStr(body.slug) ?? null, data: sanitized.data })
-    const idempotencyTtl = Math.max(60, Number.parseInt(context.env.PUBLIC_IDEMPOTENCY_TTL_SECONDS ?? '86400', 10) || 86400)
-
-    if (idempotencyKey) {
-      const existing = await idempotencyRepository.lookup(idempotencyKey)
-      if (existing && existing.expiresAt >= now) {
-        if (existing.fingerprint !== fingerprint) {
-          return publicProblem(context, { type: 'idempotency-key-conflict', title: 'Conflict', status: 409, detail: 'Idempotency-Key was already used with a different request payload.' })
-        }
-        let parsedBody: unknown = null
-        try { parsedBody = JSON.parse(existing.responseBody) } catch { parsedBody = { success: true } }
-        return context.json(parsedBody, existing.responseStatus as 201)
-      }
-    }
-
-    const id = context.get('idGenerator').uuid()
-
-    try {
-      await repository.create(seed, id, finalSlug, statusValue as any, sanitized.data)
-    } catch (error) {
-      if (error instanceof SlugConflictError) {
-        return publicProblem(context, { type: 'slug-conflict', title: 'Conflict', status: 409, detail: `An entry with slug '${finalSlug}' already exists for content type '${seedSlug}'.` })
-      }
-      throw error
-    }
-
-    const responseBody = { success: true, id, slug: finalSlug }
-    if (idempotencyKey) {
-      await idempotencyRepository.store({ key: idempotencyKey, fingerprint, responseStatus: 201, responseBody: JSON.stringify(responseBody), expiresAt: now + idempotencyTtl })
-    }
-
-    context.get('notificationService').notify({
-      title: `${seed.label}: New entry`,
-      message: `A new entry ("${sanitized.data.title || sanitized.data.name || finalSlug}") has been added via the public API.`,
-      type: 'success',
-    })
-
-    return context.json(responseBody, 201)
-  } catch (error) {
-    console.error('Public add error:', error)
-    return publicProblem(context, { type: 'internal-server-error', title: 'Internal Server Error', status: 500, detail: internalErrorDetail(context.env, error) })
-  }
-}

package/src/public/public-edit.ts

@@ -1,163 +0,0 @@
-// SPDX-License-Identifier: BUSL-1.1
-// Copyright (c) 2024–2026 Flavio De Musso. All rights reserved.
-// See LICENSE in the repository root for license terms.
-
-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 { checkPublicOperation } from './access-policy'
-import { publicProblem } from './problem-details'
-import { slugify } from './slug-utils'
-import { sanitizePublicPayload } from './sanitize'
-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<AppEnv>
-type ResolveResult<T> = { ok: true; value: T } | { ok: false; response: Response }
-
-function errorMessage(context: PublicCtx, error: unknown): string {
-  if (context.env.ENV !== 'production' && error instanceof Error) return error.message
-  return 'An unexpected error occurred.'
-}
-
-function asRecord(value: unknown): Record<string, unknown> | null {
-  return value !== null && typeof value === 'object' && !Array.isArray(value)
-    ? (value as Record<string, unknown>)
-    : null
-}
-
-function removeNullishFields(data: Record<string, unknown>): Record<string, unknown> {
-  const next: Record<string, unknown> = {}
-  for (const [key, value] of Object.entries(data)) {
-    if (value !== null) next[key] = value
-  }
-  return next
-}
-
-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(context, { type: 'invalid-json-body', title: 'Bad Request', status: 400, detail: 'Invalid JSON body' }),
-    }))
-}
-
-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(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(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(context, { type: 'invalid-status', title: 'Bad Request', status: 400, detail: 'Invalid status. Allowed values are: draft, review, published' }) }
-  }
-  return { ok: true, value: statusValue as string }
-}
-
-function resolveData(
-  context: PublicCtx,
-  seed: Seed,
-  body: Record<string, unknown>
-): ResolveResult<Record<string, unknown>> {
-  if (!Object.hasOwn(body, 'data')) {
-    // No data update — return empty patch
-    return { ok: true, value: {} }
-  }
-
-  const rawData = asRecord(body.data)
-  if (!rawData) {
-    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) => {
-    const branch = seed.branches.find((b) => b.alias === alias)
-    if (!branch) return false
-    const policies = resolvePolicies(branch)
-    return policies.privacy !== 'plain' || policies.public === false
-  })
-  if (sensitiveAliases.length > 0) {
-    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(context, { type: sanitized.code, title: 'Unprocessable Entity', status: 422, detail: sanitized.message }) }
-    }
-    return { ok: false, response: publicProblem(context, { type: sanitized.code, title: 'Bad Request', status: 400, detail: sanitized.message, errors: sanitized.details }) }
-  }
-
-  return { ok: true, value: removeNullishFields(sanitized.data) }
-}
-
-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(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(context, { type: 'operation-not-allowed', title: access.error.error, status: 403, detail: access.error.message })
-  }
-
-  if (!UUID_REGEX.test(id)) {
-    return publicProblem(context, { type: 'invalid-entry-id', title: 'Bad Request', status: 400, detail: 'Invalid entry ID format' })
-  }
-
-  const repository = context.get('repository')
-
-  try {
-    const entry = await repository.findById(seed, id)
-
-    const bodyResult = await parseBody(context)
-    if (!bodyResult.ok) return bodyResult.response
-
-    const slugResult = resolveSlug(context, bodyResult.value, (entry.slug as string) ?? '')
-    if (!slugResult.ok) return slugResult.response
-
-    const statusResult = resolveStatus(context, bodyResult.value, (entry.status as string) ?? 'draft')
-    if (!statusResult.ok) return statusResult.response
-
-    const dataResult = resolveData(context, seed, bodyResult.value)
-    if (!dataResult.ok) return dataResult.response
-
-    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 updateData = { ...dataResult.value }
-    if (slugResult.value.slugRequested) {
-      (updateData as any).slug = slugResult.value.nextSlug
-    }
-
-    await repository.update(seed, id, updateData, statusResult.value)
-
-    context.get('notificationService').notify({
-      title: `${seed.label}: Update`,
-      message: `The entry "${slugResult.value.nextSlug}" has been modified via the public API.`,
-      type: 'info',
-    })
-
-    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-errors.ts

@@ -1,19 +0,0 @@
-// SPDX-License-Identifier: BUSL-1.1
-// Copyright (c) 2024–2026 Flavio De Musso. All rights reserved.
-// See LICENSE in the repository root for license terms.
-
-/**
- * Error constants for Public API responses.
- */
-export const PUBLIC_ERRORS = {
-  API_KEY_UNAUTHORIZED: {
-    error: 'Unauthorized',
-    message:
-      'Missing or invalid API key. Provide a valid key via X-API-Key header.',
-  },
-  API_KEY_FORBIDDEN: {
-    error: 'Forbidden',
-    message: 'Public API access is not configured for this instance.',
-  },
-} as const
-

package/src/public/public-read.ts

@@ -1,63 +0,0 @@
-// SPDX-License-Identifier: BUSL-1.1
-// Copyright (c) 2024–2026 Flavio De Musso. All rights reserved.
-// See LICENSE in the repository root for license terms.
-
-import type { Context } from 'hono'
-import { cleanStr } from '../shared/query-utils'
-import { checkPublicOperation } from './access-policy'
-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'
-
-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',
-      status: 404,
-      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 })
-  }
-
-  const edgeCache = resolveEdgeCache(context)
-  const cacheKey = context.req.raw
-  if (edgeCache) {
-    const hit = await edgeCache.cache.match(cacheKey)
-    if (hit) return hit
-  }
-
-  const query = context.req.query()
-  const id = cleanStr(query.id)
-  const slug = cleanStr(query.slug)
-  const publishedOnly = context.env.PUBLIC_PUBLISHED_ONLY !== 'false'
-  const repository = context.get('repository')
-
-  try {
-    if (id || slug) {
-      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 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: internalErrorDetail(context.env, error) })
-  }
-}

package/src/public/public-routes.ts

@@ -1,88 +0,0 @@
-// SPDX-License-Identifier: BUSL-1.1
-// Copyright (c) 2024–2026 Flavio De Musso. All rights reserved.
-// See LICENSE in the repository root for license terms.
-
-import { Hono } from 'hono'
-import type { AppEnv } from '../types'
-import { publicReadHandler } from './public-read'
-import { publicAddHandler } from './public-add'
-import { publicEditHandler } from './public-edit'
-
-const publicApp = new Hono<AppEnv>()
-
-publicApp.get('/health', (c) => {
-  return c.json({ ok: true, service: 'public-api' }, 200)
-})
-
-/** Returns the public-facing schema: only seeds with public read or post enabled. */
-publicApp.get('/schema', (c) => {
-  const registry = c.get('seedRegistry')
-  const publicSeeds = registry.all()
-    .filter(seed => seed.allowPublicRead === true || seed.allowPublicPost === true || seed.allowPublicEdit === true)
-    .map(seed => ({
-      slug: seed.slug,
-      label: seed.label,
-      labelPlural: seed.labelPlural,
-      allowPublicRead: seed.allowPublicRead ?? false,
-      allowPublicPost: seed.allowPublicPost ?? false,
-      allowPublicEdit: seed.allowPublicEdit ?? false,
-      branches: (seed.branches ?? []).map(branch => ({
-        alias: branch.alias,
-        type: branch.type,
-        label: branch.label,
-        requiredOnCreate: branch.requiredOnCreate ?? false,
-        policies: {
-          public: branch.policies?.public ?? true,
-          visibility: branch.policies?.visibility ?? 'full',
-        },
-      })),
-    }))
-  return c.json({ seeds: publicSeeds })
-})
-
-/** HTML render of the public schema for quick browser inspection. */
-publicApp.get('/schema.html', (c) => {
-  const registry = c.get('seedRegistry')
-  const publicSeeds = registry.all()
-    .filter(seed => seed.allowPublicRead === true || seed.allowPublicPost === true || seed.allowPublicEdit === true)
-
-  const seedHtml = publicSeeds.map(seed => {
-    const ops = [
-      seed.allowPublicRead && 'GET /:seed',
-      seed.allowPublicPost && 'POST /:seed/add',
-      seed.allowPublicEdit && 'PUT /:seed/edit/:id',
-    ].filter(Boolean).join(', ')
-
-    const branchRows = (seed.branches ?? []).map(b =>
-      `<tr><td>${b.alias}</td><td>${b.type}</td><td>${b.label}</td><td>${b.requiredOnCreate ? 'yes' : ''}</td><td>${(b.policies?.public ?? true) ? 'readable' : 'hidden'}</td></tr>`
-    ).join('')
-
-    return `<section>
-      <h2>${seed.label} <code>${seed.slug}</code></h2>
-      <p><strong>Allowed operations:</strong> ${ops || 'none'}</p>
-      <table><thead><tr><th>alias</th><th>type</th><th>label</th><th>required</th><th>public access</th></tr></thead>
-      <tbody>${branchRows}</tbody></table>
-    </section>`
-  }).join('\n')
-
-  const html = `<!DOCTYPE html><html lang="en"><head><meta charset="UTF-8">
-<title>BeechCMS Public Schema</title>
-<style>body{font-family:system-ui,sans-serif;max-width:900px;margin:2rem auto;padding:0 1rem;color:#222}
-code{background:#f3f4f6;padding:2px 6px;border-radius:4px}
-table{border-collapse:collapse;width:100%}th,td{text-align:left;padding:6px 10px;border:1px solid #e5e7eb}
-th{background:#f9fafb}h2{margin-top:2rem}section{margin-bottom:2rem}</style>
-</head><body>
-<h1>BeechCMS — Public API Schema</h1>
-<p>Only content types with public access enabled are listed here.</p>
-${seedHtml || '<p><em>No content types with public access configured.</em></p>'}
-</body></html>`
-
-  return c.html(html)
-})
-
-publicApp.get('/:seed', publicReadHandler)
-publicApp.post('/:seed/add', publicAddHandler)
-publicApp.put('/:seed/edit/:id', publicEditHandler)
-
-export const publicRoutes = publicApp
-