acrylblends 0.6.3 → 0.6.4

package/plugins/acryl-node-server/tests/adapter/fixtures/keys/agent1-cert.pem

@@ -1,23 +0,0 @@
------BEGIN CERTIFICATE-----
-MIID6DCCAtCgAwIBAgIUFH02wcL3Qgben6tfIibXitsApCYwDQYJKoZIhvcNAQEL
-BQAwejELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMQswCQYDVQQHDAJTRjEPMA0G
-A1UECgwGSm95ZW50MRAwDgYDVQQLDAdOb2RlLmpzMQwwCgYDVQQDDANjYTExIDAe
-BgkqhkiG9w0BCQEWEXJ5QHRpbnljbG91ZHMub3JnMCAXDTIyMDkwMzIxNDAzN1oY
-DzIyOTYwNjE3MjE0MDM3WjB9MQswCQYDVQQGEwJVUzELMAkGA1UECAwCQ0ExCzAJ
-BgNVBAcMAlNGMQ8wDQYDVQQKDAZKb3llbnQxEDAOBgNVBAsMB05vZGUuanMxDzAN
-BgNVBAMMBmFnZW50MTEgMB4GCSqGSIb3DQEJARYRcnlAdGlueWNsb3Vkcy5vcmcw
-ggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDUVjIK+yDTgnCT3CxChO0E
-37q9VuHdrlKeKLeQzUJW2yczSfNzX/0zfHpjY+zKWie39z3HCJqWxtiG2wxiOI8c
-3WqWOvzVmdWADlh6EfkIlg+E7VC6JaKDA+zabmhPvnuu3JzogBMnsWl68lCXzuPx
-deQAmEwNtqjrh74DtM+Ud0ulb//Ixjxo1q3rYKu+aaexSramuee6qJta2rjrB4l8
-B/bU+j1mDf9XQQfSjo9jRnp4hiTFdBl2k+lZzqE2L/rhu6EMjA2IhAq/7xA2MbLo
-9cObVUin6lfoo5+JKRgT9Fp2xEgDOit+2EA/S6oUfPNeLSVUqmXOSWlXlwlb9Nxr
-AgMBAAGjYTBfMF0GCCsGAQUFBwEBBFEwTzAjBggrBgEFBQcwAYYXaHR0cDovL29j
-c3Aubm9kZWpzLm9yZy8wKAYIKwYBBQUHMAKGHGh0dHA6Ly9jYS5ub2RlanMub3Jn
-L2NhLmNlcnQwDQYJKoZIhvcNAQELBQADggEBAMM0mBBjLMt9pYXePtUeNO0VTw9y
-FWCM8nAcAO2kRNwkJwcsispNpkcsHZ5o8Xf5mpCotdvziEWG1hyxwU6nAWyNOLcN
-G0a0KUfbMO3B6ZYe1GwPDjXaQnv75SkAdxgX5zOzca3xnhITcjUUGjQ0fbDfwFV5
-ix8mnzvfXjDONdEznVa7PFcN6QliFUMwR/h8pCRHtE5+a10OSPeJSrGG+FtrGnRW
-G1IJUv6oiGF/MvWCr84REVgc1j78xomGANJIu2hN7bnD1nEMON6em8IfnDOUtynV
-9wfWTqiQYD5Zifj6WcGa0aAHMuetyFG4lIfMAHmd3gaKpks7j9l26LwRPvI=
------END CERTIFICATE-----

package/plugins/acryl-node-server/tests/adapter/fixtures/keys/agent1-key.pem

