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

package/src/features/automations/__tests__/webhook.executor.test.ts

@@ -1,142 +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 { describe, it, expect, vi, beforeEach } from 'vitest'
-import { executeWebhook } from '../action-executors/webhook.executor'
-import type { ResolvedContext } from '../context-resolver'
-
-function makeContext(entry: Record<string, unknown> = {}, event = 'create'): ResolvedContext {
-  return {
-    triggerEntry: entry,
-    lookup(parsed) {
-      if (parsed.kind === 'simple') {
-        const key = parsed.path.startsWith('this.') ? parsed.path.slice(5) : parsed.path
-        if (key === 'trigger_event') return event
-        return entry[key] ?? null
-      }
-      return null
-    },
-  }
-}
-
-const baseContext = makeContext({ id: 'entry-1', title: 'Hello' })
-
-const baseAction = {
-  type: 'webhook' as const,
-  url: 'https://example.com/hook',
-  body_template: '{"static":true}',
-}
-
-function makeOkResponse(status = 200): Response {
-  return { ok: true, status } as unknown as Response
-}
-
-function makeErrorResponse(status: number): Response {
-  return { ok: false, status } as unknown as Response
-}
-
-beforeEach(() => {
-  vi.restoreAllMocks()
-})
-
-describe('executeWebhook', () => {
-  it('signs request when WEBHOOK_SECRET is set', async () => {
-    const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue(makeOkResponse())
-
-    await executeWebhook(baseAction, baseContext, { WEBHOOK_SECRET: 'test-secret' })
-
-    expect(fetchSpy).toHaveBeenCalledOnce()
-    const [, init] = fetchSpy.mock.calls[0]
-    const headers = init?.headers as Record<string, string>
-    expect(headers['X-BeechCMS-Signature']).toMatch(/^sha256=[0-9a-f]{64}$/)
-  })
-
-  it('omits signature header and warns once when WEBHOOK_SECRET is absent', async () => {
-    const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue(makeOkResponse())
-    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
-
-    await executeWebhook(baseAction, baseContext, {})
-    await executeWebhook(baseAction, baseContext, {})
-
-    const [, init] = fetchSpy.mock.calls[0]
-    const headers = init?.headers as Record<string, string>
-    expect(headers['X-BeechCMS-Signature']).toBeUndefined()
-    expect(warnSpy).toHaveBeenCalledOnce()
-    expect(warnSpy.mock.calls[0][0]).toContain('WEBHOOK_SECRET')
-  })
-
-  it('overwrites user-supplied X-BeechCMS-Signature header with computed value', async () => {
-    const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue(makeOkResponse())
-
-    const action = {
-      ...baseAction,
-      headers: { 'X-BeechCMS-Signature': 'sha256=user-supplied-value' },
-    }
-
-    await executeWebhook(action, baseContext, { WEBHOOK_SECRET: 'test-secret' })
-
-    const [, init] = fetchSpy.mock.calls[0]
-    const headers = init?.headers as Record<string, string>
-    expect(headers['X-BeechCMS-Signature']).toMatch(/^sha256=[0-9a-f]{64}$/)
-    expect(headers['X-BeechCMS-Signature']).not.toBe('sha256=user-supplied-value')
-  })
-
-  it('throws with status code when endpoint responds with 500', async () => {
-    vi.spyOn(globalThis, 'fetch').mockResolvedValue(makeErrorResponse(500))
-
-    await expect(executeWebhook(baseAction, baseContext, {}))
-      .rejects.toThrow('500')
-  })
-
-  it('interpolates body_template placeholders before sending', async () => {
-    const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue(makeOkResponse())
-
-    const action = { ...baseAction, body_template: '{"event":"{{trigger_event}}","id":"{{id}}"}' }
-    const ctx = makeContext({ id: 'abc-123' }, 'update')
-
-    await executeWebhook(action, ctx, {})
-
-    const [, init] = fetchSpy.mock.calls[0]
-    const body = init?.body as string
-    expect(body).toContain('abc-123')
-    expect(body).toContain('update')
-  })
-
-  it('recalculates HMAC and matches X-BeechCMS-Signature header', async () => {
-    const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue(makeOkResponse())
-    const secret = 'verify-secret'
-
-    await executeWebhook(baseAction, baseContext, { WEBHOOK_SECRET: secret })
-
-    const [, init] = fetchSpy.mock.calls[0]
-    const headers = init?.headers as Record<string, string>
-    const sentBody = init?.body as string
-    const sentSig = headers['X-BeechCMS-Signature']
-
-    const encoder = new TextEncoder()
-    const key = await crypto.subtle.importKey(
-      'raw',
-      encoder.encode(secret),
-      { name: 'HMAC', hash: 'SHA-256' },
-      false,
-      ['sign'],
-    )
-    const sig = await crypto.subtle.sign('HMAC', key, encoder.encode(sentBody))
-    const expected = 'sha256=' + Array.from(new Uint8Array(sig))
-      .map((b) => b.toString(16).padStart(2, '0'))
-      .join('')
-
-    expect(sentSig).toBe(expected)
-  })
-
-  it('throws timeout error when fetch takes longer than 8 seconds', async () => {
-    vi.spyOn(globalThis, 'fetch').mockImplementation(() => {
-      const err = new DOMException('The operation was aborted.', 'TimeoutError')
-      return Promise.reject(err)
-    })
-
-    await expect(executeWebhook(baseAction, baseContext, {}))
-      .rejects.toThrow('timed out after 8000ms')
-  })
-})

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

