Ping cron job for keep-alive with Upstash and Suprabase

Author: webstackdev

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

@@ -5,12 +5,15 @@ import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
 import type { APIRoute } from 'astro'
 import { GET as cleanupDsar } from '@pages/api/cron/cleanup-dsar-requests'
 import { GET as cleanupConfirmations } from '@pages/api/cron/cleanup-confirmations'
+import { GET as pingIntegrations } from '@pages/api/cron/ping-integrations'
 
 const supabaseAdminMock = vi.hoisted(() => ({
   from: vi.fn(),
 }))
 
 const getCronSecretMock = vi.hoisted(() => vi.fn(() => 'cron-secret'))
+const getUpstashApiUrlMock = vi.hoisted(() => vi.fn(() => 'https://example.upstash.io'))
+const getUpstashApiTokenMock = vi.hoisted(() => vi.fn(() => 'upstash-token'))
 
 vi.mock('@pages/api/_utils', () => ({
   supabaseAdmin: supabaseAdminMock,
@@ -23,6 +26,8 @@ vi.mock('@pages/api/_environment/environmentApi', async () => {
   return {
     ...actual,
     getCronSecret: getCronSecretMock,
+    getUpstashApiUrl: getUpstashApiUrlMock,
+    getUpstashApiToken: getUpstashApiTokenMock,
   }
 })
 
@@ -58,6 +63,30 @@ const createDeleteChain = (options?: { data?: unknown[]; error?: unknown }): Del
   return chain
 }
 
+type SelectChain = {
+  select: (...args: unknown[]) => SelectChain
+  limit: (...args: unknown[]) => Promise<{ data?: unknown[]; error?: unknown; count?: number }>
+}
+
+const createSelectChain = (options?: {
+  data?: unknown[]
+  error?: unknown
+  count?: number
+}): SelectChain => {
+  const response = {
+    data: options?.data ?? [],
+    error: options?.error ?? null,
+    count: options?.count ?? options?.data?.length ?? 0,
+  }
+
+  const chain: SelectChain = {
+    select: () => chain,
+    limit: () => Promise.resolve({ ...response }),
+  }
+
+  return chain
+}
+
 describe('Cron cleanup endpoints', () => {
   let warnSpy: ReturnType<typeof vi.spyOn>
   let logSpy: ReturnType<typeof vi.spyOn>
@@ -183,4 +212,115 @@ describe('Cron cleanup endpoints', () => {
       expect(body.error.code).toBe('CRON_DELETE_CONFIRMED_TOKENS_FAILED')
     })
   })
+
+  describe('ping-integrations', () => {
+    const run = (request: Request) =>
+      pingIntegrations(buildContext(request) as unknown as Parameters<APIRoute>[0])
+
+    let fetchMock: ReturnType<typeof vi.fn>
+
+    const buildRequest = (headers?: HeadersInit) =>
+      new Request('http://localhost/api/cron/ping-integrations', {
+        method: 'GET',
+        headers,
+      })
+
+    const createFetchResponse = (overrides?: Partial<Response>): Response => ({
+      ok: true,
+      status: 200,
+      json: vi.fn().mockResolvedValue({ result: null }),
+      text: vi.fn().mockResolvedValue(''),
+      headers: new Headers(),
+      redirected: false,
+      statusText: 'OK',
+      type: 'basic',
+      url: getUpstashApiUrlMock(),
+      clone: vi.fn(() => createFetchResponse(overrides)),
+      body: null,
+      bodyUsed: false,
+      arrayBuffer: vi.fn(),
+      blob: vi.fn(),
+      formData: vi.fn(),
+      ...overrides,
+    }) as unknown as Response
+
+    beforeEach(() => {
+      fetchMock = vi.fn()
+      vi.stubGlobal('fetch', fetchMock)
+    })
+
+    afterEach(() => {
+      vi.unstubAllGlobals()
+    })
+
+    it('rejects requests without valid secret', async () => {
+      const response = await run(buildRequest())
+      const body = await response.json()
+
+      expect(response.status).toBe(401)
+      expect(body.error.code).toBe('UNAUTHORIZED')
+      expect(fetchMock).not.toHaveBeenCalled()
+    })
+
+    it('pings Upstash and Supabase once authorized', async () => {
+      fetchMock.mockResolvedValue(createFetchResponse())
+      supabaseAdminMock.from.mockReturnValueOnce(createSelectChain({ count: 5 }))
+
+      const response = await run(
+        buildRequest({
+          authorization: 'Bearer cron-secret',
+        }),
+      )
+      const body = await response.json()
+
+      expect(response.status).toBe(200)
+      expect(body.success).toBe(true)
+      expect(typeof body.upstash.durationMs).toBe('number')
+      expect(body.supabase.rowsChecked).toBe(5)
+      expect(fetchMock).toHaveBeenCalledTimes(1)
+
+      const fetchArgs = fetchMock.mock.calls[0]![1] as RequestInit | undefined
+      const headers = fetchArgs?.headers as Record<string, string> | undefined
+      expect(headers?.Authorization ?? headers?.authorization).toBe('Bearer upstash-token')
+    })
+
+    it('returns upstream error details when Upstash responds with failure', async () => {
+      fetchMock.mockResolvedValue(
+        createFetchResponse({
+          ok: false,
+          status: 503,
+          statusText: 'Service Unavailable',
+          json: vi.fn().mockResolvedValue({ error: 'unavailable' }),
+        }),
+      )
+      supabaseAdminMock.from.mockReturnValueOnce(createSelectChain())
+
+      const response = await run(
+        buildRequest({
+          authorization: 'Bearer cron-secret',
+        }),
+      )
+      const body = await response.json()
+
+      expect(response.status).toBe(503)
+      expect(body.error.code).toBe('CRON_UPSTASH_PING_FAILED')
+    })
+
+    it('surfaces Supabase errors when ping fails', async () => {
+      fetchMock.mockResolvedValue(createFetchResponse())
+      supabaseAdminMock.from.mockReturnValueOnce(
+        createSelectChain({ error: { message: 'boom' } }),
+      )
+
+      const response = await run(
+        buildRequest({
+          authorization: 'Bearer cron-secret',
+        }),
+      )
+      const body = await response.json()
+
+      expect(response.status).toBe(500)
+      expect(body.error.code).toBe('CRON_SUPABASE_PING_FAILED')
+    })
+  })
 })

