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

package/src/features/automations/action-executors/send-mail.executor.ts

@@ -1,53 +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 { AutomationAction } from '@beechcms/core'
-import type { ResolvedContext } from '../context-resolver'
-import { sendAutomationMail } from '../../email'
-import { interpolate } from '../automation-runner.utils'
-
-type SendMailAction = Extract<AutomationAction, { type: 'send_mail' }>
-
-export async function executeSendMail(
-  action: SendMailAction,
-  context: ResolvedContext,
-  env: Record<string, string | undefined>,
-): Promise<void> {
-  const missingFields: string[] = []
-  const logMissing = (field: string) => missingFields.push(field)
-
-  const to = interpolate(action.to, context, '[missing]', logMissing)
-  const subject = interpolate(action.subject_template, context, '[missing]', logMissing)
-  const body = interpolate(action.body_template, context, '[missing]', logMissing)
-
-  if (missingFields.length > 0) {
-    console.warn('[automations:send_mail] placeholders evaluated to default value due to missing concrete data:', missingFields)
-  }
-
-  const useSmtp = env.EMAIL_PROVIDER === 'smtp'
-  const apiKey = env.EMAIL_API_KEY ?? env.RESEND_API_KEY
-  if (!useSmtp && !apiKey) {
-    console.error('[automations:send_mail] Execution skipped: Email API key is missing from the environment configuration.')
-    return
-  }
-
-  const smtpBaseUrl = env.SMTP_HOST
-    ? `http://${env.SMTP_HOST}:${env.SMTP_PORT ?? '8025'}`
-    : undefined
-
-  try {
-    await sendAutomationMail({
-      to,
-      subject,
-      body,
-      apiKey: apiKey ?? '',
-      from: env.EMAIL_FROM,
-      provider: env.EMAIL_PROVIDER as 'smtp' | 'resend' | undefined,
-      smtpBaseUrl,
-    })
-  } catch (error) {
-    console.error('[automations:send_mail] failed to send automation email via provider:', error)
-    throw error
-  }
-}

package/src/features/automations/action-executors/set-variable.executor.ts

