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

package/src/features/automations/template-grammar.ts

@@ -1,245 +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.
-
-/**
- * Pure template-key parser for the automation template engine.
- *
- * Grammar (Sprint 6):
- *   simple:  {{title}}, {{author.name}}
- *   scoped:  {{<scope>:<selector>:<field>}}
- *
- * Grammar (Sprint 7):
- *   var_access: {{varname.firstone.campo}}, {{varname.count.(status=paid)}}
- *               {{varname.array[id1,id2].count}}
- *
- * Scopes: this | batch | <seedSlug> | <contextKey>
- * Selectors: lastone | firstone | all | byid(<id>) | where(<alias>=<value>)
- * Fields: branch alias, system column, or aggregate (count/sum/avg/min/max/pluck)
- *
- * Sugar:
- *   {{batch:count}}        → batch:all:count
- *   {{<scope>:<field>}}    → <scope>:lastone:<field>  (default selector)
- *
- * TODO Sprint 8: extend ParsedKey to support WhenOperand refs once the
- * recursive when-group evaluator (Tasks 10-16) is implemented.
- */
-
-export { AUTOMATION_RESERVED_WORDS } from '@beechcms/core'
-
-// ---------------------------------------------------------------------------
-// Sprint 7 types: var_access parsed key
-// ---------------------------------------------------------------------------
-
-export type VarStep =
-  | { type: 'field'; name: string }
-  | { type: 'nav'; nav: 'firstone' | 'lastone' }
-  | { type: 'agg'; op: 'count' | 'sum' | 'avg' | 'min' | 'max' | 'pluck'; field?: string }
-  | { type: 'array'; ids: string[] }
-
-export interface InlineCondition {
-  column: string
-  op: '=' | '!=' | '<' | '>' | '<=' | '>='
-  value: string
-}
-
-// ---------------------------------------------------------------------------
-
-export type AutomationContextSelector =
-  | { kind: 'lastone' }
-  | { kind: 'firstone' }
-  | { kind: 'all' }
-  | { kind: 'byid'; id: string }
-  | { kind: 'where'; alias: string; value: string }
-
-export type AggregateOp = 'count' | 'sum' | 'avg' | 'min' | 'max' | 'pluck'
-
-export type ParsedKey =
-  | { kind: 'simple'; path: string }
-  | {
-      kind: 'scoped'
-      scope: string
-      selector: AutomationContextSelector
-      op: 'field' | AggregateOp
-      field: string | null
-    }
-  | {
-      kind: 'var_access'
-      name: string
-      steps: VarStep[]
-      conditions: InlineCondition[]
-    }
-
-const SLUG_RE = /^[a-zA-Z0-9_-]+$/
-const AGGREGATE_OPS = new Set<string>(['count', 'sum', 'avg', 'min', 'max', 'pluck'])
-const NAV_OPS = new Set<string>(['firstone', 'lastone'])
-const INLINE_COND_RE = /^\(([\w]+)\s*(=|!=|<=|>=|<|>)\s*([^)]+)\)$/
-
-/**
- * Split `raw` on `:` but treat content inside `(...)` as atomic.
- */
-function splitKey(raw: string): string[] {
-  const tokens: string[] = []
-  let depth = 0
-  let current = ''
-
-  for (const ch of raw) {
-    if (ch === '(') {
-      depth++
-      current += ch
-    } else if (ch === ')') {
-      depth--
-      current += ch
-    } else if (ch === ':' && depth === 0) {
-      tokens.push(current)
-      current = ''
-    } else {
-      current += ch
-    }
-  }
-  if (current) tokens.push(current)
-  return tokens
-}
-
-/**
- * Split `raw` on `.` treating `[...]` and `(...)` as atomic blocks.
- */
-function splitDot(raw: string): string[] {
-  const tokens: string[] = []
-  let depth = 0
-  let current = ''
-
-  for (const ch of raw) {
-    if (ch === '[' || ch === '(') {
-      depth++
-      current += ch
-    } else if (ch === ']' || ch === ')') {
-      depth--
-      current += ch
-    } else if (ch === '.' && depth === 0) {
-      tokens.push(current)
-      current = ''
-    } else {
-      current += ch
-    }
-  }
-  if (current) tokens.push(current)
-  return tokens
-}
-
-function parseSelector(token: string): AutomationContextSelector | null {
-  if (token === 'lastone') return { kind: 'lastone' }
-  if (token === 'firstone') return { kind: 'firstone' }
-  if (token === 'all') return { kind: 'all' }
-
-  const byidMatch = token.match(/^byid\((.+)\)$/)
-  if (byidMatch) return { kind: 'byid', id: byidMatch[1] }
-
-  const whereMatch = token.match(/^where\(([^=]+)=(.+)\)$/)
-  if (whereMatch) return { kind: 'where', alias: whereMatch[1], value: whereMatch[2] }
-
-  return null
-}
-
-function isKnownScope(token: string): boolean {
-  return token === 'this' || token === 'batch' || SLUG_RE.test(token)
-}
-
-export function parseTemplateKey(raw: string): ParsedKey | null {
-  if (!raw) return null
-
-  const trimmed = raw.trim()
-
-  // Step 1: if contains `:` at depth 0 → existing scoped / sugar logic
-  const colonTokens = splitKey(trimmed)
-  if (colonTokens.length > 1) {
-    const [scopeToken, ...rest] = colonTokens
-    if (!isKnownScope(scopeToken)) return null
-
-    if (rest.length === 1) {
-      const fieldOrAggregate = rest[0]
-      if (AGGREGATE_OPS.has(fieldOrAggregate)) {
-        return { kind: 'scoped', scope: scopeToken, selector: { kind: 'all' }, op: fieldOrAggregate as AggregateOp, field: null }
-      }
-      return { kind: 'scoped', scope: scopeToken, selector: { kind: 'lastone' }, op: 'field', field: fieldOrAggregate }
-    }
-
-    const selectorToken = rest[0]
-    const selector = parseSelector(selectorToken)
-    if (!selector) return null
-
-    const fieldTokens = rest.slice(1)
-    if (fieldTokens.length === 0) return null
-
-    const opToken = fieldTokens[0]
-    if (AGGREGATE_OPS.has(opToken)) {
-      if (selector.kind !== 'all') return null
-      const subField = fieldTokens[1] ?? null
-      return { kind: 'scoped', scope: scopeToken, selector, op: opToken as AggregateOp, field: subField }
-    }
-
-    return { kind: 'scoped', scope: scopeToken, selector, op: 'field', field: opToken }
-  }
-
-  // Step 2: tokenise on `.` at depth 0
-  const dotTokens = splitDot(trimmed)
-
-  // Step 3: if no token contains `[` or `(`, return simple (fast path)
-  if (!dotTokens.some((t) => t.includes('[') || t.includes('('))) {
-    return { kind: 'simple', path: trimmed }
-  }
-
-  // Step 4: build var_access
-  const [nameToken, ...stepTokens] = dotTokens
-  const steps: VarStep[] = []
-  const conditions: InlineCondition[] = []
-
-  let i = 0
-  while (i < stepTokens.length) {
-    const token = stepTokens[i]
-
-    // Inline condition: (col op val)
-    const condMatch = token.match(INLINE_COND_RE)
-    if (condMatch) {
-      conditions.push({ column: condMatch[1], op: condMatch[2] as InlineCondition['op'], value: condMatch[3].trim() })
-      i++
-      continue
-    }
-
-    // Array selector: array[id1,id2,...]
-    const arrayMatch = token.match(/^array\[([^\]]*)\]$/)
-    if (arrayMatch) {
-      const ids = arrayMatch[1].split(',').map((s) => s.trim()).filter(Boolean)
-      steps.push({ type: 'array', ids })
-      i++
-      continue
-    }
-
-    // Nav: firstone / lastone
-    if (NAV_OPS.has(token)) {
-      steps.push({ type: 'nav', nav: token as 'firstone' | 'lastone' })
-      i++
-      continue
-    }
-
-    // Aggregate: count | sum | avg | min | max | pluck
-    if (AGGREGATE_OPS.has(token)) {
-      const nextToken = stepTokens[i + 1]
-      // Consume the next token as field if it's a plain identifier (no special chars)
-      if (nextToken && !nextToken.includes('[') && !nextToken.includes('(') && !AGGREGATE_OPS.has(nextToken) && !NAV_OPS.has(nextToken)) {
-        steps.push({ type: 'agg', op: token as VarStep & { type: 'agg' } extends { op: infer O } ? O : never, field: nextToken })
-        i += 2
-      } else {
-        steps.push({ type: 'agg', op: token as any })
-        i++
-      }
-      continue
-    }
-
-    // Plain field
-    steps.push({ type: 'field', name: token })
-    i++
-  }
-
-  return { kind: 'var_access', name: nameToken, steps, conditions }
-}

