@beechcms/api 0.4.1 → 0.4.3

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

@@ -136,6 +136,14 @@ export async function createHandler(context: Context<AppEnv>) {
       },
     })
 
+    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

@@ -49,7 +49,14 @@ export async function deleteHandler(context: Context<AppEnv>) {
       },
     })
 
-    
+    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

@@ -182,6 +182,14 @@ export async function updateHandler(context: Context<AppEnv>) {
       },
     })
 
+    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) {

package/src/features/draft/draft.handler.ts

@@ -1,47 +1,50 @@
 /// <reference types="@cloudflare/workers-types" />
-import { Hono } from 'hono'
+import { Context, Hono } from 'hono'
 import { 
   validateAndSanitizeSeedPayload, 
-  resolvePolicies, 
-  EntryNotFoundError 
+  resolvePolicies 
 } from '@beechcms/core'
 import { publicProblem } from '../../public/problem-details'
 import { cleanStr } from '../../shared/query-utils'
 import { applyVisibility } from '../../shared/apply-policies'
 import { AppEnv } from '../../types'
 import { CONTENT_ERRORS } from '../content/constants'
+import { draftGuard } from './draft.middleware'
 
 const draftApp = new Hono<AppEnv>()
 
+
 function normalizeBody(raw: unknown): Record<string, unknown> {
   return typeof raw === 'object' && raw !== null ? (raw as Record<string, unknown>) : {}
 }
 
-function draftNotAllowed(context: any) {
-  return publicProblem(context, {
-    type: 'draft-not-allowed', 
-    title: 'Method Not Allowed', 
-    status: 405,
-    detail: 'This content type does not support pending drafts. Set allowDrafts: true on the Seed to enable.',
+function logDraftActivity(
+  context: Context<AppEnv>,
+  id: string,
+  slug: string,
+  title: string,
+  note: 'draft saved' | 'draft published'
+) {
+  const actor = context.get('jwtPayload')
+  context.get('activityLogger').log({
+    action: 'update',
+    entityType: 'content',
+    entityId: id,
+    entitySlug: slug,
+    details: { title, note },
+    actor: {
+      id: actor.sub,
+      email: actor.email ?? 'unknown',
+      name: actor.name ?? null,
+    },
   })
 }
 
-// PUT /:slug/:id/draft — crea o sovrascrive la bozza in content_{slug}_drafts
-draftApp.put('/:slug/:id/draft', async (context) => {
+// PUT /:slug/:id/draft — Creates or overwrites the pending draft
+draftApp.put('/:slug/:id/draft', draftGuard, async (context) => {
   const slug = context.req.param('slug')
   const id = context.req.param('id')
-
-  const seed = context.get('getSeed')(slug)
-  if (!seed) {
-    return publicProblem(context, { 
-      type: 'content-seed-not-found', 
-      title: 'Not Found', 
-      status: 404, 
-      detail: CONTENT_ERRORS.SEED_NOT_FOUND 
-    })
-  }
-  
-  if (!seed.allowDrafts) return draftNotAllowed(context)
+  const seed = context.get('getSeed')(slug)!
 
   let body: Record<string, unknown>
   try {
@@ -55,22 +58,6 @@ draftApp.put('/:slug/:id/draft', async (context) => {
     })
   }
 
-  const repository = context.get('repository')
-  try {
-    // Verify entry existence
-    await repository.findById(seed, id)
-  } catch (error) {
-    if (error instanceof EntryNotFoundError) {
-      return publicProblem(context, { 
-        type: 'content-not-found', 
-        title: 'Not Found', 
-        status: 404, 
-        detail: CONTENT_ERRORS.NOT_FOUND 
-      })
-    }
-    throw error
-  }
-
   const sensitiveAliases = Object.keys(body).filter((alias) => {
     const branch = seed.branches.find((b) => b.alias === alias)
     return branch != null && resolvePolicies(branch).privacy !== 'plain'
@@ -111,173 +98,73 @@ draftApp.put('/:slug/:id/draft', async (context) => {
     })
   }
 
+  const repository = context.get('repository')
   await repository.saveDraft(seed, id, validation.data)
 
-  const draftSaveActor = context.get('jwtPayload')
-  context.get('activityLogger').log({
-    action: 'update',
-    entityType: 'content',
-    entityId: id,
-    entitySlug: slug,
-    details: {
-      title: cleanStr(validation.data[seed.displayNameAlias]) ?? id,
-      note: 'draft saved',
-    },
-    actor: {
-      id: draftSaveActor.sub,
-      email: draftSaveActor.email ?? 'unknown',
-      name: draftSaveActor.name ?? null,
-    },
-  })
+  const displayTitle = cleanStr(validation.data[seed.displayNameAlias]) ?? id
+  logDraftActivity(context, id, slug, displayTitle, 'draft saved')
 
   return context.json({ success: true })
 })
 
-// GET /:slug/:id/draft — legge la bozza pendente
-draftApp.get('/:slug/:id/draft', async (context) => {
+// GET /:slug/:id/draft — Retrieves the pending draft
+draftApp.get('/:slug/:id/draft', draftGuard, async (context) => {
   const slug = context.req.param('slug')
   const id = context.req.param('id')
-
-  const seed = context.get('getSeed')(slug)
-  if (!seed) {
-    return publicProblem(context, { 
-      type: 'content-seed-not-found', 
-      title: 'Not Found', 
-      status: 404, 
-      detail: CONTENT_ERRORS.SEED_NOT_FOUND 
-    })
-  }
-  
-  if (!seed.allowDrafts) return draftNotAllowed(context)
+  const seed = context.get('getSeed')(slug)!
 
   const repository = context.get('repository')
   const draft = await repository.getDraft(seed, id)
 
   if (!draft) {
-    try {
-      await repository.findById(seed, id)
-      return publicProblem(context, { 
-        type: 'draft-not-found', 
-        title: 'Not Found', 
-        status: 404, 
-        detail: 'No pending draft for this entry' 
-      })
-    } catch (error) {
-      if (error instanceof EntryNotFoundError) {
-        return publicProblem(context, { 
-          type: 'content-not-found', 
-          title: 'Not Found', 
-          status: 404, 
-          detail: CONTENT_ERRORS.NOT_FOUND 
-        })
-      }
-      throw error
-    }
+    return publicProblem(context, { 
+      type: 'draft-not-found', 
+      title: 'Not Found', 
+      status: 404, 
+      detail: 'No pending draft for this entry' 
+    })
   }
 
   return context.json({ data: applyVisibility(draft, seed) })
 })
 
-// POST /:slug/:id/draft/publish — promuove bozza → live atomicamente
-draftApp.post('/:slug/:id/draft/publish', async (context) => {
+// POST /:slug/:id/draft/publish — Atomically promotes draft to live
+draftApp.post('/:slug/:id/draft/publish', draftGuard, async (context) => {
   const slug = context.req.param('slug')
   const id = context.req.param('id')
-
-  const seed = context.get('getSeed')(slug)
-  if (!seed) {
-    return publicProblem(context, { 
-      type: 'content-seed-not-found', 
-      title: 'Not Found', 
-      status: 404, 
-      detail: CONTENT_ERRORS.SEED_NOT_FOUND 
-    })
-  }
-  
-  if (!seed.allowDrafts) return draftNotAllowed(context)
+  const seed = context.get('getSeed')(slug)!
 
   const repository = context.get('repository')
   const draft = await repository.getDraft(seed, id)
 
   if (!draft) {
-    try {
-      await repository.findById(seed, id)
-      return publicProblem(context, { 
-        type: 'draft-not-found', 
-        title: 'Not Found', 
-        status: 404, 
-        detail: 'No pending draft to publish' 
-      })
-    } catch (error) {
-      if (error instanceof EntryNotFoundError) {
-        return publicProblem(context, { 
-          type: 'content-not-found', 
-          title: 'Not Found', 
-          status: 404, 
-          detail: CONTENT_ERRORS.NOT_FOUND 
-        })
-      }
-      throw error
-    }
+    return publicProblem(context, { 
+      type: 'draft-not-found', 
+      title: 'Not Found', 
+      status: 404, 
+      detail: 'No pending draft to publish' 
+    })
   }
 
   await repository.publishDraft(seed, id)
 
   const displayValue = draft[seed.displayNameAlias]
   const displayStr = typeof displayValue === 'string' ? displayValue : id
-
-  const draftPublishActor = context.get('jwtPayload')
-  context.get('activityLogger').log({
-    action: 'update',
-    entityType: 'content',
-    entityId: id,
-    entitySlug: slug,
-    details: { title: displayStr, note: 'draft published' },
-    actor: {
-      id: draftPublishActor.sub,
-      email: draftPublishActor.email ?? 'unknown',
-      name: draftPublishActor.name ?? null,
-    },
-  })
+  logDraftActivity(context, id, slug, displayStr, 'draft published')
 
   return context.json({ success: true })
 })
 
-// DELETE /:slug/:id/draft — scarta la bozza pendente
-draftApp.delete('/:slug/:id/draft', async (context) => {
+// DELETE /:slug/:id/draft — Discards the pending draft
+draftApp.delete('/:slug/:id/draft', draftGuard, async (context) => {
   const slug = context.req.param('slug')
   const id = context.req.param('id')
-
-  const seed = context.get('getSeed')(slug)
-  if (!seed) {
-    return publicProblem(context, { 
-      type: 'content-seed-not-found', 
-      title: 'Not Found', 
-      status: 404, 
-      detail: CONTENT_ERRORS.SEED_NOT_FOUND 
-    })
-  }
-  
-  if (!seed.allowDrafts) return draftNotAllowed(context)
+  const seed = context.get('getSeed')(slug)!
 
   const repository = context.get('repository')
-  try {
-    await repository.findById(seed, id)
-  } catch (error) {
-    if (error instanceof EntryNotFoundError) {
-      return publicProblem(context, { 
-        type: 'content-not-found', 
-        title: 'Not Found', 
-        status: 404, 
-        detail: CONTENT_ERRORS.NOT_FOUND 
-      })
-    }
-    throw error
-  }
-
   await repository.deleteDraft(seed, id)
 
   return context.json({ success: true })
 })
 
 export { draftApp }
-

package/src/features/draft/draft.middleware.ts

@@ -0,0 +1,62 @@
+import { createMiddleware } from 'hono/factory'
+import { EntryNotFoundError } from '@beechcms/core'
+import { publicProblem } from '../../public/problem-details'
+import { CONTENT_ERRORS } from '../content/constants'
+import type { AppEnv } from '../../types'
+
+/**
+ * Middleware that guards draft-related endpoints.
+ * Responsibilities:
+ * 1. Validates that the targeted Seed schema exists.
+ * 2. Ensures the Seed configuration explicitly allows drafts.
+ * 3. Confirms that the main live content entry exists in the repository.
+ */
+export const draftGuard = createMiddleware<AppEnv>(async (context, next) => {
+  const slug = context.req.param('slug')
+  const id = context.req.param('id')
+
+  if (!slug || !id) {
+    return publicProblem(context, {
+      type: 'content-invalid-request',
+      title: 'Bad Request',
+      status: 400,
+      detail: 'Missing required route parameters',
+    })
+  }
+
+  const seed = context.get('getSeed')(slug)
+  if (!seed) {
+    return publicProblem(context, {
+      type: 'content-seed-not-found',
+      title: 'Not Found',
+      status: 404,
+      detail: CONTENT_ERRORS.SEED_NOT_FOUND,
+    })
+  }
+
+  if (!seed.allowDrafts) {
+    return publicProblem(context, {
+      type: 'draft-not-allowed',
+      title: 'Method Not Allowed',
+      status: 405,
+      detail: 'This content type does not support pending drafts. Set allowDrafts: true on the Seed to enable.',
+    })
+  }
+
+  const repository = context.get('repository')
+  try {
+    await repository.findById(seed, id)
+  } catch (error) {
+    if (error instanceof EntryNotFoundError) {
+      return publicProblem(context, {
+        type: 'content-not-found',
+        title: 'Not Found',
+        status: 404,
+        detail: CONTENT_ERRORS.NOT_FOUND,
+      })
+    }
+    throw error
+  }
+
+  await next()
+})