acrylblends 0.6.2 → 0.6.4

package/plugins/acryl-node-server/tests/adapter/setup.ts

@@ -1,16 +0,0 @@
-Object.defineProperty(global, 'fetch', {
-  value: global.fetch,
-  writable: true,
-})
-Object.defineProperty(global, 'Response', {
-  value: global.Response,
-  writable: true,
-})
-Object.defineProperty(global, 'Request', {
-  value: global.Request,
-  writable: true,
-})
-Object.defineProperty(global, 'Headers', {
-  value: global.Headers,
-  writable: true,
-})

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

@@ -1,76 +0,0 @@
-import { RequestError } from '../../src/adapter/error.ts'
-import { buildUrl } from '../../src/adapter/url.ts'
-
-describe('buildUrl', () => {
-  describe('IPv6 host', () => {
-    it('Should throw error for unmatched closing bracket in host', async () => {
-      expect(() => {
-        buildUrl('http', 'host]', '/foo.txt')
-      }).toThrow('Invalid URL')
-    })
-
-    it('Should throw error for unmatched opening bracket in host', async () => {
-      expect(() => {
-        buildUrl('http', '[host', '/foo.txt')
-      }).toThrow('Invalid URL')
-    })
-  })
-
-  describe('URL normalization', () => {
-    test.each([
-      ['https', '[::1]', '/foo.txt'],
-      ['https', '[::1]:8080', '/foo.txt'],
-      ['https', 'localhost', '/'],
-      ['https', 'localhost', '/foo/bar/baz'],
-      ['https', 'localhost', '/foo_bar'],
-      ['https', 'localhost', '/foo//bar'],
-      ['https', 'localhost', '/static/%2e%2e/foo.txt'],
-      ['https', 'localhost', '/static\\..\\foo.txt'],
-      ['https', 'localhost', '/..'],
-      ['https', 'localhost', '/foo/.'],
-      ['https', 'localhost', '/foo/bar/..'],
-      ['https', 'localhost', '/a/b/../../c'],
-      ['https', 'localhost', '/a/../../../b'],
-      ['https', 'localhost', '/a/b/c/../../../'],
-      ['https', 'localhost', '/./foo.txt'],
-      ['https', 'localhost', '/foo/../bar.txt'],
-      ['https', 'localhost', '/a/./b/../c?q=%2E%2E#hash'],
-      ['https', 'localhost', '/foo/%2E/bar/../baz'],
-      ['https', 'localhost', '/hello%20world'],
-      ['https', 'localhost', '/foo%23bar'],
-      ['https', 'localhost', '/foo"bar'],
-      ['https', 'localhost', '/%2e%2E/foo'],
-      ['https', 'localhost', '/caf%C3%A9'],
-      ['https', 'localhost', '/foo%2fbar/..//baz'],
-      ['https', 'localhost', '/foo?q=../bar'],
-      ['https', 'localhost', '/path?q=hello%20world'],
-      ['https', 'localhost', '/file.txt'],
-      ['https', 'localhost', ''],
-      ['http', 'localhost:080', '/foo.txt'],
-      ['http', 'localhost:08080', '/foo.txt'],
-      ['http', 'localhost:80', '/foo.txt'],
-      ['https', 'localhost:80', '/foo.txt'],
-      ['http', 'localhost:443', '/foo.txt'],
-      ['https', 'localhost:443', '/foo.txt'],
-      ['https', 'LOCALHOST', '/foo.txt'],
-      ['https', 'LOCALHOST:80', '/foo.txt'],
-      ['https', 'LOCALHOST:443', '/foo.txt'],
-      ['https', 'LOCALHOST:8080', '/foo.txt'],
-      ['https', 'Localhost:3000', '/foo.txt'],
-    ])('Should successfully normalize `%s://%s%s`', async (scheme, host, path) => {
-      expect(buildUrl(scheme, host, path)).toBe(new URL(path, `${scheme}://${host}`).href)
-    })
-
-    it('Should throw a RequestError for non-origin-form request-target', async () => {
-      expect(() => {
-        buildUrl('http', 'localhost', '*')
-      }).toThrow(new RequestError('Invalid URL'))
-    })
-
-    it('Should throw a RequestError for invalid host header', async () => {
-      expect(() => {
-        buildUrl('http', 'localhost/foo', '/bar')
-      }).toThrow(new RequestError('Invalid host header'))
-    })
-  })
-})

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

