@beechcms/api 0.4.0 → 0.4.2

package/src/factory.ts

@@ -3,24 +3,19 @@ import { Hono } from 'hono'
 import { cors } from 'hono/cors'
 import { getCookie, setCookie, deleteCookie } from 'hono/cookie'
 import type { Seed, ContentRepository, IdempotencyRepository, BeechBucket, MediaRepository, SystemStatsRepository } from '@beechcms/core'
+import { sha256hex, SystemClock, SystemIdGenerator, SeedRegistry } from '@beechcms/core'
 import type { Env, Variables } from './types'
+import { getClientIp } from './shared/request-utils'
 
 // Imports delle rotte e middleware
 import { AUTH_ERRORS } from './auth/constants'
 import {
   parseLoginBody,
   validateLoginInput,
-  findUserByEmail,
   verifyPassword,
   DUMMY_PASSWORD_HASH,
 } from './auth/login'
-import {
-  generateRefreshToken,
-  saveRefreshToken,
-  generateAccessToken,
-  validateRefreshToken,
-  revokeRefreshToken,
-} from './auth/refresh'
+import { generateRefreshToken } from './auth/refresh'
 import { authMiddleware } from './middleware'
 import contentFeature from './features/content'
 import { widgetApp } from './widget'
@@ -31,12 +26,16 @@ import { draftApp } from './features/draft'
 import { settingsApp } from './features/settings/settings.handler'
 import { schemaApp } from './features/schema/schema.handler'
 import { notificationsApp } from './features/notifications'
+import { automationsApp } from './features/automations'
 import { statsApp } from './features/stats'
 import { uploadRoutes, serveMediaHandler } from './upload'
 import { publicRoutes, apiKeyMiddleware, publicRateLimitMiddleware } from './public'
 import { searchRouter } from "./search"
 import { repositoryMiddleware } from './middleware/repository.middleware'
 import { storageMiddleware } from './middleware/storage.middleware'
