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

package/src/features/automations/automations.handler.ts

@@ -1,197 +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.
-
-/// <reference types="@cloudflare/workers-types" />
-import { Hono } from 'hono'
-import type { Env, Variables } from '../../types'
-import { publicProblem } from '../../public/problem-details'
-import {
-  createAutomationSchema,
-  updateAutomationSchema,
-  toggleAutomationSchema,
-} from './automations.schema'
-
-const automationsApp = new Hono<{ Bindings: Env; Variables: Variables }>()
-
-/**
- * GET /automations?seed=<slug>
- * Returns every automation declared for the given seed, newest first.
- */
-automationsApp.get('/', async (context) => {
-  const seedSlug = context.req.query('seed')
-  if (!seedSlug) {
-    return publicProblem(context, {
-      type: 'missing-seed',
-      status: 400,
-      title: 'Bad Request',
-      detail: 'Query param `seed` is required',
-    })
-  }
-  const repository = context.get('automationRepository')
-  const automations = await repository.list(seedSlug)
-  return context.json(automations)
-})
-
-/**
- * POST /automations
- * Creates a new automation. Body validated by `createAutomationSchema`.
- */
-automationsApp.post('/', async (context) => {
-  let body: unknown
-  try {
-    body = await context.req.json()
-  } catch {
-    return publicProblem(context, {
-      type: 'invalid-json',
-      status: 400,
-      title: 'Bad Request',
-      detail: 'Request body is not valid JSON',
-    })
-  }
-
-  const parsed = createAutomationSchema.safeParse(body)
-  if (!parsed.success) {
-    return publicProblem(context, {
-      type: 'automation-validation-failed',
-      status: 400,
-      title: 'Bad Request',
-      detail: parsed.error.message,
-    })
-  }
-
-  const repository = context.get('automationRepository')
-  const id = await repository.create({
-    seed_slug: parsed.data.seed_slug,
-    name: parsed.data.name,
-    triggers: parsed.data.triggers,
-    trigger_conditions: parsed.data.trigger_conditions ?? null,
-    actions: parsed.data.actions,
-  })
-  return context.json({ id }, 201)
-})
-
-/**
- * GET /automations/:id
- */
-automationsApp.get('/:id', async (context) => {
-  const id = context.req.param('id')
-  const automation = await context.get('automationRepository').findById(id)
-  if (!automation) {
-    return publicProblem(context, {
-      type: 'automation-not-found',
-      status: 404,
-      title: 'Not Found',
-      detail: `Automation ${id} does not exist`,
-    })
-  }
-  return context.json(automation)
-})
-
-/**
- * PUT /automations/:id
- * Full update — partial bodies allowed; cron expression validation
- * is enforced by the triggers array schema.
- */
-automationsApp.put('/:id', async (context) => {
-  const id = context.req.param('id')
-  const repository = context.get('automationRepository')
-  const existing = await repository.findById(id)
-  if (!existing) {
-    return publicProblem(context, {
-      type: 'automation-not-found',
-      status: 404,
-      title: 'Not Found',
-      detail: `Automation ${id} does not exist`,
-    })
-  }
-
-  let body: unknown
-  try {
-    body = await context.req.json()
-  } catch {
-    return publicProblem(context, {
-      type: 'invalid-json',
-      status: 400,
-      title: 'Bad Request',
-      detail: 'Request body is not valid JSON',
-    })
-  }
-
-  const parsed = updateAutomationSchema.safeParse(body)
-  if (!parsed.success) {
-    return publicProblem(context, {
-      type: 'automation-validation-failed',
-      status: 400,
-      title: 'Bad Request',
-      detail: parsed.error.message,
-    })
-  }
-
-  await repository.update(id, parsed.data)
-  return context.body(null, 204)
-})
-
-/**
- * PATCH /automations/:id/toggle
- * Atomic single-field flip — does not require sending the full body.
- */
-automationsApp.patch('/:id/toggle', async (context) => {
-  const id = context.req.param('id')
-  const repository = context.get('automationRepository')
-  const existing = await repository.findById(id)
-  if (!existing) {
-    return publicProblem(context, {
-      type: 'automation-not-found',
-      status: 404,
-      title: 'Not Found',
-      detail: `Automation ${id} does not exist`,
-    })
-  }
-
-  let body: unknown
-  try {
-    body = await context.req.json()
-  } catch {
-    return publicProblem(context, {
-      type: 'invalid-json',
-      status: 400,
-      title: 'Bad Request',
-      detail: 'Request body is not valid JSON',
-    })
-  }
-
-  const parsed = toggleAutomationSchema.safeParse(body)
-  if (!parsed.success) {
-    return publicProblem(context, {
-      type: 'automation-validation-failed',
-      status: 400,
-      title: 'Bad Request',
-      detail: parsed.error.message,
-    })
-  }
-
-  await repository.toggle(id, parsed.data.enabled)
-  return context.body(null, 204)
-})
-
-/**
- * DELETE /automations/:id
- */
-automationsApp.delete('/:id', async (context) => {
-  const id = context.req.param('id')
-  const repository = context.get('automationRepository')
-  const existing = await repository.findById(id)
-  if (!existing) {
-    return publicProblem(context, {
-      type: 'automation-not-found',
-      status: 404,
-      title: 'Not Found',
-      detail: `Automation ${id} does not exist`,
-    })
-  }
-  await repository.delete(id)
-  return context.body(null, 204)
-})
-
-export { automationsApp }

