mppx 0.8.17 → 0.8.18

package/src/server/NodeListener.test.ts

@@ -1,293 +0,0 @@
-import { EventEmitter } from 'node:events'
-import type { IncomingMessage, ServerResponse } from 'node:http'
-
-import { Mppx, NodeListener, Request } from 'mppx/server'
-import { afterEach, describe, expect, test } from 'vp/test'
-import * as Http from '~test/Http.js'
-
-let server: Awaited<ReturnType<typeof Http.createServer>> | undefined
-
-afterEach(() => server?.close())
-
-function createMockRequest(options: {
-  method?: string
-  url?: string
-  rawHeaders?: string[]
-}): [
-  IncomingMessage,
-  ServerResponse & { body: Buffer[]; headers?: Record<string, string | string[]> },
-] {
-  type MockResponse = ServerResponse & {
-    body: Buffer[]
-    headers?: Record<string, string | string[]>
-  }
-
-  const rawHeaders = options.rawHeaders ?? []
-  const headers = Object.fromEntries(
-    rawHeaders.reduce<[string, string][]>((acc, value, index, values) => {
-      if (index % 2 === 0 && values[index + 1]) acc.push([value.toLowerCase(), values[index + 1]!])
-      return acc
-    }, []),
-  )
-  const req = Object.assign(new EventEmitter(), {
-    method: options.method ?? 'GET',
-    url: options.url ?? '/',
-    headers,
-    rawHeaders,
-    socket: {},
-  }) as unknown as IncomingMessage
-
-  const res = Object.assign(new EventEmitter(), {
-    req,
-    body: [] as Buffer[],
-    writeHead(
-      this: MockResponse,
-      _statusCode: number,
-      statusMessageOrHeaders?: string | Record<string, string | string[]>,
-      headersMaybe?: Record<string, string | string[]>,
-    ) {
-      this.headers =
-        typeof statusMessageOrHeaders === 'string'
-          ? (headersMaybe ?? {})
-          : (statusMessageOrHeaders ?? {})
-      return this
-    },
-    write(this: MockResponse, chunk: Uint8Array | string) {
-      this.body.push(Buffer.from(chunk))
-      return true
-    },
-    end(this: MockResponse, chunk?: Uint8Array | string) {
-      if (chunk) this.body.push(Buffer.from(chunk))
-      this.emit('finish')
-      return this
-    },
-  }) as unknown as MockResponse
-
-  return [req, res]
-}
-
-describe('sendResponse', () => {
-  test('writes status and headers', async () => {
-    server = await Http.createServer(async (_, res) => {
-      const response = new Response(null, {
-        status: 204,
-        headers: { 'X-Custom': 'hello' },
-      })
-      await NodeListener.sendResponse(res, response)
-    })
-
-    const response = await fetch(server.url)
-    expect(response.status).toBe(204)
-    expect(response.headers.get('X-Custom')).toBe('hello')
-  })
-
-  test('streams text body', async () => {
-    server = await Http.createServer(async (_, res) => {
-      const response = new Response('hello world', {
-        status: 200,
-        headers: { 'Content-Type': 'text/plain' },
-      })
-      await NodeListener.sendResponse(res, response)
-    })
-
-    const response = await fetch(server.url)
-    expect(response.status).toBe(200)
-    expect(await response.text()).toBe('hello world')
-  })
-
-  test('streams json body', async () => {
-    server = await Http.createServer(async (_, res) => {
-      const response = Response.json({ fortune: 'You will be rich' })
-      await NodeListener.sendResponse(res, response)
-    })
-
-    const response = await fetch(server.url)
-    expect(response.status).toBe(200)
-    expect(await response.json()).toEqual({ fortune: 'You will be rich' })
-  })
-
-  test('streams chunked body', async () => {
-    server = await Http.createServer(async (_, res) => {
-      const stream = new ReadableStream({
-        start(controller) {
-          controller.enqueue(new TextEncoder().encode('chunk1'))
-          controller.enqueue(new TextEncoder().encode('chunk2'))
-          controller.close()
-        },
-      })
-      const response = new Response(stream, { status: 200 })
-      await NodeListener.sendResponse(res, response)
-    })
-
-    const response = await fetch(server.url)
-    expect(response.status).toBe(200)
-    expect(await response.text()).toBe('chunk1chunk2')
-  })
-
-  test('handles null body', async () => {
-    server = await Http.createServer(async (_, res) => {
-      const response = new Response(null, { status: 204 })
-      await NodeListener.sendResponse(res, response)
-    })
-
-    const response = await fetch(server.url)
-    expect(response.status).toBe(204)
-    expect(await response.text()).toBe('')
-  })
-
-  test('preserves multiple Set-Cookie headers', async () => {
-    server = await Http.createServer(async (_req, res) => {
-      const headers = new Headers()
-      headers.append('Set-Cookie', 'a=1')
-      headers.append('Set-Cookie', 'b=2')
-      const response = new Response('ok', { headers })
-      await NodeListener.sendResponse(res, response)
-    })
-
-    const response = await fetch(server.url)
-    expect(response.headers.getSetCookie()).toEqual(['a=1', 'b=2'])
-  })
-
-  test('skips body for HEAD requests', async () => {
-    let bodyWritten = false
-    server = await Http.createServer(async (_req, res) => {
-      const original = res.write.bind(res)
-      res.write = (...args: any[]) => {
-        bodyWritten = true
-        // @ts-expect-error
-        return original(...(args as any))
-      }
-      const response = new Response('should not be sent', {
-        status: 200,
-        headers: { 'Content-Type': 'text/plain' },
-      })
-      await NodeListener.sendResponse(res, response)
-    })
-
-    const response = await fetch(server.url, { method: 'HEAD' })
-    expect(response.status).toBe(200)
-    expect(response.headers.get('Content-Type')).toBe('text/plain')
-    expect(bodyWritten).toBe(false)
-  })
-})
-
-describe('toNodeListener', () => {
-  test('converts fetch handler to node listener', async () => {
-    const handler = Request.toNodeListener(async (request) => {
-      const url = new URL(request.url)
-      return Response.json({ path: url.pathname })
-    })
-
-    server = await Http.createServer(handler)
-
-    const response = await fetch(`${server.url}/hello`)
-    expect(response.status).toBe(200)
-    expect(await response.json()).toEqual({ path: '/hello' })
-  })
-
-  test('copies all receipt response headers for successful payment handlers', async () => {
-    const handler = Mppx.toNodeListener(async () => ({
-      status: 200,
-      withReceipt(response?: Response) {
-        if (!response) {
-          const error = new Error('withReceipt() requires a response argument')
-          error.name = 'MissingReceiptResponseError'
-          throw error
-        }
-        const headers = new Headers(response?.headers)
-        headers.set('Payment-Receipt', 'receipt')
-        headers.set('PAYMENT-RESPONSE', 'x402-response')
-        return new Response(response?.body, { headers })
-      },
-    }))
-
-    server = await Http.createServer(async (req, res) => {
-      await handler(req, res)
-      res.end('ok')
-    })
-
-    const response = await fetch(server.url)
-    expect(response.headers.get('Payment-Receipt')).toBe('receipt')
-    expect(response.headers.get('PAYMENT-RESPONSE')).toBe('x402-response')
-    expect(await response.text()).toBe('ok')
-  })
-
-  test('forwards request method', async () => {
-    const handler = Request.toNodeListener(async (request) => {
-      return Response.json({ method: request.method })
-    })
-
-    server = await Http.createServer(handler)
-
-    const response = await fetch(server.url, { method: 'POST' })
-    expect(await response.json()).toEqual({ method: 'POST' })
-  })
-
-  test('forwards request headers', async () => {
-    const handler = Request.toNodeListener(async (request) => {
-      return Response.json({ auth: request.headers.get('X-Api-Key') })
-    })
-
-    server = await Http.createServer(handler)
-
-    const response = await fetch(server.url, {
-      headers: { 'X-Api-Key': 'secret123' },
-    })
-    expect(await response.json()).toEqual({ auth: 'secret123' })
-  })
-
-  test('forwards request body', async () => {
-    const handler = Request.toNodeListener(async (request) => {
-      const body = await request.json()
-      return Response.json({ echo: body })
-    })
-
-    server = await Http.createServer(handler)
-
-    const response = await fetch(server.url, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ hello: 'world' }),
-    })
-    expect(await response.json()).toEqual({ echo: { hello: 'world' } })
-  })
-
-  test('streams response body', async () => {
-    const handler = Request.toNodeListener(async () => {
-      const stream = new ReadableStream({
-        start(controller) {
-          controller.enqueue(new TextEncoder().encode('a'))
-          controller.enqueue(new TextEncoder().encode('b'))
-          controller.enqueue(new TextEncoder().encode('c'))
-          controller.close()
-        },
-      })
-      return new Response(stream, {
-        headers: { 'Content-Type': 'text/plain' },
-      })
-    })
-
-    server = await Http.createServer(handler)
-
-    const response = await fetch(server.url)
-    expect(await response.text()).toBe('abc')
-  })
-
-  test('routes malformed host header URL parsing errors through onError', async () => {
-    const [req, res] = createMockRequest({
-      rawHeaders: ['Host', 'a, b'],
-    })
-    const onError = vi.fn((error: unknown) => {
-      return new Response(error instanceof TypeError ? 'bad host' : 'unexpected', {
-        status: 500,
-        headers: { 'Content-Type': 'text/plain' },
-      })
-    })
-    const handler = Request.toNodeListener(async () => new Response('ok'), { onError })
-
-    await expect(Promise.resolve(handler(req, res))).resolves.toBeUndefined()
-    expect(onError).toHaveBeenCalledTimes(1)
-    expect(onError.mock.calls[0]![0]).toBeInstanceOf(TypeError)
-    expect(Buffer.concat(res.body).toString()).toBe('bad host')
-  })
-})