@@ -1,274 +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 { describe, it, expect } from 'vitest'
-import type { WhenNode } from '@beechcms/core'
-import { evaluateWhen } from '../when-evaluator'
-import type { ResolvedContext } from '../context-resolver'
-import { parseTemplateKey } from '../template-grammar'
-
-// ---------------------------------------------------------------------------
-// Minimal ResolvedContext builder for testing
-// ---------------------------------------------------------------------------
-
-function makeContext(entry: Record<string, unknown>): ResolvedContext {
-  return {
-    triggerEntry: entry,
-    lookup(parsed, onMissing) {
-      if (!parsed) return undefined
-      if (parsed.kind === 'simple') {
-        const parts = parsed.path.split('.')
-        let cur: unknown = entry
-        for (const p of parts) {
-          cur = (cur as Record<string, unknown>)?.[p]
-        }
-        if (cur === undefined && onMissing) onMissing(parsed.path)
-        return cur
-      }
-      if (parsed.kind === 'scoped' && parsed.scope === 'this' && parsed.op === 'field' && parsed.field) {
-        return (entry as Record<string, unknown>)[parsed.field]
-      }
-      return undefined
-    },
-  }
-}
-
-const entry = { status: 'paid', total: 150, name: 'Alice', tag: 'gold' }
-const ctx = makeContext(entry)
-
-// ---------------------------------------------------------------------------
-// null / empty → true
-// ---------------------------------------------------------------------------
-
-describe('evaluateWhen — null/empty', () => {
-  it('null node returns true', () => {
-    expect(evaluateWhen(null, ctx)).toBe(true)
-  })
-
-  it('empty AND group returns true', () => {
-    const node: WhenNode = { kind: 'group', op: 'AND', children: [] }
-    expect(evaluateWhen(node, ctx)).toBe(true)
-  })
-
-  it('empty OR group returns false', () => {
-    const node: WhenNode = { kind: 'group', op: 'OR', children: [] }
-    expect(evaluateWhen(node, ctx)).toBe(false)
-  })
-})
-
-// ---------------------------------------------------------------------------
-// Basic predicates
-// ---------------------------------------------------------------------------
-
-describe('evaluateWhen — predicates', () => {
-  it('eq literal', () => {
-    const node: WhenNode = {
-      kind: 'predicate',
-      left: { kind: 'ref', key: 'this.status' },
-      op: 'eq',
-      right: { kind: 'literal', value: 'paid' },
-    }
-    expect(evaluateWhen(node, ctx)).toBe(true)
-  })
-
-  it('eq literal fails', () => {
-    const node: WhenNode = {
-      kind: 'predicate',
-      left: { kind: 'ref', key: 'this.status' },
-      op: 'eq',
-      right: { kind: 'literal', value: 'unpaid' },
-    }
-    expect(evaluateWhen(node, ctx)).toBe(false)
-  })
-
-  it('gt numeric', () => {
-    const node: WhenNode = {
-      kind: 'predicate',
-      left: { kind: 'ref', key: 'this.total' },
-      op: 'gt',
-      right: { kind: 'literal', value: 100 },
-    }
-    expect(evaluateWhen(node, ctx)).toBe(true)
-  })
-
-  it('lte numeric', () => {
-    const node: WhenNode = {
-      kind: 'predicate',
-      left: { kind: 'ref', key: 'this.total' },
-      op: 'lte',
-      right: { kind: 'literal', value: 150 },
-    }
-    expect(evaluateWhen(node, ctx)).toBe(true)
-  })
-
-  it('contains string', () => {
-    const node: WhenNode = {
-      kind: 'predicate',
-      left: { kind: 'ref', key: 'this.name' },
-      op: 'contains',
-      right: { kind: 'literal', value: 'lic' },
-    }
-    expect(evaluateWhen(node, ctx)).toBe(true)
-  })
-
-  it('startswith', () => {
-    const node: WhenNode = {
-      kind: 'predicate',
-      left: { kind: 'ref', key: 'this.name' },
-      op: 'startswith',
-      right: { kind: 'literal', value: 'Ali' },
-    }
-    expect(evaluateWhen(node, ctx)).toBe(true)
-  })
-
-  it('isempty — non-empty field', () => {
-    const node: WhenNode = {
-      kind: 'predicate',
-      left: { kind: 'ref', key: 'this.status' },
-      op: 'isempty',
-    }
-    expect(evaluateWhen(node, ctx)).toBe(false)
-  })
-
-  it('isnotempty — non-empty field', () => {
-    const node: WhenNode = {
-      kind: 'predicate',
-      left: { kind: 'ref', key: 'this.status' },
-      op: 'isnotempty',
-    }
-    expect(evaluateWhen(node, ctx)).toBe(true)
-  })
-
-  it('matches regex', () => {
-    const node: WhenNode = {
-      kind: 'predicate',
-      left: { kind: 'ref', key: 'this.tag' },
-      op: 'matches',
-      right: { kind: 'literal', value: '^g' },
-    }
-    expect(evaluateWhen(node, ctx)).toBe(true)
-  })
-
-  it('literal-to-literal comparison', () => {
-    const node: WhenNode = {
-      kind: 'predicate',
-      left: { kind: 'literal', value: 10 },
-      op: 'lt',
-      right: { kind: 'literal', value: 20 },
-    }
-    expect(evaluateWhen(node, ctx)).toBe(true)
-  })
-})
-
-// ---------------------------------------------------------------------------
-// AND / OR groups with short-circuit
-// ---------------------------------------------------------------------------
-
-describe('evaluateWhen — groups', () => {
-  it('AND group — all true', () => {
-    const node: WhenNode = {
-      kind: 'group',
-      op: 'AND',
-      children: [
-        { kind: 'predicate', left: { kind: 'ref', key: 'this.status' }, op: 'eq', right: { kind: 'literal', value: 'paid' } },
-        { kind: 'predicate', left: { kind: 'ref', key: 'this.total' }, op: 'gt', right: { kind: 'literal', value: 100 } },
-      ],
-    }
-    expect(evaluateWhen(node, ctx)).toBe(true)
-  })
-
-  it('AND group — one false', () => {
-    const node: WhenNode = {
-      kind: 'group',
-      op: 'AND',
-      children: [
-        { kind: 'predicate', left: { kind: 'ref', key: 'this.status' }, op: 'eq', right: { kind: 'literal', value: 'paid' } },
-        { kind: 'predicate', left: { kind: 'ref', key: 'this.total' }, op: 'gt', right: { kind: 'literal', value: 200 } },
-      ],
-    }
-    expect(evaluateWhen(node, ctx)).toBe(false)
-  })
-
-  it('OR group — first true short-circuits', () => {
-    const node: WhenNode = {
-      kind: 'group',
-      op: 'OR',
-      children: [
-        { kind: 'predicate', left: { kind: 'ref', key: 'this.status' }, op: 'eq', right: { kind: 'literal', value: 'paid' } },
-        { kind: 'predicate', left: { kind: 'ref', key: 'this.total' }, op: 'gt', right: { kind: 'literal', value: 200 } },
-      ],
-    }
-    expect(evaluateWhen(node, ctx)).toBe(true)
-  })
-
-  it('negate wraps group result', () => {
-    const node: WhenNode = {
-      kind: 'group',
-      op: 'AND',
-      negate: true,
-      children: [
-        { kind: 'predicate', left: { kind: 'ref', key: 'this.status' }, op: 'eq', right: { kind: 'literal', value: 'paid' } },
-      ],
-    }
-    expect(evaluateWhen(node, ctx)).toBe(false)
-  })
-
-  it('nested AND inside OR', () => {
-    const node: WhenNode = {
-      kind: 'group',
-      op: 'AND',
-      children: [
-        { kind: 'predicate', left: { kind: 'ref', key: 'this.total' }, op: 'gt', right: { kind: 'literal', value: 100 } },
-        {
-          kind: 'group',
-          op: 'OR',
-          children: [
-            { kind: 'predicate', left: { kind: 'ref', key: 'this.tag' }, op: 'eq', right: { kind: 'literal', value: 'gold' } },
-            { kind: 'predicate', left: { kind: 'ref', key: 'this.total' }, op: 'gt', right: { kind: 'literal', value: 5000 } },
-          ],
-        },
-      ],
-    }
-    expect(evaluateWhen(node, ctx)).toBe(true)
-  })
-})
-
-// ---------------------------------------------------------------------------
-// null handling
-// ---------------------------------------------------------------------------
-
-describe('evaluateWhen — null operands', () => {
-  const emptyCtx = makeContext({})
-
-  it('null == null → eq true', () => {
-    const node: WhenNode = {
-      kind: 'predicate',
-      left: { kind: 'ref', key: 'this.missing' },
-      op: 'eq',
-      right: { kind: 'literal', value: null },
-    }
-    expect(evaluateWhen(node, emptyCtx)).toBe(true)
-  })
-
-  it('null isempty → true', () => {
-    const node: WhenNode = {
-      kind: 'predicate',
-      left: { kind: 'ref', key: 'this.missing' },
-      op: 'isempty',
-    }
-    expect(evaluateWhen(node, emptyCtx)).toBe(true)
-  })
-
-  it('null gt 0 → false (no exception)', () => {
-    const node: WhenNode = {
-      kind: 'predicate',
-      left: { kind: 'ref', key: 'this.missing' },
-      op: 'gt',
-      right: { kind: 'literal', value: 0 },
-    }
-    expect(() => evaluateWhen(node, emptyCtx)).not.toThrow()
-    expect(evaluateWhen(node, emptyCtx)).toBe(false)
-  })
-})
-

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

