@beechcms/api 0.4.0-preview.8 → 0.4.0

package/src/index.ts

@@ -1,11 +1,24 @@
-import { createBeechApp } from './factory'
-
-/**
- * Entry point per lo sviluppo locale del monorepo.
- * In produzione (progetto utente), viene usato worker.ts che importa createBeechApp.
- */
-const app = createBeechApp({ seeds: [] })
-
-app.get('/', (c) => c.text('Beech API is running (Production Ready Mode)'))
-
-export default app
+import { createBeechApp } from './factory'
+
+/**
+ * Entry point per lo sviluppo locale del monorepo.
+ * Carica dinamicamente seed.ts o seeds.ts dalla root di apps/api se presenti.
+ */
+let seeds: any = []
+
+try {
+  // @ts-ignore
+  const mod = await import('../seed.ts')
+  const registry = mod.default || mod.SEED_REGISTRY || mod
+  seeds = (typeof registry === 'object' && !Array.isArray(registry)) 
+    ? Object.values(registry) 
+    : registry
+} catch (e) {
+  // Fallback se seed.ts non esiste
+}
+
+const app = createBeechApp({ seeds })
+
+app.get('/', (c) => c.text('Beech API is running (Local Dev Mode)'))
+
+export default app

package/src/media-utils.ts

