@beechcms/api 0.4.3 → 0.6.0-preview.1

package/src/features/content/handlers/bulk.handler.ts

@@ -0,0 +1,185 @@
+// 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 { Context } from 'hono'
+import { resolvePolicies, type BulkFieldUpdate } from '@beechcms/core'
+import { publicProblem } from '../../../public/problem-details'
+import { CONTENT_ERRORS } from '../constants'
+import { AppEnv } from '../../../types'
+
+const MAX_BULK_SIZE = 500
+
+const MULTI_REL_MODES = ['replace', 'add', 'remove'] as const
+type MultiRelMode = (typeof MULTI_REL_MODES)[number]
+
+interface MultiRelWrapper {
+  mode: MultiRelMode
+  value: string[]
+}
+
+function isMultiRelWrapper(v: unknown): v is MultiRelWrapper {
+  if (typeof v !== 'object' || v === null) return false
+  const obj = v as Record<string, unknown>
+  return (
+    MULTI_REL_MODES.includes(obj.mode as MultiRelMode) &&
+    Array.isArray(obj.value) &&
+    (obj.value as unknown[]).every((x) => typeof x === 'string')
+  )
+}
+
+export async function bulkHandler(context: Context<AppEnv>) {
+  const slug = context.req.param('slug')
+  if (!slug) {
+    return publicProblem(context, {
+      type: 'content-invalid-slug-or-id',
+      title: 'Bad Request',
+      status: 400,
+      detail: CONTENT_ERRORS.INVALID_SLUG_OR_ID,
+    })
+  }
+
+  const seed = context.get('getSeed')(slug)
+  if (!seed) {
+    return publicProblem(context, {
+      type: 'content-seed-not-found',
+      title: 'Not Found',
+      status: 404,
+      detail: CONTENT_ERRORS.SEED_NOT_FOUND,
+    })
+  }
+
+  let body: Record<string, unknown>
+  try {
+    body = await context.req.json<Record<string, unknown>>()
+  } catch {
+    return publicProblem(context, {
+      type: 'content-invalid-json',
+      title: 'Bad Request',
+      status: 400,
+      detail: CONTENT_ERRORS.INVALID_JSON_BODY,
+    })
+  }
+
+  // ── Validate ids ─────────────────────────────────────────────────────────────
+  const ids = body.ids
+  if (!Array.isArray(ids) || ids.length === 0 || ids.some((id) => typeof id !== 'string')) {
+    return publicProblem(context, {
+      type: 'bulk-invalid-ids',
+      title: 'Bad Request',
+      status: 400,
+      detail: 'ids must be a non-empty array of strings',
+    })
+  }
+
+  if (ids.length > MAX_BULK_SIZE) {
+    return publicProblem(context, {
+      type: 'bulk-size-exceeded',
+      title: 'Bad Request',
+      status: 400,
+      detail: `Cannot edit more than ${MAX_BULK_SIZE} entries at once`,
+    })
+  }
+
+  // ── Validate fields ───────────────────────────────────────────────────────────
+  const rawFields = body.fields
+  if (
+    typeof rawFields !== 'object' ||
+    rawFields === null ||
+    Array.isArray(rawFields) ||
+    Object.keys(rawFields as object).length === 0
+  ) {
+    return publicProblem(context, {
+      type: 'bulk-invalid-fields',
+      title: 'Bad Request',
+      status: 400,
+      detail: 'fields must be an object with at least one key',
+    })
+  }
+
+  const fieldsRaw = rawFields as Record<string, unknown>
+
+  // Validate each alias exists on the seed and is not hidden/encrypt
+  const resolvedFields: Record<string, BulkFieldUpdate> = {}
+
+  for (const [alias, rawValue] of Object.entries(fieldsRaw)) {
+    const branch = seed.branches.find((b) => b.alias === alias)
+    if (!branch) {
+      return publicProblem(context, {
+        type: 'bulk-unknown-field',
+        title: 'Bad Request',
+        status: 400,
+        detail: `Field '${alias}' does not exist on seed '${slug}'`,
+      })
+    }
+
+    const policies = resolvePolicies(branch)
+    if (policies.visibility === 'hidden' || policies.privacy === 'encrypt') {
+      return publicProblem(context, {
+        type: 'field-not-bulk-editable',
+        title: 'Bad Request',
+        status: 400,
+        detail: `Field '${alias}' cannot be bulk-edited (hidden or encrypted)`,
+      })
+    }
+
+    // Multi-relation branches accept a { mode, value } wrapper or a plain array (treated as replace)
+    const branchAny = branch as { type: string; multiple?: boolean }
+    if (branchAny.type === 'relation' && branchAny.multiple === true) {
+      if (isMultiRelWrapper(rawValue)) {
+        const kindMap: Record<MultiRelMode, BulkFieldUpdate['kind']> = {
+          replace: 'array_replace',
+          add: 'array_add',
+          remove: 'array_remove',
+        }
+        resolvedFields[alias] = { kind: kindMap[rawValue.mode], value: rawValue.value }
+      } else if (Array.isArray(rawValue) && (rawValue as unknown[]).every((x) => typeof x === 'string')) {
+        resolvedFields[alias] = { kind: 'array_replace', value: rawValue as string[] }
+      } else {
+        return publicProblem(context, {
+          type: 'bulk-invalid-field-value',
+          title: 'Bad Request',
+          status: 400,
+          detail: `Field '${alias}' is a multi-relation and requires { mode, value } or a string array`,
+        })
+      }
+    } else {
+      resolvedFields[alias] = { kind: 'set', value: rawValue }
+    }
+  }
+
+  // ── Execute ───────────────────────────────────────────────────────────────────
+  const repository = context.get('repository')
+  const { updated, failed } = await repository.bulkUpdate(slug, ids as string[], resolvedFields)
+
+  // ── Activity log (single entry for the whole operation) ───────────────────────
+  const jwtPayload = context.get('jwtPayload')
+  context.get('activityLogger').log({
+    action: 'bulk_update',
+    entityType: 'content',
+    entityId: slug,
+    entitySlug: slug,
+    details: { count: updated, fields: Object.keys(resolvedFields) },
+    actor: {
+      id: jwtPayload.sub,
+      email: jwtPayload.email ?? 'unknown',
+      name: [jwtPayload.name, jwtPayload.surname].filter(Boolean).join(' ') || null,
+    },
+  })
+
+  // ── Build structured failure objects ─────────────────────────────────────────
+  const failedProblems = failed.map(({ id, reason }) => ({
+    id,
+    problem: {
+      status: 422,
+      type: reason.startsWith('relation-target-not-found')
+        ? 'relation-target-not-found'
+        : reason === 'not-found'
+          ? 'content-not-found'
+          : 'bulk-update-error',
+      detail: reason,
+    },
+  }))
+
+  return context.json({ updated, failed: failedProblems })
+}

