@beechcms/api 0.4.1 → 0.4.3

package/src/features/automations/__tests__/automations.handler.test.ts

@@ -0,0 +1,260 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { Hono } from 'hono'
+import type { IAutomationRepository, Automation } from '@beechcms/core'
+import { automationsApp } from '../automations.handler'
+
+const baseAutomation: Automation = {
+  id: 'test-id',
+  seed_slug: 'posts',
+  name: 'test',
+  enabled: true,
+  triggers: [{ event: 'create' }],
+  trigger_conditions: null,
+  actions: [{ type: 'webhook', url: 'https://example.com' }],
+  created_at: 1000,
+  updated_at: 1000,
+}
+
+function makeStub(overrides: Partial<IAutomationRepository> = {}): IAutomationRepository {
+  return {
+    list: vi.fn().mockResolvedValue([baseAutomation]),
+    findById: vi.fn().mockResolvedValue(baseAutomation),
+    findActive: vi.fn().mockResolvedValue([]),
+    create: vi.fn().mockResolvedValue('new-id'),
+    update: vi.fn().mockResolvedValue(undefined),
+    toggle: vi.fn().mockResolvedValue(undefined),
+    delete: vi.fn().mockResolvedValue(undefined),
+    ...overrides,
+  }
+}
+
+function buildApp(stub: IAutomationRepository) {
+  const app = new Hono()
+  app.use('*', async (c, next) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ;(c as any).set('automationRepository', stub)
+    await next()
+  })
+  app.route('/', automationsApp)
+  return app
+}
+
+describe('GET /', () => {
+  it('returns 400 missing-seed without ?seed=', async () => {
+    const app = buildApp(makeStub())
+    const res = await app.request('/')
+    expect(res.status).toBe(400)
+    const body = await res.json() as { type: string }
+    expect(body.type).toContain('missing-seed')
+  })
+
+  it('returns 200 with automations list', async () => {
+    const app = buildApp(makeStub())
+    const res = await app.request('/?seed=posts')
+    expect(res.status).toBe(200)
+    const body = await res.json() as Automation[]
+    expect(body).toHaveLength(1)
+    expect(body[0].id).toBe('test-id')
+  })
+})
+
+describe('POST /', () => {
+  it('returns 400 invalid-json for malformed JSON body', async () => {
+    const app = buildApp(makeStub())
+    const res = await app.request('/', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: 'malformed-not-json',
+    })
+    expect(res.status).toBe(400)
+    const body = await res.json() as { type: string }
+    expect(body.type).toContain('invalid-json')
+  })
+
+  it('returns 400 automation-validation-failed for schema non-compliant body', async () => {
+    const app = buildApp(makeStub())
+    const res = await app.request('/', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ seed_slug: 'posts' }), // missing name, triggers, actions
+    })
+    expect(res.status).toBe(400)
+    const body = await res.json() as { type: string }
+    expect(body.type).toContain('automation-validation-failed')
+  })
+
+  it('returns 201 with id for valid body including optional trigger fields', async () => {
+    const app = buildApp(makeStub())
+    const res = await app.request('/', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        seed_slug: 'posts',
+        name: 'test-cron-automation',
+        triggers: [{ event: 'cron', cron: '0 0 * * *' }],
+        trigger_conditions: {
+          kind: 'group',
+          op: 'AND',
+          children: [
+            { kind: 'predicate', left: { kind: 'ref', key: 'this.status' }, op: 'eq', right: { kind: 'literal', value: 'draft' } },
+          ],
+        },
+        actions: [{ type: 'webhook', url: 'https://example.com' }],
+      }),
+    })
+    expect(res.status).toBe(201)
+    const body = await res.json() as { id: string }
+    expect(body.id).toBe('new-id')
+  })
+
+  it('returns 201 with id for valid body omitting optional trigger fields', async () => {
+    const app = buildApp(makeStub())
+    const res = await app.request('/', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        seed_slug: 'posts',
+        name: 'test-create-automation',
+        triggers: [{ event: 'create' }],
+        actions: [{ type: 'webhook', url: 'https://example.com' }],
+      }),
+    })
+    expect(res.status).toBe(201)
+    const body = await res.json() as { id: string }
+    expect(body.id).toBe('new-id')
+  })
+})
+
+describe('GET /:id', () => {
+  it('returns 404 when not found', async () => {
+    const app = buildApp(makeStub({ findById: vi.fn().mockResolvedValue(null) }))
+    const res = await app.request('/unknown-id')
+    expect(res.status).toBe(404)
+  })
+
+  it('returns 200 with automation', async () => {
+    const app = buildApp(makeStub())
+    const res = await app.request('/test-id')
+    expect(res.status).toBe(200)
+  })
+})
+
+describe('PUT /:id', () => {
+  it('returns 404 when not found', async () => {
+    const app = buildApp(makeStub({ findById: vi.fn().mockResolvedValue(null) }))
+    const res = await app.request('/unknown-id', {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name: 'renamed' }),
+    })
+    expect(res.status).toBe(404)
+  })
+
+  it('returns 400 invalid-json for malformed JSON body', async () => {
+    const app = buildApp(makeStub())
+    const res = await app.request('/test-id', {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: 'malformed-not-json',
+    })
+    expect(res.status).toBe(400)
+    const body = await res.json() as { type: string }
+    expect(body.type).toContain('invalid-json')
+  })
+
+  it('returns 400 automation-validation-failed for invalid update values', async () => {
+    const app = buildApp(makeStub())
+    const res = await app.request('/test-id', {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name: 12345 }), // name must be string
+    })
+    expect(res.status).toBe(400)
+    const body = await res.json() as { type: string }
+    expect(body.type).toContain('automation-validation-failed')
+  })
+
+  it('returns 400 when cron trigger has no cron expression', async () => {
+    const app = buildApp(makeStub())
+    const res = await app.request('/test-id', {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ triggers: [{ event: 'cron' }] }),
+    })
+    expect(res.status).toBe(400)
+    const body = await res.json() as { type: string }
+    expect(body.type).toContain('automation-validation-failed')
+  })
+
+  it('returns 204 for valid update', async () => {
+    const app = buildApp(makeStub())
+    const res = await app.request('/test-id', {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name: 'renamed' }),
+    })
+    expect(res.status).toBe(204)
+  })
+})
+
+describe('PATCH /:id/toggle', () => {
+  it('returns 404 when automation not found', async () => {
+    const app = buildApp(makeStub({ findById: vi.fn().mockResolvedValue(null) }))
+    const res = await app.request('/unknown-id/toggle', {
+      method: 'PATCH',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ enabled: false }),
+    })
+    expect(res.status).toBe(404)
+  })
+
+  it('returns 400 invalid-json for malformed JSON body', async () => {
+    const app = buildApp(makeStub())
+    const res = await app.request('/test-id/toggle', {
+      method: 'PATCH',
+      headers: { 'Content-Type': 'application/json' },
+      body: 'malformed-not-json',
+    })
+    expect(res.status).toBe(400)
+    const body = await res.json() as { type: string }
+    expect(body.type).toContain('invalid-json')
+  })
+
+  it('returns 400 automation-validation-failed for invalid payload', async () => {
+    const app = buildApp(makeStub())
+    const res = await app.request('/test-id/toggle', {
+      method: 'PATCH',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ enabled: 'not-a-boolean' }),
+    })
+    expect(res.status).toBe(400)
+    const body = await res.json() as { type: string }
+    expect(body.type).toContain('automation-validation-failed')
+  })
+
+  it('returns 204 and calls toggle(id, false)', async () => {
+    const stub = makeStub()
+    const app = buildApp(stub)
+    const res = await app.request('/test-id/toggle', {
+      method: 'PATCH',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ enabled: false }),
+    })
+    expect(res.status).toBe(204)
+    expect(stub.toggle).toHaveBeenCalledWith('test-id', false)
+  })
+})
+
+describe('DELETE /:id', () => {
+  it('returns 404 when not found', async () => {
+    const app = buildApp(makeStub({ findById: vi.fn().mockResolvedValue(null) }))
+    const res = await app.request('/unknown-id', { method: 'DELETE' })
+    expect(res.status).toBe(404)
+  })
+
+  it('returns 204 on success', async () => {
+    const app = buildApp(makeStub())
+    const res = await app.request('/test-id', { method: 'DELETE' })
+    expect(res.status).toBe(204)
+  })
+})

