@beechcms/api 0.5.0 → 0.6.0-preview.2

package/src/features/automations/var-access-resolver.ts

@@ -1,136 +1,140 @@
-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
-}
+// 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,83 +1,87 @@
-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
-}
+// 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,53 +1,57 @@
-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,
-  )
-}
+// 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,
+  )
+}