@@ -1,159 +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 { AutomationAction, ContentRepository, Seed } from '@beechcms/core'
-import type { ResolvedContext } from '../context-resolver'
-import { conditionToFilterGroup } from '../filter-translation'
-import { interpolate } from '../automation-runner.utils'
-
-type SetVariableAction = Extract<AutomationAction, { type: 'set_variable' }>
-
-export async function executeSetVariable(
-  action: SetVariableAction,
-  ctx: {
-    entry: Record<string, unknown>
-    variables: Record<string, unknown>
-    repository: ContentRepository
-    getSeed: (slug: string) => Seed | null
-    seed: Seed
-    context: ResolvedContext
-  },
-): Promise<void> {
-  const seedSlug = action.seed_slug ?? ctx.seed.slug
-  const targetSeed = ctx.getSeed(seedSlug)
-  if (!targetSeed) {
-    console.warn(`[set_variable] seed "${seedSlug}" not found; "${action.name}" → null`)
-    ctx.variables[action.name] = null
-    return
-  }
-
-  // ── legacy read normalisation ─────────────────────────────────────────────
-  let effectiveFixedId = action.fixed_id
-  if (effectiveFixedId === undefined && action.load_type === 'fruit') {
-    const idFilter = (action.filters ?? []).find(
-      (f) => f.field === 'id' && f.op === 'eq' && typeof f.value === 'string',
-    )
-    if (idFilter) effectiveFixedId = String(idFilter.value)
-  }
-
-  if (effectiveFixedId !== undefined) {
-    const resolvedId = interpolate(effectiveFixedId, ctx.context)
-    const { items } = await ctx.repository.findMany(targetSeed, {
-      filters: [{ column: 'id', type: 'system', conditions: [{ op: 'eq', value: resolvedId }] }],
-      status: null,
-      pagination: { limit: 1, offset: 0 },
-    })
-    const item = items[0] ?? null
-    if (!item) console.warn(`[set_variable] "${action.name}": id "${resolvedId}" not found`)
-    if (action.column) {
-      ctx.variables[action.name] = item ? { _value: item[action.column] } : null
-    } else {
-      ctx.variables[action.name] = item
-    }
-    return
-  }
-
-  const resolvedFilters = (action.filters ?? []).map((f) => {
-    const value = typeof f.value === 'string' ? interpolate(f.value, ctx.context) : f.value
-    return conditionToFilterGroup({ ...f, value }, targetSeed)
-  })
-
-  const orderDir: 'ASC' | 'DESC' = action.order === 'asc' ? 'ASC' : 'DESC'
-  const { items } = await ctx.repository.findMany(targetSeed, {
-    filters: resolvedFilters,
-    status: null,
-    pagination: { limit: 1000, offset: 0 },
-    orderBy: action.order_by ? { column: action.order_by, dir: orderDir } : undefined,
-  })
-
-  ctx.variables[action.name] = materializeCollection(targetSeed, items, action.column ?? null)
-}
-
-export function materializeCollection(
-  seed: Seed,
-  items: Array<Record<string, unknown>>,
-  pinned: string | null,
-): Record<string, unknown> {
-  const firstone = items.length > 0
-    ? items.reduce((best, r) => (Number(r['created_at']) < Number(best['created_at']) ? r : best), items[0])
-    : null
-  const lastone = items.length > 0
-    ? items.reduce((best, r) => (Number(r['created_at']) > Number(best['created_at']) ? r : best), items[0])
-    : null
-
-  let out: Record<string, unknown>
-
-  if (pinned === null) {
-    out = calculateGeneralStats(seed, items)
-    out.firstone = firstone
-    out.lastone = lastone
-  } else {
-    out = calculatePinnedStats(items, pinned)
-    out.firstone = firstone
-    out.lastone = lastone
-  }
-
-  Object.defineProperty(out, '_items', { value: items, enumerable: false })
-  return out
-}
-
-function formatPluckValues(items: Array<Record<string, unknown>>, key: string): string {
-  const vals = items.slice(0, 100).map((r) => String(r[key] ?? ''))
-  return vals.join(', ') + (items.length > 100 ? ' …' : '')
-}
-
-function calculatePinnedStats(items: Array<Record<string, unknown>>, pinned: string): Record<string, unknown> {
-  const nonNull = items.filter((r) => r[pinned] != null)
-  const nums = nonNull.map((r) => Number(r[pinned]))
-  const validNums = nums.filter((n) => !Number.isNaN(n))
-  const total = validNums.reduce((a, n) => a + n, 0)
-  const pluck = formatPluckValues(items, pinned)
-
-  return {
-    count: nonNull.length,
-    sum: validNums.length > 0 ? total : 0,
-    avg: validNums.length > 0 ? total / validNums.length : 0,
-    min: validNums.length > 0 ? Math.min(...validNums) : 0,
-    max: validNums.length > 0 ? Math.max(...validNums) : 0,
-    pluck,
-  }
-}
-
-function extractValidNumbers(items: Array<Record<string, unknown>>, key: string): number[] {
-  return items
-    .map((r) => {
-      const v = r[key]
-      const n = Number(v)
-      if (!Number.isNaN(n)) return n
-      if (typeof v === 'string') {
-        const d = Date.parse(v)
-        return Number.isNaN(d) ? Number.NaN : d / 1000
-      }
-      return Number.NaN
-    })
-    .filter((n) => !Number.isNaN(n))
-}
-
-function calculateGeneralStats(seed: Seed, items: Array<Record<string, unknown>>): Record<string, unknown> {
-  const sum: Record<string, number> = {}
-  const avg: Record<string, number> = {}
-  const min: Record<string, number> = {}
-  const max: Record<string, number> = {}
-  const pluck: Record<string, string> = {}
-
-  for (const branch of seed.branches) {
-    if (branch.type === 'number' || branch.type === 'date') {
-      const nums = extractValidNumbers(items, branch.alias)
-      const total = nums.reduce((a, n) => a + n, 0)
-      sum[branch.alias] = total
-      avg[branch.alias] = items.length > 0 ? total / items.length : 0
-      min[branch.alias] = nums.length > 0 ? Math.min(...nums) : 0
-      max[branch.alias] = nums.length > 0 ? Math.max(...nums) : 0
-    } else {
-      pluck[branch.alias] = formatPluckValues(items, branch.alias)
-    }
-  }
-
-  return { count: items.length, sum, avg, min, max, pluck }
-}

package/src/features/automations/action-executors/webhook.executor.ts

@@ -1,67 +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 { AutomationAction } from '@beechcms/core'
-import type { ResolvedContext } from '../context-resolver'
-import { interpolate } from '../automation-runner.utils'
-
-type WebhookAction = Extract<AutomationAction, { type: 'webhook' }>
-
-const WEBHOOK_TIMEOUT_MS = 8_000
-
-let warnedNoSecret = false
-
-async function signBody(body: string, secret: string): Promise<string> {
-  const encoder = new TextEncoder()
-  const key = await crypto.subtle.importKey(
-    'raw',
-    encoder.encode(secret),
-    { name: 'HMAC', hash: 'SHA-256' },
-    false,
-    ['sign'],
-  )
-  const sig = await crypto.subtle.sign('HMAC', key, encoder.encode(body))
-  return 'sha256=' + Array.from(new Uint8Array(sig))
-    .map((b) => b.toString(16).padStart(2, '0'))
-    .join('')
-}
-
-export async function executeWebhook(
-  action: WebhookAction,
-  context: ResolvedContext,
-  env: Record<string, string | undefined>,
-): Promise<void> {
-  const body = interpolate(action.body_template ?? '{}', context)
-
-  const secret = env.WEBHOOK_SECRET
-  let signatureHeader: Record<string, string> = {}
-  if (secret) {
-    signatureHeader = { 'X-BeechCMS-Signature': await signBody(body, secret) }
-  } else if (!warnedNoSecret) {
-    warnedNoSecret = true
-    console.warn('[webhook] WEBHOOK_SECRET not set — outgoing webhooks are unsigned')
-  }
-
-  try {
-    const response = await fetch(action.url, {
-      method: action.method ?? 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        ...(action.headers ?? {}),
-        ...signatureHeader,
-      },
-      body,
-      signal: AbortSignal.timeout(WEBHOOK_TIMEOUT_MS),
-    })
-
-    if (!response.ok) {
-      throw new Error(`Webhook ${action.url} responded ${response.status}`)
-    }
-  } catch (err) {
-    if (err instanceof Error && err.name === 'TimeoutError') {
-      throw new Error(`Webhook ${action.url} timed out after ${WEBHOOK_TIMEOUT_MS}ms`)
-    }
-    throw err
-  }
-}

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

