@beechcms/api 0.4.0 → 0.4.2

package/src/middleware/repository.middleware.ts

@@ -1,9 +1,24 @@
 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'
 import { D1SystemStatsRepository } from '../shared/system-stats.repository.d1'
-import type { ContentRepository, IdempotencyRepository, MediaRepository, SystemStatsRepository } from '@beechcms/core'
+import { D1UserRepository } from '../shared/d1-user.repository'
+import { D1SessionRepository } from '../shared/d1-session.repository'
+import { D1PasswordResetTokenRepository } from '../shared/d1-password-reset-token.repository'
+import { D1ActivityLogRepository } from '../shared/d1-activity-log.repository'
+import { D1NotificationRepository } from '../shared/d1-notification.repository'
+import { D1WidgetRepository } from '../shared/d1-widget.repository'
+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, 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 {
@@ -11,14 +26,66 @@ interface RepositoryOverrides {
   idempotencyRepository?: IdempotencyRepository
   mediaRepository?: MediaRepository
   systemStatsRepository?: SystemStatsRepository
+  userRepository?: IUserRepository
+  sessionRepository?: ISessionRepository
+  passwordResetTokenRepository?: IPasswordResetTokenRepository
+  activityLogRepository?: IActivityLogRepository
+  notificationRepository?: INotificationRepository
+  widgetRepository?: IWidgetRepository
+  searchRepository?: ISearchRepository
+  analyticsRepository?: IAnalyticsRepository
+  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) => {
   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))
+    const resolvedClock = overrides?.clock ?? SystemClock
+    const resolvedIdGenerator = overrides?.idGenerator ?? SystemIdGenerator
+    const database = context.env.DB
+
+    context.set('repository', overrides?.repository ?? new D1ContentRepository(database))
+    context.set('idempotencyRepository', overrides?.idempotencyRepository ?? new D1IdempotencyRepository(database))
+    context.set('mediaRepository', overrides?.mediaRepository ?? new D1MediaRepository(database))
+    context.set('systemStatsRepository', overrides?.systemStatsRepository ?? new D1SystemStatsRepository(database))
+    context.set('userRepository', overrides?.userRepository ?? new D1UserRepository(database))
+    context.set('sessionRepository', overrides?.sessionRepository ?? new D1SessionRepository(database, resolvedClock))
+    context.set('passwordResetTokenRepository', overrides?.passwordResetTokenRepository ?? new D1PasswordResetTokenRepository(database, resolvedIdGenerator))
+    context.set('activityLogRepository', overrides?.activityLogRepository ?? new D1ActivityLogRepository(database))
+    context.set('notificationRepository', overrides?.notificationRepository ?? new D1NotificationRepository(database, resolvedClock, resolvedIdGenerator))
+    context.set('widgetRepository', overrides?.widgetRepository ?? new D1WidgetRepository(database))
+    context.set('searchRepository', overrides?.searchRepository ?? new D1SearchRepository(database))
+    context.set('analyticsRepository', overrides?.analyticsRepository ?? new D1AnalyticsRepository(database, resolvedClock))
+    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/middleware.ts

@@ -1,20 +1,14 @@
 /// <reference types="@cloudflare/workers-types" />
 import type { Context, Next } from 'hono'
 import { HTTPException } from 'hono/http-exception'
-import { jwtVerify } from 'jose'
+import type { Env, Variables } from './types'
 
-/** 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() {
@@ -24,44 +18,30 @@ function unauthorizedResponse() {
   })
 }
 
-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).
+ * JWT authentication middleware. Reads the Bearer token from the Authorization
+ * header and delegates verification to the ITokenService injected in context.
+ * Returns 401 on any missing or invalid token; never exposes failure details.
  */
-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 ')) {
+export function authMiddleware() {
+  return async (c: Context<{ Bindings: Env; Variables: Variables }>, next: Next): Promise<Response | void> => {
+    const authHeader = c.req.header('Authorization')
+    if (!authHeader?.startsWith('Bearer ')) {
       throw new HTTPException(401, { res: unauthorizedResponse() })
     }
 
-    const token = auth.slice(7)
+    const token = authHeader.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 {
+    const claims = await c.get('tokenService').verify(token)
+
+    if (!claims) {
       throw new HTTPException(401, { res: unauthorizedResponse() })
     }
+
+    c.set('jwtPayload', claims as JwtPayload)
+    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,166 +1,110 @@
-import { isValidContentStatus, SlugConflictError } 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 { createNotification } from '../shared/notification-service'
-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
-}
-
-function toHex(buffer: ArrayBuffer): string {
-  return [...new Uint8Array(buffer)].map((v) => v.toString(16).padStart(2, '0')).join('')
-}
-
-async function sha256Hex(input: string): Promise<string> {
-  const data = new TextEncoder().encode(input)
-  const digest = await crypto.subtle.digest('SHA-256', data)
-  return toHex(digest)
-}
-
-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 || crypto.randomUUID().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 = crypto.randomUUID()
-    
-    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 
-      })
-    }
-
-    await createNotification(context, {
-      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) })
+  }
+}

package/src/public/public-edit.ts

@@ -6,7 +6,6 @@ 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'
 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
@@ -77,7 +76,9 @@ function resolveData(
 
   const sensitiveAliases = Object.keys(rawData).filter((alias) => {
     const branch = seed.branches.find((b) => b.alias === alias)
-    return branch != null && resolvePolicies(branch).privacy !== 'plain'
+    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(', ')}` }) }
@@ -141,7 +142,7 @@ export async function publicEditHandler(context: PublicCtx) {
 
     await repository.update(seed, id, updateData, statusResult.value)
 
-    await createNotification(context, {
+    context.get('notificationService').notify({
       title: `${seed.label}: Update`,
       message: `The entry "${slugResult.value.nextSlug}" has been modified via the public API.`,
       type: 'info',