package/src/features/automations/automations.schema.ts

@@ -1,177 +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.
-
-// Mirror: apps/dashboard/src/features/automations/schema/automation.schema.ts — keep structurally identical.
-import { z } from 'zod'
-import type { WhenNode } from '@beechcms/core'
-import { isPrivateHost } from '@beechcms/core'
-import { AUTOMATION_RESERVED_WORDS } from './template-grammar'
-
-// ---------------------------------------------------------------------------
-// Trigger conditions — recursive WhenNode schema (Task 14)
-// ---------------------------------------------------------------------------
-
-const whenOperandSchema = z.union([
-  z.object({ kind: z.literal('literal'), value: z.unknown() }),
-  z.object({ kind: z.literal('ref'), key: z.string().min(1) }),
-])
-
-const whenPredicateSchema = z.object({
-  kind: z.literal('predicate'),
-  left: whenOperandSchema,
-  op: z.enum(['eq', 'neq', 'gt', 'gte', 'lt', 'lte', 'contains', 'startswith', 'endswith', 'in', 'notin', 'isempty', 'isnotempty', 'matches']),
-  right: whenOperandSchema.optional(),
-})
-
-const whenNodeSchema: z.ZodType<WhenNode> = z.lazy(() =>
-  z.union([
-    whenPredicateSchema,
-    z.object({
-      kind: z.literal('group'),
-      op: z.enum(['AND', 'OR']),
-      children: z.array(whenNodeSchema).min(1),
-      negate: z.boolean().optional(),
-    }).refine(
-      (g) => depthOf(g) <= 10,
-      { message: 'WhenNode nesting exceeds maximum depth of 10' },
-    ),
-  ]),
-)
-
-function depthOf(node: unknown, d = 0): number {
-  if (d > 10) return d
-  if (typeof node !== 'object' || !node) return d
-  const n = node as Record<string, unknown>
-  if (n['kind'] === 'group' && Array.isArray(n['children'])) {
-    return Math.max(...(n['children'] as unknown[]).map((c) => depthOf(c, d + 1)))
-  }
-  return d
-}
-
-const triggerConditionsSchema = whenNodeSchema.nullable().optional()
-
-const setVariableFilterSchema = z.object({
-  field: z.string().min(1),
-  op: z.enum(['eq', 'neq', 'contains', 'gt', 'lt', 'isempty', 'isnotempty']),
-  value: z.unknown(),
-})
-
-// ---------------------------------------------------------------------------
-// Action schemas
-// ---------------------------------------------------------------------------
-
-const setVariableActionSchema = z.object({
-  type: z.literal('set_variable'),
-  name: z
-    .string()
-    .min(1)
-    .regex(/^[a-zA-Z_][a-zA-Z0-9_]*$/)
-    .refine((v) => !AUTOMATION_RESERVED_WORDS.has(v), {
-      message: 'automations.editor.errors.variableNameReserved',
-    }),
-  seed_slug: z.string().min(1).optional(),
-  fixed_id: z.string().min(1).optional(),
-  column: z.string().min(1).optional(),
-  filters: z.array(setVariableFilterSchema).default([]),
-  order_by: z.string().optional(),
-  order: z.enum(['asc', 'desc']).optional(),
-  load_type: z.enum(['fruit', 'branch']).optional(),  // accepted but ignored at runtime
-})
-
-const webhookActionSchema = z.object({
-  type: z.literal('webhook'),
-  url: z
-    .string()
-    .url()
-    .refine((u) => {
-      try { return new URL(u).protocol === 'https:' } catch { return false }
-    }, { message: 'automations.editor.errors.webhookHttpsRequired' })
-    .refine((u) => {
-      try { return !isPrivateHost(new URL(u).hostname) } catch { return false }
-    }, { message: 'automations.editor.errors.webhookPrivateHostBlocked' }),
-  method: z.enum(['POST', 'GET', 'PUT']).optional(),
-  headers: z.record(z.string(), z.string()).optional(),
-  body_template: z.preprocess(
-    (v) => (v == null ? '' : v),
-    z.string().min(1, 'automations.editor.errors.bodyRequired'),
-  ),
-})
-
-const sendMailActionSchema = z.object({
-  type: z.literal('send_mail'),
-  to: z.string().email(),
-  subject_template: z.string().min(1),
-  body_template: z.string().min(1),
-})
-
-const editFieldActionSchema = z.object({
-  type: z.literal('edit_field'),
-  field: z.string().min(1),
-  value: z.unknown(),
-})
-
-const createEntryActionSchema = z.object({
-  type: z.literal('create_entry'),
-  seed_slug: z.string().min(1),
-  field_map: z.record(z.string(), z.string()),
-})
-
-export const automationActionSchema = z.discriminatedUnion('type', [
-  setVariableActionSchema,
-  webhookActionSchema,
-  sendMailActionSchema,
-  editFieldActionSchema,
-  createEntryActionSchema,
-])
-
-// ---------------------------------------------------------------------------
-// Triggers schema
-// ---------------------------------------------------------------------------
-
-const automationTriggerSchema = z.object({
-  event: z.enum(['create', 'update', 'delete', 'cron']),
-  cron: z.string().nullable().optional(),
-})
-
-const triggersSchema = z
-  .array(automationTriggerSchema)
-  .min(1, 'At least one trigger is required')
-  .refine(
-    (triggers) => triggers.filter((t) => t.event === 'cron').length <= 1,
-    { message: 'Only one cron trigger is allowed per automation' },
-  )
-  .refine(
-    (triggers) => {
-      const events = triggers.map((t) => t.event)
-      return new Set(events).size === events.length
-    },
-    { message: 'Duplicate trigger events are not allowed' },
-  )
-  .refine(
-    (triggers) => triggers.every((t) => t.event !== 'cron' || !!t.cron),
-    { message: 'cron expression is required for cron triggers', path: ['cron'] },
-  )
-
-// ---------------------------------------------------------------------------
-// Automation create/update schemas
-// ---------------------------------------------------------------------------
-
-const createAutomationBaseSchema = z.object({
-  seed_slug: z.string().min(1),
-  name: z.string().min(1).max(100),
-  triggers: triggersSchema,
-  trigger_conditions: triggerConditionsSchema,
-  actions: z.array(automationActionSchema).min(1, 'At least one action is required'),
-})
-
-export const createAutomationSchema = createAutomationBaseSchema
-
-export const updateAutomationSchema = createAutomationBaseSchema.partial()
-
-export const toggleAutomationSchema = z.object({
-  enabled: z.boolean(),
-})
-
-export type CreateAutomationBody = z.infer<typeof createAutomationSchema>
-export type UpdateAutomationBody = z.infer<typeof updateAutomationSchema>