package/src/features/automations/var-access-resolver.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 { Seed } from '@beechcms/core'
-import type { ParsedKey, InlineCondition } from './template-grammar'
-import { materializeCollection } from './action-executors/set-variable.executor'
-
-type VarAccessParsed = Extract<ParsedKey, { kind: 'var_access' }>
-
-function toNumeric(v: unknown): number {
-  const n = Number(v)
-  if (Number.isFinite(n)) return n
-  if (typeof v === 'string') {
-    const d = Date.parse(v)
-    if (!Number.isNaN(d)) return d / 1000
-  }
-  return NaN
-}
-
-function numericCoerce(a: unknown, b: unknown): { left: unknown; right: unknown } {
-  const na = toNumeric(a)
-  const nb = toNumeric(b)
-  const numeric = Number.isFinite(na) || Number.isFinite(nb)
-  return { left: numeric ? na : a, right: numeric ? nb : b }
-}
-
-function applyCondition(record: Record<string, unknown>, cond: InlineCondition): boolean {
-  const raw = record[cond.column]
-  const { left, right } = numericCoerce(raw, cond.value)
-  switch (cond.op) {
-    case '=':  return left === right
-    case '!=': return left !== right
-    case '<':  return (left as number) < (right as number)
-    case '>':  return (left as number) > (right as number)
-    case '<=': return (left as number) <= (right as number)
-    case '>=': return (left as number) >= (right as number)
-  }
-}
-
-function applyConditions(
-  record: Record<string, unknown>,
-  conditions: InlineCondition[],
-): boolean {
-  return conditions.every((c) => applyCondition(record, c))
-}
-
-function filterItems(
-  items: Array<Record<string, unknown>>,
-  conditions: InlineCondition[],
-): Array<Record<string, unknown>> {
-  if (conditions.length === 0) return items
-  return items.filter((r) => applyConditions(r, conditions))
-}
-
-function getItems(value: unknown): Array<Record<string, unknown>> | null {
-  if (!value || typeof value !== 'object') return null
-  const items = (value as any)['_items']
-  return Array.isArray(items) ? items : null
-}
-
-const EMPTY_SEED = { branches: [] } as unknown as Seed
-
-export function resolveVarAccess(
-  parsed: VarAccessParsed,
-  variables: Record<string, unknown>,
-  onMissing?: (field: string) => void,
-): unknown {
-  if (!(parsed.name in variables)) {
-    onMissing?.(parsed.name)
-    return undefined
-  }
-
-  let current: unknown = variables[parsed.name]
-  const { steps, conditions } = parsed
-
-  for (let i = 0; i < steps.length; i++) {
-    const step = steps[i]
-
-    // ── array selector ─────────────────────────────────────────────────────
-    if (step.type === 'array') {
-      const items = getItems(current) ?? (Array.isArray(current) ? current as Array<Record<string, unknown>> : null)
-      if (!items) return undefined
-      const idSet = new Set(step.ids)
-      const subset = items.filter((r) => idSet.has(String(r['id'] ?? '')))
-      // Apply conditions to the subset before building the collection
-      const filtered = filterItems(subset, conditions)
-      current = materializeCollection(EMPTY_SEED, filtered, null)
-      // Conditions consumed — no post-filter needed
-      continue
-    }
-
-    // ── nav: firstone / lastone ────────────────────────────────────────────
-    if (step.type === 'nav') {
-      // Nav moves us from a collection to a single record.
-      // Conditions are a guard on that record, NOT a pre-filter on _items.
-      const record = (current as any)?.[step.nav] as Record<string, unknown> | null | undefined
-      if (!record) { current = null; continue }
-      // Apply conditions to the single record (post-filter)
-      if (conditions.length > 0 && !applyConditions(record, conditions)) return undefined
-      current = record
-      continue
-    }
-
-    // ── aggregate ──────────────────────────────────────────────────────────
-    if (step.type === 'agg') {
-      // Apply conditions to _items before aggregating
-      const items = getItems(current)
-      if (items !== null) {
-        const filtered = filterItems(items, conditions)
-        current = materializeCollection(EMPTY_SEED, filtered, null)
-      }
-      if (step.op === 'count') {
-        current = (current as any)?.['count']
-      } else if (step.field) {
-        const sub = (current as any)?.[step.op]
-        current = typeof sub === 'object' && sub !== null ? sub[step.field] : sub
-      } else {
-        current = (current as any)?.[step.op]
-      }
-      // Conditions consumed by filtering _items
-      return current
-    }
-
-    // ── field access ───────────────────────────────────────────────────────
-    if (step.type === 'field') {
-      current = (current as any)?.[step.name]
-    }
-  }
-
-  // Post-filter on single record (conditions not consumed by agg or array)
-  if (conditions.length > 0 && current !== null && current !== undefined) {
-    if (typeof current === 'object' && !Array.isArray(current)) {
-      if (!applyConditions(current as Record<string, unknown>, conditions)) return undefined
-    }
-    // For scalar values: conditions cannot be checked — pass through
-  }
-
-  return current
-}

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