package/src/features/content/handlers/create.ts

@@ -1,32 +1,27 @@
+// 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 { Context } from 'hono'
 import { 
   slugify, 
   isValidContentStatus, 
-  validateAndSanitizeSeedPayload,
-  SlugConflictError
+  validateAndSanitizeSeedPayload
 } from '@beechcms/core'
 import { applyPrivacy, PrivacyPolicyError } from '../../../shared/apply-policies'
 import { publicProblem } from '../../../public/problem-details'
+import {
+  normalizeBody,
+  contentValidationProblem,
+  logContentActivity,
+  dispatchContentAutomation,
+  handleContentDatabaseError
+} from './helpers'
 import { CONTENT_ERRORS } from '../constants'
 import { cleanStr } from '../../../shared/query-utils'
 import { AppEnv } from '../../../types'
 
-function normalizeBody(raw: unknown): Record<string, unknown> {
-  return typeof raw === 'object' && raw !== null ? (raw as Record<string, unknown>) : {}
-}
 
-function contentValidationProblem(
-  context: Context,
-  details: Array<{ field: string; expected: string; received: string; message: string }>
-) {
-  return publicProblem(context, { 
-    type: 'content-validation-failed', 
-    title: 'Bad Request', 
-    status: 400, 
-    detail: 'Validation failed', 
-    errors: details 
-  })
-}
 
 export async function createHandler(context: Context<AppEnv>) {
   const slug = context.req.param('slug')
@@ -77,10 +72,11 @@ export async function createHandler(context: Context<AppEnv>) {
   delete bodyForData.status
 
   const validation = validateAndSanitizeSeedPayload(seed, bodyForData, {
-    operation: 'create', 
-    allowNull: false, 
-    requireAtLeastOneValidField: true, 
+    operation: 'create',
+    allowNull: false,
+    requireAtLeastOneValidField: true,
     enforceRequiredFields: true,
+    idGenerator: context.get('idGenerator'),
   })
 
   if (validation.dangerousFields.length > 0) {
@@ -123,43 +119,11 @@ export async function createHandler(context: Context<AppEnv>) {
     const jwtPayload = context.get('jwtPayload')
     const title = privacyData.title || privacyData.name || finalSlug
 
-    context.get('activityLogger').log({
-      action: 'create',
-      entityType: 'content',
-      entityId: id,
-      entitySlug: slug,
-      details: { title },
-      actor: {
-        id: jwtPayload.sub,
-        email: jwtPayload.email ?? 'unknown',
-        name: jwtPayload.name ?? null,
-      },
-    })
-
-    context.get('scheduler').waitUntil(
-      context.get('automationRunner').run({
-        seedSlug: slug,
-        event: 'create',
-        entry: { id, slug: finalSlug, status, ...privacyData },
-      }),
-    )
+    logContentActivity(context, 'create', id, slug, String(title))
+    dispatchContentAutomation(context, slug, 'create', { id, slug: finalSlug, status, ...privacyData })
 
     return context.json({ id }, 201)
   } catch (error) {
-    if (error instanceof SlugConflictError) {
-      return publicProblem(context, { 
-        type: 'content-slug-conflict', 
-        title: 'Conflict', 
-        status: 409, 
-        detail: CONTENT_ERRORS.SLUG_CONFLICT 
-      })
-    }
-    console.error('Content create error:', error)
-    return publicProblem(context, { 
-      type: 'content-database-error', 
-      title: 'Internal Server Error', 
-      status: 500, 
-      detail: CONTENT_ERRORS.DATABASE_ERROR 
-    })
+    return handleContentDatabaseError(context, error)
   }
 }

package/src/features/content/handlers/delete.ts

@@ -1,8 +1,16 @@
+// 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 { Context } from 'hono'
-import { EntryNotFoundError } from '@beechcms/core'
 import { deleteR2Objects } from '../../../upload'
 import { extractMediaKeysFromData } from '../../../media-utils'
 import { publicProblem } from '../../../public/problem-details'
+import {
+  logContentActivity,
+  dispatchContentAutomation,
+  handleContentDatabaseError
+} from './helpers'
 import { CONTENT_ERRORS } from '../constants'
 import { AppEnv } from '../../../types'
 
@@ -33,29 +41,10 @@ export async function deleteHandler(context: Context<AppEnv>) {
     // Repository.delete returns the row data for cleanup
     const { row } = await repository.delete(seed, entryId)
 
-    const jwtPayload = context.get('jwtPayload')
     const title = row.title || row.name || entryId
 
-    context.get('activityLogger').log({
-      action: 'delete',
-      entityType: 'content',
-      entityId: entryId,
-      entitySlug: schemaSlug,
-      details: { title },
-      actor: {
-        id: jwtPayload.sub,
-        email: jwtPayload.email ?? 'unknown',
-        name: jwtPayload.name ?? null,
-      },
-    })
-
-    context.get('scheduler').waitUntil(
-      context.get('automationRunner').run({
-        seedSlug: schemaSlug,
-        event: 'delete',
-        entry: { ...row, id: entryId },
-      }),
-    )
+    logContentActivity(context, 'delete', entryId, schemaSlug, String(title))
+    dispatchContentAutomation(context, schemaSlug, 'delete', { ...row, id: entryId })
 
     const r2ObjectKeys = extractMediaKeysFromData(seed, row)
     if (r2ObjectKeys.length > 0) {
@@ -68,20 +57,6 @@ export async function deleteHandler(context: Context<AppEnv>) {
 
     return context.json({ success: true })
   } catch (error) {
-    if (error instanceof EntryNotFoundError) {
-      return publicProblem(context, { 
-        type: 'content-not-found', 
-        title: 'Not Found', 
-        status: 404, 
-        detail: CONTENT_ERRORS.NOT_FOUND 
-      })
-    }
-    console.error('Content delete error:', error)
-    return publicProblem(context, { 
-      type: 'content-database-error', 
-      title: 'Internal Server Error', 
-      status: 500, 
-      detail: CONTENT_ERRORS.DATABASE_ERROR 
-    })
+    return handleContentDatabaseError(context, error)
   }
 }

package/src/features/content/handlers/facets.ts

@@ -1,3 +1,7 @@
+// 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 { Context } from 'hono'
 import { publicProblem } from '../../../public/problem-details'
 import { CONTENT_ERRORS } from '../constants'

package/src/features/content/handlers/get.ts

@@ -1,3 +1,7 @@
+// 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 { Context } from 'hono'
 import { applyVisibility } from '../../../shared/apply-policies'
 import { publicProblem } from '../../../public/problem-details'

package/src/features/content/handlers/helpers.test.ts

@@ -0,0 +1,180 @@
+import { describe, it, expect, vi } from 'vitest'
+import { Context } from 'hono'
+import { EntryNotFoundError, SlugConflictError } from '@beechcms/core'
+import { normalizeBody, contentValidationProblem, logContentActivity, dispatchContentAutomation, handleContentDatabaseError } from './helpers'
+import { CONTENT_ERRORS } from '../constants'
+
+// Mock dependencies
+vi.mock('../../../public/problem-details', () => ({
+  publicProblem: vi.fn((_ctx, details) => ({ mockProblem: true, ...details })),
+  fkProblemOrNull: vi.fn((_ctx, err, method) => {
+    if (err instanceof Error && err.message === 'FK_ERROR') return { mockFkProblem: true }
+    return null
+  }),
+}))
+
+describe('content handlers helpers', () => {
+  describe('normalizeBody', () => {
+    it('returns the object when input is an object', () => {
+      const obj = { a: 1 }
+      expect(normalizeBody(obj)).toBe(obj)
+    })
+
+    it('returns an empty object when input is null', () => {
+      expect(normalizeBody(null)).toEqual({})
+    })
+
+    it('returns an empty object when input is a primitive', () => {
+      expect(normalizeBody('string')).toEqual({})
+      expect(normalizeBody(123)).toEqual({})
+      expect(normalizeBody(true)).toEqual({})
+    })
+  })
+
+  describe('contentValidationProblem', () => {
+    it('calls publicProblem with correct parameters', () => {
+      const ctx = {} as Context
+      const errors = [{ field: 'title', expected: 'string', received: 'number', message: 'Wrong type' }]
+      const result = contentValidationProblem(ctx, errors)
+      
+      expect(result).toEqual({
+        mockProblem: true,
+        type: 'content-validation-failed',
+        title: 'Bad Request',
+        status: 400,
+        detail: 'Validation failed',
+        errors,
+      })
+    })
+  })
+
+  describe('logContentActivity', () => {
+    it('logs activity with correct payload', () => {
+      const mockLog = vi.fn()
+      const ctx = {
+        get: vi.fn((key) => {
+          if (key === 'jwtPayload') return { sub: 'user-1', email: 'test@test.com', name: 'John', surname: 'Doe' }
+          if (key === 'activityLogger') return { log: mockLog }
+        })
+      } as unknown as Context<any>
+
+      logContentActivity(ctx, 'create', 'entry-1', 'test-slug', 'Test Title')
+
+      expect(mockLog).toHaveBeenCalledWith({
+        action: 'create',
+        entityType: 'content',
+        entityId: 'entry-1',
+        entitySlug: 'test-slug',
+        details: { title: 'Test Title' },
+        actor: {
+          id: 'user-1',
+          email: 'test@test.com',
+          name: 'John Doe',
+        },
+      })
+    })
+
+    it('handles missing name and surname', () => {
+      const mockLog = vi.fn()
+      const ctx = {
+        get: vi.fn((key) => {
+          if (key === 'jwtPayload') return { sub: 'user-1' } // Missing name, surname, email
+          if (key === 'activityLogger') return { log: mockLog }
+        })
+      } as unknown as Context<any>
+
+      logContentActivity(ctx, 'update', 'entry-1', 'test-slug', 'Test Title')
+
+      expect(mockLog).toHaveBeenCalledWith({
+        action: 'update',
+        entityType: 'content',
+        entityId: 'entry-1',
+        entitySlug: 'test-slug',
+        details: { title: 'Test Title' },
+        actor: {
+          id: 'user-1',
+          email: 'unknown',
+          name: null,
+        },
+      })
+    })
+  })
+
+  describe('dispatchContentAutomation', () => {
+    it('schedules automation run', () => {
+      const mockWaitUntil = vi.fn()
+      const mockRun = vi.fn().mockReturnValue('mock-promise')
+      const ctx = {
+        get: vi.fn((key) => {
+          if (key === 'scheduler') return { waitUntil: mockWaitUntil }
+          if (key === 'automationRunner') return { run: mockRun }
+        })
+      } as unknown as Context<any>
+
+      const entry = { id: 1 }
+      dispatchContentAutomation(ctx, 'posts', 'create', entry)
+
+      expect(mockRun).toHaveBeenCalledWith({
+        seedSlug: 'posts',
+        event: 'create',
+        entry,
+      })
+      expect(mockWaitUntil).toHaveBeenCalledWith('mock-promise')
+    })
+  })
+
+  describe('handleContentDatabaseError', () => {
+    it('handles EntryNotFoundError', () => {
+      const ctx = {} as Context<any>
+      const error = new EntryNotFoundError('Not found')
+      const result = handleContentDatabaseError(ctx, error)
+
+      expect(result).toEqual({
+        mockProblem: true,
+        type: 'content-not-found',
+        title: 'Not Found',
+        status: 404,
+        detail: CONTENT_ERRORS.NOT_FOUND,
+      })
+    })
+
+    it('handles SlugConflictError', () => {
+      const ctx = {} as Context<any>
+      const error = new SlugConflictError('Conflict', 'slug')
+      const result = handleContentDatabaseError(ctx, error)
+
+      expect(result).toEqual({
+        mockProblem: true,
+        type: 'content-slug-conflict',
+        title: 'Conflict',
+        status: 409,
+        detail: CONTENT_ERRORS.SLUG_CONFLICT,
+      })
+    })
+
+    it('handles foreign key error', () => {
+      const ctx = { req: { method: 'POST' } } as unknown as Context<any>
+      const error = new Error('FK_ERROR')
+      const result = handleContentDatabaseError(ctx, error)
+
+      expect(result).toEqual({ mockFkProblem: true })
+    })
+
+    it('handles generic errors as 500', () => {
+      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+      const ctx = { req: { method: 'POST' } } as unknown as Context<any>
+      const error = new Error('Some db error')
+      const result = handleContentDatabaseError(ctx, error)
+
+      expect(result).toEqual({
+        mockProblem: true,
+        type: 'content-database-error',
+        title: 'Internal Server Error',
+        status: 500,
+        detail: CONTENT_ERRORS.DATABASE_ERROR,
+      })
+      expect(consoleSpy).toHaveBeenCalledWith('Content database error:', error)
+      consoleSpy.mockRestore()
+    })
+  })
+})

package/src/features/content/handlers/helpers.ts

@@ -0,0 +1,93 @@
+// 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 { Context } from 'hono'
+import { EntryNotFoundError, SlugConflictError } from '@beechcms/core'
+import { publicProblem, fkProblemOrNull } from '../../../public/problem-details'
+import { CONTENT_ERRORS } from '../constants'
+import { AppEnv } from '../../../types'
+
+export function normalizeBody(raw: unknown): Record<string, unknown> {
+  return typeof raw === 'object' && raw !== null ? (raw as Record<string, unknown>) : {}
+}
+
+export function contentValidationProblem(
+  context: Context,
+  details: Array<{ field: string; expected: string; received: string; message: string }>
+) {
+  return publicProblem(context, { 
+    type: 'content-validation-failed', 
+    title: 'Bad Request', 
+    status: 400, 
+    detail: 'Validation failed', 
+    errors: details 
+  })
+}
+
+export function logContentActivity(
+  context: Context<AppEnv>,
+  action: 'create' | 'update' | 'delete',
+  id: string,
+  slug: string,
+  title: string
+) {
+  const jwtPayload = context.get('jwtPayload')
+  context.get('activityLogger').log({
+    action,
+    entityType: 'content',
+    entityId: id,
+    entitySlug: slug,
+    details: { title },
+    actor: {
+      id: jwtPayload.sub,
+      email: jwtPayload.email ?? 'unknown',
+      name: [jwtPayload.name, jwtPayload.surname].filter(Boolean).join(' ') || null,
+    },
+  })
+}
+
+export function dispatchContentAutomation(
+  context: Context<AppEnv>,
+  seedSlug: string,
+  event: 'create' | 'update' | 'delete',
+  entry: Record<string, unknown>
+) {
+  context.get('scheduler').waitUntil(
+    context.get('automationRunner').run({
+      seedSlug,
+      event,
+      entry,
+    }),
+  )
+}
+
+export function handleContentDatabaseError(context: Context<AppEnv>, error: unknown) {
+  if (error instanceof EntryNotFoundError) {
+    return publicProblem(context, { 
+      type: 'content-not-found', 
+      title: 'Not Found', 
+      status: 404, 
+      detail: CONTENT_ERRORS.NOT_FOUND 
+    })
+  }
+  if (error instanceof SlugConflictError) {
+    return publicProblem(context, {
+      type: 'content-slug-conflict',
+      title: 'Conflict',
+      status: 409,
+      detail: CONTENT_ERRORS.SLUG_CONFLICT,
+    })
+  }
+  
+  const fkResponse = fkProblemOrNull(context, error, context.req.method)
+  if (fkResponse) return fkResponse
+
+  console.error('Content database error:', error)
+  return publicProblem(context, {
+    type: 'content-database-error',
+    title: 'Internal Server Error',
+    status: 500,
+    detail: CONTENT_ERRORS.DATABASE_ERROR,
+  })
+}