package/src/features/automations/context-resolver.ts

@@ -1,152 +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 type { Automation } from '@beechcms/core'
-import type { AutomationContextSelector, ParsedKey } from './template-grammar'
-import { resolvePath } from './automation-runner.utils'
-
-export interface ResolvedContext {
-  lookup(key: ParsedKey, onMissing?: (field: string) => void): unknown
-  triggerEntry: Record<string, unknown> | null
-}
-
-const MAX_PLUCK = 100
-const AGGREGATE_OPS = new Set(['count', 'sum', 'avg', 'min', 'max', 'pluck'])
-
-function applyAggregate(
-  op: string,
-  field: string | null,
-  rows: Array<Record<string, unknown>>,
-  onMissing?: (f: string) => void,
-): unknown {
-  switch (op) {
-    case 'count':
-      return rows.length
-
-    case 'sum': {
-      if (!field) { if (onMissing) onMissing('sum:field'); return 0 }
-      return rows.reduce((acc, r) => {
-        const v = Number(r[field])
-        if (Number.isNaN(v)) { if (onMissing) onMissing(`sum:${field}:NaN`); return acc }
-        return acc + v
-      }, 0)
-    }
-
-    case 'avg': {
-      if (!field || rows.length === 0) { if (onMissing && !field) onMissing('avg:field'); return 0 }
-      const total = rows.reduce((acc, r) => {
-        const v = Number(r[field])
-        if (Number.isNaN(v)) { if (onMissing) onMissing(`avg:${field}:NaN`); return acc }
-        return acc + v
-      }, 0)
-      return rows.length > 0 ? total / rows.length : 0
-    }
-
-    case 'min': {
-      if (!field || rows.length === 0) { if (onMissing && !field) onMissing('min:field'); return null }
-      return rows.reduce<number | null>((acc, r) => {
-        const v = Number(r[field])
-        if (Number.isNaN(v)) return acc
-        return acc === null || v < acc ? v : acc
-      }, null)
-    }
-
-    case 'max': {
-      if (!field || rows.length === 0) { if (onMissing && !field) onMissing('max:field'); return null }
-      return rows.reduce<number | null>((acc, r) => {
-        const v = Number(r[field])
-        if (Number.isNaN(v)) return acc
-        return acc === null || v > acc ? v : acc
-      }, null)
-    }
-
-    case 'pluck': {
-      if (!field) { if (onMissing) onMissing('pluck:field'); return '' }
-      const values = rows.slice(0, MAX_PLUCK).map((r) => String(r[field] ?? ''))
-      const truncated = rows.length > MAX_PLUCK
-      return values.join(', ') + (truncated ? ' …' : '')
-    }
-
-    default:
-      return undefined
-  }
-}
-
-export async function resolveAutomationContext(
-  _automation: Automation,
-  triggerEntry: Record<string, unknown> | null,
-  batchEntries: Array<Record<string, unknown>>,
-): Promise<ResolvedContext> {
-  function lookup(parsed: ParsedKey, onMissing?: (field: string) => void): unknown {
-    if (parsed.kind === 'simple') {
-      if (parsed.path.startsWith('this.')) {
-        const field = parsed.path.slice(5)
-        const val = resolvePath(triggerEntry ?? {}, field)
-        if (val === undefined && onMissing) onMissing(parsed.path)
-        return val
-      }
-      const val = resolvePath(triggerEntry ?? {}, parsed.path)
-      if (val === undefined && onMissing) onMissing(parsed.path)
-      return val
-    }
-
-    if (parsed.kind !== 'scoped') {
-      if (onMissing) onMissing(parsed.kind === 'var_access' ? parsed.name : 'unknown')
-      return undefined
-    }
-
-    const { scope, selector: _selector, op, field } = parsed
-
-    if (scope === 'this') {
-      if (op !== 'field' || !field) { if (onMissing) onMissing(`this.${field}`); return undefined }
-      const val = resolvePath(triggerEntry ?? {}, field)
-      if (val === undefined && onMissing) onMissing(`this.${field}`)
-      return val
-    }
-
-    if (scope === 'batch') {
-      if (op === 'field') {
-        if (!field) { if (onMissing) onMissing('batch.field'); return undefined }
-        const val = resolvePath(batchEntries[0] ?? {}, field)
-        if (val === undefined && onMissing) onMissing(`batch.${field}`)
-        return val
-      }
-      return applyAggregate(op, field, batchEntries, onMissing)
-    }
-
-    if (onMissing) onMissing(scope)
-    return undefined
-  }
-
-  return { lookup, triggerEntry }
-}
-
-export function deriveEntryContext(
-  base: ResolvedContext,
-  entry: Record<string, unknown>,
-): ResolvedContext {
-  return {
-    lookup(parsed: ParsedKey, onMissing?: (field: string) => void): unknown {
-      if (parsed.kind === 'simple') {
-        if (parsed.path.startsWith('this.')) {
-          const field = parsed.path.slice(5)
-          const val = resolvePath(entry, field)
-          if (val === undefined && onMissing) onMissing(parsed.path)
-          return val
-        }
-        const val = resolvePath(entry, parsed.path)
-        if (val === undefined && onMissing) onMissing(parsed.path)
-        return val
-      }
-      if (parsed.kind === 'scoped' && parsed.scope === 'this') {
-        if (parsed.op !== 'field' || !parsed.field) { if (onMissing) onMissing('this.field'); return undefined }
-        const val = resolvePath(entry, parsed.field)
-        if (val === undefined && onMissing) onMissing(`this.${parsed.field}`)
-        return val
-      }
-      return base.lookup(parsed, onMissing)
-    },
-    triggerEntry: entry,
-  }
-}