@@ -1,78 +1,78 @@
-/**
- * Media utils: estrazione chiavi R2 dal data di un'entry.
- * Usato alla cancellazione entry per eliminare i file associati da R2.
- *
- * @see docs/media-engine.md
- */
-import type { Seed } from '@beechcms/core'
-
-/** Pattern per estrarre la chiave R2 da URL in formato /api/media/KEY */
-const MEDIA_URL_PATTERN = /\/api\/media\/([^/?#]+)/
-
-/**
- * Estrae la chiave R2 da un URL di media.
- * Es: "https://x.com/api/media/1739123456-avatar.png" → "1739123456-avatar.png"
- *
- * @param mediaUrl - URL completo o path (es. /api/media/123-foto.png)
- * @returns Chiave R2 o null se l'URL non è valido
- */
-export function extractMediaKey(mediaUrl: string): string | null {
-  const match = MEDIA_URL_PATTERN.exec(String(mediaUrl))
-  return match ? decodeURIComponent(match[1]) : null
-}
-
-/**
- * Attraversa ricorsivamente un valore (stringa, array, oggetto) e raccoglie
- * tutte le chiavi R2 trovate in stringhe che matchano /api/media/KEY.
- */
-function collectMediaKeysRecursive(value: unknown, collectedKeys: Set<string>): void {
-  if (typeof value === 'string') {
-    const r2Key = extractMediaKey(value)
-    if (r2Key) {
-      collectedKeys.add(r2Key)
-      return
-    }
-    // Legacy compat: campi json/file possono contenere JSON serializzato.
-    try {
-      const parsed = JSON.parse(value) as unknown
-      if (parsed !== value) {
-        collectMediaKeysRecursive(parsed, collectedKeys)
-      }
-    } catch {
-      // ignore
-    }
-    return
-  }
-  if (Array.isArray(value)) {
-    for (const item of value) collectMediaKeysRecursive(item, collectedKeys)
-    return
-  }
-  if (value != null && typeof value === 'object') {
-    for (const nestedValue of Object.values(value)) {
-      collectMediaKeysRecursive(nestedValue, collectedKeys)
-    }
-  }
-}
-
-/**
- * Estrae tutte le chiavi R2 dal data di un'entry.
- * Cerca nei campi `file` (stringa URL) e `json` (array/oggetto con URL).
- * Il data è in formato DB: chiavi = branch.id (es. art_03, prd_05).
- *
- * @param seed - Schema del tipo di contenuto
- * @param entryData - Payload in formato DB (chiavi = branch ID)
- * @returns Array di chiavi R2 uniche da eliminare
- */
-export function extractMediaKeysFromData(
-  seed: Seed,
-  entryData: Record<string, unknown>
-): string[] {
-  const r2Keys = new Set<string>()
-  for (const branch of seed.branches) {
-    if (branch.type !== 'file' && branch.type !== 'json') continue
-    const fieldValue = entryData[branch.alias]
-    if (fieldValue == null) continue
-    collectMediaKeysRecursive(fieldValue, r2Keys)
-  }
-  return [...r2Keys]
-}
+/**
+ * Media utils: estrazione chiavi R2 dal data di un'entry.
+ * Usato alla cancellazione entry per eliminare i file associati da R2.
+ *
+ * @see docs/media-engine.md
+ */
+import type { Seed } from '@beechcms/core'
+
+/** Pattern per estrarre la chiave R2 da URL in formato /api/media/KEY */
+const MEDIA_URL_PATTERN = /\/api\/media\/([^/?#]+)/
+
+/**
+ * Estrae la chiave R2 da un URL di media.
+ * Es: "https://x.com/api/media/1739123456-avatar.png" → "1739123456-avatar.png"
+ *
+ * @param mediaUrl - URL completo o path (es. /api/media/123-foto.png)
+ * @returns Chiave R2 o null se l'URL non è valido
+ */
+export function extractMediaKey(mediaUrl: string): string | null {
+  const match = MEDIA_URL_PATTERN.exec(String(mediaUrl))
+  return match ? decodeURIComponent(match[1]) : null
+}
+
+/**
+ * Attraversa ricorsivamente un valore (stringa, array, oggetto) e raccoglie
+ * tutte le chiavi R2 trovate in stringhe che matchano /api/media/KEY.
+ */
+function collectMediaKeysRecursive(value: unknown, collectedKeys: Set<string>): void {
+  if (typeof value === 'string') {
+    const r2Key = extractMediaKey(value)
+    if (r2Key) {
+      collectedKeys.add(r2Key)
+      return
+    }
+    // Legacy compat: campi json/file possono contenere JSON serializzato.
+    try {
+      const parsed = JSON.parse(value) as unknown
+      if (parsed !== value) {
+        collectMediaKeysRecursive(parsed, collectedKeys)
+      }
+    } catch {
+      // ignore
+    }
+    return
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) collectMediaKeysRecursive(item, collectedKeys)
+    return
+  }
+  if (value != null && typeof value === 'object') {
+    for (const nestedValue of Object.values(value)) {
+      collectMediaKeysRecursive(nestedValue, collectedKeys)
+    }
+  }
+}
+
+/**
+ * Estrae tutte le chiavi R2 dal data di un'entry.
+ * Cerca nei campi `file` (stringa URL) e `json` (array/oggetto con URL).
+ * Il data è in formato DB: chiavi = branch.id (es. art_03, prd_05).
+ *
+ * @param seed - Schema del tipo di contenuto
+ * @param entryData - Payload in formato DB (chiavi = branch ID)
+ * @returns Array di chiavi R2 uniche da eliminare
+ */
+export function extractMediaKeysFromData(
+  seed: Seed,
+  entryData: Record<string, unknown>
+): string[] {
+  const r2Keys = new Set<string>()
+  for (const branch of seed.branches) {
+    if (branch.type !== 'file' && branch.type !== 'json') continue
+    const fieldValue = entryData[branch.alias]
+    if (fieldValue == null) continue
+    collectMediaKeysRecursive(fieldValue, r2Keys)
+  }
+  return [...r2Keys]
+}

package/src/middleware/repository.middleware.ts

@@ -0,0 +1,24 @@
+import { createMiddleware } from 'hono/factory'
+import { D1ContentRepository } from '../shared/content.repository.d1'
+import { D1IdempotencyRepository } from '../shared/idempotency.repository.d1'
+import { D1MediaRepository } from '../shared/media.repository.d1'
+import { D1SystemStatsRepository } from '../shared/system-stats.repository.d1'
+import type { ContentRepository, IdempotencyRepository, MediaRepository, SystemStatsRepository } from '@beechcms/core'
+import type { Env, Variables } from '../types'
+
+interface RepositoryOverrides {
+  repository?: ContentRepository
+  idempotencyRepository?: IdempotencyRepository
+  mediaRepository?: MediaRepository
+  systemStatsRepository?: SystemStatsRepository
+}
+
+export const repositoryMiddleware = (overrides?: RepositoryOverrides) => {
+  return createMiddleware<{ Bindings: Env; Variables: Variables }>(async (context, next) => {
+    context.set('repository', overrides?.repository ?? new D1ContentRepository(context.env.DB))
+    context.set('idempotencyRepository', overrides?.idempotencyRepository ?? new D1IdempotencyRepository(context.env.DB))
+    context.set('mediaRepository', overrides?.mediaRepository ?? new D1MediaRepository(context.env.DB))
+    context.set('systemStatsRepository', overrides?.systemStatsRepository ?? new D1SystemStatsRepository(context.env.DB))
+    await next()
+  })
+}

package/src/middleware/storage.middleware.ts

@@ -0,0 +1,21 @@
+import { createMiddleware } from 'hono/factory'
+import { BeechBucket } from '@beechcms/core'
+import { AppEnv } from '../types'
+import { createBucketProvider } from '../shared/storage/factory'
+
+interface StorageOverrides {
+  bucket?: BeechBucket
+}
+
+export const storageMiddleware = (overrides?: StorageOverrides) => {
+  return createMiddleware<AppEnv>(async (context, next) => {
+    if (overrides?.bucket) {
+      context.set('bucket', overrides.bucket)
+    } else {
+      // Determine base URL for getUrl() only if we need to create the provider
+      const baseUrl = context.env.MEDIA_BASE_URL?.trim().replace(/\/$/, '') || new URL(context.req.url).origin
+      context.set('bucket', createBucketProvider(context.env, baseUrl))
+    }
+    await next()
+  })
+}

package/src/middleware.ts

@@ -1,67 +1,67 @@
-/// <reference types="@cloudflare/workers-types" />
-import type { Context, Next } from 'hono'
-import { HTTPException } from 'hono/http-exception'
-import { jwtVerify } from 'jose'
-
-/** Payload JWT decodificato (sub = userId, email opzionale, name opzionale) */
-export type JwtPayload = {
-  sub: string
-  email?: string
-  name?: string
-}
-
-/** Variabili iniettate nel context Hono dopo auth */
-export type AuthVariables = {
-  jwtPayload: JwtPayload
-}
-
-const UNAUTHORIZED_JSON = JSON.stringify({ error: 'Unauthorized' })
-
-function unauthorizedResponse() {
-  return new Response(UNAUTHORIZED_JSON, {
-    status: 401,
-    headers: { 'Content-Type': 'application/json' },
-  })
-}
-
-export type JwtVerifyOptions = {
-  issuer?: string
-  audience?: string
-}
-
-/**
- * Middleware di autenticazione JWT.
- * Intercetta Authorization: Bearer <token>, verifica con jose e JWT_SECRET.
- * Se valido: imposta jwtPayload nel context e chiama next().
- * Se invalido/mancante: lancia HTTPException 401 (gestita dal framework).
- */
-export function authMiddleware(secret: string, options: JwtVerifyOptions = {}) {
-  return async (c: Context, next: Next): Promise<Response | void> => {
-    const auth = c.req.header('Authorization')
-    if (!auth?.startsWith('Bearer ')) {
-      throw new HTTPException(401, { res: unauthorizedResponse() })
-    }
-
-    const token = auth.slice(7)
-    if (!token) {
-      throw new HTTPException(401, { res: unauthorizedResponse() })
-    }
-
-    try {
-      const secretBytes = new TextEncoder().encode(secret)
-      const { payload, protectedHeader } = await jwtVerify(token, secretBytes, {
-        algorithms: ['HS256'],
-        issuer: options.issuer,
-        audience: options.audience,
-      })
-      // Hardening: accetta solo token JWT standard (se presente il typ)
-      if (protectedHeader.typ && protectedHeader.typ !== 'JWT') {
-        throw new Error('Invalid typ header')
-      }
-      c.set('jwtPayload', payload as JwtPayload)
-      await next()
-    } catch {
-      throw new HTTPException(401, { res: unauthorizedResponse() })
-    }
-  }
-}
+/// <reference types="@cloudflare/workers-types" />
+import type { Context, Next } from 'hono'
+import { HTTPException } from 'hono/http-exception'
+import { jwtVerify } from 'jose'
+
+/** Payload JWT decodificato (sub = userId, email opzionale, name opzionale) */
+export type JwtPayload = {
+  sub: string
+  email?: string
+  name?: string
+}
+
+/** Variabili iniettate nel context Hono dopo auth */
+export type AuthVariables = {
+  jwtPayload: JwtPayload
+}
+
+const UNAUTHORIZED_JSON = JSON.stringify({ error: 'Unauthorized' })
+
+function unauthorizedResponse() {
+  return new Response(UNAUTHORIZED_JSON, {
+    status: 401,
+    headers: { 'Content-Type': 'application/json' },
+  })
+}
+
+export type JwtVerifyOptions = {
+  issuer?: string
+  audience?: string
+}
+
+/**
+ * Middleware di autenticazione JWT.
+ * Intercetta Authorization: Bearer <token>, verifica con jose e JWT_SECRET.
+ * Se valido: imposta jwtPayload nel context e chiama next().
+ * Se invalido/mancante: lancia HTTPException 401 (gestita dal framework).
+ */
+export function authMiddleware(secret: string, options: JwtVerifyOptions = {}) {
+  return async (c: Context, next: Next): Promise<Response | void> => {
+    const auth = c.req.header('Authorization')
+    if (!auth?.startsWith('Bearer ')) {
+      throw new HTTPException(401, { res: unauthorizedResponse() })
+    }
+
+    const token = auth.slice(7)
+    if (!token) {
+      throw new HTTPException(401, { res: unauthorizedResponse() })
+    }
+
+    try {
+      const secretBytes = new TextEncoder().encode(secret)
+      const { payload, protectedHeader } = await jwtVerify(token, secretBytes, {
+        algorithms: ['HS256'],
+        issuer: options.issuer,
+        audience: options.audience,
+      })
+      // Hardening: accetta solo token JWT standard (se presente il typ)
+      if (protectedHeader.typ && protectedHeader.typ !== 'JWT') {
+        throw new Error('Invalid typ header')
+      }
+      c.set('jwtPayload', payload as JwtPayload)
+      await next()
+    } catch {
+      throw new HTTPException(401, { res: unauthorizedResponse() })
+    }
+  }
+}

package/src/public/access-policy.ts

@@ -1,23 +1,23 @@
-import type { Seed } from '@beechcms/core'
-
-export type PublicOperation = 'read' | 'add' | 'edit'
-
-function isAllowed(seed: Seed, operation: PublicOperation): boolean {
-  if (operation === 'read') return seed.allowPublicRead === true
-  if (operation === 'add') return seed.allowPublicPost === true
-  return seed.allowPublicEdit === true
-}
-
-export function checkPublicOperation(seed: Seed, operation: PublicOperation) {
-  if (isAllowed(seed, operation)) {
-    return { ok: true } as const
-  }
-
-  return {
-    ok: false,
-    error: {
-      error: 'Forbidden',
-      message: `Public ${operation.toUpperCase()} is not allowed for content type '${seed.slug}'.`,
-    },
-  } as const
-}
+import type { Seed } from '@beechcms/core'
+
+export type PublicOperation = 'read' | 'add' | 'edit'
+
+function isAllowed(seed: Seed, operation: PublicOperation): boolean {
+  if (operation === 'read') return seed.allowPublicRead === true
+  if (operation === 'add') return seed.allowPublicPost === true
+  return seed.allowPublicEdit === true
+}
+
+export function checkPublicOperation(seed: Seed, operation: PublicOperation) {
+  if (isAllowed(seed, operation)) {
+    return { ok: true } as const
+  }
+
+  return {
+    ok: false,
+    error: {
+      error: 'Forbidden',
+      message: `Public ${operation.toUpperCase()} is not allowed for content type '${seed.slug}'.`,
+    },
+  } as const
+}

package/src/public/api-key-middleware.ts

@@ -1,53 +1,53 @@
-import type { Context, Next } from 'hono'
-import { PUBLIC_ERRORS } from './public-errors'
-import { publicProblem } from './problem-details'
-
-type PublicBindings = {
-  PUBLIC_READ_API_KEY?: string
-  PUBLIC_WRITE_API_KEY?: string
-}
-
-function isReadMethod(method: string): boolean {
-  return method === 'GET' || method === 'HEAD' || method === 'OPTIONS'
-}
-
-function getConfiguredKey(env: PublicBindings, method: string): string | undefined {
-  if (isReadMethod(method)) {
-    return env.PUBLIC_READ_API_KEY
-  }
-  return env.PUBLIC_WRITE_API_KEY
-}
-
-/**
- * API key auth middleware for Public API routes.
- * Uses X-API-Key header only.
- */
-export function apiKeyMiddleware() {
-  return async (c: Context, next: Next): Promise<Response | void> => {
-    const env = c.env as PublicBindings
-    const configuredKey = getConfiguredKey(env, c.req.method)
-
-    if (!configuredKey) {
-      return publicProblem(c, {
-        type: 'public-api-not-configured',
-        title: PUBLIC_ERRORS.API_KEY_FORBIDDEN.error,
-        status: 403,
-        detail: PUBLIC_ERRORS.API_KEY_FORBIDDEN.message,
-      })
-    }
-
-    const providedKey = c.req.header('X-API-Key')
-
-    if (!providedKey || providedKey !== configuredKey) {
-      return publicProblem(c, {
-        type: 'public-api-key-unauthorized',
-        title: PUBLIC_ERRORS.API_KEY_UNAUTHORIZED.error,
-        status: 401,
-        detail: PUBLIC_ERRORS.API_KEY_UNAUTHORIZED.message,
-      })
-    }
-
-    await next()
-  }
-}
-
+import type { Context, Next } from 'hono'
+import { PUBLIC_ERRORS } from './public-errors'
+import { publicProblem } from './problem-details'
+
+type PublicBindings = {
+  PUBLIC_READ_API_KEY?: string
+  PUBLIC_WRITE_API_KEY?: string
+}
+
+function isReadMethod(method: string): boolean {
+  return method === 'GET' || method === 'HEAD' || method === 'OPTIONS'
+}
+
+function getConfiguredKey(env: PublicBindings, method: string): string | undefined {
+  if (isReadMethod(method)) {
+    return env.PUBLIC_READ_API_KEY
+  }
+  return env.PUBLIC_WRITE_API_KEY
+}
+
+/**
+ * API key auth middleware for Public API routes.
+ * Uses X-API-Key header only.
+ */
+export function apiKeyMiddleware() {
+  return async (c: Context, next: Next): Promise<Response | void> => {
+    const env = c.env as PublicBindings
+    const configuredKey = getConfiguredKey(env, c.req.method)
+
+    if (!configuredKey) {
+      return publicProblem(c, {
+        type: 'public-api-not-configured',
+        title: PUBLIC_ERRORS.API_KEY_FORBIDDEN.error,
+        status: 403,
+        detail: PUBLIC_ERRORS.API_KEY_FORBIDDEN.message,
+      })
+    }
+
+    const providedKey = c.req.header('X-API-Key')
+
+    if (!providedKey || providedKey !== configuredKey) {
+      return publicProblem(c, {
+        type: 'public-api-key-unauthorized',
+        title: PUBLIC_ERRORS.API_KEY_UNAUTHORIZED.error,
+        status: 401,
+        detail: PUBLIC_ERRORS.API_KEY_UNAUTHORIZED.message,
+      })
+    }
+
+    await next()
+  }
+}
+

package/src/public/index.ts

@@ -1,12 +1,12 @@
-export { apiKeyMiddleware } from './api-key-middleware'
-export { publicRateLimitMiddleware } from './rate-limit-middleware'
-export { publicRoutes } from './public-routes'
-export { PUBLIC_ERRORS } from './public-errors'
-export { sanitizePublicPayload } from './sanitize'
-export { generateEntrySlug, slugify } from './slug-utils'
-export { buildPublicListMeta, buildPublicSingleMeta } from './response-builder'
-export { parseLatestCount, parsePublicPagination } from './query-builder'
-export { publicReadHandler } from './public-read'
-export { publicAddHandler } from './public-add'
-export { publicEditHandler } from './public-edit'
-
+export { apiKeyMiddleware } from './api-key-middleware'
+export { publicRateLimitMiddleware } from './rate-limit-middleware'
+export { publicRoutes } from './public-routes'
+export { PUBLIC_ERRORS } from './public-errors'
+export { sanitizePublicPayload } from './sanitize'
+export { generateEntrySlug, slugify } from './slug-utils'
+export { buildPublicListMeta, buildPublicSingleMeta } from './response-builder'
+export { parseLatestCount, parsePublicPagination } from './query-builder'
+export { publicReadHandler } from './public-read'
+export { publicAddHandler } from './public-add'
+export { publicEditHandler } from './public-edit'
+

package/src/public/problem-details.ts

@@ -1,42 +1,48 @@
-import type { Context } from 'hono'
-
-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[]
-}
-
-function normalizeProblemType(type: string): string {
-  if (type.startsWith('http://') || type.startsWith('https://')) {
-    return type
-  }
-  return `https://beechcms.dev/problems/${type}`
-}
-
-/**
- * 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',
-  })
-}
+import type { Context } from 'hono'
+
+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}`
+}
+
+/**
+ * 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',
+  })
+}