package/src/server/NodeListener.ts

@@ -1,45 +0,0 @@
-import type * as http from 'node:http'
-import type * as http2 from 'node:http2'
-
-/**
- * Writes a Fetch API `Response` to a Node.js `ServerResponse`.
- *
- * Useful when bridging Fetch API handlers with Node.js HTTP servers.
- */
-export async function sendResponse(
-  res: http.ServerResponse | http2.Http2ServerResponse,
-  response: Response,
-): Promise<void> {
-  const headers: Record<string, string | string[]> = {}
-  for (const [key, value] of response.headers) {
-    if (key in headers) {
-      const existing = headers[key]
-      if (Array.isArray(existing)) existing.push(value)
-      else headers[key] = [existing!, value]
-    } else {
-      headers[key] = value
-    }
-  }
-
-  if ('req' in res && (res as http.ServerResponse).req?.httpVersionMajor === 1)
-    (res as http.ServerResponse).writeHead(response.status, response.statusText, headers)
-  else (res as http2.Http2ServerResponse).writeHead(response.status, headers)
-
-  if (response.body != null && (res as http.ServerResponse).req?.method !== 'HEAD') {
-    const reader = response.body.getReader()
-    try {
-      while (true) {
-        const { done, value } = await reader.read()
-        if (done) break
-        if ((res as http.ServerResponse).write(value) === false)
-          await new Promise<void>((resolve) => {
-            res.once('drain', resolve)
-          })
-      }
-    } finally {
-      reader.releaseLock()
-    }
-  }
-
-  res.end()
-}

