@beechcms/api 0.6.0-preview.2 → 0.6.0-preview.4

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

@@ -1,180 +0,0 @@
-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

@@ -1,93 +0,0 @@
-// SPDX-License-Identifier: BUSL-1.1
-// Copyright (c) 2024–2026 Flavio De Musso. All rights reserved.
-// See LICENSE in the repository root for license terms.
-
-import { 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,
-  })
-}

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

@@ -1,174 +0,0 @@
-// SPDX-License-Identifier: BUSL-1.1
-// Copyright (c) 2024–2026 Flavio De Musso. All rights reserved.
-// See LICENSE in the repository root for license terms.
-
-import { Context } from 'hono'
-import { parsePositiveInt, parseQueryFilters, cleanStr, toEngineFilters } from '../../../shared/query-utils'
-import { applyVisibility } from '../../../shared/apply-policies'
-import { publicProblem } from '../../../public/problem-details'
-import { CONTENT_ERRORS } from '../constants'
-import { AppEnv } from '../../../types'
-
-/**
- * Builds a compact `relations` map for the list response.
- * For each relation branch in the seed, collects non-null referenced ids from
- * the page items, then fires ONE batched query per target seed to retrieve
- * only the label column. This is O(R) extra queries per page (R = # relation
- * branches) instead of O(N*R) per-row fetches.
- *
- * Shape: { [branchAlias]: { [targetId]: labelString } }
- */
-async function buildRelationsMap(
-  context: Context<AppEnv>,
-  seed: Parameters<typeof applyVisibility>[1],
-  entries: Record<string, unknown>[]
-): Promise<Record<string, Record<string, string>>> {
-  const relationBranches = seed.branches.filter(
-    (b: { type: string }) => b.type === 'relation'
-  ) as Array<{ alias: string; targetSeed?: string }>
-
-  if (relationBranches.length === 0) return {}
-
-  const relations: Record<string, Record<string, string>> = {}
-  const repository = context.get('repository')
-  const seedRegistry = context.get('seedRegistry')
-
-  for (const branch of relationBranches) {
-    const targetSlug = branch.targetSeed
-    if (!targetSlug) continue
-
-    const targetSeedDef = seedRegistry.get(targetSlug)
-    if (!targetSeedDef) continue
-
-    const labelAlias = targetSeedDef.displayNameAlias ?? 'title'
-
-    // Collect unique non-null ids referenced by this branch
-    const ids = Array.from(
-      new Set(
-        entries
-          .map((entry) => {
-            const data = entry.data as Record<string, unknown>
-            return typeof data[branch.alias] === 'string' && data[branch.alias]
-              ? (data[branch.alias] as string)
-              : null
-          })
-          .filter((id): id is string => id !== null)
-      )
-    )
-
-    if (ids.length === 0) continue
-
-    try {
-      const { items } = await repository.findMany(targetSeedDef, {
-        filters: [
-          {
-            column: 'id',
-            type: 'system' as const,
-            conditions: [{ op: 'in' as const, value: ids }],
-          },
-        ],
-        fields: ['id', labelAlias],
-        pagination: { limit: ids.length, offset: 0 },
-      })
-
-      const map: Record<string, string> = {}
-      for (const item of items) {
-        const id = (item as Record<string, unknown>).id as string
-        const data = (item as Record<string, unknown>).data as Record<string, unknown>
-        const label = data[labelAlias]
-        map[id] = label != null && label !== '' ? String(label) : id
-      }
-
-      relations[branch.alias] = map
-    } catch {
-      // Non-fatal: if the target seed table doesn't exist yet, skip
-    }
-  }
-
-  return relations
-}
-
-export async function listHandler(context: Context<AppEnv>) {
-  const slug = context.req.param('slug')
-  if (!slug) {
-    return publicProblem(context, {
-      type: 'content-invalid-slug',
-      title: 'Bad Request',
-      status: 400,
-      detail: CONTENT_ERRORS.INVALID_SLUG
-    })
-  }
-
-  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
-    })
-  }
-
-  try {
-    const query = context.req.query()
-    const search = cleanStr(query.search) ?? ''
-    const sortBy = cleanStr(query.sortBy) ?? ''
-    const sortDirRaw = cleanStr(query.sortDir)?.toLowerCase() ?? 'asc'
-    const rawFilters = parseQueryFilters(query.filters)
-    const engineFilters = toEngineFilters(rawFilters)
-
-    // Note: repository doesn't yet support has_pending_draft filter/column natively
-    // in findMany without SQL manipulation. We'll stick to basic findMany for now
-    // and might need to enhance the repository if this feature is critical for v1 of this refactor.
-    // The legacy code was doing a lot of SQL injection here.
-
-    const page = parsePositiveInt(query.page, 1)
-    const limit = Math.min(parsePositiveInt(query.limit, 25), 100)
-    const offset = (page - 1) * limit
-
-    const orderBy = sortBy
-      ? { column: sortBy, dir: (sortDirRaw === 'desc' ? 'DESC' : 'ASC') as 'ASC' | 'DESC' }
-      : undefined
-
-    const repository = context.get('repository')
-    const { items, total } = await repository.findMany(seed, {
-      filters: engineFilters,
-      orderBy,
-      search: search || undefined,
-      pagination: { limit, offset },
-    })
-
-    const entries = await Promise.all(items.map(async (item) => {
-      // Check for pending draft if allowed
-      let hasPendingDraft = false
-      if (seed.allowDrafts) {
-        hasPendingDraft = await repository.hasDraft(seed, item.id)
-      }
-
-      return {
-        ...item,
-        has_pending_draft: hasPendingDraft,
-        data: applyVisibility(item, seed) // Repository returns "pure" data including system fields
-      }
-    }))
-
-    // If no query params (except slug), return array directly (legacy compatibility)
-    const hasQueryParams = Boolean(search) || Boolean(sortBy) || Boolean(query.filters) || query.page !== undefined || query.limit !== undefined
-    if (!hasQueryParams) {
-      return context.json(entries)
-    }
-
-    // Build compact relation labels map for N+1 mitigation
-    const relations = await buildRelationsMap(context, seed, entries)
-
-    return context.json({ items: entries, total, page, limit, relations })
-  } catch (error) {
-    console.error('Content list error:', error)
-    return publicProblem(context, {
-      type: 'content-database-error',
-      title: 'Internal Server Error',
-      status: 500,
-      detail: CONTENT_ERRORS.DATABASE_ERROR
-    })
-  }
-}

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