@@ -1,27 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIIEpAIBAAKCAQEA1FYyCvsg04Jwk9wsQoTtBN+6vVbh3a5Snii3kM1CVtsnM0nz
-c1/9M3x6Y2Psylont/c9xwialsbYhtsMYjiPHN1qljr81ZnVgA5YehH5CJYPhO1Q
-uiWigwPs2m5oT757rtyc6IATJ7FpevJQl87j8XXkAJhMDbao64e+A7TPlHdLpW//
-yMY8aNat62CrvmmnsUq2prnnuqibWtq46weJfAf21Po9Zg3/V0EH0o6PY0Z6eIYk
-xXQZdpPpWc6hNi/64buhDIwNiIQKv+8QNjGy6PXDm1VIp+pX6KOfiSkYE/RadsRI
-AzorfthAP0uqFHzzXi0lVKplzklpV5cJW/TcawIDAQABAoIBAAvbtHfAhpjJVBgt
-15rvaX04MWmZjIugzKRgib/gdq/7FTlcC+iJl85kSUF7tyGl30n62MxgwqFhAX6m
-hQ6HMhbelrFFIhGbwbyhEHfgwROlrcAysKt0pprCgVvBhrnNXYLqdyjU3jz9P3LK
-TY3s0/YMK2uNFdI+PTjKH+Z9Foqn9NZUnUonEDepGyuRO7fLeccWJPv2L4CR4a/5
-ku4VbDgVpvVSVRG3PSVzbmxobnpdpl52og+T7tPx1cLnIknPtVljXPWtZdfekh2E
-eAp2KxCCHOKzzG3ItBKsVu0woeqEpy8JcoO6LbgmEoVnZpgmtQClbBgef8+i+oGE
-BgW9nmECgYEA8gA63QQuZOUC56N1QXURexN2PogF4wChPaCTFbQSJXvSBkQmbqfL
-qRSD8P0t7GOioPrQK6pDwFf4BJB01AvkDf8Z6DxxOJ7cqIC7LOwDupXocWX7Q0Qk
-O6cwclBVsrDZK00v60uRRpl/a39GW2dx7IiQDkKQndLh3/0TbMIWHNcCgYEA4J6r
-yinZbLpKw2+ezhi4B4GT1bMLoKboJwpZVyNZZCzYR6ZHv+lS7HR/02rcYMZGoYbf
-n7OHwF4SrnUS7vPhG4g2ZsOhKQnMvFSQqpGmK1ZTuoKGAevyvtouhK/DgtLWzGvX
-9fSahiq/UvfXs/z4M11q9Rv9ztPCmG1cwSEHlo0CgYEAogQNZJK8DMhVnYcNpXke
-7uskqtCeQE/Xo06xqkIYNAgloBRYNpUYAGa/vsOBz1UVN/kzDUi8ezVp0oRz8tLT
-J5u2WIi+tE2HJTiqF3UbOfvK1sCT64DfUSCpip7GAQ/tFNRkVH8PD9kMOYfILsGe
-v+DdsO5Xq5HXrwHb02BNNZkCgYBsl8lt33WiPx5OBfS8pu6xkk+qjPkeHhM2bKZs
-nkZlS9j0KsudWGwirN/vkkYg8zrKdK5AQ0dqFRDrDuasZ3N5IA1M+V88u+QjWK7o
-B6pSYVXxYZDv9OZSpqC+vUrEQLJf+fNakXrzSk9dCT1bYv2Lt6ox/epix7XYg2bI
-Z/OHMQKBgQC2FUGhlndGeugTJaoJ8nhT/0VfRUX/h6sCgSerk5qFr/hNCBV4T022
-x0NDR2yLG6MXyqApJpG6rh3QIDElQoQCNlI3/KJ6JfEfmqrLLN2OigTvA5sE4fGU
-Dp/ha8OQAx95EwXuaG7LgARduvOIK3x8qi8KsZoUGJcg2ywurUbkWA==
------END RSA PRIVATE KEY-----

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