@@ -1,23 +0,0 @@
-import { Acryl } from '../../../../acryl-router/src/index.ts'
-import type { HttpBindings } from '../../../src/adapter/index.ts'
-import { createAdaptorServer } from '../../../src/adapter/server.ts'
-import { RESPONSE_ALREADY_SENT } from '../../../src/adapter/utils/response.ts'
-import { requestServer } from '../helpers/request.ts'
-
-describe('RESPONSE_ALREADY_SENT', () => {
-  const app = new Acryl<{ Bindings: HttpBindings }>()
-  app.get('/', (c) => {
-    const { outgoing } = c.env
-    outgoing.writeHead(200, { 'Content-Type': 'text/plain' })
-    outgoing.end('Acryl!')
-    return RESPONSE_ALREADY_SENT
-  })
-  const server = createAdaptorServer(app)
-
-  it('Should return 200 response - GET /', async () => {
-    const res = await requestServer(server, { method: 'GET', path: '/' })
-    expect(res.status).toBe(200)
-    expect(res.headers.get('content-type')).toMatch('text/plain')
-    expect(await res.text()).toBe('Acryl!')
-  })
-})

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

@@ -1,75 +0,0 @@
-import { EventEmitter } from 'node:events'
-import type { ReadStream } from 'node:fs'
-import { createStreamBody } from '../../../src/adapter/utils/stream.ts'
-
-class FakeReadStream extends EventEmitter {
-  pause = vi.fn(() => this)
-  resume = vi.fn(() => this)
-  destroy = vi.fn(() => this)
-}
-
-const asReadStream = (stream: FakeReadStream) => stream as unknown as ReadStream
-
-describe('createStreamBody fallback', () => {
-  it('pauses the node stream when the web stream queue is full and resumes on pull', async () => {
-    const stream = new FakeReadStream()
-    const body = createStreamBody(asReadStream(stream), false)
-    const pauseCallsAfterStart = stream.pause.mock.calls.length
-
-    stream.emit('data', Buffer.from('a'))
-
-    expect(stream.pause.mock.calls.length).toBeGreaterThan(pauseCallsAfterStart)
-
-    const reader = body.getReader()
-    const resumeCallsBeforeRead = stream.resume.mock.calls.length
-    const result = await reader.read()
-    await Promise.resolve()
-
-    expect(result.done).toBe(false)
-    expect(Buffer.from(result.value ?? []).toString()).toBe('a')
-    expect(stream.resume.mock.calls.length).toBeGreaterThan(resumeCallsBeforeRead)
-
-    await reader.cancel()
-  })
-
-  it('destroys the node stream on cancel and ignores later terminal events', async () => {
-    const stream = new FakeReadStream()
-    const body = createStreamBody(asReadStream(stream), false)
-    const reader = body.getReader()
-
-    await reader.cancel()
-
-    expect(stream.destroy).toHaveBeenCalledTimes(1)
-    expect(stream.listenerCount('data')).toBe(0)
-    expect(stream.listenerCount('end')).toBe(0)
-    expect(() => stream.emit('end')).not.toThrow()
-    expect(() => stream.emit('error', new Error('late error'))).not.toThrow()
-
-    stream.emit('close')
-    expect(stream.listenerCount('error')).toBe(0)
-  })
-
-  it('propagates node stream errors to the web stream reader', async () => {
-    const stream = new FakeReadStream()
-    const body = createStreamBody(asReadStream(stream), false)
-    const reader = body.getReader()
-    const error = new Error('read failed')
-    const readPromise = reader.read()
-
-    stream.emit('error', error)
-
-    await expect(readPromise).rejects.toBe(error)
-  })
-
-  it('closes the web stream on end and ignores a later close event', async () => {
-    const stream = new FakeReadStream()
-    const body = createStreamBody(asReadStream(stream), false)
-    const reader = body.getReader()
-    const readPromise = reader.read()
-
-    stream.emit('end')
-
-    await expect(readPromise).resolves.toEqual({ done: true, value: undefined })
-    expect(() => stream.emit('close')).not.toThrow()
-  })
-})

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

