Add single API endpoint to trigger all CRON jobs, avoiding need to upgrade Vercel plan atm

Author: webstackdev

playwright.config.ts

@@ -4,7 +4,10 @@ import { defineConfig, devices } from '@playwright/test'
  * Read environment variables from file.
  * https://github.com/motdotla/dotenv
  */
-import 'dotenv/config'
+import dotenv from 'dotenv'
+import { isCI } from 'src/lib/config/environmentServer'
+
+if ( !isCI() ) dotenv.config({ path: '.env.development' })
 
 /**
  * See https://playwright.dev/docs/test-configuration.

src/pages/api/cron/__tests__/runner.spec.ts

@@ -0,0 +1,119 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
+import type { APIRoute } from 'astro'
+import { GET as runAll } from '@pages/api/cron/run-all'
+
+const getCronSecretMock = vi.hoisted(() => vi.fn(() => 'cron-secret'))
+const getSiteUrlMock = vi.hoisted(() => vi.fn(() => 'https://example.com'))
+
+vi.mock('@pages/api/_environment/environmentApi', async () => {
+  const actual = await vi.importActual<typeof import('@pages/api/_environment/environmentApi')>(
+    '@pages/api/_environment/environmentApi',
+  )
+  return {
+    ...actual,
+    getCronSecret: getCronSecretMock,
+    getSiteUrl: getSiteUrlMock,
+  }
+})
+
+const buildContext = (request: Request) => ({
+  request,
+  clientAddress: '127.0.0.1',
+  cookies: {
+    get: () => undefined,
+  },
+})
+
+describe('cron runner', () => {
+  let fetchMock: ReturnType<typeof vi.fn>
+  let warnSpy: ReturnType<typeof vi.spyOn>
+
+  const run = (request: Request) => runAll(buildContext(request) as unknown as Parameters<APIRoute>[0])
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    fetchMock = vi.fn()
+    vi.stubGlobal('fetch', fetchMock)
+    warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+  })
+
+  afterEach(() => {
+    vi.unstubAllGlobals()
+    warnSpy.mockRestore()
+  })
+
+  const createResponse = (path: string, overrides?: Partial<Response>) =>
+    ({
+      ok: true,
+      status: 200,
+      statusText: 'OK',
+      headers: new Headers({ 'x-vercel-elapsed-time': '123' }),
+      json: vi.fn().mockResolvedValue({ path }),
+      text: vi.fn().mockResolvedValue(''),
+      ...overrides,
+    }) as unknown as Response
+
+  it('rejects unauthorized requests', async () => {
+    const request = new Request('https://example.com/api/cron/run-all')
+    const response = await run(request)
+    const body = await response.json()
+
+    expect(response.status).toBe(401)
+    expect(body.error.code).toBe('UNAUTHORIZED')
+    expect(fetchMock).not.toHaveBeenCalled()
+    expect(warnSpy).toHaveBeenCalled()
+  })
+
+  it('calls downstream cron endpoints sequentially', async () => {
+    fetchMock
+      .mockResolvedValueOnce(createResponse('/api/cron/cleanup-confirmations'))
+      .mockResolvedValueOnce(createResponse('/api/cron/cleanup-dsar-requests'))
+      .mockResolvedValueOnce(createResponse('/api/cron/ping-integrations'))
+
+    const request = new Request('https://example.com/api/cron/run-all', {
+      method: 'GET',
+      headers: {
+        authorization: 'Bearer cron-secret',
+      },
+    })
+
+    const response = await run(request)
+    const body = await response.json()
+
+    expect(response.status).toBe(200)
+    expect(Array.isArray(body.results)).toBe(true)
+    expect(body.results).toHaveLength(3)
+    expect(fetchMock).toHaveBeenCalledTimes(3)
+
+    const headersUsed = fetchMock.mock.calls[0]?.[1]?.headers as Record<string, string>
+    expect(headersUsed.Authorization ?? headersUsed.authorization).toBe('Bearer cron-secret')
+  })
+
+  it('surfaces downstream failure details', async () => {
+    fetchMock
+      .mockResolvedValueOnce(
+        createResponse('/api/cron/cleanup-confirmations', {
+          ok: false,
+          status: 500,
+          statusText: 'Internal Server Error',
+          headers: new Headers(),
+        }),
+      )
+      .mockResolvedValueOnce(createResponse('/api/cron/cleanup-dsar-requests'))
+      .mockResolvedValueOnce(createResponse('/api/cron/ping-integrations'))
+
+    const request = new Request('https://example.com/api/cron/run-all', {
+      method: 'GET',
+      headers: {
+        authorization: 'Bearer cron-secret',
+      },
+    })
+
+    const response = await run(request)
+    const body = await response.json()
+
+    expect(response.status).toBe(500)
+    expect(body.error.code).toBe('CRON_RUNNER_TARGET_FAILED')
+    expect(body.error.message).toBe('Cron runner failed to execute downstream jobs')
+  })
+})

src/pages/api/cron/run-all.ts

@@ -0,0 +1,115 @@
+import type { APIRoute } from 'astro'
+import { getCronSecret, getSiteUrl } from '@pages/api/_environment/environmentApi'
+import { ApiFunctionError } from '@pages/api/_errors/ApiFunctionError'
+import { buildApiErrorResponse, handleApiFunctionError } from '@pages/api/_errors/apiFunctionHandler'
+import { createApiFunctionContext } from '@pages/api/_utils/requestContext'
+
+export const prerender = false
+
+const ROUTE = '/api/cron/run-all'
+const CRON_ENDPOINTS = [
+  '/api/cron/cleanup-confirmations',
+  '/api/cron/cleanup-dsar-requests',
+  '/api/cron/ping-integrations',
+]
+
+const buildErrorResponse = (
+  error: unknown,
+  context: ReturnType<typeof createApiFunctionContext>['context'],
+  fallbackMessage: string,
+) => buildApiErrorResponse(handleApiFunctionError(error, context), { fallbackMessage })
+
+async function triggerCronEndpoint(path: string) {
+  const url = new URL(path, getSiteUrl())
+  const response = await fetch(url.toString(), {
+    headers: {
+      Authorization: `Bearer ${getCronSecret()}`,
+    },
+  })
+
+  const elapsedMs = response.headers.get('x-vercel-elapsed-time')
+  const duration = typeof elapsedMs === 'string' ? Number(elapsedMs) : undefined
+
+  let body: unknown
+
+  try {
+    body = await response.json()
+  } catch {
+    body = await response.text()
+  }
+
+  if (!response.ok) {
+    throw new ApiFunctionError(
+      `Cron runner failed for ${path}: ${response.status} ${response.statusText}`,
+      {
+        status: response.status,
+        code: 'CRON_RUNNER_TARGET_FAILED',
+        route: ROUTE,
+        operation: path,
+        details: {
+          body,
+        },
+      },
+    )
+  }
+
+  return {
+    path,
+    status: response.status,
+    durationMs: typeof duration === 'number' && Number.isFinite(duration) ? duration : undefined,
+    body,
+  }
+}
+
+export const GET: APIRoute = async ({ request, clientAddress, cookies }) => {
+  const { context: apiContext } = createApiFunctionContext({
+    route: ROUTE,
+    operation: 'GET',
+    request,
+    clientAddress,
+    cookies,
+  })
+
+  const authHeader = request.headers.get('authorization')
+  if (authHeader !== `Bearer ${getCronSecret()}`) {
+    console.warn('Unauthorized cron runner attempt - invalid CRON_SECRET')
+    apiContext.extra = {
+      ...(apiContext.extra || {}),
+      authHeader: authHeader ? 'PRESENT' : 'MISSING',
+      clientAddress,
+    }
+    return buildErrorResponse(
+      new ApiFunctionError({
+        message: 'Unauthorized',
+        status: 401,
+        code: 'UNAUTHORIZED',
+      }),
+      apiContext,
+      'Unauthorized cron access',
+    )
+  }
+
+  try {
+    const results = await Promise.all(CRON_ENDPOINTS.map(triggerCronEndpoint))
+
+    return new Response(
+      JSON.stringify({
+        success: true,
+        results,
+        timestamp: new Date().toISOString(),
+      }),
+      {
+        status: 200,
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      },
+    )
+  } catch (error) {
+    apiContext.extra = {
+      ...(apiContext.extra || {}),
+      authHeader: 'REDACTED',
+    }
+    return buildErrorResponse(error, apiContext, 'Cron runner failed to execute downstream jobs')
+  }
+}

vercel.json

@@ -4,16 +4,8 @@
   "regions": ["iad1"],
   "crons": [
     {
-      "path": "/api/cron/cleanup-confirmations",
+      "path": "/api/cron/run-all",
       "schedule": "0 2 * * *"
-    },
-    {
-      "path": "/api/cron/cleanup-dsar-requests",
-      "schedule": "0 3 * * *"
-    },
-    {
-      "path": "/api/cron/ping-integrations",
-      "schedule": "0 4 * * *"
     }
   ]
 }