acrylblends 0.6.3 → 0.6.4

package/plugins/acryl-node-server/tests/adapter/content-length.test.ts

@@ -1,248 +0,0 @@
-import { Acryl } from '../../../acryl-router/src/index.ts'
-import { once } from 'node:events'
-import { createServer } from 'node:http'
-import type { IncomingMessage, ServerResponse } from 'node:http'
-import { createServer as createHttp2Server } from 'node:http2'
-import { connect as connectNet } from 'node:net'
-import type { AddressInfo } from 'node:net'
-import { getRequestListener } from '../../src/adapter/listener.ts'
-import { defaultContentType } from '../../src/adapter/response.ts'
-import { createAdaptorServer } from '../../src/adapter/server.ts'
-import { requestServer, requestServerHttp2 } from './helpers/request.ts'
-
-// These tests exercise Node's real HTTP serializer. In addition to correctness,
-// assert that plain headers reach writeHead with the original record:
-// silently falling back to a copy must not hide a change to Node's internals.
-describe('automatic Content-Length compatibility', () => {
-  it.each(['', 'hello'])('serializes a frozen record without a copy: %j', async (body) => {
-    const headers = Object.freeze({ 'content-type': 'text/plain' })
-    let writeHeadCalls: unknown[][] = []
-    const listener = getRequestListener(() => new Response(body, { headers }))
-    const server = createServer((incoming, outgoing) => {
-      writeHeadCalls = vi.spyOn(outgoing, 'writeHead').mock.calls
-      void listener(incoming, outgoing)
-    })
-    const res = await requestServer(server, { path: '/' })
-    expect(res.status).toBe(200)
-    expect(res.headers.get('content-length')).toBe(String(Buffer.byteLength(body)))
-    expect(res.headers.has('transfer-encoding')).toBe(false)
-    expect(await res.text()).toBe(body)
-    expect(writeHeadCalls[0][1]).toBe(headers)
-  })
-
-  it('preserves the byte length for c.json()', async () => {
-    const app = new Acryl()
-    app.get('/', (c) => c.json({ message: 'hello' }))
-    const server = createServer(getRequestListener(app.fetch))
-    const res = await requestServer(server, { path: '/' })
-    const text = await res.text()
-    expect(JSON.parse(text)).toEqual({ message: 'hello' })
-    expect(res.headers.get('content-type')).toBe('application/json')
-    expect(res.headers.get('content-length')).toBe(String(Buffer.byteLength(text)))
-    expect(res.headers.has('transfer-encoding')).toBe(false)
-  })
-
-  it('uses automatic length for JSON with a plain header record', async () => {
-    const headers = Object.freeze({ 'Content-Type': 'application/json' })
-    let writeHeadCalls: unknown[][] = []
-    const listener = getRequestListener(
-      () => new Response(JSON.stringify({ message: 'hello' }), { headers })
-    )
-    const server = createServer((incoming, outgoing) => {
-      writeHeadCalls = vi.spyOn(outgoing, 'writeHead').mock.calls
-      void listener(incoming, outgoing)
-    })
-    const res = await requestServer(server, { path: '/' })
-    const text = await res.text()
-    expect(JSON.parse(text)).toEqual({ message: 'hello' })
-    expect(res.headers.get('content-length')).toBe(String(Buffer.byteLength(text)))
-    expect(writeHeadCalls[0][1]).toBe(headers)
-  })
-
-  it('uses the UTF-8 byte length for automatic Content-Length with c.text()', async () => {
-    const app = new Acryl()
-    app.get('/', (c) => c.text('こんにちは'))
-    let writeHeadCalls: unknown[][] = []
-    const listener = getRequestListener(app.fetch)
-    const server = createServer((incoming, outgoing) => {
-      outgoing.strictContentLength = true
-      writeHeadCalls = vi.spyOn(outgoing, 'writeHead').mock.calls
-      void listener(incoming, outgoing)
-    })
-    const res = await requestServer(server, { path: '/' })
-    expect(await res.text()).toBe('こんにちは')
-    expect(res.headers.get('content-type')).toBe(defaultContentType)
-    expect(res.headers.get('content-length')).toBe('15')
-    expect(res.headers.has('transfer-encoding')).toBe(false)
-    expect(writeHeadCalls[0][1]).toEqual({ 'Content-Type': defaultContentType })
-  })
-
-  describe.each([
-    { protocol: 'HTTP/1.1', serverOptions: {}, request: requestServer },
-    {
-      protocol: 'HTTP/2',
-      serverOptions: { createServer: createHttp2Server },
-      request: requestServerHttp2,
-    },
-  ])('default headers over $protocol', ({ serverOptions, request }) => {
-    it.each([
-      { name: 'string', makeBody: (text: string) => text },
-      { name: 'Uint8Array', makeBody: (text: string) => new TextEncoder().encode(text) },
-      { name: 'Blob', makeBody: (text: string) => new Blob([text]) },
-    ])('preserves byte lengths for a $name body', async ({ makeBody }) => {
-      const bodies = ['', 'hello']
-      let index = 0
-      const server = createAdaptorServer({
-        fetch: () => new Response(makeBody(bodies[index++])),
-        ...serverOptions,
-      })
-      for (const body of bodies) {
-        const res = await request(server, { path: '/' })
-        expect(res.status).toBe(200)
-        expect(res.headers.get('content-type')).toBe(defaultContentType)
-        expect(res.headers.get('content-length')).toBe(String(Buffer.byteLength(body)))
-        expect(res.headers.has('transfer-encoding')).toBe(false)
-        expect(await res.text()).toBe(body)
-      }
-    })
-  })
-
-  it.each([204, 304])(
-    'preserves explicit length when status %i suppresses the body',
-    async (status) => {
-      const server = createServer(getRequestListener(() => new Response('hello', { status })))
-      const res = await requestServer(server, { path: '/' })
-      expect(res.status).toBe(status)
-      expect(res.headers.get('content-length')).toBe('5')
-      expect(await res.text()).toBe('')
-    }
-  )
-
-  describe.each([false, true])('custom headers: %s', (customHeaders) => {
-    it.each([
-      {
-        name: 'HEAD',
-        method: 'HEAD',
-        prepare: () => {},
-      },
-      {
-        name: 'previously set Content-Length',
-        method: 'GET',
-        prepare: (_incoming: IncomingMessage, outgoing: ServerResponse) => {
-          outgoing.setHeader('Content-Length', '999')
-        },
-      },
-      {
-        name: 'previously removed Content-Length',
-        method: 'GET',
-        prepare: (_incoming: IncomingMessage, outgoing: ServerResponse) => {
-          outgoing.removeHeader('Content-Length')
-        },
-      },
-      {
-        name: 'disabled default chunking',
-        method: 'GET',
-        prepare: (_incoming: IncomingMessage, outgoing: ServerResponse) => {
-          outgoing.useChunkedEncodingByDefault = false
-        },
-      },
-      {
-        name: 'unavailable native length',
-        method: 'GET',
-        prepare: (_incoming: IncomingMessage, outgoing: ServerResponse) => {
-          Object.defineProperty(outgoing, '_contentLength', { value: undefined })
-        },
-      },
-      {
-        name: 'already initialized native length',
-        method: 'GET',
-        prepare: (_incoming: IncomingMessage, outgoing: ServerResponse) => {
-          Object.defineProperty(outgoing, '_contentLength', { value: 999 })
-        },
-      },
-    ])('preserves explicit length behavior for $name', async ({ method, prepare }) => {
-      const headers = customHeaders ? Object.freeze({ 'content-type': 'text/plain' }) : undefined
-      const listener = getRequestListener(() => new Response('hello', { headers }))
-      const server = createServer((incoming, outgoing) => {
-        prepare(incoming, outgoing)
-        void listener(incoming, outgoing)
-      })
-      const res = await requestServer(server, { path: '/', method })
-      expect(res.status).toBe(200)
-      expect(res.headers.get('content-length')).toBe('5')
-      expect(await res.text()).toBe(method === 'HEAD' ? '' : 'hello')
-    })
-  })
-
-  it('honors strictContentLength for JSON', async () => {
-    const app = new Acryl()
-    app.get('/', (c) => c.json({ message: 'hello' }))
-    const listener = getRequestListener(app.fetch)
-    const server = createServer((incoming, outgoing) => {
-      outgoing.strictContentLength = true
-      void listener(incoming, outgoing)
-    })
-    const res = await requestServer(server, { path: '/' })
-    const text = await res.text()
-    expect(res.status).toBe(200)
-    expect(JSON.parse(text)).toEqual({ message: 'hello' })
-    expect(res.headers.get('content-length')).toBe(String(Buffer.byteLength(text)))
-  })
-
-  it('preserves the spelling of an explicit Content-Length value', async () => {
-    const headers = Object.freeze({ 'cOnTeNt-LeNgTh': '00005' })
-    const server = createServer(getRequestListener(() => new Response('hello', { headers })))
-    const res = await requestServer(server, { path: '/' })
-    expect(res.headers.get('content-length')).toBe('00005')
-    expect(await res.text()).toBe('hello')
-  })
-
-  it.each([
-    {
-      name: 'an invalid header value',
-      response: () => new Response('hi', { headers: { 'x-bad': 'a\r\nb' } }),
-    },
-    {
-      name: 'an invalid status code with custom headers',
-      response: () => new Response('hi', { status: 1000, headers: { 'x-ok': '1' } }),
-    },
-    {
-      name: 'an invalid status code without custom headers',
-      response: () => new Response('hi', { status: 1000 }),
-    },
-  ])('does not leak a stale length into the 500 response after $name', async ({ response }) => {
-    const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
-    const server = createServer(getRequestListener(async () => response()))
-    try {
-      server.listen(0, '127.0.0.1')
-      await once(server, 'listening')
-      const { port } = server.address() as AddressInfo
-      // Read the wire response so a stale length cannot truncate the observed body.
-      const raw = await new Promise<string>((resolve, reject) => {
-        const chunks: Buffer[] = []
-        const socket = connectNet(port, '127.0.0.1', () => {
-          socket.write('GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n')
-        })
-        socket.setTimeout(2000, () => socket.destroy(new Error('Response timed out')))
-        socket.on('data', (chunk) => chunks.push(chunk))
-        socket.on('end', () => resolve(Buffer.concat(chunks).toString('latin1')))
-        socket.on('error', reject)
-      })
-      const separator = raw.indexOf('\r\n\r\n')
-      expect(separator).toBeGreaterThan(0)
-      const head = raw.slice(0, separator)
-      const body = raw.slice(separator + 4)
-      expect(head).toMatch(/^HTTP\/1\.1 500 /)
-      expect(body).toContain('Error: ')
-      const contentLength = head.match(/^content-length: (\d+)$/im)?.[1]
-      if (contentLength !== undefined) {
-        expect(Number(contentLength)).toBe(Buffer.byteLength(body, 'latin1'))
-      } else {
-        expect(head).toMatch(/^transfer-encoding: chunked$/im)
-      }
-    } finally {
-      await new Promise<void>((resolve) => server.close(() => resolve()))
-      consoleSpy.mockRestore()
-    }
-  })
-})

