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

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

@@ -1,274 +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 { 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

@@ -1,281 +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 { 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, i) => ({ id: `br_0${i + 1}`, 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

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

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

@@ -1,37 +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, 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, ctx.env)
-    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}`)
-    }
-  }
-}