package/src/server/Request.test.ts

@@ -1,255 +0,0 @@
-import { EventEmitter } from 'node:events'
-import { createServer } from 'node:http'
-import type { IncomingMessage, ServerResponse } from 'node:http'
-import type { AddressInfo } from 'node:net'
-import { connect } from 'node:net'
-
-import { Request } from 'mppx/server'
-import { describe, expect, test } from 'vp/test'
-
-function createMockRequest(options: {
-  method?: string
-  url?: string
-  rawHeaders?: string[]
-  socket?: { encrypted?: boolean }
-}): [IncomingMessage, ServerResponse] {
-  const rawHeaders = options.rawHeaders ?? []
-  const headers = Object.fromEntries(
-    rawHeaders.reduce<[string, string][]>((acc, v, i, arr) => {
-      if (i % 2 === 0 && arr[i + 1]) acc.push([v.toLowerCase(), arr[i + 1]!])
-      return acc
-    }, []),
-  )
-  const req = Object.assign(new EventEmitter(), {
-    method: options.method ?? 'GET',
-    url: options.url ?? '/',
-    headers,
-    rawHeaders,
-    socket: options.socket ?? {},
-  }) as unknown as IncomingMessage
-
-  const res = new EventEmitter() as unknown as ServerResponse
-
-  return [req, res]
-}
-
-describe('fromNodeListener', () => {
-  test('converts IncomingMessage to Fetch Request', () => {
-    const [req, res] = createMockRequest({
-      method: 'POST',
-      url: '/api/resource',
-      rawHeaders: [
-        'Host',
-        'example.com',
-        'Authorization',
-        'Bearer token',
-        'Content-Type',
-        'application/json',
-      ],
-    })
-
-    const request = Request.fromNodeListener(req, res)
-
-    expect(request.method).toBe('POST')
-    expect(request.url).toBe('http://example.com/api/resource')
-    expect(request.headers.get('Authorization')).toBe('Bearer token')
-    expect(request.headers.get('Content-Type')).toBe('application/json')
-  })
-
-  test('uses default values when host/url/method missing', () => {
-    const [req, res] = createMockRequest({})
-
-    const request = Request.fromNodeListener(req, res)
-
-    expect(request.method).toBe('GET')
-    expect(request.url).toBe('http://localhost/')
-  })
-
-  test('normalizes absolute-form request targets to the host header', () => {
-    const [req, res] = createMockRequest({
-      url: 'http://unexpected.example/api/resource?q=1',
-      rawHeaders: ['Host', 'example.com'],
-    })
-
-    const request = Request.fromNodeListener(req, res)
-
-    expect(request.url).toBe('http://example.com/api/resource?q=1')
-  })
-
-  // The request target's authority must never override the trusted host
-  // (options.host > Host > :authority > localhost). A raw request line can
-  // carry protocol-relative, triple-slash, backslash, or embedded-authority
-  // targets that WHATWG URL would otherwise resolve into a foreign host.
-  test.each([
-    ['protocol-relative', '//evil.com/path?q=1', 'http://example.com/path?q=1'],
-    ['triple-slash', '///evil.com/x', 'http://example.com/x'],
-    ['backslash', '/\\evil.com/x', 'http://example.com/x'],
-    ['userinfo authority', '//user:pass@evil.com/path', 'http://example.com/path'],
-    ['ipv6 authority', '//[2001:db8::1]:8443/path', 'http://example.com/path'],
-    ['embedded authority', '//first.example//evil.com/path', 'http://example.com//evil.com/path'],
-    [
-      'absolute embedded authority',
-      'http://first.example//evil.com/p',
-      'http://example.com//evil.com/p',
-    ],
-    ['encoded slashes stay path', '/%2F%2Fevil.com/p', 'http://example.com/%2F%2Fevil.com/p'],
-  ])('binds host to Host header for %s request targets', (_name, url, expected) => {
-    const [req, res] = createMockRequest({ url, rawHeaders: ['Host', 'example.com'] })
-
-    const request = Request.fromNodeListener(req, res)
-
-    expect(request.url).toBe(expected)
-    expect(new URL(request.url).host).toBe('example.com')
-  })
-
-  test('uses explicit protocol and host overrides', () => {
-    const [req, res] = createMockRequest({
-      url: '/api/resource',
-      rawHeaders: ['Host', 'internal.local'],
-      socket: { encrypted: false },
-    })
-
-    const request = Request.fromNodeListener(req, res, {
-      host: 'api.example.com',
-      protocol: 'https:',
-    })
-
-    expect(request.url).toBe('https://api.example.com/api/resource')
-  })
-
-  test('preserves multi-value headers via append', () => {
-    const [req, res] = createMockRequest({
-      rawHeaders: ['Host', 'example.com', 'Set-Cookie', 'a=1', 'Set-Cookie', 'b=2'],
-    })
-
-    const request = Request.fromNodeListener(req, res)
-
-    expect(request.headers.get('Set-Cookie')).toBe('a=1, b=2')
-  })
-
-  test('skips HTTP/2 pseudo-headers', () => {
-    const [req, res] = createMockRequest({
-      rawHeaders: [':method', 'GET', ':path', '/', 'Host', 'example.com'],
-    })
-
-    const request = Request.fromNodeListener(req, res)
-
-    expect([...request.headers.keys()]).toEqual(['host'])
-    expect(request.headers.get('Host')).toBe('example.com')
-  })
-
-  test('streams body for POST requests', async () => {
-    const [req, res] = createMockRequest({
-      method: 'POST',
-      rawHeaders: [
-        'Host',
-        'example.com',
-        'Content-Length',
-        '17',
-        'Content-Type',
-        'application/json',
-      ],
-    })
-
-    const request = Request.fromNodeListener(req, res)
-
-    setImmediate(() => {
-      req.emit('data', Buffer.from('{"hello":'))
-      req.emit('data', Buffer.from('"world"}'))
-      req.emit('end')
-    })
-
-    const body = await request.text()
-    expect(body).toBe('{"hello":"world"}')
-  })
-
-  test('does not attach a body stream for empty POST requests', () => {
-    const [req, res] = createMockRequest({
-      method: 'POST',
-      rawHeaders: ['Host', 'example.com'],
-    })
-
-    const request = Request.fromNodeListener(req, res)
-
-    expect(request.body).toBeNull()
-  })
-
-  test('does not attach a body stream for content-length: 0', () => {
-    const [req, res] = createMockRequest({
-      method: 'POST',
-      rawHeaders: ['Host', 'example.com', 'Content-Length', '0'],
-    })
-
-    const request = Request.fromNodeListener(req, res)
-
-    expect(request.body).toBeNull()
-  })
-
-  test('attaches a body stream for chunked POST requests', async () => {
-    const [req, res] = createMockRequest({
-      method: 'POST',
-      rawHeaders: ['Host', 'example.com', 'Transfer-Encoding', 'chunked'],
-    })
-
-    const request = Request.fromNodeListener(req, res)
-
-    setImmediate(() => {
-      req.emit('data', Buffer.from('hello'))
-      req.emit('end')
-    })
-
-    expect(await request.text()).toBe('hello')
-  })
-})
-
-// Conformance harness: a normal HTTP client cannot emit these request targets,
-// so they are driven through Node's real HTTP parser over a raw socket to prove
-// the adapter neutralizes host confusion end-to-end (not just via mocks).
-describe('toNodeListener (raw request target)', () => {
-  async function captureRequestUrl(rawRequestLine: string): Promise<string> {
-    let resolveUrl!: (url: string) => void
-    const observed = new Promise<string>((resolve) => {
-      resolveUrl = resolve
-    })
-
-    const server = createServer(
-      Request.toNodeListener(async (request) => {
-        resolveUrl(request.url)
-        return new Response('ok')
-      }),
-    )
-
-    try {
-      await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', () => resolve()))
-      const { port } = server.address() as AddressInfo
-      const socket = connect(port, '127.0.0.1')
-      await new Promise<void>((resolve, reject) => {
-        socket.once('connect', () => resolve())
-        socket.once('error', reject)
-      })
-      socket.write(rawRequestLine)
-      const url = await observed
-      socket.destroy()
-      return url
-    } finally {
-      await new Promise<void>((resolve) => server.close(() => resolve()))
-    }
-  }
-
-  test('binds host to Host header for a protocol-relative raw request target', async () => {
-    const url = await captureRequestUrl(
-      'GET //evil.com/protected?q=1 HTTP/1.1\r\nHost: example.com\r\nConnection: close\r\n\r\n',
-    )
-
-    expect(url).toBe('http://example.com/protected?q=1')
-    expect(new URL(url).host).toBe('example.com')
-  })
-
-  test('binds host to Host header for an embedded-authority raw request target', async () => {
-    const url = await captureRequestUrl(
-      'GET //first.example//evil.com/protected HTTP/1.1\r\nHost: example.com\r\nConnection: close\r\n\r\n',
-    )
-
-    expect(new URL(url).host).toBe('example.com')
-  })
-})