@beechcms/api 0.4.1 → 0.4.2

package/src/features/email/email.service.ts

@@ -16,10 +16,12 @@
 import { ResendEmailProvider } from './providers/resend'
 import { buildPasswordResetEmail } from './templates/password-reset'
 import { buildPasswordChangedEmail } from './templates/password-changed'
+import { buildAutomationEmail } from './templates/automation-mail'
 import type { EmailProvider } from './email.provider'
 import type {
   PasswordResetEmailParams,
   PasswordChangedEmailParams,
+  AutomationMailParams,
 } from './email.types'
 
 /** Default sender address (Resend test sender, works without a verified domain). */
@@ -78,3 +80,14 @@ export async function sendPasswordChangedEmail(
     html,
   })
 }
+
+export async function sendAutomationMail(params: AutomationMailParams): Promise<void> {
+  const provider = createProvider(params.apiKey ?? params.resendApiKey ?? '', false)
+  const message = buildAutomationEmail(params)
+  await provider.send({
+    from: params.from ?? DEFAULT_FROM,
+    to: [message.to],
+    subject: message.subject,
+    html: message.html,
+  })
+}

package/src/features/email/email.types.ts

@@ -96,3 +96,13 @@ export interface PasswordResetEmailParams extends BaseEmailParams {
 
 /** Parameters for the "password changed" notification. No additional fields. */
 export type PasswordChangedEmailParams = BaseEmailParams
+
+export interface AutomationMailParams {
+  to: string
+  subject: string
+  /** Plain text or HTML — passed verbatim to provider. */
+  body: string
+  apiKey?: string
+  resendApiKey?: string
+  from?: string
+}

package/src/features/email/index.ts

@@ -16,7 +16,7 @@
  *   PasswordChangedEmailParams — shape dei parametri per sendPasswordChangedEmail
  */
 
-export { sendPasswordResetEmail, sendPasswordChangedEmail } from './email.service'
+export { sendPasswordResetEmail, sendPasswordChangedEmail, sendAutomationMail } from './email.service'
 export {
   resolveEmailLocale,
   SUPPORTED_EMAIL_LOCALES,
@@ -25,4 +25,5 @@ export type {
   EmailLocale,
   PasswordResetEmailParams,
   PasswordChangedEmailParams,
+  AutomationMailParams,
 } from './email.types'

package/src/features/email/templates/automation-mail.ts

@@ -0,0 +1,15 @@
+import type { AutomationMailParams } from '../email.types'
+
+/** Identity builder: automation payloads are already user-authored. */
+export function buildAutomationEmail(params: AutomationMailParams) {
+  return {
+    to: params.to,
+    subject: params.subject,
+    html: params.body,
+    text: stripHtml(params.body),
+  }
+}
+
+function stripHtml(input: string): string {
+  return input.replace(/<[^>]+>/g, '').trim()
+}

package/src/features/settings/settings.handler.ts

@@ -24,7 +24,8 @@ settingsApp.get('/', async (context) => {
       drafts: true,
       media: true,
       search: true,
-      activityLog: true
+      activityLog: true,
+      email: !!(context.env.EMAIL_API_KEY || context.env.RESEND_API_KEY),
     }
   })
 })

package/src/index.ts

@@ -1,17 +1,18 @@
 import { createBeechApp } from './factory'
+import { SeedRegistry, SystemIdGenerator } from '@beechcms/core'
+import { runCronAutomations } from './features/automations'
+import { D1AutomationRepository } from './shared/automations.repository.d1'
+import { D1ContentRepository } from './shared/content.repository.d1'
+import type { Env } from './types'
 