@@ -1,252 +0,0 @@
-import type { IncomingMessage } from 'node:http'
-import { Http2ServerRequest } from 'node:http2'
-import type { ServerHttp2Stream } from 'node:http2'
-import { Duplex } from 'node:stream'
-import { inspect } from 'node:util'
-import { GlobalHeaders, RequestHeaders, newHeadersFromIncoming } from '../../src/adapter/headers.ts'
-import { newRequest, Request as LightweightRequest } from '../../src/adapter/request.ts'
-
-// Compatibility cases adapted from srvx's Node header suite:
-// https://github.com/h3js/srvx/blob/4052594e76d5ead2cc4c7cf8f7fa6d5ea9558a0a/test/node-headers.test.ts
-
-const incoming = (rawHeaders: string[], headers: Record<string, unknown>): IncomingMessage =>
-  ({ rawHeaders, headers }) as IncomingMessage
-
-const incomingHttp2 = (
-  rawHeaders: string[],
-  headers: Record<string, string | string[]>
-): Http2ServerRequest =>
-  new Http2ServerRequest(new Duplex() as ServerHttp2Stream, headers, {}, rawHeaders)
-
-const lightweightHeaders = (request: IncomingMessage | Http2ServerRequest): GlobalHeaders =>
-  newHeadersFromIncoming(request)
-
-const nonJoinedHeaderNames = [
-  'age',
-  'authorization',
-  'content-length',
-  'content-type',
-  'etag',
-  'expires',
-  'from',
-  'host',
-  'if-modified-since',
-  'if-unmodified-since',
-  'last-modified',
-  'location',
-  'max-forwards',
-  'proxy-authorization',
-  'referer',
-  'retry-after',
-  'server',
-  'user-agent',
-]
-
-describe('RequestHeaders', () => {
-  it('reads common headers without iterating rawHeaders', () => {
-    let rawHeadersReads = 0
-    const request = {
-      headers: { 'x-test': 'value' },
-      get rawHeaders() {
-        rawHeadersReads++
-        return ['x-test', 'value']
-      },
-    } as unknown as IncomingMessage
-
-    const headers = lightweightHeaders(request)
-
-    expect(headers).toBeInstanceOf(GlobalHeaders)
-    expect(headers.get('X-Test')).toBe('value')
-    expect(headers.has('x-test')).toBe(true)
-    expect(rawHeadersReads).toBe(0)
-    expect(() => headers.get('bad name')).toThrow(TypeError)
-    expect(() => headers.has(':path')).toThrow(TypeError)
-    expect(rawHeadersReads).toBe(0)
-
-    expect([...headers]).toEqual([['x-test', 'value']])
-    expect(rawHeadersReads).toBe(1)
-  })
-
-  it.each(nonJoinedHeaderNames)(
-    'combines repeated %s values consistently before and after iteration',
-    (name) => {
-      const rawHeaders = [name, 'one', name, 'two']
-      const collapsed = { [name]: 'one' }
-
-      const before = lightweightHeaders(incoming(rawHeaders, collapsed))
-      expect(before.get(name)).toBe('one, two')
-      expect(before.has(name)).toBe(true)
-
-      const after = lightweightHeaders(incoming(rawHeaders, collapsed))
-      void [...after]
-      expect(after.get(name)).toBe('one, two')
-    }
-  )
-
-  it('combines headers collapsed by the HTTP/2 parser', () => {
-    const headers = lightweightHeaders(
-      incomingHttp2(['if-none-match', '"a"', 'if-none-match', '"b"'], {
-        'if-none-match': '"a"',
-      })
-    )
-
-    expect(headers.get('if-none-match')).toBe('"a", "b"')
-    void [...headers]
-    expect(headers.get('if-none-match')).toBe('"a", "b"')
-  })
-
-  it('uses an immutable raw-header snapshot for HTTP/2', () => {
-    const rawHeaders = ['x-secret', 'topsecret', 'host', 'localhost']
-    const request = incomingHttp2(rawHeaders, {
-      'x-secret': 'topsecret',
-      host: 'localhost',
-    })
-    const headers = lightweightHeaders(request)
-
-    delete request.headers['x-secret']
-    request.headers['x-added'] = 'value'
-    rawHeaders[1] = 'changed'
-    rawHeaders.push('x-added', 'value')
-
-    expect(headers.get('x-secret')).toBe('topsecret')
-    expect(headers.has('x-added')).toBe(false)
-    void [...headers]
-    expect(headers.get('x-secret')).toBe('topsecret')
-    expect(headers.has('x-added')).toBe(false)
-  })
-
-  it('ignores non-string values in synthesized parsed headers', () => {
-    const headers = lightweightHeaders(
-      incoming(['content-length', '123'], { 'content-length': 123 })
-    )
-
-    expect(headers.get('content-length')).toBe('123')
-    expect(headers.has('content-length')).toBe(true)
-    void [...headers]
-    expect(headers.get('content-length')).toBe('123')
-  })
-
-  it('normalizes raw values consistently before and after materialization', () => {
-    const rawHeaders = ['x-token', '  abc\t', 'x-tab', '\tv v\t', 'x-interior', 'a  b']
-    const headers = lightweightHeaders(incomingHttp2(rawHeaders, {}))
-
-    expect(headers.get('x-token')).toBe('abc')
-    expect(headers.get('x-tab')).toBe('v v')
-    expect(headers.get('x-interior')).toBe('a  b')
-    void [...headers]
-    expect(headers.get('x-token')).toBe('abc')
-    expect(headers.get('x-tab')).toBe('v v')
-    expect(headers.get('x-interior')).toBe('a  b')
-  })
-
-  it('fails closed on values rejected by native Headers', () => {
-    const rawHeaders = ['x-evil', 'ok', 'x-evil', 'bad\0value']
-
-    expect(() => lightweightHeaders(incomingHttp2(rawHeaders, {})).get('x-evil')).toThrow(TypeError)
-    expect(() => lightweightHeaders(incomingHttp2(rawHeaders, {})).has('x-evil')).toThrow(TypeError)
-    expect(() => [...lightweightHeaders(incomingHttp2(rawHeaders, {}))]).toThrow(TypeError)
-  })
-
-  it('preserves cookie and set-cookie representations', () => {
-    const headers = lightweightHeaders(
-      incoming(['cookie', 'a=1', 'cookie', 'b=2', 'set-cookie', 'a=1', 'set-cookie', 'b=2'], {
-        cookie: 'a=1; b=2',
-        'set-cookie': ['ignored'],
-      })
-    )
-
-    expect(headers.get('cookie')).toBe('a=1; b=2')
-    expect(headers.get('set-cookie')).toBe('a=1, b=2')
-    expect(headers.getSetCookie()).toEqual(['a=1', 'b=2'])
-    expect(Object.fromEntries(headers).cookie).toBe('a=1; b=2')
-  })
-
-  it('reads a literal __proto__ header without exposing prototype properties', () => {
-    const headers = lightweightHeaders(
-      incoming(['__proto__', 'value', 'x-test', 'one'], { 'x-test': 'one' })
-    )
-
-    expect(headers.get('__proto__')).toBe('value')
-    expect(headers.has('__proto__')).toBe(true)
-    expect(headers.get('toString')).toBe(null)
-    expect(headers.has('toString')).toBe(false)
-  })
-
-  it('materializes for validation and mutation while preserving identity', () => {
-    const headers = lightweightHeaders(incoming(['host', 'localhost'], { host: 'localhost' }))
-
-    expect(() => headers.get('bad name')).toThrow(TypeError)
-    expect(() => headers.has(':path')).toThrow(TypeError)
-    headers.set('x-test', 'value')
-    headers.append('x-test', 'second')
-
-    expect(headers.get('x-test')).toBe('value, second')
-    let callbackParent: GlobalHeaders | undefined
-    headers.forEach((_value, _key, parent) => {
-      callbackParent = parent
-    })
-    expect(callbackParent).toBe(headers)
-  })
-
-  it('uses the lightweight inspection format', () => {
-    const headers = lightweightHeaders(incoming(['x-test', 'value'], { 'x-test': 'value' }))
-
-    expect(inspect(headers)).toContain("Headers (lightweight) { 'x-test': 'value' }")
-  })
-
-  it('leaves the standard Headers constructor unchanged', () => {
-    const headers = new Headers({ 'x-test': 'one' })
-    headers.append('x-test', 'two')
-
-    expect(global.Headers).toBe(GlobalHeaders)
-    expect(Object.getPrototypeOf(headers)).toBe(GlobalHeaders.prototype)
-    expect(headers.get('x-test')).toBe('one, two')
-    expect(new Headers(headers).get('x-test')).toBe('one, two')
-    expect(new Headers({ rawHeaders: 'ordinary value' }).get('rawHeaders')).toBe('ordinary value')
-  })
-
-  it('uses the internal implementation without replacing the global constructor', () => {
-    const request = incoming(['x-test', 'value'], { 'x-test': 'value' })
-    const headers = newHeadersFromIncoming(request)
-
-    expect(global.Headers).toBe(GlobalHeaders)
-    expect(Object.getPrototypeOf(headers)).toBe(RequestHeaders.prototype)
-    expect(headers).toBeInstanceOf(GlobalHeaders)
-    expect(new GlobalHeaders(headers).get('x-test')).toBe('value')
-  })
-
-  it('uses the live global Headers constructor when it changes after module initialization', () => {
-    class PolyfillHeaders extends GlobalHeaders {}
-    const descriptor = Object.getOwnPropertyDescriptor(globalThis, 'Headers')
-    Object.defineProperty(globalThis, 'Headers', {
-      value: PolyfillHeaders,
-      configurable: true,
-      writable: true,
-    })
-
-    try {
-      const headers = newHeadersFromIncoming(incoming(['x-test', 'value'], { 'x-test': 'value' }))
-
-      expect(headers).toBeInstanceOf(PolyfillHeaders)
-      expect(Object.getPrototypeOf(headers)).toBe(PolyfillHeaders.prototype)
-      expect(headers.get('x-test')).toBe('value')
-    } finally {
-      Object.defineProperty(globalThis, 'Headers', descriptor!)
-    }
-  })
-
-  it('can initialize and clone a native Request after header mutation', () => {
-    const request = newRequest({
-      method: 'GET',
-      url: '/',
-      headers: { host: 'localhost' },
-      rawHeaders: ['host', 'localhost'],
-    } as IncomingMessage)
-    const headers = request.headers
-    headers.set('x-test', 'value')
-
-    expect(request.keepalive).toBe(false)
-    expect(request.headers).toBe(headers)
-    expect(new LightweightRequest(request).headers.get('x-test')).toBe('value')
-  })
-})