package/src/features/automations/__tests__/automations.repository.test.ts

@@ -0,0 +1,159 @@
+import { describe, it, expect, vi } from 'vitest'
+import { D1AutomationRepository } from '../../../shared/automations.repository.d1'
+
+function makeDb() {
+  const calls: { sql: string; bindings: unknown[] }[] = []
+  let nextAllResult: unknown[] = []
+  let nextFirstResult: unknown = null
+
+  const db = {
+    _calls: calls,
+    _setAllResult(rows: unknown[]) { nextAllResult = rows },
+    _setFirstResult(row: unknown) { nextFirstResult = row },
+    prepare(sql: string) {
+      let boundValues: unknown[] = []
+      const stmt = {
+        bind(...args: unknown[]) { boundValues = args; return stmt },
+        async run() {
+          calls.push({ sql, bindings: boundValues })
+          return { success: true }
+        },
+        async all() {
+          calls.push({ sql, bindings: boundValues })
+          return { results: nextAllResult }
+        },
+        async first() {
+          calls.push({ sql, bindings: boundValues })
+          return nextFirstResult
+        },
+      }
+      return stmt
+    },
+  }
+  return db as unknown as D1Database & typeof db
+}
+
+const fixtureRow = {
+  id: 'abc',
+  seed_slug: 'posts',
+  name: 'test',
+  enabled: 1,
+  triggers: JSON.stringify([{ event: 'create' }]),
+  trigger_conditions: null,
+  actions: JSON.stringify([{ type: 'webhook', url: 'https://example.com' }]),
+  created_at: 1000,
+  updated_at: 1000,
+}
+
+describe('D1AutomationRepository.create', () => {
+  it('serialises actions and trigger_conditions to JSON', async () => {
+    const db = makeDb()
+    const repo = new D1AutomationRepository(db)
+    const whenNode = {
+      kind: 'group' as const,
+      op: 'AND' as const,
+      children: [{ kind: 'predicate' as const, left: { kind: 'ref' as const, key: 'this.status' }, op: 'eq' as const, right: { kind: 'literal' as const, value: 'published' } }],
+    }
+    await repo.create({
+      seed_slug: 'posts',
+      name: 'test',
+      triggers: [{ event: 'create' }],
+      trigger_conditions: whenNode,
+      actions: [{ type: 'webhook', url: 'https://example.com' }],
+    })
+    expect(db._calls).toHaveLength(1)
+    const { bindings } = db._calls[0]
+    // triggers is index 3, trigger_conditions is index 4, actions is index 5
+    expect(typeof bindings[3]).toBe('string')
+    expect(JSON.parse(bindings[3] as string)).toEqual([{ event: 'create' }])
+    expect(typeof bindings[4]).toBe('string')
+    expect(JSON.parse(bindings[4] as string)).toEqual(whenNode)
+    expect(typeof bindings[5]).toBe('string')
+    expect(JSON.parse(bindings[5] as string)).toEqual([{ type: 'webhook', url: 'https://example.com' }])
+  })
+
+  it('stores null for missing trigger_conditions', async () => {
+    const db = makeDb()
+    const repo = new D1AutomationRepository(db)
+    await repo.create({
+      seed_slug: 'posts',
+      name: 'test',
+      triggers: [{ event: 'create' }],
+      trigger_conditions: null,
+      actions: [{ type: 'webhook', url: 'https://example.com' }],
+    })
+    const { bindings } = db._calls[0]
+    expect(bindings[4]).toBeNull()
+  })
+})
+
+describe('D1AutomationRepository.update', () => {
+  it('builds SET clause only from provided keys', async () => {
+    const db = makeDb()
+    const repo = new D1AutomationRepository(db)
+    await repo.update('abc', { name: 'renamed' })
+    expect(db._calls).toHaveLength(1)
+    expect(db._calls[0].sql).toContain('name = ?')
+    expect(db._calls[0].sql).not.toContain('seed_slug')
+  })
+
+  it('short-circuits when no fields provided', async () => {
+    const db = makeDb()
+    const repo = new D1AutomationRepository(db)
+    await repo.update('abc', {})
+    expect(db._calls).toHaveLength(0)
+  })
+})
+
+describe('D1AutomationRepository.toggle', () => {
+  it('only writes enabled and updated_at', async () => {
+    const db = makeDb()
+    const repo = new D1AutomationRepository(db)
+    await repo.toggle('abc', false)
+    expect(db._calls).toHaveLength(1)
+    const { sql, bindings } = db._calls[0]
+    expect(sql).toBe('UPDATE automations SET enabled = ?, updated_at = ? WHERE id = ?')
+    expect(bindings[0]).toBe(0)
+    expect(bindings[2]).toBe('abc')
+  })
+})
+
+describe('rowToAutomation JSON round-trip', () => {
+  it('deserialises trigger_conditions as null when column is null', async () => {
+    const db = makeDb()
+    db._setAllResult([fixtureRow])
+    const repo = new D1AutomationRepository(db)
+    const rows = await repo.list('posts')
+    expect(rows[0].trigger_conditions).toBeNull()
+  })
+
+  it('deserialises trigger_conditions as WhenNode when column contains WhenNode JSON', async () => {
+    const db = makeDb()
+    const whenNode = {
+      kind: 'group',
+      op: 'AND',
+      children: [{
+        kind: 'predicate',
+        left: { kind: 'ref', key: 'this.status' },
+        op: 'eq',
+        right: { kind: 'literal', value: 'published' },
+      }],
+    }
+    const rowWithConditions = {
+      ...fixtureRow,
+      trigger_conditions: JSON.stringify(whenNode),
+    }
+    db._setAllResult([rowWithConditions])
+    const repo = new D1AutomationRepository(db)
+    const rows = await repo.list('posts')
+    expect(rows[0].trigger_conditions).toEqual(whenNode)
+  })
+
+  it('deserialises actions as parsed array', async () => {
+    const db = makeDb()
+    db._setAllResult([fixtureRow])
+    const repo = new D1AutomationRepository(db)
+    const rows = await repo.list('posts')
+    expect(rows[0].actions).toEqual([{ type: 'webhook', url: 'https://example.com' }])
+  })
+})