@@ -1,85 +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 {
-  IAutomationRunner,
-  IAutomationRepository,
-  AutomationEventPayload,
-  ContentRepository,
-  Seed,
-  IIdGenerator,
-} from '@beechcms/core'
-import { resolvePath } from './automation-runner.utils'
-import { resolveAutomationContext, type ResolvedContext } from './context-resolver'
-import type { ParsedKey } from './template-grammar'
-import { executeAction } from './action-executors'
-import { evaluateWhen } from './when-evaluator'
-import { resolveVarAccess } from './var-access-resolver'
-
-export interface AutomationRunnerDeps {
-  automationRepository: IAutomationRepository
-  contentRepository: ContentRepository
-  getSeed: (slug: string) => Seed | null
-  idGenerator: IIdGenerator
-  env: Record<string, string | undefined>
-}
-
-function withVariables(base: ResolvedContext, variables: Record<string, unknown>): ResolvedContext {
-  return {
-    triggerEntry: base.triggerEntry,
-    lookup(parsed: ParsedKey, onMissing?: (field: string) => void): unknown {
-      if (parsed.kind === 'simple') {
-        const varVal = resolvePath(variables, parsed.path)
-        if (varVal !== undefined) return varVal
-      } else if (parsed.kind === 'var_access') {
-        return resolveVarAccess(parsed, variables, onMissing)
-      }
-      return base.lookup(parsed, onMissing)
-    },
-  }
-}
-
-export class AutomationRunner implements IAutomationRunner {
-  constructor(private readonly deps: AutomationRunnerDeps) {}
-
-  async run(payload: AutomationEventPayload): Promise<void> {
-    const { seedSlug, event, entry } = payload
-    const seed = this.deps.getSeed(seedSlug)
-    if (!seed) return
-
-    const automations = await this.deps.automationRepository.findActive(seedSlug, event)
-
-    for (const automation of automations) {
-      const resolved = await resolveAutomationContext(automation, entry, [entry])
-
-      // Evaluate conditions with the resolved context (this + batch scopes available).
-      // Variables from set_variable actions are not yet available here; use inline refs
-      // like {{customers:byid({{this.id}}):field}} for cross-seed conditions in v1.
-      if (!evaluateWhen(automation.trigger_conditions, resolved)) continue
-
-      const variables: Record<string, unknown> = {}
-
-      for (const action of automation.actions) {
-        try {
-          await executeAction(action, {
-            entry,
-            env: this.deps.env,
-            repository: this.deps.contentRepository,
-            getSeed: this.deps.getSeed,
-            seed,
-            idGenerator: this.deps.idGenerator,
-            context: withVariables(resolved, variables),
-            variables,
-          })
-        } catch (error) {
-          console.error('[automations] action failed', {
-            automationId: automation.id,
-            actionType: action.type,
-            error,
-          })
-        }
-      }
-    }
-  }
-}

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

@@ -1,47 +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 { ResolvedContext } from './context-resolver'
-import { parseTemplateKey } from './template-grammar'
-
-export function interpolate(
-  template: string,
-  context: ResolvedContext,
-  defaultValue = '',
-  onMissing?: (field: string) => void,
-): string {
-  if (!template) return ''
-
-  const replacer = (_: string, key: string) => {
-    const trimmedKey = key.trim()
-    const parsed = parseTemplateKey(trimmedKey)
-    if (!parsed) {
-      if (onMissing) onMissing(trimmedKey)
-      return defaultValue
-    }
-    const val = context.lookup(parsed, onMissing)
-    if (val == null || val === '') {
-      return defaultValue
-    }
-    return String(val)
-  }
-
-  return template.replace(/\{\{\s*([^{}]+?)\s*\}\}/g, replacer)
-}
-
-export function resolvePath(obj: Record<string, unknown>, path: string): unknown {
-  if (path in obj && obj[path] !== undefined) {
-    return obj[path]
-  }
-  const parts = path.split('.')
-  let current: unknown = obj
-  for (const part of parts) {
-    if (current && typeof current === 'object') {
-      current = (current as Record<string, unknown>)[part]
-    } else {
-      return undefined
-    }
-  }
-  return current
-}

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 }