package/plugins/acryl-node-server/tests/adapter/helpers/request.ts

@@ -1,190 +0,0 @@
-import { once } from 'node:events'
-import { request as requestHTTP } from 'node:http'
-import type { IncomingMessage, RequestOptions } from 'node:http'
-import { connect } from 'node:http2'
-import type { IncomingHttpHeaders as IncomingHttp2Headers } from 'node:http2'
-import { Server as HttpsServer, request as requestHTTPS } from 'node:https'
-import type { AddressInfo } from 'node:net'
-import { newHeadersFromIncoming } from '../../../src/adapter/headers.ts'
-import { GlobalResponse } from '../../../src/adapter/response.ts'
-import type { ServerType } from '../../../src/adapter/types.ts'
-
-export type ServerRequestInit = Omit<
-  RequestOptions,
-  'agent' | 'host' | 'hostname' | 'path' | 'port' | 'protocol'
-> & {
-  body?: string | Uint8Array
-  path: string
-}
-
-export type ServerRequestHooks = {
-  onHeaders?: (headers: Headers, status: number) => void
-  onChunk?: (chunk: Buffer, index: number) => void
-}
-
-export type Http2RequestInit = {
-  headers?: Record<string, string>
-  method?: string
-  path: string
-}
-
-const ensureListening = async (server: ServerType) => {
-  let address = server.address() as AddressInfo | null
-  let startedByHelper = false
-  if (!address) {
-    server.listen(0, '127.0.0.1')
-    await once(server, 'listening')
-    startedByHelper = true
-    address = server.address() as AddressInfo | null
-  }
-  if (!address) {
-    throw new Error('Server is not listening on a TCP address')
-  }
-
-  return {
-    address,
-    // a no-op if the server was already listening before the request, its
-    // owner is responsible for closing it in that case
-    close: async () => {
-      if (startedByHelper) {
-        await new Promise<void>((resolve) => server.close(() => resolve()))
-      }
-    },
-  }
-}
-
-const sendRequest = (server: ServerType, address: AddressInfo, init: ServerRequestInit) => {
-  const { body, path, ...options } = init
-  const common = {
-    ...options,
-    agent: false,
-    hostname: address.address,
-    path,
-    port: address.port,
-  }
-  const request =
-    server instanceof HttpsServer
-      ? requestHTTPS({ ...common, rejectUnauthorized: false })
-      : requestHTTP(common)
-  request.end(body)
-  return request
-}
-
-const receiveResponse = async (request: ReturnType<typeof sendRequest>) => {
-  const [incoming] = (await once(request, 'response')) as [IncomingMessage]
-  const status = incoming.statusCode
-  if (!status) {
-    throw new Error('Server response did not include a status code')
-  }
-  return { incoming, status }
-}
-
-export const requestServer = async (
-  server: ServerType,
-  init: ServerRequestInit
-): Promise<Response> => {
-  const { address, close } = await ensureListening(server)
-
-  // the request may fail mid-flight (e.g. aborted via `init.signal`), so the
-  // helper-started server is always fully closed before returning or
-  // surfacing an error
-  try {
-    const { incoming, status } = await receiveResponse(sendRequest(server, address, init))
-
-    const hasBody = init.method?.toUpperCase() !== 'HEAD' && ![101, 204, 205, 304].includes(status)
-
-    let responseBody: BodyInit | null = null
-    if (hasBody) {
-      // buffer the body so a helper-started server can be fully closed before
-      // returning, otherwise a subsequent request could hit a half-closed server
-      const chunks: Buffer[] = []
-      for await (const chunk of incoming) {
-        chunks.push(chunk)
-      }
-      responseBody = new Uint8Array(Buffer.concat(chunks))
-    }
-
-    return new GlobalResponse(responseBody, {
-      headers: newHeadersFromIncoming(incoming),
-      status,
-      statusText: incoming.statusMessage,
-    })
-  } finally {
-    await close()
-  }
-}
-
-/**
- * Same as `requestServer`, but exposes the raw body chunks for tests that
- * assert streaming behavior: `onHeaders` fires before any body data arrives
- * and `onChunk` fires per received chunk, so a test can synchronize with the
- * server mid-response. Chunk boundaries are preserved by the chunked
- * transfer-encoding framing.
- */
-export const requestServerChunked = async (
-  server: ServerType,
-  init: ServerRequestInit,
-  hooks: ServerRequestHooks = {}
-): Promise<{ chunks: Buffer[]; response: Response }> => {
-  const { address, close } = await ensureListening(server)
-
-  try {
-    const { incoming, status } = await receiveResponse(sendRequest(server, address, init))
-    const headers = newHeadersFromIncoming(incoming)
-    hooks.onHeaders?.(headers, status)
-
-    const chunks: Buffer[] = []
-    incoming.on('data', (chunk: Buffer) => {
-      hooks.onChunk?.(chunk, chunks.length)
-      chunks.push(chunk)
-    })
-    await once(incoming, 'end')
-
-    return {
-      chunks,
-      response: new GlobalResponse(new Uint8Array(Buffer.concat(chunks)), {
-        headers,
-        status,
-        statusText: incoming.statusMessage,
-      }),
-    }
-  } finally {
-    await close()
-  }
-}
-
-export const requestServerHttp2 = async (
-  server: ServerType,
-  init: Http2RequestInit
-): Promise<Response> => {
-  const { address, close } = await ensureListening(server)
-  const client = connect(`http://${address.address}:${address.port}`)
-  // stream errors reject `once()` below, a session error would otherwise crash
-  client.once('error', () => {})
-
-  try {
-    const stream = client.request({
-      ':method': init.method ?? 'GET',
-      ':path': init.path,
-      ...init.headers,
-    })
-    stream.end()
-
-    const [incomingHeaders, , rawHeaders] = (await once(stream, 'response')) as [
-      IncomingHttp2Headers,
-      number,
-      string[],
-    ]
-    const status = Number(incomingHeaders[':status'])
-    const headers = newHeadersFromIncoming({ rawHeaders })
-
-    const chunks: Buffer[] = []
-    stream.on('data', (chunk: Buffer) => chunks.push(chunk))
-    await once(stream, 'end')
-
-    return new GlobalResponse(new Uint8Array(Buffer.concat(chunks)), { headers, status })
-  } finally {
-    client.close()
-    await close()
-  }
-}