@beechcms/api 0.4.0 → 0.4.2

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

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

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

@@ -0,0 +1,53 @@
+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,
+  )
+}

package/src/features/content/handlers/create.ts

@@ -8,7 +8,6 @@ import {
 import { applyPrivacy, PrivacyPolicyError } from '../../../shared/apply-policies'
 import { publicProblem } from '../../../public/problem-details'
 import { CONTENT_ERRORS } from '../constants'
-import { logActivity } from '../../../shared/activity-logger'
 import { cleanStr } from '../../../shared/query-utils'
 import { AppEnv } from '../../../types'
 
@@ -110,7 +109,7 @@ export async function createHandler(context: Context<AppEnv>) {
     throw error
   }
 
-  const id = crypto.randomUUID()
+  const id = context.get('idGenerator').uuid()
   let finalSlug = entrySlug
   if (!finalSlug) {
     const fallbackSource = privacyData[seed.displayNameAlias ?? 'title'] || privacyData.title || privacyData.name || id
@@ -121,17 +120,30 @@ export async function createHandler(context: Context<AppEnv>) {
     const repository = context.get('repository')
     await repository.create(seed, id, finalSlug, status, privacyData)
 
-    const userId = context.get('jwtPayload')?.sub
+    const jwtPayload = context.get('jwtPayload')
     const title = privacyData.title || privacyData.name || finalSlug
-    
-    logActivity(context, { 
-      action: 'create', 
-      entityType: 'content', 
-      entityId: id, 
-      entitySlug: slug, 
-      details: { title } 
+
+    context.get('activityLogger').log({
+      action: 'create',
+      entityType: 'content',
+      entityId: id,
+      entitySlug: slug,
+      details: { title },
+      actor: {
+        id: jwtPayload.sub,
+        email: jwtPayload.email ?? 'unknown',
+        name: jwtPayload.name ?? null,
+      },
     })
 
+    context.get('scheduler').waitUntil(
+      context.get('automationRunner').run({
+        seedSlug: slug,
+        event: 'create',
+        entry: { id, slug: finalSlug, status, ...privacyData },
+      }),
+    )
+
     return context.json({ id }, 201)
   } catch (error) {
     if (error instanceof SlugConflictError) {

package/src/features/content/handlers/delete.ts

@@ -4,7 +4,6 @@ import { deleteR2Objects } from '../../../upload'
 import { extractMediaKeysFromData } from '../../../media-utils'
 import { publicProblem } from '../../../public/problem-details'
 import { CONTENT_ERRORS } from '../constants'
-import { logActivity } from '../../../shared/activity-logger'
 import { AppEnv } from '../../../types'
 
 export async function deleteHandler(context: Context<AppEnv>) {
@@ -34,18 +33,30 @@ export async function deleteHandler(context: Context<AppEnv>) {
     // Repository.delete returns the row data for cleanup
     const { row } = await repository.delete(seed, entryId)
 
-    const userId = context.get('jwtPayload')?.sub
+    const jwtPayload = context.get('jwtPayload')
     const title = row.title || row.name || entryId
-    
-    logActivity(context, { 
-      action: 'delete', 
-      entityType: 'content', 
-      entityId: entryId, 
-      entitySlug: schemaSlug, 
-      details: { title } 
+
+    context.get('activityLogger').log({
+      action: 'delete',
+      entityType: 'content',
+      entityId: entryId,
+      entitySlug: schemaSlug,
+      details: { title },
+      actor: {
+        id: jwtPayload.sub,
+        email: jwtPayload.email ?? 'unknown',
+        name: jwtPayload.name ?? null,
+      },
     })
 
-    
+    context.get('scheduler').waitUntil(
+      context.get('automationRunner').run({
+        seedSlug: schemaSlug,
+        event: 'delete',
+        entry: { ...row, id: entryId },
+      }),
+    )
+
     const r2ObjectKeys = extractMediaKeysFromData(seed, row)
     if (r2ObjectKeys.length > 0) {
       await deleteR2Objects(context, r2ObjectKeys).catch((error) => {

package/src/features/content/handlers/update.ts

@@ -10,7 +10,6 @@ import {
 import { applyPrivacy, PrivacyPolicyError } from '../../../shared/apply-policies'
 import { publicProblem } from '../../../public/problem-details'
 import { CONTENT_ERRORS } from '../constants'
-import { logActivity } from '../../../shared/activity-logger'
 import { cleanStr } from '../../../shared/query-utils'
 import { AppEnv } from '../../../types'
 
@@ -167,17 +166,30 @@ export async function updateHandler(context: Context<AppEnv>) {
 
     await repository.update(seed, id, mergedData, newStatus)
 
-    const userId = context.get('jwtPayload')?.sub
+    const jwtPayload = context.get('jwtPayload')
     const title = mergedData.title || mergedData.name || newSlug
-    
-    logActivity(context, { 
-      action: 'update', 
-      entityType: 'content', 
-      entityId: id, 
-      entitySlug: slug, 
-      details: { title } 
+
+    context.get('activityLogger').log({
+      action: 'update',
+      entityType: 'content',
+      entityId: id,
+      entitySlug: slug,
+      details: { title },
+      actor: {
+        id: jwtPayload.sub,
+        email: jwtPayload.email ?? 'unknown',
+        name: jwtPayload.name ?? null,
+      },
     })
 
+    context.get('scheduler').waitUntil(
+      context.get('automationRunner').run({
+        seedSlug: slug,
+        event: 'update',
+        entry: { ...current, ...mergedData, id, status: newStatus },
+      }),
+    )
+
     return context.json({ success: true })
   } catch (error) {
     if (error instanceof EntryNotFoundError) {