@@ -1,281 +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 { describe, it, expect } from 'vitest'
-import type { WhenNode, Seed } from '@beechcms/core'
-import { extractPushdownFilters } from '../when-pushdown'
-
-// ---------------------------------------------------------------------------
-// Minimal Seed
-// ---------------------------------------------------------------------------
-
-function makeSeed(aliases: string[] = []): Seed {
-  return {
-    slug: 'orders',
-    label: 'Orders',
-    displayNameAlias: aliases[0] ?? 'id',
-    branches: aliases.map((alias, i) => ({ id: `br_0${i + 1}`, alias, label: alias, type: 'text' as const })),
-  }
-}
-
-const seed = makeSeed(['status', 'total', 'name', 'tag'])
-
-// ---------------------------------------------------------------------------
-// null / empty
-// ---------------------------------------------------------------------------
-
-describe('extractPushdownFilters — null/empty', () => {
-  it('null returns []', () => {
-    expect(extractPushdownFilters(null, seed)).toEqual([])
-  })
-
-  it('empty AND group returns []', () => {
-    const node: WhenNode = { kind: 'group', op: 'AND', children: [] }
-    expect(extractPushdownFilters(node, seed)).toEqual([])
-  })
-
-  it('empty OR group returns []', () => {
-    const node: WhenNode = { kind: 'group', op: 'OR', children: [] }
-    expect(extractPushdownFilters(node, seed)).toEqual([])
-  })
-})
-
-// ---------------------------------------------------------------------------
-// Safe single-predicate push-down
-// ---------------------------------------------------------------------------
-
-describe('extractPushdownFilters — safe predicates', () => {
-  it('root eq predicate is pushed', () => {
-    const node: WhenNode = {
-      kind: 'predicate',
-      left: { kind: 'ref', key: 'this.status' },
-      op: 'eq',
-      right: { kind: 'literal', value: 'paid' },
-    }
-    const result = extractPushdownFilters(node, seed)
-    expect(result).toHaveLength(1)
-    expect(result[0].column).toBe('status')
-    expect(result[0].conditions[0].op).toBe('eq')
-    expect(result[0].conditions[0].value).toBe('paid')
-  })
-
-  it('root neq predicate is pushed', () => {
-    const node: WhenNode = {
-      kind: 'predicate',
-      left: { kind: 'ref', key: 'this.status' },
-      op: 'neq',
-      right: { kind: 'literal', value: 'cancelled' },
-    }
-    const result = extractPushdownFilters(node, seed)
-    expect(result).toHaveLength(1)
-    expect(result[0].conditions[0].op).toBe('neq')
-  })
-
-  it('root gt predicate is pushed', () => {
-    const node: WhenNode = {
-      kind: 'predicate',
-      left: { kind: 'ref', key: 'this.total' },
-      op: 'gt',
-      right: { kind: 'literal', value: 100 },
-    }
-    const result = extractPushdownFilters(node, seed)
-    expect(result).toHaveLength(1)
-    expect(result[0].conditions[0].op).toBe('gt')
-  })
-
-  it('root lt predicate is pushed', () => {
-    const node: WhenNode = {
-      kind: 'predicate',
-      left: { kind: 'ref', key: 'this.total' },
-      op: 'lt',
-      right: { kind: 'literal', value: 500 },
-    }
-    const result = extractPushdownFilters(node, seed)
-    expect(result).toHaveLength(1)
-    expect(result[0].conditions[0].op).toBe('lt')
-  })
-
-  it('root contains predicate is pushed', () => {
-    const node: WhenNode = {
-      kind: 'predicate',
-      left: { kind: 'ref', key: 'this.name' },
-      op: 'contains',
-      right: { kind: 'literal', value: 'Alice' },
-    }
-    const result = extractPushdownFilters(node, seed)
-    expect(result).toHaveLength(1)
-    expect(result[0].conditions[0].op).toBe('contains')
-  })
-
-  it('root isempty predicate is pushed (no right operand)', () => {
-    const node: WhenNode = {
-      kind: 'predicate',
-      left: { kind: 'ref', key: 'this.name' },
-      op: 'isempty',
-    }
-    const result = extractPushdownFilters(node, seed)
-    expect(result).toHaveLength(1)
-    expect(result[0].conditions[0].op).toBe('is_empty')
-  })
-
-  it('root isnotempty predicate is pushed (no right operand)', () => {
-    const node: WhenNode = {
-      kind: 'predicate',
-      left: { kind: 'ref', key: 'this.name' },
-      op: 'isnotempty',
-    }
-    const result = extractPushdownFilters(node, seed)
-    expect(result).toHaveLength(1)
-    expect(result[0].conditions[0].op).toBe('is_not_empty')
-  })
-})
-
-// ---------------------------------------------------------------------------
-// AND group — only direct safe predicate children are pushed
-// ---------------------------------------------------------------------------
-
-describe('extractPushdownFilters — AND group', () => {
-  it('all safe AND children are pushed', () => {
-    const node: WhenNode = {
-      kind: 'group',
-      op: 'AND',
-      children: [
-        { kind: 'predicate', left: { kind: 'ref', key: 'this.status' }, op: 'eq', right: { kind: 'literal', value: 'paid' } },
-        { kind: 'predicate', left: { kind: 'ref', key: 'this.total' }, op: 'gt', right: { kind: 'literal', value: 100 } },
-      ],
-    }
-    const result = extractPushdownFilters(node, seed)
-    expect(result).toHaveLength(2)
-    expect(result.map((r) => r.column)).toContain('status')
-    expect(result.map((r) => r.column)).toContain('total')
-  })
-
-  it('mixed AND: unsafe children skipped, safe ones pushed', () => {
-    const node: WhenNode = {
-      kind: 'group',
-      op: 'AND',
-      children: [
-        { kind: 'predicate', left: { kind: 'ref', key: 'this.status' }, op: 'eq', right: { kind: 'literal', value: 'paid' } },
-        // gte is not in PUSHDOWN_OPS → skipped
-        { kind: 'predicate', left: { kind: 'ref', key: 'this.total' }, op: 'gte', right: { kind: 'literal', value: 100 } },
-      ],
-    }
-    const result = extractPushdownFilters(node, seed)
-    expect(result).toHaveLength(1)
-    expect(result[0].column).toBe('status')
-  })
-})
-
-// ---------------------------------------------------------------------------
-// Unsafe operators stay in-memory
-// ---------------------------------------------------------------------------
-
-describe('extractPushdownFilters — unsafe operators stay in-memory', () => {
-  for (const op of ['gte', 'lte', 'startswith', 'endswith', 'matches', 'in', 'notin'] as const) {
-    it(`${op} is NOT pushed`, () => {
-      const node: WhenNode = {
-        kind: 'predicate',
-        left: { kind: 'ref', key: 'this.status' },
-        op,
-        right: { kind: 'literal', value: 'x' },
-      }
-      expect(extractPushdownFilters(node, seed)).toHaveLength(0)
-    })
-  }
-})
-
-// ---------------------------------------------------------------------------
-// OR branches stay in-memory
-// ---------------------------------------------------------------------------
-
-describe('extractPushdownFilters — OR branches stay in-memory', () => {
-  it('OR root group returns []', () => {
-    const node: WhenNode = {
-      kind: 'group',
-      op: 'OR',
-      children: [
-        { kind: 'predicate', left: { kind: 'ref', key: 'this.status' }, op: 'eq', right: { kind: 'literal', value: 'paid' } },
-        { kind: 'predicate', left: { kind: 'ref', key: 'this.total' }, op: 'gt', right: { kind: 'literal', value: 100 } },
-      ],
-    }
-    expect(extractPushdownFilters(node, seed)).toHaveLength(0)
-  })
-
-  it('AND group with nested OR child: only direct predicate siblings are pushed', () => {
-    const node: WhenNode = {
-      kind: 'group',
-      op: 'AND',
-      children: [
-        { kind: 'predicate', left: { kind: 'ref', key: 'this.status' }, op: 'eq', right: { kind: 'literal', value: 'paid' } },
-        {
-          kind: 'group',
-          op: 'OR',
-          children: [
-            { kind: 'predicate', left: { kind: 'ref', key: 'this.total' }, op: 'gt', right: { kind: 'literal', value: 100 } },
-            { kind: 'predicate', left: { kind: 'ref', key: 'this.tag' }, op: 'eq', right: { kind: 'literal', value: 'gold' } },
-          ],
-        },
-      ],
-    }
-    const result = extractPushdownFilters(node, seed)
-    // Only the direct 'status' predicate is pushed; the nested OR group is skipped
-    expect(result).toHaveLength(1)
-    expect(result[0].column).toBe('status')
-  })
-})
-
-// ---------------------------------------------------------------------------
-// Negated group stays in-memory
-// ---------------------------------------------------------------------------
-
-describe('extractPushdownFilters — negated AND group stays in-memory', () => {
-  it('negated AND root returns []', () => {
-    const node: WhenNode = {
-      kind: 'group',
-      op: 'AND',
-      negate: true,
-      children: [
-        { kind: 'predicate', left: { kind: 'ref', key: 'this.status' }, op: 'eq', right: { kind: 'literal', value: 'paid' } },
-      ],
-    }
-    expect(extractPushdownFilters(node, seed)).toHaveLength(0)
-  })
-})
-
-// ---------------------------------------------------------------------------
-// Cross-seed refs stay in-memory
-// ---------------------------------------------------------------------------
-
-describe('extractPushdownFilters — cross-seed refs stay in-memory', () => {
-  it('ref not starting with this. is NOT pushed', () => {
-    const node: WhenNode = {
-      kind: 'predicate',
-      left: { kind: 'ref', key: 'customers:lastone:status' },
-      op: 'eq',
-      right: { kind: 'literal', value: 'active' },
-    }
-    expect(extractPushdownFilters(node, seed)).toHaveLength(0)
-  })
-
-  it('right operand is a ref (not literal) → NOT pushed', () => {
-    const node: WhenNode = {
-      kind: 'predicate',
-      left: { kind: 'ref', key: 'this.status' },
-      op: 'eq',
-      right: { kind: 'ref', key: 'customers:lastone:status' },
-    }
-    expect(extractPushdownFilters(node, seed)).toHaveLength(0)
-  })
-
-  it('literal left operand is NOT pushed', () => {
-    const node: WhenNode = {
-      kind: 'predicate',
-      left: { kind: 'literal', value: 'paid' },
-      op: 'eq',
-      right: { kind: 'literal', value: 'paid' },
-    }
-    expect(extractPushdownFilters(node, seed)).toHaveLength(0)
-  })
-})
-