fix: add twirp catch-all with proxy support for unmatched paths (#237)

lib/proxy-agent.ts

@@ -0,0 +1,66 @@
+import { ProxyAgent } from 'undici'
+
+let proxyUrl: string | undefined
+let proxyAgent: ProxyAgent | undefined
+let noProxyPatterns: string[] = []
+
+function refreshConfig() {
+  proxyUrl =
+    process.env.HTTPS_PROXY ||
+    process.env.https_proxy ||
+    process.env.HTTP_PROXY ||
+    process.env.http_proxy
+
+  const raw = process.env.NO_PROXY || process.env.no_proxy || ''
+  noProxyPatterns = raw
+    .split(',')
+    .map((s) => s.trim().toLowerCase())
+    .filter(Boolean)
+
+  if (proxyUrl) {
+    proxyAgent = new ProxyAgent(proxyUrl, {
+      connect: {
+        rejectUnauthorized: false,
+      },
+    })
+  } else {
+    proxyAgent = undefined
+  }
+}
+
+function matchesNoProxy(hostname: string): boolean {
+  if (noProxyPatterns.length === 0) {
+    return false
+  }
+  const h = hostname.toLowerCase()
+  return noProxyPatterns.some((pattern) => {
+    if (pattern === '*') {
+      return true
+    }
+    if (pattern.startsWith('.')) {
+      return h === pattern.slice(1) || h.endsWith(pattern)
+    }
+    if (pattern.includes('*')) {
+      const regex = new RegExp(
+        '^' + pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*') + '$',
+      )
+      return regex.test(h)
+    }
+    return h === pattern || h.endsWith('.' + pattern)
+  })
+}
+
+export function getProxyDispatcher(url: string) {
+  refreshConfig()
+
+  if (!proxyUrl) {
+    return undefined
+  }
+
+  const hostname = new URL(url).hostname
+  if (matchesNoProxy(hostname)) {
+    return undefined
+  }
+
+  return proxyAgent
+}

package.json

@@ -53,6 +53,7 @@
     "remeda": "^2.33.6",
     "ts-pattern": "^5.9.0",
     "typescript": "^5.9.3",
+    "undici": "^8.3.0",
     "zod": "^4.3.6"
   },
   "devDependencies": {

routes/[...path].ts

@@ -1,7 +1,19 @@
+import { fetch as undiciFetch } from 'undici'
 import { env } from '~/lib/env'
 import { logger } from '~/lib/logger'
+import { getProxyDispatcher } from '~/lib/proxy-agent'
 
 export default defineEventHandler(async (event) => {
-  logger.debug('proxying unknown path', event.path, 'to', env.DEFAULT_ACTIONS_RESULTS_URL)
-  return proxyRequest(event, `${env.DEFAULT_ACTIONS_RESULTS_URL}${event.path}`)
+  const upstream = env.DEFAULT_ACTIONS_RESULTS_URL
+  const targetUrl = `${upstream}${event.path}`
+
+  logger.debug('proxying unknown path', event.path, 'to', upstream)
+
+  const fetchOptions: Record<string, unknown> = {}
+  const dispatcher = getProxyDispatcher(targetUrl)
+  if (dispatcher) {
+    fetchOptions.dispatcher = dispatcher
+  }
+
+  return proxyRequest(event, targetUrl, { fetch: undiciFetch, fetchOptions })
 })

routes/twirp/[...path].ts

@@ -0,0 +1,58 @@
+import { fetch as undiciFetch } from 'undici'
+import { env } from '~/lib/env'
+import { logger } from '~/lib/logger'
+import { getProxyDispatcher } from '~/lib/proxy-agent'
+
+const SKIP_HEADERS = new Set([
+  'content-length',
+  'host',
+  'connection',
+  'keep-alive',
+  'transfer-encoding',
+])
+
+export default defineEventHandler(async (event) => {
+  const upstream = env.DEFAULT_ACTIONS_RESULTS_URL
+  const targetUrl = `${upstream}${event.path}`
+
+  try {
+    logger.debug('proxying twirp path', event.path, 'to', upstream)
+
+    const dispatcher = getProxyDispatcher(targetUrl)
+
+    const headers: Record<string, string> = {}
+    for (const [key, value] of Object.entries(getRequestHeaders(event))) {
+      if (!SKIP_HEADERS.has(key.toLowerCase()) && typeof value === 'string') {
+        headers[key] = value
+      }
+    }
+
+    const body = await readRawBody(event, false).catch(() => undefined)
+    const res = await undiciFetch(targetUrl, {
+      method: event.method,
+      headers,
+      body: body || undefined,
+      signal: AbortSignal.timeout(5000),
+      ...(dispatcher ? { dispatcher } : {}),
+    })
+
+    setResponseStatus(event, res.status, res.statusText)
+    for (const [key, value] of res.headers) {
+      setResponseHeader(event, key, value)
+    }
+    return res.body
+  } catch (err) {
+    logger.warn(
+      'twirp proxy failed for',
+      event.path,
+      '- returning stub 200',
+      err,
+    )
+
+    const contentType =
+      getRequestHeader(event, 'content-type') || 'application/protobuf'
+    setResponseHeader(event, 'content-type', contentType)
+    setResponseStatus(event, 200)
+    return ''
+  }
+})

tests/twirp-catchall.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, test } from 'vitest'
+
+describe('twirp catch-all route', () => {
+  test(
+    'unmatched twirp paths should not return 404',
+    { timeout: 10_000 },
+    async () => {
+      const res = await fetch(
+        `${process.env.API_BASE_URL}/twirp/github.actions.results.api.v1.ArtifactService/CreateArtifact`,
+        {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: '{}',
+        },
+      )
+      expect(res.status).toBe(200)
+    },
+  )
+})