-/**
- * 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 = []
+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) 
+  seeds = (typeof registry === 'object' && !Array.isArray(registry))
+    ? Object.values(registry)
     : registry
 } catch (e) {
   // Fallback se seed.ts non esiste
@@ -21,4 +22,35 @@ const app = createBeechApp({ seeds })
 
 app.get('/', (c) => c.text('Beech API is running (Local Dev Mode)'))
 
-export default app
+const validSeeds = seeds.filter((s: any) => s && typeof s === 'object' && 'slug' in s)
+
+export default {
+  fetch: app.fetch,
+
+  async scheduled(controller: ScheduledController, env: Env, ctx: ExecutionContext) {
+    const scheduledTime = controller?.scheduledTime ?? Date.now()
+
+    if (!env.DB) {
+      console.warn('[cron] D1 binding missing. Skipping cron automations.')
+      return
+    }
+
+    const automationRepository = new D1AutomationRepository(env.DB)
+    const contentRepository = new D1ContentRepository(env.DB)
+    const registry = new SeedRegistry(validSeeds)
+    const getSeed = (slug: string) => registry.get(slug) ?? null
+
+    ctx.waitUntil(
+      runCronAutomations(
+        {
+          automationRepository,
+          contentRepository,
+          getSeed,
+          env: env as unknown as Record<string, string | undefined>,
+          idGenerator: SystemIdGenerator,
+        },
+        scheduledTime,
+      ),
+    )
+  },
+} satisfies ExportedHandler<Env>

package/src/middleware/repository.middleware.ts

@@ -1,4 +1,5 @@
 import { createMiddleware } from 'hono/factory'
+import type { Context } from 'hono'
 import { D1ContentRepository } from '../shared/content.repository.d1'
 import { D1IdempotencyRepository } from '../shared/idempotency.repository.d1'
 import { D1MediaRepository } from '../shared/media.repository.d1'
@@ -13,7 +14,11 @@ import { D1SearchRepository } from '../shared/d1-search.repository'
 import { D1AnalyticsRepository } from '../shared/d1-analytics.repository'
 import { D1ContentScanRepository } from '../shared/d1-content-scan.repository'
 import { SystemClock, SystemIdGenerator } from '@beechcms/core'
-import type { ContentRepository, IdempotencyRepository, MediaRepository, SystemStatsRepository, IUserRepository, ISessionRepository, IPasswordResetTokenRepository, IActivityLogRepository, INotificationRepository, IWidgetRepository, ISearchRepository, IAnalyticsRepository, IContentScanRepository, IClock, IIdGenerator } from '@beechcms/core'
+import type { ContentRepository, IdempotencyRepository, MediaRepository, SystemStatsRepository, IUserRepository, ISessionRepository, IPasswordResetTokenRepository, IActivityLogRepository, INotificationRepository, IWidgetRepository, ISearchRepository, IAnalyticsRepository, IContentScanRepository, IClock, IIdGenerator, IAutomationRunner, IAutomationRepository, IScheduler } from '@beechcms/core'
+import { NoOpScheduler } from '@beechcms/core'
+import { AutomationRunner } from '../features/automations'
+import { D1AutomationRepository } from '../shared/automations.repository.d1'
+import { ExecutionContextScheduler } from '../shared/execution-context-scheduler'
 import type { Env, Variables } from '../types'
 
 interface RepositoryOverrides {
@@ -32,6 +37,17 @@ interface RepositoryOverrides {
   contentScanRepository?: IContentScanRepository
   clock?: IClock
   idGenerator?: IIdGenerator
+  automationRepository?: IAutomationRepository
+  automationRunner?: IAutomationRunner
+  scheduler?: IScheduler
+}
+
+function buildScheduler(context: Context): IScheduler {
+  try {
+    return new ExecutionContextScheduler(context.executionCtx)
+  } catch {
+    return new NoOpScheduler()
+  }
 }
 
 export const repositoryMiddleware = (overrides?: RepositoryOverrides) => {
@@ -55,6 +71,21 @@ export const repositoryMiddleware = (overrides?: RepositoryOverrides) => {
     context.set('contentScanRepository', overrides?.contentScanRepository ?? new D1ContentScanRepository(database))
     context.set('clock', resolvedClock)
     context.set('idGenerator', resolvedIdGenerator)
+    const automationRepository = overrides?.automationRepository
+      ?? new D1AutomationRepository(database)
+
+    context.set('automationRepository', automationRepository)
+    context.set(
+      'automationRunner',
+      overrides?.automationRunner ?? new AutomationRunner({
+        automationRepository,
+        contentRepository: context.get('repository'),
+        getSeed: context.get('getSeed'),
+        idGenerator: resolvedIdGenerator,
+        env: context.env as unknown as Record<string, string | undefined>,
+      }),
+    )
+    context.set('scheduler', overrides?.scheduler ?? buildScheduler(context))
     await next()
   })
 }

package/src/public/cache-utils.ts

@@ -0,0 +1,34 @@
+import type { Context } from 'hono'
+
+type EdgeCache = {
+  cache: Cache
+  executionCtx: { waitUntil: (p: Promise<unknown>) => void }
+} | null
+
+export function resolveEdgeCache(c: Context): EdgeCache {
+  try {
+    const cache = caches.default
+    let executionCtx: any
+    try {
+      executionCtx = c.executionCtx
+    } catch {
+      return null
+    }
+
+    if (!executionCtx?.waitUntil) return null
+    return { cache, executionCtx: executionCtx as { waitUntil: (p: Promise<unknown>) => void } }
+  } catch {
+    return null
+  }
+}
+
+export function withCachedResponse(edgeCache: EdgeCache, cacheKey: Request, response: Response): Response {
+  if (!edgeCache) return response
+  const cloned = response.clone()
+  const headers = new Headers(cloned.headers)
+  headers.set('Cache-Control', 'public, max-age=60')
+  edgeCache.executionCtx.waitUntil(
+    edgeCache.cache.put(cacheKey, new Response(cloned.body, { status: cloned.status, headers }))
+  )
+  return response
+}

package/src/public/entry-projection.ts

@@ -0,0 +1,42 @@
+import { resolvePolicies } from '@beechcms/core'
+import type { Seed } from '@beechcms/core'
+
+const SYSTEM_FIELDS = ['id', 'slug', 'status', 'created_at', 'updated_at']
+const IDENTITY_FIELDS = ['id', 'slug']
+
+function applyPublicPolicies(data: Record<string, unknown>, seed: Seed): Record<string, unknown> {
+  const result: Record<string, unknown> = {}
+
+  for (const key of SYSTEM_FIELDS) {
+    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
+    result[branch.alias] = visibility === 'masked' && typeof value === 'string' && value.length > 0
+      ? '••••••••'
+      : value
+  }
+  return result
+}
+
+export function toFlatPublicEntry(data: Record<string, unknown>, seed: Seed, fieldsParam?: string): Record<string, unknown> {
+  const projected = applyPublicPolicies(data, seed)
+  const requestedFields = (fieldsParam ?? '').split(',').map(f => f.trim()).filter(Boolean)
+
+  if (requestedFields.length === 0) return projected
+
+  const filtered: Record<string, unknown> = {}
+  for (const field of requestedFields) {
+    if (field in projected) filtered[field] = projected[field]
+  }
+
+  for (const key of IDENTITY_FIELDS) {
+    if (key in projected && !filtered[key]) filtered[key] = projected[key]
+  }
+
+  return filtered
+}

package/src/public/idempotency.ts

@@ -0,0 +1,19 @@
+import { sha256hex } from '@beechcms/core'
+
+export function parseIdempotencyKey(rawValue: string | undefined): string | null {
+  if (!rawValue) return null
+  const key = rawValue.trim()
+  if (!key || key.length > 128) return null
+  return key
+}
+
+type FingerprintInput = {
+  seedSlug: string
+  statusValue: unknown
+  slug: string | null
+  data: Record<string, unknown>
+}
+
+export function buildRequestFingerprint(input: FingerprintInput): Promise<string> {
+  return sha256hex(JSON.stringify({ seedSlug: input.seedSlug, statusValue: input.statusValue, slug: input.slug, data: input.data }))
+}

package/src/public/problem-details.ts

@@ -28,6 +28,11 @@ function normalizeProblemType(type: string): string {
   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).
  */