+import { authProvidersMiddleware } from './middleware/auth-providers.middleware'
+import { rateLimiterMiddleware } from './middleware/rate-limit.middleware'
+import { observabilityMiddleware } from './middleware/observability.middleware'
 
 export interface BeechConfig {
   seeds: Seed[] | Record<string, Seed>
@@ -55,10 +54,6 @@ function isRequestSecure(url: string): boolean {
   return new URL(url).protocol === 'https:'
 }
 
-function getClientIp(headers: Headers): string {
-  return headers.get('cf-connecting-ip') ?? 'unknown'
-}
-
 function getRefreshTokenCookieOptions(secure: boolean) {
   return {
     httpOnly: true,
@@ -98,15 +93,14 @@ export function createBeechApp(config: BeechConfig): Hono<{ Bindings: Env; Varia
   const seedsArray = Array.isArray(config.seeds) ? config.seeds : Object.values(config.seeds)
   // Filter out any invalid objects that might have leaked into the registry (e.g. module exports)
   const validSeeds = seedsArray.filter(s => s && typeof s === 'object' && 'slug' in s)
-  const registry: Record<string, Seed> = Object.fromEntries(validSeeds.map(s => [s.slug, s]))
-  const getSeedFn = (slug: string): Seed | null => registry[slug] ?? null
+  const seedRegistry = new SeedRegistry(validSeeds)
 
   const app = new Hono<{ Bindings: Env; Variables: Variables }>()
 
   // 1. Core Middleware (Seeds, CORS, Security)
   app.use('*', async (context, next) => {
-    context.set('getSeed', getSeedFn)
-    context.set('seedRegistry', registry)
+    context.set('getSeed', (slug: string) => seedRegistry.get(slug))
+    context.set('seedRegistry', seedRegistry)
     await next()
   })
 
@@ -122,6 +116,10 @@ export function createBeechApp(config: BeechConfig): Hono<{ Bindings: Env; Varia
     bucket: config.bucket,
   }))
 
+  app.use('*', authProvidersMiddleware())
+  app.use('*', rateLimiterMiddleware())
+  app.use('*', observabilityMiddleware())
+
   app.use('*', async (context, next) => {
     const isDev = context.env.ENV !== 'production'
 
@@ -174,27 +172,23 @@ export function createBeechApp(config: BeechConfig): Hono<{ Bindings: Env; Varia
   // 2. Analytics Middleware
   app.use('/api/*', async (context, next) => {
     await next()
-    if (context.req.method !== 'OPTIONS' && context.res.status >= 200 && context.res.status < 300) {
-      const db = context.env.DB
-      let executionCtx: any
-      try { executionCtx = context.executionCtx } catch {}
-
-      if (db && executionCtx) {
-        const seed = extractPublicSeed(context.req.path)
-        executionCtx.waitUntil((async () => {
-          try {
-            const today = Math.floor(new Date().setHours(0, 0, 0, 0) / 1000)
-            await db.prepare(
-              `INSERT INTO analytics (day_ts, metric, seed, value)
-               VALUES (?, 'requests', ?, 1)
-               ON CONFLICT(day_ts, metric, seed) DO UPDATE SET value = value + 1`
-            ).bind(today, seed).run()
-          } catch (error) {
-            console.error('Analytics middleware error:', error)
-          }
-        })())
-      }
-    }
+    if (context.req.method === 'OPTIONS') return
+    if (context.res.status < 200 || context.res.status >= 300) return
+
+    let executionCtx: any
+    try { executionCtx = context.executionCtx } catch {}
+    if (!executionCtx) return
+
+    const analyticsRepository = context.get('analyticsRepository')
+    if (!analyticsRepository) return
+
+    const seedSlug = extractPublicSeed(context.req.path)
+
+    executionCtx.waitUntil(
+      analyticsRepository.recordRequest(seedSlug).catch((error: unknown) => {
+        console.error('Analytics middleware error:', error)
+      })
+    )
   })
 
   // 3. Auth Routes
@@ -207,28 +201,27 @@ export function createBeechApp(config: BeechConfig): Hono<{ Bindings: Env; Varia
       const { email, password } = credentials
       if (!validateLoginInput(email, password)) return context.json({ error: AUTH_ERRORS.INVALID_REQUEST }, 400)
 
-      const loginLimiter = context.env.LOGIN_RATE_LIMITER
-      if (loginLimiter) {
-        const clientIp = getClientIp(context.req.raw.headers)
-        const { success } = await loginLimiter.limit({ key: `${clientIp}:${email}` })
-        if (!success) return context.json({ error: AUTH_ERRORS.RATE_LIMIT_EXCEEDED }, 429)
-      }
+      const clientIp = getClientIp(context.req)
+      const loginRateLimit = await context.get('rateLimiters').getLimiter('login').checkLimit(clientIp)
+      if (!loginRateLimit.isAllowed) return context.json({ error: AUTH_ERRORS.RATE_LIMIT_EXCEEDED }, 429)
 
-      const { DB, JWT_SECRET } = context.env
-      const user = await findUserByEmail(DB, email)
-      const hashToCompare = user?.password_hash ?? DUMMY_PASSWORD_HASH
-      const isValid = await verifyPassword(password, hashToCompare)
+      const user = await context.get('userRepository').findByEmail(email)
+      const hashToCompare = user?.passwordHash ?? DUMMY_PASSWORD_HASH
+      const isValid = await verifyPassword(password, hashToCompare, context.get('hashProvider'))
 
       if (!user || !isValid) return context.json({ error: AUTH_ERRORS.INVALID_CREDENTIALS }, 401)
 
-      const userProfile = await DB.prepare('SELECT name FROM users WHERE id = ? LIMIT 1').bind(user.id).first<{ name: string | null }>()
-      const accessToken = await generateAccessToken(user.id, user.email, JWT_SECRET, {
-        issuer: context.env.JWT_ISSUER,
-        audience: context.env.JWT_AUDIENCE,
-      }, userProfile?.name ?? undefined)
+      const accessToken = await context.get('tokenService').issue({ sub: user.id, email: user.email, name: user.name ?? undefined })
       const refreshToken = generateRefreshToken()
-
-      await saveRefreshToken(DB, user.id, refreshToken, REFRESH_TOKEN_EXPIRY_DAYS)
+      const refreshTokenHash = await sha256hex(refreshToken)
+      const nowSeconds = SystemClock.nowSeconds()
+
+      await context.get('sessionRepository').saveRefreshToken({
+        id: SystemIdGenerator.uuid(),
+        userId: user.id,
+        tokenHash: refreshTokenHash,
+        expiresAt: nowSeconds + REFRESH_TOKEN_EXPIRY_DAYS * SECONDS_PER_DAY,
+      })
       setCookie(context, 'refresh_token', refreshToken, getRefreshTokenCookieOptions(isRequestSecure(context.req.url)))
       return context.json({ token: accessToken, expiresIn: '15m' }, 200)
     } catch (error) {
@@ -238,33 +231,40 @@ export function createBeechApp(config: BeechConfig): Hono<{ Bindings: Env; Varia
 
   app.post('/auth/refresh', async (context) => {
     try {
-      const refreshLimiter = context.env.REFRESH_RATE_LIMITER
-      if (refreshLimiter) {
-        const clientIp = getClientIp(context.req.raw.headers)
-        const { success } = await refreshLimiter.limit({ key: clientIp })
-        if (!success) return context.json({ error: AUTH_ERRORS.RATE_LIMIT_EXCEEDED }, 429)
-      }
+      const refreshClientIp = getClientIp(context.req)
+      const refreshRateLimit = await context.get('rateLimiters').getLimiter('tokenRefresh').checkLimit(refreshClientIp)
+      if (!refreshRateLimit.isAllowed) return context.json({ error: AUTH_ERRORS.RATE_LIMIT_EXCEEDED }, 429)
 
       const refreshToken = getCookie(context, 'refresh_token')
       if (!refreshToken) return context.json({ error: 'Refresh token missing' }, 401)
 
-      const { DB, JWT_SECRET } = context.env
-      const validation = await validateRefreshToken(DB, refreshToken)
-      if (!validation.valid || !validation.userId) return context.json({ error: 'Invalid refresh token' }, 401)
+      const nowSeconds = SystemClock.nowSeconds()
+      const tokenHash = await sha256hex(refreshToken)
+      const activeSession = await context.get('sessionRepository').findActiveByHash(tokenHash, nowSeconds)
+      if (!activeSession) return context.json({ error: 'Invalid refresh token' }, 401)
 
-      const user = await DB.prepare('SELECT id, email, name FROM users WHERE id = ? LIMIT 1').bind(validation.userId).first<{ id: string; email: string; name: string | null }>()
-      if (!user) return context.json({ error: 'User not found' }, 401)
-
-      const revoked = await revokeRefreshToken(DB, refreshToken)
-      if (!revoked) return context.json({ error: 'Invalid refresh token' }, 401)
+      const user = await context.get('userRepository').findById(activeSession.userId)
+      if (!user) {
+        await context.get('sessionRepository').revokeByHash(tokenHash, nowSeconds)
+        return context.json({ error: 'User not found' }, 401)
+      }
 
-      const newAccessToken = await generateAccessToken(user.id, user.email, JWT_SECRET, {
-        issuer: context.env.JWT_ISSUER,
-        audience: context.env.JWT_AUDIENCE,
-      }, user.name ?? undefined)
+      // Issue new tokens before revoking the old one: if saveRefreshToken fails,
+      // the old token stays valid and the user is not locked out.
+      const newAccessToken = await context.get('tokenService').issue({ sub: user.id, email: user.email, name: user.name ?? undefined })
       const newRefreshToken = generateRefreshToken()
+      const newRefreshTokenHash = await sha256hex(newRefreshToken)
+
+      await context.get('sessionRepository').saveRefreshToken({
+        id: SystemIdGenerator.uuid(),
+        userId: user.id,
+        tokenHash: newRefreshTokenHash,
+        expiresAt: nowSeconds + REFRESH_TOKEN_EXPIRY_DAYS * SECONDS_PER_DAY,
+      })
+
+      const revoked = await context.get('sessionRepository').revokeByHash(tokenHash, nowSeconds)
+      if (!revoked) return context.json({ error: 'Invalid refresh token' }, 401)
 
-      await saveRefreshToken(DB, user.id, newRefreshToken, REFRESH_TOKEN_EXPIRY_DAYS)
       setCookie(context, 'refresh_token', newRefreshToken, getRefreshTokenCookieOptions(isRequestSecure(context.req.url)))
       return context.json({ token: newAccessToken, expiresIn: '15m' }, 200)
     } catch (error) {
@@ -275,7 +275,11 @@ export function createBeechApp(config: BeechConfig): Hono<{ Bindings: Env; Varia
   app.post('/auth/logout', async (context) => {
     try {
       const refreshToken = getCookie(context, 'refresh_token')
-      if (refreshToken) await revokeRefreshToken(context.env.DB, refreshToken)
+      if (refreshToken) {
+        const nowSeconds = SystemClock.nowSeconds()
+        const tokenHash = await sha256hex(refreshToken)
+        await context.get('sessionRepository').revokeByHash(tokenHash, nowSeconds)
+      }
       deleteCookie(context, 'refresh_token', getRefreshTokenDeleteCookieOptions(isRequestSecure(context.req.url)))
       return context.json({ message: 'Logged out' }, 200)
     } catch (error) {
@@ -289,12 +293,7 @@ export function createBeechApp(config: BeechConfig): Hono<{ Bindings: Env; Varia
 
   // 5. Protected CMS API
   const apiProtected = new Hono<{ Bindings: Env; Variables: Variables }>()
-  apiProtected.use('*', async (context, next) => {
-    await authMiddleware(context.env.JWT_SECRET, {
-      issuer: context.env.JWT_ISSUER,
-      audience: context.env.JWT_AUDIENCE,
-    })(context, next)
-  })
+  apiProtected.use('*', authMiddleware())
 
   apiProtected.route('/settings', settingsApp)
   apiProtected.route('/schema', schemaApp)
@@ -304,6 +303,7 @@ export function createBeechApp(config: BeechConfig): Hono<{ Bindings: Env; Varia
   apiProtected.route('/content', draftApp)
   apiProtected.route('/content', contentFeature)
   apiProtected.route('/widget', widgetApp)
+  apiProtected.route('/automations', automationsApp)
   apiProtected.route('/', uploadRoutes)
   
   // 6. Public API (must be registered before apiProtected to avoid auth middleware interception)

package/src/features/automations/__tests__/action-executors.test.ts

@@ -0,0 +1,268 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { executeAction } from '../action-executors'
+import type { ActionContext } from '../action-executors'
+import type { ContentRepository, Seed, IIdGenerator } from '@beechcms/core'
+
+// ── Shared mock context factory ───────────────────────────────────────────────
+
+function makeCtx(overrides: Partial<ActionContext> = {}): ActionContext {
+  const { entry: entryOverride, context: contextOverride, ...rest } = overrides
+  const entry: Record<string, unknown> = entryOverride ?? { id: 'entry-1', title: 'Test Entry', status: 'published' }
+  const context = contextOverride ?? {
+    triggerEntry: entry,
+    lookup(parsed: import('../template-grammar').ParsedKey, onMissing?: (f: string) => void) {
+      if (parsed.kind === 'simple') {
+        const val = entry[parsed.path]
+        if (val == null && onMissing) onMissing(parsed.path)
+        return val
+      }
+      if (parsed.kind === 'scoped' && parsed.scope === 'this' && parsed.field) {
+        return entry[parsed.field]
+      }
+      return undefined
+    },
+  }
+  return {
+    entry,
+    env: { RESEND_API_KEY: 'test-key', EMAIL_FROM: 'test@example.com' },
+    repository: {
+      update: vi.fn().mockResolvedValue(undefined),
+      create: vi.fn().mockResolvedValue(undefined),
+    } as unknown as ContentRepository,
+    getSeed: vi.fn().mockReturnValue({ branches: [] } as unknown as Seed),
+    seed: { slug: 'posts', branches: [] } as unknown as Seed,
+    idGenerator: { uuid: vi.fn().mockReturnValue('new-id-123') } as unknown as IIdGenerator,
+    context,
+    variables: {},
+    ...rest,
+  }
+}
+
+// ── webhook ───────────────────────────────────────────────────────────────────
+
+describe('webhook executor', () => {
+  beforeEach(() => { vi.restoreAllMocks() })
+
+  it('POSTs to URL with JSON body derived from entry when no body_template', async () => {
+    const fetchMock = vi.fn().mockResolvedValue({ ok: true, status: 200 })
+    vi.stubGlobal('fetch', fetchMock)
+
+    const ctx = makeCtx()
+    await executeAction({ type: 'webhook', url: 'https://example.com/hook' }, ctx)
+
+    expect(fetchMock).toHaveBeenCalledOnce()
+    const [url, init] = fetchMock.mock.calls[0]
+    expect(url).toBe('https://example.com/hook')
+    expect(init.method).toBe('POST')
+    expect(JSON.parse(init.body)).toMatchObject({ id: 'entry-1', title: 'Test Entry' })
+  })
+
+  it('interpolates body_template with entry values', async () => {
+    const fetchMock = vi.fn().mockResolvedValue({ ok: true })
+    vi.stubGlobal('fetch', fetchMock)
+
+    const ctx = makeCtx()
+    await executeAction({ type: 'webhook', url: 'https://example.com/hook', body_template: '{"t":"{{title}}"}' }, ctx)
+
+    const [, init] = fetchMock.mock.calls[0]
+    expect(init.body).toBe('{"t":"Test Entry"}')
+  })
+
+  it('merges custom headers', async () => {
+    const fetchMock = vi.fn().mockResolvedValue({ ok: true })
+    vi.stubGlobal('fetch', fetchMock)
+
+    const ctx = makeCtx()
+    await executeAction({ type: 'webhook', url: 'https://x.com', headers: { 'X-Token': 'abc' } }, ctx)
+
+    const [, init] = fetchMock.mock.calls[0]
+    expect(init.headers['X-Token']).toBe('abc')
+  })
+
+  it('throws when response is not ok', async () => {
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({ ok: false, status: 500 }))
+    const ctx = makeCtx()
+    await expect(executeAction({ type: 'webhook', url: 'https://x.com' }, ctx)).rejects.toThrow('500')
+  })
+
+  it('uses custom HTTP method', async () => {
+    const fetchMock = vi.fn().mockResolvedValue({ ok: true })
+    vi.stubGlobal('fetch', fetchMock)
+    const ctx = makeCtx()
+    await executeAction({ type: 'webhook', url: 'https://x.com', method: 'PUT' }, ctx)
+    expect(fetchMock.mock.calls[0][1].method).toBe('PUT')
+  })
+})
+
+// ── send_mail ─────────────────────────────────────────────────────────────────
+
+vi.mock('../../email', () => ({
+  sendAutomationMail: vi.fn().mockResolvedValue(undefined),
+}))
+
+describe('send_mail executor', () => {
+  beforeEach(async () => {
+    const { sendAutomationMail } = await import('../../email')
+    vi.mocked(sendAutomationMail).mockClear()
+  })
+
+  it('interpolates to/subject/body and calls sendAutomationMail', async () => {
+    const { sendAutomationMail } = await import('../../email')
+    const ctx = makeCtx({ entry: { id: '1', email: 'user@example.com', title: 'Hello' } })
+
+    await executeAction(
+      {
+        type: 'send_mail',
+        to: '{{email}}',
+        subject_template: 'Re: {{title}}',
+        body_template: 'Your entry {{title}} was created.',
+      },
+      ctx,
+    )
+
+    expect(sendAutomationMail).toHaveBeenCalledWith(
+      expect.objectContaining({
+        to: 'user@example.com',
+        subject: 'Re: Hello',
+        body: 'Your entry Hello was created.',
+      }),
+    )
+  })
+
+  it('substitutes default value [missing] and logs a warning when concrete data is absent', async () => {
+    const { sendAutomationMail } = await import('../../email')
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    const ctx = makeCtx({ entry: { id: '1' } })
+
+    await executeAction(
+      {
+        type: 'send_mail',
+        to: '{{email}}',
+        subject_template: 'Re: {{title}}',
+        body_template: 'Content: {{desc}}',
+      },
+      ctx,
+    )
+
+    expect(sendAutomationMail).toHaveBeenCalledWith(
+      expect.objectContaining({
+        to: '[missing]',
+        subject: 'Re: [missing]',
+        body: 'Content: [missing]',
+      }),
+    )
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringContaining('missing concrete data'),
+      ['email', 'title', 'desc'],
+    )
+  })
+
+  it('skips execution gracefully and logs an error without calling sendAutomationMail if apiKey is missing', async () => {
+    const { sendAutomationMail } = await import('../../email')
+    const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+    const ctx = makeCtx({ env: {} }) // missing email/resend api keys
+
+    await executeAction(
+      {
+        type: 'send_mail',
+        to: 'user@beech.io',
+        subject_template: 'Hello',
+        body_template: 'World',
+      },
+      ctx,
+    )
+
+    expect(sendAutomationMail).not.toHaveBeenCalled()
+    expect(errSpy).toHaveBeenCalledWith(expect.stringContaining('Execution skipped'))
+  })
+
+  it('logs error and rethrows when sendAutomationMail fails', async () => {
+    const { sendAutomationMail } = await import('../../email')
+    vi.mocked(sendAutomationMail).mockRejectedValueOnce(new Error('provider error'))
+    const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+    const ctx = makeCtx()
+
+    await expect(
+      executeAction(
+        {
+          type: 'send_mail',
+          to: 'test@beech.io',
+          subject_template: 'Hello',
+          body_template: 'World',
+        },
+        ctx,
+      ),
+    ).rejects.toThrow('provider error')
+
+    expect(errSpy).toHaveBeenCalledWith(
+      expect.stringContaining('failed to send automation email'),
+      expect.any(Error),
+    )
+  })
+})
+
+// ── edit_field ────────────────────────────────────────────────────────────────
+
+describe('edit_field executor', () => {
+  it('calls repository.update with interpolated string value', async () => {
+    const ctx = makeCtx({ entry: { id: 'entry-1', title: 'Old Title' } })
+    await executeAction({ type: 'edit_field', field: 'summary', value: 'Based on {{title}}' }, ctx)
+    expect(ctx.repository.update).toHaveBeenCalledWith(ctx.seed, 'entry-1', { summary: 'Based on Old Title' })
+  })
+
+  it('calls repository.update with raw non-string value', async () => {
+    const ctx = makeCtx({ entry: { id: 'entry-1', title: 'T' } })
+    await executeAction({ type: 'edit_field', field: 'count', value: 42 }, ctx)
+    expect(ctx.repository.update).toHaveBeenCalledWith(ctx.seed, 'entry-1', { count: 42 })
+  })
+
+  it('throws when entry.id is missing', async () => {
+    const ctx = makeCtx({ entry: { title: 'No ID' } })
+    await expect(executeAction({ type: 'edit_field', field: 'x', value: 'y' }, ctx)).rejects.toThrow('entry.id missing')
+  })
+})
+
+// ── create_entry ──────────────────────────────────────────────────────────────
+
+describe('create_entry executor', () => {
+  it('creates a new entry with field_map values from trigger entry', async () => {
+    const ctx = makeCtx({ entry: { id: 'e1', author: 'Alice' } })
+    await executeAction(
+      { type: 'create_entry', seed_slug: 'comments', field_map: { writer: 'author', fixed: 'literal-value' } },
+      ctx,
+    )
+    expect(ctx.idGenerator.uuid).toHaveBeenCalled()
+    expect(ctx.repository.create).toHaveBeenCalledWith(
+      expect.anything(),
+      'new-id-123',
+      'new-id-123',
+      'draft',
+      { writer: 'Alice', fixed: 'literal-value' },
+    )
+  })
+
+  it('uses literal string when source field is not in entry', async () => {
+    const ctx = makeCtx({ entry: { id: 'e1' } })
+    await executeAction(
+      { type: 'create_entry', seed_slug: 'comments', field_map: { tag: 'missing-field' } },
+      ctx,
+    )
+    expect(ctx.repository.create).toHaveBeenCalledWith(
+      expect.anything(), 'new-id-123', 'new-id-123', 'draft',
+      { tag: 'missing-field' },
+    )
+  })
+
+  it('throws when seed not found', async () => {
+    const ctx = makeCtx({ getSeed: vi.fn().mockReturnValue(null) })
+    await expect(
+      executeAction({ type: 'create_entry', seed_slug: 'unknown', field_map: {} }, ctx),
+    ).rejects.toThrow('unknown seed unknown')
+  })
+
+  it('throws error for unknown action type to cover exhaustive default check', async () => {
+    const ctx = makeCtx()
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    await expect(executeAction({ type: 'unknown_custom_action' } as any, ctx)).rejects.toThrow('unknown action type')
+  })
+})