@@ -1,235 +0,0 @@
-import { Writable } from 'node:stream'
-import {
-  buildOutgoingHttpHeaders,
-  writeFromReadableStream,
-  readWithoutBlocking,
-} from '../../src/adapter/utils.ts'
-
-describe('buildOutgoingHttpHeaders', () => {
-  it('original content-type is preserved', () => {
-    const headers = new Headers({
-      a: 'b',
-      'content-type': 'text/html; charset=UTF-8',
-    })
-    const result = buildOutgoingHttpHeaders(headers, 'text/plain; charset=UTF-8')
-    expect(result).toEqual({
-      a: 'b',
-      'content-type': 'text/html; charset=UTF-8',
-    })
-  })
-
-  it('multiple set-cookie with default content-type', () => {
-    const headers = new Headers()
-    headers.append('set-cookie', 'a')
-    headers.append('set-cookie', 'b')
-    const result = buildOutgoingHttpHeaders(headers, 'text/plain; charset=UTF-8')
-    expect(result).toEqual({
-      'set-cookie': ['a', 'b'],
-      'content-type': 'text/plain; charset=UTF-8',
-    })
-  })
-
-  it('Headers with default content-type', () => {
-    const headers = new Headers({
-      a: 'b',
-    })
-    const result = buildOutgoingHttpHeaders(headers, 'text/plain; charset=UTF-8')
-    expect(result).toEqual({
-      a: 'b',
-      'content-type': 'text/plain; charset=UTF-8',
-    })
-  })
-
-  it('Record<string, string> with default content-type', () => {
-    const headers = {
-      a: 'b',
-      'Set-Cookie': 'c', // case-insensitive
-    }
-    const result = buildOutgoingHttpHeaders(headers, 'text/plain; charset=UTF-8')
-    expect(result).toEqual({
-      a: 'b',
-      'set-cookie': ['c'],
-      'content-type': 'text/plain; charset=UTF-8',
-    })
-  })
-
-  it('Record<string, string>[] with default content-type', () => {
-    const headers: HeadersInit = [['a', 'b']]
-    const result = buildOutgoingHttpHeaders(headers, 'text/plain; charset=UTF-8')
-    expect(result).toEqual({
-      a: 'b',
-      'content-type': 'text/plain; charset=UTF-8',
-    })
-  })
-
-  it('null without default content-type', () => {
-    const result = buildOutgoingHttpHeaders(null, undefined)
-    expect(result).toEqual({})
-  })
-
-  it('undefined without default content-type', () => {
-    const result = buildOutgoingHttpHeaders(undefined, undefined)
-    expect(result).toEqual({})
-  })
-
-  it('null with default content-type', () => {
-    const result = buildOutgoingHttpHeaders(null, 'text/plain; charset=UTF-8')
-    expect(result).toEqual({
-      'content-type': 'text/plain; charset=UTF-8',
-    })
-  })
-
-  it('does not override existing content-type when default is provided', () => {
-    const result = buildOutgoingHttpHeaders(
-      {
-        'content-type': 'application/json',
-      },
-      'text/plain; charset=UTF-8'
-    )
-    expect(result).toEqual({
-      'content-type': 'application/json',
-    })
-  })
-})
-
-describe('writeFromReadableStream', () => {
-  it('should handle client disconnection', async () => {
-    let enqueueCalled = false
-    let cancelCalled = false
-    let enqueueTimeout: NodeJS.Timeout | undefined
-
-    // Create test ReadableStream
-    const stream = new ReadableStream({
-      start(controller) {
-        enqueueTimeout = setTimeout(() => {
-          try {
-            controller.enqueue(new TextEncoder().encode('test'))
-            enqueueCalled = true
-          } catch {
-            // Test should fail if error occurs
-          }
-          controller.close()
-        }, 100)
-      },
-      cancel() {
-        cancelCalled = true
-        clearTimeout(enqueueTimeout)
-      },
-    })
-
-    // Test Writable stream
-    const writable = new Writable()
-
-    // Simulate client disconnection after 50ms
-    setTimeout(() => {
-      writable.destroy()
-    }, 50)
-
-    await writeFromReadableStream(stream, writable)
-
-    expect(enqueueCalled).toBe(false) // enqueue should not be called
-    expect(cancelCalled).toBe(true) // cancel should be called
-  })
-})
-
-describe('readWithoutBlocking', () => {
-  const encode = (body: string) => new TextEncoder().encode(body)
-  it('should return the body for simple text', async () => {
-    const text = 'Hello! Node!'
-    const response = new Response(text)
-    const reader = response.body!.getReader()
-    const firstChunk = await readWithoutBlocking(reader.read())
-    expect(firstChunk).toEqual({ done: false, value: encode(text) })
-    const secondChunk = await readWithoutBlocking(reader.read())
-    expect(secondChunk).toEqual({ done: true, value: undefined })
-  })
-
-  it('should return the body for large text', async () => {
-    const text = 'a'.repeat(1024 * 1024 * 10)
-    const response = new Response(text)
-    const reader = response.body!.getReader()
-    const firstChunk = await readWithoutBlocking(reader.read())
-    expect(firstChunk?.done).toBe(false)
-    expect(firstChunk?.value?.length).toEqual(10 * 1024 * 1024)
-    const secondChunk = await readWithoutBlocking(reader.read())
-    expect(secondChunk).toEqual({ done: true, value: undefined })
-  })
-
-  it('should return the body simple synchronous readable stream', async () => {
-    const text = 'Hello! Node!'
-    const body = new ReadableStream({
-      start(controller) {
-        controller.enqueue(encode(text))
-        controller.close()
-      },
-    })
-    const response = new Response(body)
-    const reader = response.body!.getReader()
-    const result = await readWithoutBlocking(reader.read())
-    expect(result).toEqual({ done: false, value: encode(text) })
-  })
-
-  it('should return undefined if stream is not ready', async () => {
-    const text = 'Hello! Node!'
-    const body = new ReadableStream({
-      async start(controller) {
-        await new Promise((resolve) => setTimeout(resolve))
-        controller.enqueue(encode(text))
-        controller.close()
-      },
-    })
-    const response = new Response(body)
-    const reader = response.body!.getReader()
-    const readPromise = reader.read()
-
-    const result = await readWithoutBlocking(readPromise)
-    expect(result).toBeUndefined()
-
-    await new Promise((resolve) => setTimeout(resolve))
-    const result2 = await readWithoutBlocking(readPromise)
-    expect(result2).toEqual({ done: false, value: encode(text) })
-    const result3 = await readWithoutBlocking(reader.read())
-    expect(result3).toEqual({ done: true, value: undefined })
-  })
-
-  it('should return undefined value if stream is closed in start', async () => {
-    const body = new ReadableStream({
-      async start(controller) {
-        controller.close()
-      },
-    })
-
-    const response = new Response(body)
-    const reader = response.body!.getReader()
-    const readPromise = reader.read()
-
-    const result = await readWithoutBlocking(readPromise)
-    expect(result).toEqual({ done: true, value: undefined })
-  })
-
-  it('should return undefined if stream is errored in start', async () => {
-    const body = new ReadableStream({
-      async start() {
-        throw new Error('test')
-      },
-    })
-    const response = new Response(body)
-    const reader = response.body!.getReader()
-    const readPromise = reader.read()
-
-    await expect(readWithoutBlocking(readPromise)).rejects.toThrow('test')
-  })
-
-  it('should return undefined if stream is errored', async () => {
-    const body = new ReadableStream({
-      pull() {
-        throw new Error('test')
-      },
-    })
-    const response = new Response(body)
-    const reader = response.body!.getReader()
-    const readPromise = reader.read()
-
-    await expect(readWithoutBlocking(readPromise)).rejects.toThrow('test')
-  })
-})

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