package/src/features/automations/__tests__/automations.schema.test.ts

@@ -0,0 +1,134 @@
+import { describe, it, expect } from 'vitest'
+import {
+  createAutomationSchema,
+  updateAutomationSchema,
+  toggleAutomationSchema,
+} from '../automations.schema'
+
+const validWebhookAction = { type: 'webhook' as const, url: 'https://example.com/hook' }
+
+const minimalValid = {
+  seed_slug: 'posts',
+  name: 'notify-on-create',
+  triggers: [{ event: 'create' as const }],
+  actions: [validWebhookAction],
+}
+
+describe('createAutomationSchema', () => {
+  it('accepts minimal valid create payload', () => {
+    expect(createAutomationSchema.safeParse(minimalValid).success).toBe(true)
+  })
+
+  it('rejects cron trigger without cron expression', () => {
+    const result = createAutomationSchema.safeParse({
+      ...minimalValid,
+      triggers: [{ event: 'cron' }],
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('accepts cron trigger with cron expression', () => {
+    const result = createAutomationSchema.safeParse({
+      ...minimalValid,
+      triggers: [{ event: 'cron', cron: '0 * * * *' }],
+    })
+    expect(result.success).toBe(true)
+  })
+
+  it('rejects duplicate trigger events', () => {
+    const result = createAutomationSchema.safeParse({
+      ...minimalValid,
+      triggers: [{ event: 'create' }, { event: 'create' }],
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('accepts multiple distinct triggers', () => {
+    const result = createAutomationSchema.safeParse({
+      ...minimalValid,
+      triggers: [{ event: 'create' }, { event: 'update' }],
+    })
+    expect(result.success).toBe(true)
+  })
+
+  it('rejects empty actions array', () => {
+    const result = createAutomationSchema.safeParse({ ...minimalValid, actions: [] })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects unknown action type', () => {
+    const result = createAutomationSchema.safeParse({
+      ...minimalValid,
+      actions: [{ type: 'unknown_type', url: 'https://example.com' }],
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects webhook with non-url', () => {
+    const result = createAutomationSchema.safeParse({
+      ...minimalValid,
+      actions: [{ type: 'webhook', url: 'not-a-url' }],
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects send_mail with invalid email', () => {
+    const result = createAutomationSchema.safeParse({
+      ...minimalValid,
+      actions: [{ type: 'send_mail', to: 'not-an-email', subject_template: 'hi', body_template: 'body' }],
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('accepts trigger_conditions as null', () => {
+    const result = createAutomationSchema.safeParse({
+      ...minimalValid,
+      trigger_conditions: null,
+    })
+
+    expect(result.success).toBe(true)
+  })
+
+  it('accepts trigger_conditions as WhenNode', () => {
+    const result = createAutomationSchema.safeParse({
+      ...minimalValid,
+      trigger_conditions: {
+        kind: 'group',
+        op: 'AND',
+        children: [
+          { kind: 'predicate', left: { kind: 'ref', key: 'this.status' }, op: 'eq', right: { kind: 'literal', value: 'published' } },
+        ],
+      },
+    })
+    expect(result.success).toBe(true)
+  })
+})
+
+describe('updateAutomationSchema', () => {
+  it('accepts empty object', () => {
+    expect(updateAutomationSchema.safeParse({}).success).toBe(true)
+  })
+
+  it('accepts name-only without requiring triggers', () => {
+    const result = updateAutomationSchema.safeParse({ name: 'renamed' })
+    expect(result.success).toBe(true)
+  })
+})
+
+describe('toggleAutomationSchema', () => {
+  it('accepts { enabled: true }', () => {
+    expect(toggleAutomationSchema.safeParse({ enabled: true }).success).toBe(true)
+  })
+
+  it('accepts { enabled: false }', () => {
+    expect(toggleAutomationSchema.safeParse({ enabled: false }).success).toBe(true)
+  })
+
+  it('rejects missing enabled', () => {
+    expect(toggleAutomationSchema.safeParse({}).success).toBe(false)
+  })
+
+  it('rejects non-boolean enabled', () => {
+    expect(toggleAutomationSchema.safeParse({ enabled: 'true' }).success).toBe(false)
+  })
+})

package/src/features/automations/__tests__/context-resolver.test.ts

@@ -0,0 +1,122 @@
+import { describe, it, expect } from 'vitest'
+import type { Automation } from '@beechcms/core'
+import { resolveAutomationContext, deriveEntryContext } from '../context-resolver'
+import { parseTemplateKey } from '../template-grammar'
+
+function makeAutomation(overrides: Partial<Automation> = {}): Automation {
+  return {
+    id: 'auto-1',
+    seed_slug: 'orders',
+    name: 'test',
+    enabled: true,
+    triggers: [{ event: 'cron' as const, cron: '* * * * *' }],
+    trigger_conditions: null,
+    actions: [],
+    created_at: 0,
+    updated_at: 0,
+    ...overrides,
+  }
+}
+
+describe('resolveAutomationContext', () => {
+  const triggerEntry = { id: 'e1', email: 'alice@example.com', product_id: 'p1' }
+  const batchEntries = [
+    { id: 'e1', total: 10, email: 'alice@example.com' },
+    { id: 'e2', total: 20, email: 'bob@example.com' },
+    { id: 'e3', total: 30, email: 'carol@example.com' },
+  ]
+
+  it('this scope resolves to triggering entry field', async () => {
+    const ctx = await resolveAutomationContext(makeAutomation(), triggerEntry, [triggerEntry])
+    expect(ctx.lookup(parseTemplateKey('this:email')!)).toBe('alice@example.com')
+  })
+
+  it('this. dot notation resolves to triggering entry field', async () => {
+    const ctx = await resolveAutomationContext(makeAutomation(), triggerEntry, [triggerEntry])
+    expect(ctx.lookup(parseTemplateKey('email')!)).toBe('alice@example.com')
+    expect(ctx.lookup(parseTemplateKey('this:product_id')!)).toBe('p1')
+  })
+
+  it('batch:all:count matches batchEntries length', async () => {
+    const ctx = await resolveAutomationContext(makeAutomation(), triggerEntry, batchEntries)
+    expect(ctx.lookup(parseTemplateKey('batch:all:count')!)).toBe(3)
+  })
+
+  it('unknown scope → undefined + onMissing fires', async () => {
+    const ctx = await resolveAutomationContext(makeAutomation(), triggerEntry, [triggerEntry])
+    const missing: string[] = []
+    const val = ctx.lookup(parseTemplateKey('unknownseed:lastone:email')!, (f) => missing.push(f))
+    expect(val).toBeUndefined()
+    expect(missing).toHaveLength(1)
+    expect(missing[0]).toBe('unknownseed')
+  })
+
+  it('pluck truncates to 100 entries and appends truncation marker', async () => {
+    const rows = Array.from({ length: 150 }, (_, i) => ({ email: `u${i}@example.com` }))
+    const ctx = await resolveAutomationContext(makeAutomation(), triggerEntry, rows)
+    const key = parseTemplateKey('batch:all:pluck:email')!
+    const result = ctx.lookup(key) as string
+    const values = result.split(', ')
+    expect(result.endsWith(' …')).toBe(true)
+    expect(values.length).toBe(100)
+  })
+
+  it('sum on non-numeric field values returns 0 and fires onMissing for NaN', async () => {
+    const ctx = await resolveAutomationContext(
+      makeAutomation(),
+      triggerEntry,
+      [{ id: 'e1', amount: 'not-a-number' }, { id: 'e2', amount: 'also-not' }],
+    )
+    const missing: string[] = []
+    const result = ctx.lookup(parseTemplateKey('batch:all:sum:amount')!, (f) => missing.push(f))
+    expect(result).toBe(0)
+    expect(missing.length).toBeGreaterThan(0)
+  })
+
+  describe('aggregates on batch', () => {
+    const rows = [
+      { id: 'e1', total: 10 },
+      { id: 'e2', total: 20 },
+      { id: 'e3', total: 30 },
+    ]
+
+    async function makeCtx(batchRows: Record<string, unknown>[]) {
+      return resolveAutomationContext(makeAutomation(), batchRows[0] ?? null, batchRows)
+    }
+
+    it('count', async () => {
+      const ctx = await makeCtx(rows)
+      expect(ctx.lookup(parseTemplateKey('batch:all:count')!)).toBe(3)
+    })
+
+    it('sum', async () => {
+      const ctx = await makeCtx(rows)
+      expect(ctx.lookup(parseTemplateKey('batch:all:sum:total')!)).toBe(60)
+    })
+
+    it('avg', async () => {
+      const ctx = await makeCtx(rows)
+      expect(ctx.lookup(parseTemplateKey('batch:all:avg:total')!)).toBe(20)
+    })
+
+    it('min', async () => {
+      const ctx = await makeCtx(rows)
+      expect(ctx.lookup(parseTemplateKey('batch:all:min:total')!)).toBe(10)
+    })
+
+    it('max', async () => {
+      const ctx = await makeCtx(rows)
+      expect(ctx.lookup(parseTemplateKey('batch:all:max:total')!)).toBe(30)
+    })
+  })
+})
+
+describe('deriveEntryContext', () => {
+  it('this scope returns new entry, batch scope delegates to base', async () => {
+    const batchRows = [{ id: 'e1', val: 1 }, { id: 'e2', val: 2 }]
+    const base = await resolveAutomationContext(makeAutomation(), batchRows[0] ?? null, batchRows)
+    const derived = deriveEntryContext(base, { id: 'e2', val: 2, email: 'derived@example.com' })
+    expect(derived.lookup(parseTemplateKey('this:email')!)).toBe('derived@example.com')
+    expect(derived.lookup(parseTemplateKey('batch:all:count')!)).toBe(2)
+  })
+})