package/src/public/public-add.ts

@@ -1,156 +1,110 @@
-import { isValidContentStatus, SlugConflictError, sha256hex } 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 { generateEntrySlug, slugify } from './slug-utils'
-import { sanitizePublicPayload } from './sanitize'
-import { AppEnv } from '../types'
-
-function errorMessage(context: Context<AppEnv>, 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 pickSlugFromBody(body: Record<string, unknown>, sanitizedData: Record<string, unknown>): string {
-  const explicitSlug = cleanStr(body.slug)
-  if (explicitSlug) return slugify(explicitSlug)
-  return generateEntrySlug({ title: sanitizedData.title, name: sanitizedData.name })
-}
-
-function parseIdempotencyKey(rawValue: string | undefined): string | null {
-  if (!rawValue) return null
-  const key = rawValue.trim()
-  if (!key || key.length > 128) return null
-  return key
-}
-
-
-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 entrySlug = pickSlugFromBody(body, sanitized.data)
-  const finalSlug = entrySlug || 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 fingerprintPayload = JSON.stringify({ seedSlug, statusValue, slug: cleanStr(body.slug) ?? null, data: sanitized.data })
-    const fingerprint = await sha256hex(fingerprintPayload)
-    const idempotencyTtlSeconds = 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 + idempotencyTtlSeconds 
-      })
-    }
-
-    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: errorMessage(context, error) 
-    })
-  }
-}
+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) })
+  }
+}