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

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

@@ -1,264 +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 { 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', body_template: '{}' }],
-  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', body_template: '{}' }],
-      }),
-    })
-    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', body_template: '{}' }],
-      }),
-    })
-    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

@@ -1,163 +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 } 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

@@ -1,224 +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 {
-  createAutomationSchema,
-  updateAutomationSchema,
-  toggleAutomationSchema,
-} from '../automations.schema'
-
-const validWebhookAction = { type: 'webhook' as const, url: 'https://example.com/hook', body_template: '{}' }
-
-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', body_template: '{}' }],
-    })
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects webhook with HTTP url (not HTTPS)', () => {
-    const result = createAutomationSchema.safeParse({
-      ...minimalValid,
-      actions: [{ type: 'webhook', url: 'http://example.com', body_template: '{}' }],
-    })
-    expect(result.success).toBe(false)
-    const issues = result.error?.issues ?? []
-    expect(issues.some((i) => i.message === 'automations.editor.errors.webhookHttpsRequired')).toBe(true)
-  })
-
-  it('rejects webhook with localhost url', () => {
-    const result = createAutomationSchema.safeParse({
-      ...minimalValid,
-      actions: [{ type: 'webhook', url: 'https://localhost/x', body_template: '{}' }],
-    })
-    expect(result.success).toBe(false)
-    const issues = result.error?.issues ?? []
-    expect(issues.some((i) => i.message === 'automations.editor.errors.webhookPrivateHostBlocked')).toBe(true)
-  })
-
-  it('rejects webhook with 127.0.0.1', () => {
-    const result = createAutomationSchema.safeParse({
-      ...minimalValid,
-      actions: [{ type: 'webhook', url: 'https://127.0.0.1/x', body_template: '{}' }],
-    })
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects webhook with AWS metadata IP (169.254.169.254)', () => {
-    const result = createAutomationSchema.safeParse({
-      ...minimalValid,
-      actions: [{ type: 'webhook', url: 'https://169.254.169.254/x', body_template: '{}' }],
-    })
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects webhook with 10.x.x.x private IP', () => {
-    const result = createAutomationSchema.safeParse({
-      ...minimalValid,
-      actions: [{ type: 'webhook', url: 'https://10.0.0.5/x', body_template: '{}' }],
-    })
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects webhook with 192.168.x.x private IP', () => {
-    const result = createAutomationSchema.safeParse({
-      ...minimalValid,
-      actions: [{ type: 'webhook', url: 'https://192.168.1.1/x', body_template: '{}' }],
-    })
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects webhook with 172.16.x.x private IP', () => {
-    const result = createAutomationSchema.safeParse({
-      ...minimalValid,
-      actions: [{ type: 'webhook', url: 'https://172.16.0.1/x', body_template: '{}' }],
-    })
-    expect(result.success).toBe(false)
-  })
-
-  it('accepts webhook with 172.32.x.x (outside private range)', () => {
-    const result = createAutomationSchema.safeParse({
-      ...minimalValid,
-      actions: [{ type: 'webhook', url: 'https://172.32.0.1/x', body_template: '{}' }],
-    })
-    expect(result.success).toBe(true)
-  })
-
-  it('rejects webhook without body_template', () => {
-    const result = createAutomationSchema.safeParse({
-      ...minimalValid,
-      actions: [{ type: 'webhook', url: 'https://example.com/x' }],
-    })
-    expect(result.success).toBe(false)
-    const issues = result.error?.issues ?? []
-    expect(issues.some((i) => i.message === 'automations.editor.errors.bodyRequired')).toBe(true)
-  })
-
-  it('accepts webhook with valid HTTPS public url and body_template', () => {
-    const result = createAutomationSchema.safeParse({
-      ...minimalValid,
-      actions: [{ type: 'webhook', url: 'https://example.com/x', body_template: '{}' }],
-    })
-    expect(result.success).toBe(true)
-  })
-
-  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)
-  })
-})