@beechcms/api 0.4.1 → 0.4.2

package/src/features/automations/__tests__/when-evaluator.test.ts

@@ -0,0 +1,270 @@
+import { describe, it, expect } from 'vitest'
+import type { WhenNode } from '@beechcms/core'
+import { evaluateWhen } from '../when-evaluator'
+import type { ResolvedContext } from '../context-resolver'
+import { parseTemplateKey } from '../template-grammar'
+
+// ---------------------------------------------------------------------------
+// Minimal ResolvedContext builder for testing
+// ---------------------------------------------------------------------------
+
+function makeContext(entry: Record<string, unknown>): ResolvedContext {
+  return {
+    triggerEntry: entry,
+    lookup(parsed, onMissing) {
+      if (!parsed) return undefined
+      if (parsed.kind === 'simple') {
+        const parts = parsed.path.split('.')
+        let cur: unknown = entry
+        for (const p of parts) {
+          cur = (cur as Record<string, unknown>)?.[p]
+        }
+        if (cur === undefined && onMissing) onMissing(parsed.path)
+        return cur
+      }
+      if (parsed.kind === 'scoped' && parsed.scope === 'this' && parsed.op === 'field' && parsed.field) {
+        return (entry as Record<string, unknown>)[parsed.field]
+      }
+      return undefined
+    },
+  }
+}
+
+const entry = { status: 'paid', total: 150, name: 'Alice', tag: 'gold' }
+const ctx = makeContext(entry)
+
+// ---------------------------------------------------------------------------
+// null / empty → true
+// ---------------------------------------------------------------------------
+
+describe('evaluateWhen — null/empty', () => {
+  it('null node returns true', () => {
+    expect(evaluateWhen(null, ctx)).toBe(true)
+  })
+
+  it('empty AND group returns true', () => {
+    const node: WhenNode = { kind: 'group', op: 'AND', children: [] }
+    expect(evaluateWhen(node, ctx)).toBe(true)
+  })
+
+  it('empty OR group returns false', () => {
+    const node: WhenNode = { kind: 'group', op: 'OR', children: [] }
+    expect(evaluateWhen(node, ctx)).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Basic predicates
+// ---------------------------------------------------------------------------
+
+describe('evaluateWhen — predicates', () => {
+  it('eq literal', () => {
+    const node: WhenNode = {
+      kind: 'predicate',
+      left: { kind: 'ref', key: 'this.status' },
+      op: 'eq',
+      right: { kind: 'literal', value: 'paid' },
+    }
+    expect(evaluateWhen(node, ctx)).toBe(true)
+  })
+
+  it('eq literal fails', () => {
+    const node: WhenNode = {
+      kind: 'predicate',
+      left: { kind: 'ref', key: 'this.status' },
+      op: 'eq',
+      right: { kind: 'literal', value: 'unpaid' },
+    }
+    expect(evaluateWhen(node, ctx)).toBe(false)
+  })
+
+  it('gt numeric', () => {
+    const node: WhenNode = {
+      kind: 'predicate',
+      left: { kind: 'ref', key: 'this.total' },
+      op: 'gt',
+      right: { kind: 'literal', value: 100 },
+    }
+    expect(evaluateWhen(node, ctx)).toBe(true)
+  })
+
+  it('lte numeric', () => {
+    const node: WhenNode = {
+      kind: 'predicate',
+      left: { kind: 'ref', key: 'this.total' },
+      op: 'lte',
+      right: { kind: 'literal', value: 150 },
+    }
+    expect(evaluateWhen(node, ctx)).toBe(true)
+  })
+
+  it('contains string', () => {
+    const node: WhenNode = {
+      kind: 'predicate',
+      left: { kind: 'ref', key: 'this.name' },
+      op: 'contains',
+      right: { kind: 'literal', value: 'lic' },
+    }
+    expect(evaluateWhen(node, ctx)).toBe(true)
+  })
+
+  it('startswith', () => {
+    const node: WhenNode = {
+      kind: 'predicate',
+      left: { kind: 'ref', key: 'this.name' },
+      op: 'startswith',
+      right: { kind: 'literal', value: 'Ali' },
+    }
+    expect(evaluateWhen(node, ctx)).toBe(true)
+  })
+
+  it('isempty — non-empty field', () => {
+    const node: WhenNode = {
+      kind: 'predicate',
+      left: { kind: 'ref', key: 'this.status' },
+      op: 'isempty',
+    }
+    expect(evaluateWhen(node, ctx)).toBe(false)
+  })
+
+  it('isnotempty — non-empty field', () => {
+    const node: WhenNode = {
+      kind: 'predicate',
+      left: { kind: 'ref', key: 'this.status' },
+      op: 'isnotempty',
+    }
+    expect(evaluateWhen(node, ctx)).toBe(true)
+  })
+
+  it('matches regex', () => {
+    const node: WhenNode = {
+      kind: 'predicate',
+      left: { kind: 'ref', key: 'this.tag' },
+      op: 'matches',
+      right: { kind: 'literal', value: '^g' },
+    }
+    expect(evaluateWhen(node, ctx)).toBe(true)
+  })
+
+  it('literal-to-literal comparison', () => {
+    const node: WhenNode = {
+      kind: 'predicate',
+      left: { kind: 'literal', value: 10 },
+      op: 'lt',
+      right: { kind: 'literal', value: 20 },
+    }
+    expect(evaluateWhen(node, ctx)).toBe(true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// AND / OR groups with short-circuit
+// ---------------------------------------------------------------------------
+
+describe('evaluateWhen — groups', () => {
+  it('AND group — all true', () => {
+    const node: WhenNode = {
+      kind: 'group',
+      op: 'AND',
+      children: [
+        { kind: 'predicate', left: { kind: 'ref', key: 'this.status' }, op: 'eq', right: { kind: 'literal', value: 'paid' } },
+        { kind: 'predicate', left: { kind: 'ref', key: 'this.total' }, op: 'gt', right: { kind: 'literal', value: 100 } },
+      ],
+    }
+    expect(evaluateWhen(node, ctx)).toBe(true)
+  })
+
+  it('AND group — one false', () => {
+    const node: WhenNode = {
+      kind: 'group',
+      op: 'AND',
+      children: [
+        { kind: 'predicate', left: { kind: 'ref', key: 'this.status' }, op: 'eq', right: { kind: 'literal', value: 'paid' } },
+        { kind: 'predicate', left: { kind: 'ref', key: 'this.total' }, op: 'gt', right: { kind: 'literal', value: 200 } },
+      ],
+    }
+    expect(evaluateWhen(node, ctx)).toBe(false)
+  })
+
+  it('OR group — first true short-circuits', () => {
+    const node: WhenNode = {
+      kind: 'group',
+      op: 'OR',
+      children: [
+        { kind: 'predicate', left: { kind: 'ref', key: 'this.status' }, op: 'eq', right: { kind: 'literal', value: 'paid' } },
+        { kind: 'predicate', left: { kind: 'ref', key: 'this.total' }, op: 'gt', right: { kind: 'literal', value: 200 } },
+      ],
+    }
+    expect(evaluateWhen(node, ctx)).toBe(true)
+  })
+
+  it('negate wraps group result', () => {
+    const node: WhenNode = {
+      kind: 'group',
+      op: 'AND',
+      negate: true,
+      children: [
+        { kind: 'predicate', left: { kind: 'ref', key: 'this.status' }, op: 'eq', right: { kind: 'literal', value: 'paid' } },
+      ],
+    }
+    expect(evaluateWhen(node, ctx)).toBe(false)
+  })
+
+  it('nested AND inside OR', () => {
+    const node: WhenNode = {
+      kind: 'group',
+      op: 'AND',
+      children: [
+        { kind: 'predicate', left: { kind: 'ref', key: 'this.total' }, op: 'gt', right: { kind: 'literal', value: 100 } },
+        {
+          kind: 'group',
+          op: 'OR',
+          children: [
+            { kind: 'predicate', left: { kind: 'ref', key: 'this.tag' }, op: 'eq', right: { kind: 'literal', value: 'gold' } },
+            { kind: 'predicate', left: { kind: 'ref', key: 'this.total' }, op: 'gt', right: { kind: 'literal', value: 5000 } },
+          ],
+        },
+      ],
+    }
+    expect(evaluateWhen(node, ctx)).toBe(true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// null handling
+// ---------------------------------------------------------------------------
+
+describe('evaluateWhen — null operands', () => {
+  const emptyCtx = makeContext({})
+
+  it('null == null → eq true', () => {
+    const node: WhenNode = {
+      kind: 'predicate',
+      left: { kind: 'ref', key: 'this.missing' },
+      op: 'eq',
+      right: { kind: 'literal', value: null },
+    }
+    expect(evaluateWhen(node, emptyCtx)).toBe(true)
+  })
+
+  it('null isempty → true', () => {
+    const node: WhenNode = {
+      kind: 'predicate',
+      left: { kind: 'ref', key: 'this.missing' },
+      op: 'isempty',
+    }
+    expect(evaluateWhen(node, emptyCtx)).toBe(true)
+  })
+
+  it('null gt 0 → false (no exception)', () => {
+    const node: WhenNode = {
+      kind: 'predicate',
+      left: { kind: 'ref', key: 'this.missing' },
+      op: 'gt',
+      right: { kind: 'literal', value: 0 },
+    }
+    expect(() => evaluateWhen(node, emptyCtx)).not.toThrow()
+    expect(evaluateWhen(node, emptyCtx)).toBe(false)
+  })
+})
+

package/src/features/automations/__tests__/when-pushdown.test.ts

@@ -0,0 +1,277 @@
+import { describe, it, expect } from 'vitest'
+import type { WhenNode, Seed } from '@beechcms/core'
+import { extractPushdownFilters } from '../when-pushdown'
+
+// ---------------------------------------------------------------------------
+// Minimal Seed
+// ---------------------------------------------------------------------------
+
+function makeSeed(aliases: string[] = []): Seed {
+  return {
+    slug: 'orders',
+    label: 'Orders',
+    displayNameAlias: aliases[0] ?? 'id',
+    branches: aliases.map((alias) => ({ alias, label: alias, type: 'text' as const })),
+  }
+}
+
+const seed = makeSeed(['status', 'total', 'name', 'tag'])
+
+// ---------------------------------------------------------------------------
+// null / empty
+// ---------------------------------------------------------------------------
+
+describe('extractPushdownFilters — null/empty', () => {
+  it('null returns []', () => {
+    expect(extractPushdownFilters(null, seed)).toEqual([])
+  })
+
+  it('empty AND group returns []', () => {
+    const node: WhenNode = { kind: 'group', op: 'AND', children: [] }
+    expect(extractPushdownFilters(node, seed)).toEqual([])
+  })
+
+  it('empty OR group returns []', () => {
+    const node: WhenNode = { kind: 'group', op: 'OR', children: [] }
+    expect(extractPushdownFilters(node, seed)).toEqual([])
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Safe single-predicate push-down
+// ---------------------------------------------------------------------------
+
+describe('extractPushdownFilters — safe predicates', () => {
+  it('root eq predicate is pushed', () => {
+    const node: WhenNode = {
+      kind: 'predicate',
+      left: { kind: 'ref', key: 'this.status' },
+      op: 'eq',
+      right: { kind: 'literal', value: 'paid' },
+    }
+    const result = extractPushdownFilters(node, seed)
+    expect(result).toHaveLength(1)
+    expect(result[0].column).toBe('status')
+    expect(result[0].conditions[0].op).toBe('eq')
+    expect(result[0].conditions[0].value).toBe('paid')
+  })
+
+  it('root neq predicate is pushed', () => {
+    const node: WhenNode = {
+      kind: 'predicate',
+      left: { kind: 'ref', key: 'this.status' },
+      op: 'neq',
+      right: { kind: 'literal', value: 'cancelled' },
+    }
+    const result = extractPushdownFilters(node, seed)
+    expect(result).toHaveLength(1)
+    expect(result[0].conditions[0].op).toBe('neq')
+  })
+
+  it('root gt predicate is pushed', () => {
+    const node: WhenNode = {
+      kind: 'predicate',
+      left: { kind: 'ref', key: 'this.total' },
+      op: 'gt',
+      right: { kind: 'literal', value: 100 },
+    }
+    const result = extractPushdownFilters(node, seed)
+    expect(result).toHaveLength(1)
+    expect(result[0].conditions[0].op).toBe('gt')
+  })
+
+  it('root lt predicate is pushed', () => {
+    const node: WhenNode = {
+      kind: 'predicate',
+      left: { kind: 'ref', key: 'this.total' },
+      op: 'lt',
+      right: { kind: 'literal', value: 500 },
+    }
+    const result = extractPushdownFilters(node, seed)
+    expect(result).toHaveLength(1)
+    expect(result[0].conditions[0].op).toBe('lt')
+  })
+
+  it('root contains predicate is pushed', () => {
+    const node: WhenNode = {
+      kind: 'predicate',
+      left: { kind: 'ref', key: 'this.name' },
+      op: 'contains',
+      right: { kind: 'literal', value: 'Alice' },
+    }
+    const result = extractPushdownFilters(node, seed)
+    expect(result).toHaveLength(1)
+    expect(result[0].conditions[0].op).toBe('contains')
+  })
+
+  it('root isempty predicate is pushed (no right operand)', () => {
+    const node: WhenNode = {
+      kind: 'predicate',
+      left: { kind: 'ref', key: 'this.name' },
+      op: 'isempty',
+    }
+    const result = extractPushdownFilters(node, seed)
+    expect(result).toHaveLength(1)
+    expect(result[0].conditions[0].op).toBe('is_empty')
+  })
+
+  it('root isnotempty predicate is pushed (no right operand)', () => {
+    const node: WhenNode = {
+      kind: 'predicate',
+      left: { kind: 'ref', key: 'this.name' },
+      op: 'isnotempty',
+    }
+    const result = extractPushdownFilters(node, seed)
+    expect(result).toHaveLength(1)
+    expect(result[0].conditions[0].op).toBe('is_not_empty')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// AND group — only direct safe predicate children are pushed
+// ---------------------------------------------------------------------------
+
+describe('extractPushdownFilters — AND group', () => {
+  it('all safe AND children are pushed', () => {
+    const node: WhenNode = {
+      kind: 'group',
+      op: 'AND',
+      children: [
+        { kind: 'predicate', left: { kind: 'ref', key: 'this.status' }, op: 'eq', right: { kind: 'literal', value: 'paid' } },
+        { kind: 'predicate', left: { kind: 'ref', key: 'this.total' }, op: 'gt', right: { kind: 'literal', value: 100 } },
+      ],
+    }
+    const result = extractPushdownFilters(node, seed)
+    expect(result).toHaveLength(2)
+    expect(result.map((r) => r.column)).toContain('status')
+    expect(result.map((r) => r.column)).toContain('total')
+  })
+
+  it('mixed AND: unsafe children skipped, safe ones pushed', () => {
+    const node: WhenNode = {
+      kind: 'group',
+      op: 'AND',
+      children: [
+        { kind: 'predicate', left: { kind: 'ref', key: 'this.status' }, op: 'eq', right: { kind: 'literal', value: 'paid' } },
+        // gte is not in PUSHDOWN_OPS → skipped
+        { kind: 'predicate', left: { kind: 'ref', key: 'this.total' }, op: 'gte', right: { kind: 'literal', value: 100 } },
+      ],
+    }
+    const result = extractPushdownFilters(node, seed)
+    expect(result).toHaveLength(1)
+    expect(result[0].column).toBe('status')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Unsafe operators stay in-memory
+// ---------------------------------------------------------------------------
+
+describe('extractPushdownFilters — unsafe operators stay in-memory', () => {
+  for (const op of ['gte', 'lte', 'startswith', 'endswith', 'matches', 'in', 'notin'] as const) {
+    it(`${op} is NOT pushed`, () => {
+      const node: WhenNode = {
+        kind: 'predicate',
+        left: { kind: 'ref', key: 'this.status' },
+        op,
+        right: { kind: 'literal', value: 'x' },
+      }
+      expect(extractPushdownFilters(node, seed)).toHaveLength(0)
+    })
+  }
+})
+
+// ---------------------------------------------------------------------------
+// OR branches stay in-memory
+// ---------------------------------------------------------------------------
+
+describe('extractPushdownFilters — OR branches stay in-memory', () => {
+  it('OR root group returns []', () => {
+    const node: WhenNode = {
+      kind: 'group',
+      op: 'OR',
+      children: [
+        { kind: 'predicate', left: { kind: 'ref', key: 'this.status' }, op: 'eq', right: { kind: 'literal', value: 'paid' } },
+        { kind: 'predicate', left: { kind: 'ref', key: 'this.total' }, op: 'gt', right: { kind: 'literal', value: 100 } },
+      ],
+    }
+    expect(extractPushdownFilters(node, seed)).toHaveLength(0)
+  })
+
+  it('AND group with nested OR child: only direct predicate siblings are pushed', () => {
+    const node: WhenNode = {
+      kind: 'group',
+      op: 'AND',
+      children: [
+        { kind: 'predicate', left: { kind: 'ref', key: 'this.status' }, op: 'eq', right: { kind: 'literal', value: 'paid' } },
+        {
+          kind: 'group',
+          op: 'OR',
+          children: [
+            { kind: 'predicate', left: { kind: 'ref', key: 'this.total' }, op: 'gt', right: { kind: 'literal', value: 100 } },
+            { kind: 'predicate', left: { kind: 'ref', key: 'this.tag' }, op: 'eq', right: { kind: 'literal', value: 'gold' } },
+          ],
+        },
+      ],
+    }
+    const result = extractPushdownFilters(node, seed)
+    // Only the direct 'status' predicate is pushed; the nested OR group is skipped
+    expect(result).toHaveLength(1)
+    expect(result[0].column).toBe('status')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Negated group stays in-memory
+// ---------------------------------------------------------------------------
+
+describe('extractPushdownFilters — negated AND group stays in-memory', () => {
+  it('negated AND root returns []', () => {
+    const node: WhenNode = {
+      kind: 'group',
+      op: 'AND',
+      negate: true,
+      children: [
+        { kind: 'predicate', left: { kind: 'ref', key: 'this.status' }, op: 'eq', right: { kind: 'literal', value: 'paid' } },
+      ],
+    }
+    expect(extractPushdownFilters(node, seed)).toHaveLength(0)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Cross-seed refs stay in-memory
+// ---------------------------------------------------------------------------
+
+describe('extractPushdownFilters — cross-seed refs stay in-memory', () => {
+  it('ref not starting with this. is NOT pushed', () => {
+    const node: WhenNode = {
+      kind: 'predicate',
+      left: { kind: 'ref', key: 'customers:lastone:status' },
+      op: 'eq',
+      right: { kind: 'literal', value: 'active' },
+    }
+    expect(extractPushdownFilters(node, seed)).toHaveLength(0)
+  })
+
+  it('right operand is a ref (not literal) → NOT pushed', () => {
+    const node: WhenNode = {
+      kind: 'predicate',
+      left: { kind: 'ref', key: 'this.status' },
+      op: 'eq',
+      right: { kind: 'ref', key: 'customers:lastone:status' },
+    }
+    expect(extractPushdownFilters(node, seed)).toHaveLength(0)
+  })
+
+  it('literal left operand is NOT pushed', () => {
+    const node: WhenNode = {
+      kind: 'predicate',
+      left: { kind: 'literal', value: 'paid' },
+      op: 'eq',
+      right: { kind: 'literal', value: 'paid' },
+    }
+    expect(extractPushdownFilters(node, seed)).toHaveLength(0)
+  })
+})
+

package/src/features/automations/action-executors/create-entry.executor.ts

@@ -0,0 +1,23 @@
+import type { AutomationAction, ContentRepository, Seed, IIdGenerator } from '@beechcms/core'
+
+type CreateEntryAction = Extract<AutomationAction, { type: 'create_entry' }>
+type SeedResolver = (slug: string) => Seed | null
+
+export async function executeCreateEntry(
+  action: CreateEntryAction,
+  entry: Record<string, unknown>,
+  repository: ContentRepository,
+  getSeed: SeedResolver,
+  idGenerator: IIdGenerator,
+): Promise<void> {
+  const targetSeed = getSeed(action.seed_slug)
+  if (!targetSeed) throw new Error(`create_entry: unknown seed ${action.seed_slug}`)
+
+  const payload: Record<string, unknown> = {}
+  for (const [targetField, sourceField] of Object.entries(action.field_map)) {
+    payload[targetField] = (sourceField as string) in entry ? entry[sourceField as string] : sourceField
+  }
+
+  const newId = idGenerator.uuid()
+  await repository.create(targetSeed, newId, newId, 'draft', payload)
+}

package/src/features/automations/action-executors/edit-field.executor.ts

@@ -0,0 +1,22 @@
+import type { AutomationAction, ContentRepository, Seed } from '@beechcms/core'
+import type { ResolvedContext } from '../context-resolver'
+import { interpolate } from '../automation-runner.utils'
+
+type EditFieldAction = Extract<AutomationAction, { type: 'edit_field' }>
+
+export async function executeEditField(
+  action: EditFieldAction,
+  entry: Record<string, unknown>,
+  context: ResolvedContext,
+  repository: ContentRepository,
+  seed: Seed,
+): Promise<void> {
+  const id = entry.id
+  if (typeof id !== 'string') {
+    throw new Error('edit_field: entry.id missing')
+  }
+  const resolved = typeof action.value === 'string'
+    ? interpolate(action.value, context)
+    : action.value
+  await repository.update(seed, id, { [action.field]: resolved })
+}

package/src/features/automations/action-executors/index.ts

@@ -0,0 +1,33 @@
+import type { AutomationAction, ContentRepository, Seed, IIdGenerator } from '@beechcms/core'
+import type { ResolvedContext } from '../context-resolver'
+import { executeWebhook }      from './webhook.executor'
+import { executeSendMail }     from './send-mail.executor'
+import { executeEditField }    from './edit-field.executor'
+import { executeCreateEntry }  from './create-entry.executor'
+import { executeSetVariable }  from './set-variable.executor'
+
+export interface ActionContext {
+  entry: Record<string, unknown>
+  env: Record<string, string | undefined>
+  repository: ContentRepository
+  getSeed: (slug: string) => Seed | null
+  seed: Seed
+  idGenerator: IIdGenerator
+  context: ResolvedContext
+  variables: Record<string, unknown>
+  // TODO Sprint 8: context will also power evaluateWhen() for per-action when-guards
+}
+
+export async function executeAction(action: AutomationAction, ctx: ActionContext): Promise<void> {
+  switch (action.type) {
+    case 'set_variable':  return executeSetVariable(action, ctx)
+    case 'webhook':       return executeWebhook(action, ctx.context)
+    case 'send_mail':     return executeSendMail(action, ctx.context, ctx.env)
+    case 'edit_field':    return executeEditField(action, ctx.entry, ctx.context, ctx.repository, ctx.seed)
+    case 'create_entry':  return executeCreateEntry(action, ctx.entry, ctx.repository, ctx.getSeed, ctx.idGenerator)
+    default: {
+      const _exhaustive: never = action
+      throw new Error(`unknown action type: ${(action as { type: string }).type}`)
+    }
+  }
+}

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

@@ -0,0 +1,42 @@
+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 apiKey = env.EMAIL_API_KEY ?? env.RESEND_API_KEY
+  if (!apiKey) {
+    console.error('[automations:send_mail] Execution skipped: Email API key is missing from the environment configuration.')
+    return
+  }
+
+  try {
+    await sendAutomationMail({
+      to,
+      subject,
+      body,
+      apiKey,
+      from: env.EMAIL_FROM,
+    })
+  } catch (error) {
+    console.error('[automations:send_mail] failed to send automation email via provider:', error)
+    throw error
+  }
+}