@@ -1,87 +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 { WhenNode, WhenPredicate, WhenGroup, WhenOperand } from '@beechcms/core'
-import type { ResolvedContext } from './context-resolver'
-import { parseTemplateKey } from './template-grammar'
-
-export function evaluateWhen(
-  node: WhenNode | null,
-  context: ResolvedContext,
-): boolean {
-  if (!node) return true
-  if (node.kind === 'predicate') return evalPredicate(node, context)
-  return evalGroup(node, context)
-}
-
-function evalGroup(group: WhenGroup, context: ResolvedContext): boolean {
-  if (group.children.length === 0) {
-    const empty = group.op === 'AND'
-    return group.negate ? !empty : empty
-  }
-
-  for (const child of group.children) {
-    const r = evaluateWhen(child, context)
-    if (group.op === 'AND' && !r) return group.negate ? true : false
-    if (group.op === 'OR' && r)  return group.negate ? false : true
-  }
-
-  const combined = group.op === 'AND'
-  return group.negate ? !combined : combined
-}
-
-function resolveOperand(operand: WhenOperand, context: ResolvedContext): unknown {
-  if (operand.kind === 'literal') return operand.value
-
-  // this.field (dot notation from UI) → this:field (colon, parsed as scoped key)
-  const key = operand.key.startsWith('this.') ? 'this:' + operand.key.slice(5) : operand.key
-  const parsed = parseTemplateKey(key)
-  if (!parsed) return null
-
-  const val = context.lookup(parsed)
-  return val ?? null
-}
-
-function evalPredicate(pred: WhenPredicate, context: ResolvedContext): boolean {
-  const left = resolveOperand(pred.left, context)
-  const right = pred.right !== undefined ? resolveOperand(pred.right, context) : undefined
-  return compare(pred.op, left, right)
-}
-
-function compare(op: string, left: unknown, right: unknown): boolean {
-  switch (op) {
-    case 'isempty':    return left == null || left === ''
-    case 'isnotempty': return left != null && left !== ''
-
-    case 'eq':  return coerceEqual(left, right)
-    case 'neq': return !coerceEqual(left, right)
-
-    case 'gt':  return Number(left) > Number(right)
-    case 'gte': return Number(left) >= Number(right)
-    case 'lt':  return Number(left) < Number(right)
-    case 'lte': return Number(left) <= Number(right)
-
-    case 'contains':   return typeof left === 'string' && typeof right === 'string' && left.includes(right)
-    case 'startswith': return typeof left === 'string' && typeof right === 'string' && left.startsWith(right)
-    case 'endswith':   return typeof left === 'string' && typeof right === 'string' && left.endsWith(right)
-
-    case 'in':    return Array.isArray(right) && right.some((r) => coerceEqual(left, r))
-    case 'notin': return !Array.isArray(right) || !right.some((r) => coerceEqual(left, r))
-
-    case 'matches': {
-      if (typeof left !== 'string' || typeof right !== 'string') return false
-      try { return new RegExp(right).test(left) } catch { return false }
-    }
-
-    default: return false
-  }
-}
-
-function coerceEqual(a: unknown, b: unknown): boolean {
-  if (a === null && b === null) return true
-  if (a === null || b === null) return false
-  if (typeof a === 'number' && typeof b === 'string' && !Number.isNaN(Number(b))) return a === Number(b)
-  if (typeof b === 'number' && typeof a === 'string' && !Number.isNaN(Number(a))) return Number(a) === b
-  return a === b
-}

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