src/pages/api/cron/ping-integrations.ts

@@ -0,0 +1,143 @@
+/**
+ * Cron API Route to ping third-party integrations to keep them awake.
+ * Currently pings:
+ * - Upstash (key-value store)
+ * - Supabase (database)
+ */
+import type { APIRoute } from 'astro'
+import {
+  getCronSecret,
+  getUpstashApiToken,
+  getUpstashApiUrl,
+} from '@pages/api/_environment/environmentApi'
+import { supabaseAdmin } from '@pages/api/_utils'
+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/ping-integrations'
+const UPSTASH_KEY = '__cron_keepalive__'
+
+const buildErrorResponse = (
+  error: unknown,
+  context: ReturnType<typeof createApiFunctionContext>['context'],
+  fallbackMessage: string,
+) => buildApiErrorResponse(handleApiFunctionError(error, context), { fallbackMessage })
+
+const pingUpstash = async () => {
+  const start = Date.now()
+  const endpoint = new URL(`/get/${encodeURIComponent(UPSTASH_KEY)}`, getUpstashApiUrl())
+  const response = await fetch(endpoint.toString(), {
+    headers: {
+      Authorization: `Bearer ${getUpstashApiToken()}`,
+    },
+  })
+
+  if (!response.ok) {
+    throw new ApiFunctionError({
+      message: `Upstash ping failed with status ${response.status}`,
+      status: response.status,
+      code: 'CRON_UPSTASH_PING_FAILED',
+      route: ROUTE,
+      operation: 'pingUpstash',
+    })
+  }
+
+  let payload: unknown
+
+  try {
+    payload = await response.json()
+  } catch {
+    payload = await response.text()
+  }
+
+  return {
+    payload,
+    durationMs: Date.now() - start,
+  }
+}
+
+const pingSupabase = async () => {
+  const start = Date.now()
+  const { data, error, count } = await supabaseAdmin
+    .from('newsletter_confirmations')
+    .select('id', { count: 'exact' })
+    .limit(1)
+
+  if (error) {
+    throw new ApiFunctionError({
+      message: `Supabase ping failed: ${error.message ?? 'Unknown error'}`,
+      cause: error,
+      status: 500,
+      code: 'CRON_SUPABASE_PING_FAILED',
+      route: ROUTE,
+      operation: 'pingSupabase',
+    })
+  }
+
+  return {
+    rowsChecked: typeof count === 'number' ? count : data?.length ?? 0,
+    durationMs: Date.now() - start,
+  }
+}
+
+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 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 [upstashResult, supabaseResult] = await Promise.all([
+      pingUpstash(),
+      pingSupabase(),
+    ])
+
+    return new Response(
+      JSON.stringify({
+        success: true,
+        upstash: upstashResult,
+        supabase: supabaseResult,
+        timestamp: new Date().toISOString(),
+      }),
+      {
+        status: 200,
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      },
+    )
+  } catch (error) {
+    apiContext.extra = {
+      ...(apiContext.extra || {}),
+      authHeader: 'REDACTED',
+    }
+    return buildErrorResponse(error, apiContext, 'Failed to ping backing services')
+  }
+}

vercel.json

@@ -10,6 +10,10 @@
     {
       "path": "/api/cron/cleanup-dsar-requests",
       "schedule": "0 3 * * *"
+    },
+    {
+      "path": "/api/cron/ping-integrations",
+      "schedule": "0 4 * * *"
     }
   ]
 }