@@ -1,174 +0,0 @@
-// SPDX-License-Identifier: BUSL-1.1
-// Copyright (c) 2024–2026 Flavio De Musso. All rights reserved.
-// See LICENSE in the repository root for license terms.
-
-import { Context } from 'hono'
-import { 
-  slugify, 
-  isValidContentStatus, 
-  validateAndSanitizeSeedPayload,
-  resolvePolicies
-} 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'
-
-
-
-export async function updateHandler(context: Context<AppEnv>) {
-  const slug = context.req.param('slug')
-  const id = context.req.param('id')
-  if (!slug || !id) {
-    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 = normalizeBody(await context.req.json<unknown>())
-  } catch {
-    return publicProblem(context, { 
-      type: 'content-invalid-json', 
-      title: 'Bad Request', 
-      status: 400, 
-      detail: CONTENT_ERRORS.INVALID_JSON_BODY 
-    })
-  }
-
-  const bodyForData = { ...body }
-  delete bodyForData.slug
-  delete bodyForData.status
-
-  try {
-    const repository = context.get('repository')
-    // We need current data to handle slug and status if not provided, 
-    // and to verify existence.
-    const current = await repository.findById(seed, id)
-
-    const newSlug = body.slug !== undefined ? slugify(String(body.slug)) : (current.slug as string)
-    const newStatus = body.status !== undefined ? (cleanStr(body.status) ?? current.status as string) : current.status as string
-
-    if (!isValidContentStatus(newStatus)) {
-      return publicProblem(context, { 
-        type: 'content-invalid-status', 
-        title: 'Bad Request', 
-        status: 400, 
-        detail: 'Invalid status. Allowed values are: draft, review, published' 
-      })
-    }
-    
-    if (!newSlug) {
-      return publicProblem(context, { 
-        type: 'content-missing-slug', 
-        title: 'Bad Request', 
-        status: 400, 
-        detail: 'Missing required field: slug' 
-      })
-    }
-
-    let mergedData: Record<string, unknown> = {}
-
-    if (Object.keys(bodyForData).length > 0) {
-      const sensitiveAliases = Object.keys(bodyForData).filter((alias) => {
-        const branch = seed.branches.find((b) => b.alias === alias)
-        return branch != null && resolvePolicies(branch).privacy !== 'plain'
-      })
-      
-      if (sensitiveAliases.length > 0) {
-        return publicProblem(context, { 
-          type: 'content-sensitive-field-edit', 
-          title: 'Unprocessable Entity', 
-          status: 422, 
-          detail: `${CONTENT_ERRORS.SENSITIVE_FIELD_EDIT}: ${sensitiveAliases.join(', ')}` 
-        })
-      }
-
-      const validation = validateAndSanitizeSeedPayload(seed, bodyForData, {
-        operation: 'update',
-        allowNull: true,
-        requireAtLeastOneValidField: true,
-        enforceRequiredFields: true,
-        idGenerator: context.get('idGenerator'),
-      })
-
-      if (validation.dangerousFields.length > 0) {
-        return publicProblem(context, { 
-          type: 'content-dangerous-content', 
-          title: 'Unprocessable Entity', 
-          status: 422, 
-          detail: `Content rejected: dangerous markup detected in field '${validation.dangerousFields[0]}'` 
-        })
-      }
-      
-      if (validation.details.length > 0) return contentValidationProblem(context, validation.details)
-
-      let privacyPatch: Record<string, unknown>
-      try {
-        privacyPatch = await applyPrivacy(validation.data, seed)
-      } catch (error) {
-        if (error instanceof PrivacyPolicyError) {
-          return publicProblem(context, { 
-            type: 'content-policy-not-implemented', 
-            title: 'Not Implemented', 
-            status: 501, 
-            detail: error.message 
-          })
-        }
-        throw error
-      }
-
-      // Remove null values from patch (patch semantics: null = leave unchanged)
-      for (const [k, v] of Object.entries(privacyPatch)) {
-        if (v !== null) mergedData[k] = v
-      }
-    }
-
-    if (newSlug !== current.slug) {
-      if (await repository.existsSlug(seed, newSlug, id)) {
-        return publicProblem(context, { 
-          type: 'content-slug-conflict', 
-          title: 'Conflict', 
-          status: 409, 
-          detail: CONTENT_ERRORS.SLUG_CONFLICT 
-        })
-      }
-      // Add slug to mergedData if changed
-      mergedData.slug = newSlug
-    }
-
-    await repository.update(seed, id, mergedData, newStatus)
-
-    const jwtPayload = context.get('jwtPayload')
-    const title = mergedData.title || mergedData.name || newSlug
-
-    logContentActivity(context, 'update', id, slug, String(title))
-    dispatchContentAutomation(context, slug, 'update', { ...current, ...mergedData, id, status: newStatus })
-
-    return context.json({ success: true })
-  } catch (error) {
-    return handleContentDatabaseError(context, error)
-  }
-}

package/src/features/content/index.ts

@@ -1,26 +0,0 @@
-// SPDX-License-Identifier: BUSL-1.1
-// Copyright (c) 2024–2026 Flavio De Musso. All rights reserved.
-// See LICENSE in the repository root for license terms.
-
-import { Hono } from 'hono'
-import { AppEnv } from '../../types'
-import { listHandler } from './handlers/list'
-import { getByIdHandler, getBySlugHandler } from './handlers/get'
-import { createHandler } from './handlers/create'
-import { updateHandler } from './handlers/update'
-import { deleteHandler } from './handlers/delete'
-import { facetsHandler } from './handlers/facets'
-import { bulkHandler } from './handlers/bulk.handler'
-
-const content = new Hono<AppEnv>()
-
-content.get('/:slug', listHandler)
-content.get('/:slug/facets', facetsHandler)
-content.get('/:schema_slug/by-slug/:entry_slug', getBySlugHandler)
-content.get('/:slug/:id', getByIdHandler)
-content.post('/:slug', createHandler)
-content.patch('/:slug/bulk', bulkHandler)
-content.put('/:slug/:id', updateHandler)
-content.delete('/:slug/:id', deleteHandler)
-
-export default content