package/src/features/automations/cron-runner.ts

@@ -1,140 +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 type {
-  Automation,
-  ContentRepository,
-  FilterGroup,
-  IAutomationRepository,
-  IIdGenerator,
-  Seed,
-} from '@beechcms/core'
-import { cronMatches } from './cron-runner.utils'
-import { executeAction } from './action-executors'
-import { resolveAutomationContext, deriveEntryContext } from './context-resolver'
-import { extractPushdownFilters } from './when-pushdown'
-import { evaluateWhen } from './when-evaluator'
-
-export interface CronRunnerDeps {
-  automationRepository: IAutomationRepository
-  contentRepository: ContentRepository
-  getSeed: (slug: string) => Seed | null
-  env: Record<string, string | undefined>
-  idGenerator: IIdGenerator
-}
-
-// These actions mutate individual entries and must run once per entry.
-// All other actions (send_mail, webhook) run once per automation with a batch context.
-const PER_ENTRY_ACTIONS = new Set(['edit_field', 'create_entry'])
-
-export async function runCronAutomations(
-  deps: CronRunnerDeps,
-  scheduledTime: number,
-): Promise<void> {
-  console.log(`[cron] Starting runCronAutomations at scheduledTime: ${new Date(scheduledTime).toISOString()}`)
-
-  let automations: Automation[]
-  try {
-    automations = await deps.automationRepository.findActive('*', 'cron')
-  } catch (err) {
-    console.error('[cron] Failed to fetch automations — is migration 0029_automations.sql applied?', err)
-    return
-  }
-
-  console.log(`[cron] Found ${automations.length} active cron automation(s)`)
-
-  for (const automation of automations) {
-    const cronTrigger = automation.triggers.find((t) => t.event === 'cron')
-    if (!cronMatches(cronTrigger?.cron ?? null, scheduledTime)) {
-      console.log(`[cron] Skipping "${automation.name}": cron expression "${cronTrigger?.cron}" does not match.`)
-      continue
-    }
-
-    const seed = deps.getSeed(automation.seed_slug)
-    if (!seed) {
-      console.warn('[cron] unknown seed', { automationId: automation.id, seedSlug: automation.seed_slug })
-      continue
-    }
-
-    let entries: Array<Record<string, unknown>> = []
-    try {
-      entries = await fetchMatchingEntries(deps.contentRepository, seed, automation)
-      console.log(`[cron] Fetched ${entries.length} matching entries for automation "${automation.name}"`)
-    } catch (err) {
-      console.error('[cron] fetch entries failed', { automationId: automation.id, err })
-      continue
-    }
-
-    if (entries.length === 0) continue
-
-    // Build the base ResolvedContext once per automation (shared seed-query cache).
-    // triggerEntry = first entry; batchEntries = full SQL-filtered list.
-    const batchResolved = await resolveAutomationContext(
-      automation,
-      entries[0] ?? null,
-      entries,
-    )
-
-    const variables: Record<string, unknown> = {}
-    const baseCtx = {
-      env: deps.env,
-      repository: deps.contentRepository,
-      getSeed: deps.getSeed,
-      seed,
-      idGenerator: deps.idGenerator,
-      variables,
-    }
-
-    for (const action of automation.actions) {
-      if (PER_ENTRY_ACTIONS.has(action.type)) {
-        for (const entry of entries) {
-          // Per-entry: derive a lightweight context whose `this` is the current entry.
-          // Seed-query cache is reused from batchResolved.
-          const entryResolved = deriveEntryContext(batchResolved, entry)
-          // In-memory per-entry condition check (Task 13)
-          if (!evaluateWhen(automation.trigger_conditions, entryResolved)) continue
-          try {
-            await executeAction(action, { ...baseCtx, entry, context: entryResolved })
-          } catch (err) {
-            console.error('[cron] entry action failed', {
-              automationId: automation.id,
-              entryId: entry['id'],
-              actionType: action.type,
-              err,
-            })
-          }
-        }
-      } else {
-        // Batch actions run once per automation with the shared batch context.
-        try {
-          await executeAction(action, { ...baseCtx, entry: entries[0] ?? {}, context: batchResolved })
-        } catch (err) {
-          console.error('[cron] batch action failed', {
-            automationId: automation.id,
-            actionType: action.type,
-            err,
-          })
-        }
-      }
-    }
-  }
-}
-
-async function fetchMatchingEntries(
-  repository: ContentRepository,
-  seed: Seed,
-  automation: Automation,
-): Promise<Array<Record<string, unknown>>> {
-  // Task 12: push down only safe predicates to SQL (this.<field> = literal, AND group only).
-  // OR branches, cross-seed refs, and gte/lte/etc. ops are evaluated in-memory by evaluateWhen().
-  const filters: FilterGroup[] = automation.trigger_conditions
-    ? extractPushdownFilters(automation.trigger_conditions, seed)
-    : []
-  const result = await repository.findMany(seed, {
-    filters,
-    status: null,
-    pagination: { limit: 1000, offset: 0 },
-  })
-  return result.items
-}