@@ -1,260 +0,0 @@
-import { Acryl } from '../../../acryl-router/src/index.ts'
-import { WebSocket, WebSocketServer } from 'ws'
-import { connect } from 'node:net'
-import type { AddressInfo } from 'node:net'
-import { createAdaptorServer, upgradeWebSocket } from '../../src/adapter/index.ts'
-
-describe('WebSocket', () => {
-  const startServer = (app: Acryl) => {
-    const wss = new WebSocketServer({ noServer: true })
-    const server = createAdaptorServer({ fetch: app.fetch, websocket: { server: wss } })
-    return new Promise<{ server: ReturnType<typeof createAdaptorServer>; address: AddressInfo }>(
-      (resolve) => {
-        server.listen(0, () => {
-          resolve({ server, address: server.address() as AddressInfo })
-        })
-      }
-    )
-  }
-
-  it('should connect with upgradeWebSocket without manual injection', async () => {
-    const app = new Acryl()
-
-    app.get(
-      '/ws',
-      upgradeWebSocket(() => ({
-        onMessage(event, ws) {
-          ws.send(event.data as string)
-        },
-      }))
-    )
-
-    const { server, address } = await startServer(app)
-
-    try {
-      const ws = new WebSocket(`ws://127.0.0.1:${address.port}/ws`)
-      await new Promise<void>((resolve, reject) => {
-        ws.once('open', () => {
-          ws.send('hello')
-        })
-        ws.once('message', (data) => {
-          expect(data.toString()).toBe('hello')
-          resolve()
-        })
-        ws.once('error', reject)
-      })
-      ws.close()
-    } finally {
-      await new Promise<void>((resolve) => server.close(() => resolve()))
-    }
-  })
-
-  it('should reject WebSocket upgrade when route is not upgraded', async () => {
-    const app = new Acryl()
-    app.get('/ws', (c) => c.text('ok'))
-
-    const { server, address } = await startServer(app)
-
-    try {
-      const ws = new WebSocket(`ws://127.0.0.1:${address.port}/ws`)
-      await new Promise<void>((resolve, reject) => {
-        ws.once('unexpected-response', (_, response) => {
-          expect(response.statusCode).toBe(200)
-          resolve()
-        })
-        ws.once('open', () => reject(new Error('WebSocket must not be upgraded')))
-        ws.once('error', () => resolve())
-      })
-    } finally {
-      await new Promise<void>((resolve) => server.close(() => resolve()))
-    }
-  })
-
-  it('should forward response headers set by middleware on a successful upgrade', async () => {
-    const app = new Acryl()
-
-    app.use(async (c, next) => {
-      await next()
-      c.header('x-auth-result', c.req.header('authorization') ? 'authorized' : 'missing')
-    })
-    app.get(
-      '/ws',
-      upgradeWebSocket(() => ({}))
-    )
-
-    const { server, address } = await startServer(app)
-
-    try {
-      const ws = new WebSocket(`ws://127.0.0.1:${address.port}/ws`, {
-        headers: {
-          authorization: 'Bearer token',
-        },
-      })
-      const responseHeaders = await new Promise<Record<string, string | string[] | undefined>>(
-        (resolve, reject) => {
-          ws.once('upgrade', (response) => {
-            resolve(response.headers)
-          })
-          ws.once('error', reject)
-        }
-      )
-      expect(responseHeaders['x-auth-result']).toBe('authorized')
-      ws.close()
-    } finally {
-      await new Promise<void>((resolve) => server.close(() => resolve()))
-    }
-  })
-
-  it('should forward response headers when the upgrade is rejected', async () => {
-    const app = new Acryl()
-
-    app.get(
-      '/ws',
-      () =>
-        new Response(null, {
-          status: 401,
-          headers: {
-            'x-auth-result': 'missing',
-          },
-        })
-    )
-
-    const { server, address } = await startServer(app)
-
-    try {
-      const ws = new WebSocket(`ws://127.0.0.1:${address.port}/ws`)
-      const responseHeaders = await new Promise<Record<string, string | string[] | undefined>>(
-        (resolve, reject) => {
-          ws.once('unexpected-response', (_, response) => {
-            resolve(response.headers)
-          })
-          ws.once('open', () => reject(new Error('WebSocket must not be upgraded')))
-        }
-      )
-      expect(responseHeaders['x-auth-result']).toBe('missing')
-    } finally {
-      await new Promise<void>((resolve) => server.close(() => resolve()))
-    }
-  })
-
-  it('should not block other upgrade listeners', async () => {
-    const app = new Acryl()
-    const { server, address } = await startServer(app)
-    const wss = new WebSocketServer({ noServer: true })
-
-    server.on('upgrade', (request, socket, head) => {
-      if (request.url !== '/custom') {
-        return
-      }
-      wss.handleUpgrade(request, socket, head, (ws) => {
-        wss.emit('connection', ws, request)
-      })
-    })
-
-    try {
-      const ws = new WebSocket(`ws://127.0.0.1:${address.port}/custom`)
-      await new Promise<void>((resolve, reject) => {
-        ws.once('open', resolve)
-        ws.once('error', reject)
-      })
-      ws.close()
-    } finally {
-      wss.close()
-      await new Promise<void>((resolve) => server.close(() => resolve()))
-    }
-  })
-
-  it('should call onError with the underlying error when the raw socket errors', async () => {
-    const app = new Acryl()
-    const receivedError = new Error('boom')
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    let rawWs: any
-    const onErrorCalled = new Promise<Event>((resolve) => {
-      app.get(
-        '/ws',
-        upgradeWebSocket(() => ({
-          onOpen(_evt, ws) {
-            rawWs = ws.raw
-          },
-          onError(evt) {
-            resolve(evt)
-          },
-        }))
-      )
-    })
-
-    const { server, address } = await startServer(app)
-
-    try {
-      const ws = new WebSocket(`ws://127.0.0.1:${address.port}/ws`)
-      await new Promise<void>((resolve, reject) => {
-        ws.once('open', resolve)
-        ws.once('error', reject)
-      })
-
-      rawWs.emit('error', receivedError)
-
-      const evt = await onErrorCalled
-      expect(evt).toBeInstanceOf(Event)
-      expect((evt as ErrorEvent).error).toBe(receivedError)
-
-      ws.close()
-    } finally {
-      await new Promise<void>((resolve) => server.close(() => resolve()))
-    }
-  })
-
-  it('should not leak the request when a handshake is aborted by an invalid Sec-WebSocket-Key', async () => {
-    let liveCount = 0
-    const registry = new FinalizationRegistry(() => {
-      liveCount--
-    })
-
-    const app = new Acryl()
-    app.use('/ws', async (c, next) => {
-      liveCount++
-      registry.register((c.env as { incoming: object }).incoming, 'incoming')
-      await next()
-    })
-    app.get(
-      '/ws',
-      upgradeWebSocket(() => ({
-        onOpen() {
-          throw new Error('onOpen must not be called for an aborted handshake')
-        },
-      }))
-    )
-
-    const { server, address } = await startServer(app)
-
-    try {
-      const statusLine = await new Promise<string>((resolve, reject) => {
-        const socket = connect(address.port, '127.0.0.1', () => {
-          socket.write(
-            'GET /ws HTTP/1.1\r\n' +
-              `Host: 127.0.0.1:${address.port}\r\n` +
-              'Upgrade: websocket\r\n' +
-              'Connection: Upgrade\r\n' +
-              'Sec-WebSocket-Version: 13\r\n' +
-              'Sec-WebSocket-Key: not-a-valid-key\r\n' +
-              '\r\n'
-          )
-        })
-        socket.once('data', (chunk) => {
-          socket.destroy()
-          resolve(chunk.toString('utf-8').split('\r\n')[0])
-        })
-        socket.once('error', reject)
-      })
-      expect(statusLine).toContain('400')
-
-      for (let i = 0; i < 20 && liveCount > 0; i++) {
-        global.gc?.()
-        await new Promise((resolve) => setTimeout(resolve, 10))
-      }
-      expect(liveCount).toBe(0)
-    } finally {
-      await new Promise<void>((resolve) => server.close(() => resolve()))
-    }
-  })
-})