package/plugins/acryl-node-server/tests/adapter/early-hints.test.ts

@@ -1,457 +0,0 @@
-import type { Context, MiddlewareHandler } from '../../../acryl-router/src/index.ts'
-import { Acryl } from '../../../acryl-router/src/index.ts'
-import { describe, it, expect, expectTypeOf, vi } from 'vitest'
-import http, { createServer } from 'node:http'
-import http2 from 'node:http2'
-import type { AddressInfo } from 'node:net'
-import { earlyHints } from '../../src/adapter/early-hints.ts'
-import { getRequestListener } from '../../src/adapter/listener.ts'
-
-describe('HTTP/1.1 Early Hints Middleware', () => {
-  it('should send a 103 early hints response before the final response using a string link', async () => {
-    const app = new Acryl()
-    app.use(
-      '*',
-      earlyHints({
-        link: '</style.css>; rel=preload; as=style',
-      })
-    )
-    app.get('/', (c) => c.text('Hello Early Hints'))
-
-    const server = createServer(getRequestListener(app.fetch))
-
-    await new Promise<void>((resolve, reject) => {
-      server.listen(0, () => {
-        const address = server.address() as AddressInfo
-        const port = address.port
-
-        const req = http.request(
-          {
-            port,
-            path: '/',
-          },
-          (res) => {
-            let body = ''
-            res.on('data', (chunk) => (body += chunk))
-            res.on('end', () => {
-              try {
-                expect(res.statusCode).toBe(200)
-                expect(body).toBe('Hello Early Hints')
-                expect(earlyHintReceived).toBe(true)
-                server.close((err) => (err ? reject(err) : resolve()))
-              } catch (err) {
-                server.close()
-                reject(err)
-              }
-            })
-            res.on('error', (err) => {
-              server.close()
-              reject(err)
-            })
-          }
-        )
-
-        let earlyHintReceived = false
-        req.on('information', (info) => {
-          try {
-            expect(info.statusCode).toBe(103)
-            expect(info.headers.link).toBe('</style.css>; rel=preload; as=style')
-            earlyHintReceived = true
-          } catch (err) {
-            server.close()
-            reject(err)
-          }
-        })
-
-        req.on('error', (err) => {
-          server.close()
-          reject(err)
-        })
-        req.end()
-      })
-    })
-  })
-
-  it('should send early hints with an array of link headers', async () => {
-    const app = new Acryl()
-    app.use(
-      '*',
-      earlyHints({
-        link: ['</style.css>; rel=preload; as=style', '</script.js>; rel=preload; as=script'],
-      })
-    )
-    app.get('/', (c) => c.text('Hello Middleware'))
-
-    const server = createServer(getRequestListener(app.fetch))
-
-    await new Promise<void>((resolve, reject) => {
-      server.listen(0, () => {
-        const address = server.address() as AddressInfo
-        const port = address.port
-
-        const req = http.request(
-          {
-            port,
-            path: '/',
-          },
-          (res) => {
-            let body = ''
-            res.on('data', (chunk) => (body += chunk))
-            res.on('end', () => {
-              try {
-                expect(res.statusCode).toBe(200)
-                expect(body).toBe('Hello Middleware')
-                expect(earlyHintReceived).toBe(true)
-                server.close((err) => (err ? reject(err) : resolve()))
-              } catch (err) {
-                server.close()
-                reject(err)
-              }
-            })
-            res.on('error', (err) => {
-              server.close()
-              reject(err)
-            })
-          }
-        )
-
-        let earlyHintReceived = false
-        req.on('information', (info) => {
-          try {
-            expect(info.statusCode).toBe(103)
-            expect(info.headers.link).toBe(
-              '</style.css>; rel=preload; as=style, </script.js>; rel=preload; as=script'
-            )
-            earlyHintReceived = true
-          } catch (err) {
-            server.close()
-            reject(err)
-          }
-        })
-
-        req.on('error', (err) => {
-          server.close()
-          reject(err)
-        })
-        req.end()
-      })
-    })
-  })
-
-  it('should evaluate dynamic link function with Context', async () => {
-    const app = new Acryl()
-    app.use(
-      '*',
-      earlyHints({
-        link: (c) =>
-          c.req.query('theme') === 'dark'
-            ? '</dark.css>; rel=preload; as=style'
-            : '</light.css>; rel=preload; as=style',
-      })
-    )
-    app.get('/', (c) => c.text('Hello Dynamic'))
-
-    const server = createServer(getRequestListener(app.fetch))
-
-    await new Promise<void>((resolve, reject) => {
-      server.listen(0, () => {
-        const address = server.address() as AddressInfo
-        const port = address.port
-
-        const req = http.request(
-          {
-            port,
-            path: '/?theme=dark',
-          },
-          (res) => {
-            let body = ''
-            res.on('data', (chunk) => (body += chunk))
-            res.on('end', () => {
-              try {
-                expect(res.statusCode).toBe(200)
-                expect(body).toBe('Hello Dynamic')
-                expect(earlyHintReceived).toBe(true)
-                server.close((err) => (err ? reject(err) : resolve()))
-              } catch (err) {
-                server.close()
-                reject(err)
-              }
-            })
-            res.on('error', (err) => {
-              server.close()
-              reject(err)
-            })
-          }
-        )
-
-        let earlyHintReceived = false
-        req.on('information', (info) => {
-          try {
-            expect(info.statusCode).toBe(103)
-            expect(info.headers.link).toBe('</dark.css>; rel=preload; as=style')
-            earlyHintReceived = true
-          } catch (err) {
-            server.close()
-            reject(err)
-          }
-        })
-
-        req.on('error', (err) => {
-          server.close()
-          reject(err)
-        })
-        req.end()
-      })
-    })
-  })
-})
-
-describe('HTTP/2 Early Hints Middleware', () => {
-  it('should send a 103 early hints response over HTTP/2', async () => {
-    const app = new Acryl()
-    app.use(
-      '*',
-      earlyHints({
-        link: '</style.css>; rel=preload; as=style',
-      })
-    )
-    app.get('/', (c) => c.text('Hello HTTP2 Early Hints'))
-
-    const server = http2.createServer(getRequestListener(app.fetch))
-
-    await new Promise<void>((resolve, reject) => {
-      server.listen(0, () => {
-        const address = server.address() as AddressInfo
-        const port = address.port
-
-        const client = http2.connect(`http://localhost:${port}`)
-        const req = client.request({ ':path': '/' })
-
-        let earlyHintReceived = false
-        req.on('headers', (headers) => {
-          try {
-            if (headers[':status'] === 103) {
-              expect(headers.link).toBe('</style.css>; rel=preload; as=style')
-              earlyHintReceived = true
-            }
-          } catch (err) {
-            client.close()
-            server.close()
-            reject(err)
-          }
-        })
-
-        let finalResponseReceived = false
-        req.on('response', (headers) => {
-          try {
-            expect(headers[':status']).toBe(200)
-            finalResponseReceived = true
-          } catch (err) {
-            client.close()
-            server.close()
-            reject(err)
-          }
-        })
-
-        let body = ''
-        req.on('data', (chunk) => (body += chunk))
-
-        req.on('end', () => {
-          try {
-            expect(earlyHintReceived).toBe(true)
-            expect(finalResponseReceived).toBe(true)
-            expect(body).toBe('Hello HTTP2 Early Hints')
-            client.close()
-            server.close((err) => (err ? reject(err) : resolve()))
-          } catch (err) {
-            client.close()
-            server.close()
-            reject(err)
-          }
-        })
-
-        req.on('error', (err) => {
-          client.close()
-          server.close()
-          reject(err)
-        })
-      })
-    })
-  })
-})
-
-describe('Early Hints Middleware Fetch Metadata Filtering', () => {
-  const createContext = (mode?: string, dest?: string) => {
-    const writeEarlyHints = vi.fn()
-    const context = {
-      req: {
-        header: (name: string) => {
-          if (name === 'Sec-Fetch-Mode') {
-            return mode
-          }
-          if (name === 'Sec-Fetch-Dest') {
-            return dest
-          }
-        },
-      },
-      env: {
-        outgoing: {
-          writeEarlyHints,
-          headersSent: false,
-        },
-      },
-    } as unknown as Context
-
-    return { context, writeEarlyHints }
-  }
-
-  it.each([
-    ['both headers are missing', undefined, undefined],
-    ['both headers match', 'navigate', 'document'],
-    ['only the mode header matches', 'navigate', undefined],
-    ['only the destination header matches', undefined, 'document'],
-  ])('should send hints when %s', async (_description, mode, dest) => {
-    const { context, writeEarlyHints } = createContext(mode, dest)
-    const next = vi.fn().mockResolvedValue(undefined)
-    const middleware = earlyHints({
-      link: '</style.css>; rel=preload; as=style',
-    })
-
-    await middleware(context, next)
-
-    expect(writeEarlyHints).toHaveBeenCalledWith({
-      link: '</style.css>; rel=preload; as=style',
-    })
-    expect(next).toHaveBeenCalledTimes(1)
-  })
-
-  it.each([
-    ['the mode is cors', 'cors', undefined],
-    ['the destination is empty', undefined, 'empty'],
-    ['the destination is an iframe', 'navigate', 'iframe'],
-    ['the mode is no-cors', 'no-cors', 'document'],
-  ])('should skip hints when %s', async (_description, mode, dest) => {
-    const { context, writeEarlyHints } = createContext(mode, dest)
-    const next = vi.fn().mockResolvedValue(undefined)
-    const middleware = earlyHints({
-      link: '</style.css>; rel=preload; as=style',
-    })
-
-    await middleware(context, next)
-
-    expect(writeEarlyHints).not.toHaveBeenCalled()
-    expect(next).toHaveBeenCalledTimes(1)
-  })
-})
-
-describe('Early Hints Middleware Unit & Edge Cases', () => {
-  it('should preserve the application Env type', () => {
-    type TestEnv = {
-      Bindings: {
-        theme: string
-      }
-      Variables: {
-        userId: string
-      }
-    }
-
-    const middleware = earlyHints<TestEnv>({
-      link: (c) => {
-        expectTypeOf(c.env.theme).toEqualTypeOf<string>()
-        expectTypeOf(c.get('userId')).toEqualTypeOf<string>()
-        return undefined
-      },
-    })
-
-    expectTypeOf(middleware).toEqualTypeOf<MiddlewareHandler<TestEnv>>()
-  })
-
-  it('should warn once per middleware instance when writeEarlyHints is unavailable', async () => {
-    const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
-
-    const mockCtx = {
-      req: {
-        header: () => undefined,
-      },
-      env: {
-        outgoing: {
-          headersSent: false,
-        },
-      },
-    } as unknown as Context
-
-    const nextFn = vi.fn().mockResolvedValue(undefined)
-
-    const mw1 = earlyHints({ link: '/style.css' })
-    await mw1(mockCtx, nextFn)
-    await mw1(mockCtx, nextFn)
-
-    expect(consoleSpy).toHaveBeenCalledTimes(1)
-    expect(consoleSpy).toHaveBeenCalledWith(
-      'Early Hints Middleware is not supported because writeEarlyHints is not defined.'
-    )
-    expect(nextFn).toHaveBeenCalledTimes(2)
-
-    const mw2 = earlyHints({ link: '/style.css' })
-    await mw2(mockCtx, nextFn)
-
-    expect(consoleSpy).toHaveBeenCalledTimes(2)
-    expect(nextFn).toHaveBeenCalledTimes(3)
-
-    consoleSpy.mockRestore()
-  })
-
-  it('should no-op safely when headersSent is true', async () => {
-    const writeEarlyHintsMock = vi.fn()
-    const mockCtx = {
-      req: {
-        header: () => undefined,
-      },
-      env: {
-        outgoing: {
-          writeEarlyHints: writeEarlyHintsMock,
-          headersSent: true,
-        },
-      },
-    } as unknown as Context
-
-    const nextFn = vi.fn().mockResolvedValue(undefined)
-    const mw = earlyHints({ link: '/style.css' })
-
-    await mw(mockCtx, nextFn)
-
-    expect(writeEarlyHintsMock).not.toHaveBeenCalled()
-    expect(nextFn).toHaveBeenCalledTimes(1)
-  })
-
-  it('should skip sending hints when dynamic link function returns undefined or empty array', async () => {
-    const writeEarlyHintsMock = vi.fn()
-    const mockCtx = {
-      req: {
-        header: () => undefined,
-      },
-      env: {
-        outgoing: {
-          writeEarlyHints: writeEarlyHintsMock,
-          headersSent: false,
-        },
-      },
-    } as unknown as Context
-
-    const nextFn = vi.fn().mockResolvedValue(undefined)
-
-    // Undefined return
-    const mwUndefined = earlyHints({ link: () => undefined })
-    await mwUndefined(mockCtx, nextFn)
-
-    expect(writeEarlyHintsMock).not.toHaveBeenCalled()
-    expect(nextFn).toHaveBeenCalledTimes(1)
-
-    // Empty array return
-    const mwEmptyArray = earlyHints({ link: () => [] })
-    await mwEmptyArray(mockCtx, nextFn)
-
-    expect(writeEarlyHintsMock).not.toHaveBeenCalled()
-    expect(nextFn).toHaveBeenCalledTimes(2)
-  })
-})