@@ -1,57 +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 { WhenNode, WhenPredicate, TriggerCondition, FilterGroup, Seed } from '@beechcms/core'
-import { conditionToFilterGroup } from './filter-translation'
-
-const PUSHDOWN_OPS = new Set<string>(['eq', 'neq', 'contains', 'gt', 'lt', 'isempty', 'isnotempty'])
-
-export function extractPushdownFilters(
-  node: WhenNode | null,
-  seed: Seed,
-): FilterGroup[] {
-  if (!node) return []
-
-  // Single predicate at root
-  if (node.kind === 'predicate') {
-    const f = tryPushdown(node, seed)
-    return f ? [f] : []
-  }
-
-  // Only extract direct predicate children of the outermost AND group (non-negated)
-  if (node.kind === 'group' && node.op === 'AND' && !node.negate) {
-    return node.children.flatMap((child) => {
-      if (child.kind !== 'predicate') return []
-      const f = tryPushdown(child, seed)
-      return f ? [f] : []
-    })
-  }
-
-  return []
-}
-
-function tryPushdown(pred: WhenPredicate, seed: Seed): FilterGroup | null {
-  if (pred.left.kind !== 'ref') return null
-
-  const key = pred.left.key
-  if (!key.startsWith('this.')) return null
-  const field = key.slice(5)
-  if (!field) return null
-
-  if (!PUSHDOWN_OPS.has(pred.op)) return null
-
-  if (pred.op === 'isempty' || pred.op === 'isnotempty') {
-    return conditionToFilterGroup(
-      { field, op: pred.op as TriggerCondition['op'], value: null },
-      seed,
-    )
-  }
-
-  if (!pred.right || pred.right.kind !== 'literal') return null
-
-  return conditionToFilterGroup(
-    { field, op: pred.op as TriggerCondition['op'], value: pred.right.value },
-    seed,
-  )
-}