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

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
-}

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

@@ -1,44 +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.
-
-export function cronMatches(expression: string | null, scheduledTime: number): boolean {
-  if (!expression) return false
-  const parts = expression.trim().split(/\s+/)
-  if (parts.length !== 5) return false
-
-  const d = new Date(scheduledTime)
-  const actual = [
-    d.getUTCMinutes(),
-    d.getUTCHours(),
-    d.getUTCDate(),
-    d.getUTCMonth() + 1,
-    d.getUTCDay(),
-  ] as const
-
-  return parts.every((field, i) => matchField(field, actual[i]))
-}
-
-function matchField(field: string, value: number): boolean {
-  if (field === '*') return true
-  if (field.includes(',')) {
-    return field.split(',').some((part) => matchField(part, value))
-  }
-  if (field.includes('/')) {
-    const [rangePart, stepPart] = field.split('/')
-    const step = Number(stepPart)
-    if (!Number.isFinite(step) || step <= 0) return false
-    if (rangePart === '*') return value % step === 0
-    if (rangePart.includes('-')) {
-      const [lo, hi] = rangePart.split('-').map(Number)
-      return value >= lo && value <= hi && (value - lo) % step === 0
-    }
-    return false
-  }
-  if (field.includes('-')) {
-    const [lo, hi] = field.split('-').map(Number)
-    return Number.isFinite(lo) && Number.isFinite(hi) && value >= lo && value <= hi
-  }
-  const n = Number(field)
-  return Number.isFinite(n) && n === value
-}

package/src/features/automations/filter-translation.ts

@@ -1,46 +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.
-
-/**
- * Shared helper: converts a TriggerCondition into a FilterGroup accepted by
- * ContentRepository.findMany. Used by cron-runner and context-resolver.
- *
- * TODO Sprint 8 (Task 12): when-pushdown.ts will call extractPushdownFilters
- * to convert safe WhenNode predicates to FilterGroup[] for SQL pre-filtering.
- */
-import type { BranchType, FilterGroup, FilterOperator, FilterType, Seed, TriggerCondition } from '@beechcms/core'
-
-const SYSTEM_COLUMNS = new Set(['id', 'slug', 'status', 'created_at', 'updated_at'])
-
-function mapBranchTypeToFilterType(type: BranchType): FilterType {
-  switch (type) {
-    case 'number': return 'number'
-    case 'boolean': return 'boolean'
-    case 'date': return 'date'
-    case 'tags': return 'tags'
-    case 'json': return 'json'
-    default: return 'text'
-  }
-}
-
-function mapOp(op: TriggerCondition['op']): FilterOperator {
-  switch (op) {
-    case 'isempty': return 'is_empty'
-    case 'isnotempty': return 'is_not_empty'
-    default: return op
-  }
-}
-
-export function conditionToFilterGroup(c: TriggerCondition, seed: Seed): FilterGroup {
-  const branch = seed.branches.find((b) => b.alias === c.field)
-  const type: FilterType = branch
-    ? mapBranchTypeToFilterType(branch.type)
-    : SYSTEM_COLUMNS.has(c.field) ? 'system' : 'text'
-
-  return {
-    column: c.field,
-    type,
-    conditions: [{ op: mapOp(c.op), value: c.value as string | number | boolean | null }],
-  }
-}

package/src/features/automations/index.ts

@@ -1,16 +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.
-
-export { AutomationRunner } from './automation-runner'
-export type { AutomationRunnerDeps } from './automation-runner'
-export { runCronAutomations } from './cron-runner'
-export type { CronRunnerDeps } from './cron-runner'
-export { automationsApp } from './automations.handler'
-export {
-  createAutomationSchema,
-  updateAutomationSchema,
-  toggleAutomationSchema,
-  automationActionSchema,
-} from './automations.schema'
-export type { CreateAutomationBody, UpdateAutomationBody } from './automations.schema'