acrylblends 0.6.3 → 0.7.0

package/plugins/acryl-inspect/tests/service.spec.ts

@@ -1,121 +0,0 @@
-/**
- * The inspector against real Cordis plugins: what it reports is what Cordis holds, so the tests build a small system and
- * compare the report with what the plugins actually did.
- */
-
-import { Context } from '@deepseek-ai/cordis'
-import { Acryl, apply as routerApply, name as routerName } from '../../acryl-router/src/index.ts'
-import { afterEach, describe, expect, it } from 'vitest'
-import { apply, name, type PluginReport } from '../src/index.ts'
-
-const contexts: Context[] = []
-const settle = (): Promise<void> => new Promise(resolve => setTimeout(resolve, 0))
-afterEach(async () => {
-  while (contexts.length > 0) await contexts.pop()?.fiber.dispose()
-})
-
-const market = {
-  name: 'demo-market',
-  inject: ['router'],
-  apply(ctx: Context): void {
-    ctx.router.route('/api/demo', new Acryl()
-      .use(async (_c, next) => { await next() })
-      .get('/state', c => c.json({ ok: true }))
-      .post('/sources', c => c.json({ ok: true }, 201)))
-  },
-}
-
-async function system(): Promise<Context> {
-  const ctx = new Context()
-  contexts.push(ctx)
-  ctx.plugin({ name: routerName, apply: routerApply }, { trailingSlash: 'strict' })
-  ctx.plugin({ name, apply })
-  await settle()
-  return ctx
-}
-
-const byName = (reports: readonly PluginReport[], pluginName: string): PluginReport => {
-  const found = reports.find(report => report.name === pluginName)
-  if (found === undefined) throw new Error(`no report for ${pluginName}`)
-  return found
-}
-
-describe('acryl-inspect', () => {
-  it('counts what an inline ctx.inject callback registers as the owning plugin\'s', async () => {
-    const ctx = await system()
-    ctx.plugin({
-      name: 'demo-inline',
-      apply(inner: Context): void {
-        inner.inject(['router'], deeper => { deeper.router.route('/', new Acryl().get('/api/inline', c => c.json({ ok: true }))) })
-      },
-    })
-    await settle()
-    const reports = ctx.inspect.plugins()
-    expect(byName(reports, 'demo-inline').routes).toEqual([{ method: 'GET', path: '/api/inline' }])
-    expect(reports.every(report => report.name !== 'anonymous')).toBe(true)
-  })
-
-  it('reports what a plugin requires, provides and registers, from the running system', async () => {
-    const ctx = await system()
-    ctx.plugin(market)
-    await settle()
-    const reports = ctx.inspect.plugins()
-
-    expect(byName(reports, 'acryl-router')).toMatchObject({ state: 'ACTIVE', requires: [], provides: ['router'] })
-    expect(byName(reports, 'acryl-inspect')).toMatchObject({ state: 'ACTIVE', provides: ['inspect'] })
-    const demo = byName(reports, 'demo-market')
-    expect(demo).toMatchObject({
-      state: 'ACTIVE',
-      requires: ['router'],
-      provides: [],
-      mounts: ['/api/demo'],
-      routes: [{ method: 'ALL', path: '/api/demo/*' }, { method: 'GET', path: '/api/demo/state' }, { method: 'POST', path: '/api/demo/sources' }],
-      removedOnUnload: 1,
-    })
-  })
-
-  it('shows a plugin whose service is missing as PENDING and says what it waits for', async () => {
-    const ctx = await system()
-    ctx.plugin({ name: 'needs-a-thing', inject: ['neverProvided'], apply() { /* never runs */ } })
-    await settle()
-    expect(byName(ctx.inspect.plugins(), 'needs-a-thing')).toMatchObject({ state: 'PENDING', requires: ['neverProvided'] })
-    expect(ctx.inspect.explain('needs-a-thing')).toContain('it starts when neverProvided is available')
-  })
-
-  it('stops listing a plugin that unloaded, and the router really lost what the report said would go', async () => {
-    const ctx = await system()
-    const baseline = ctx.router.size
-    const fiber = ctx.plugin(market)
-    await settle()
-    const promised = byName(ctx.inspect.plugins(), 'demo-market').removedOnUnload
-    expect(ctx.router.size - baseline).toBe(promised)
-
-    await fiber.dispose()
-    await settle()
-    expect(ctx.inspect.plugins().some(report => report.name === 'demo-market' && report.state === 'ACTIVE')).toBe(false)
-    expect(ctx.router.size).toBe(baseline)
-  })
-
-  it('serves the same facts on the router, in process', async () => {
-    const ctx = await system()
-    ctx.plugin(market)
-    await settle()
-    const list = await ctx.router.fetch(new Request('http://acryl.test/api/inspect/plugins'))
-    expect(list.status).toBe(200)
-    const reports = await list.json() as PluginReport[]
-    expect(byName(reports, 'demo-market').routes).toHaveLength(3)
-
-    const one = await ctx.router.fetch(new Request('http://acryl.test/api/inspect/plugins/demo-market'))
-    expect(await one.text()).toContain('removes 1 registration and nothing else')
-    expect((await ctx.router.fetch(new Request('http://acryl.test/api/inspect/plugins/nope'))).status).toBe(404)
-  })
-
-  it('needs no router: without one it still answers in code and registers no routes', async () => {
-    const ctx = new Context()
-    contexts.push(ctx)
-    ctx.plugin({ name, apply })
-    await settle()
-    expect(byName(ctx.inspect.plugins(), 'acryl-inspect').routes).toEqual([])
-    expect(ctx.inspect.render()).toContain('acryl-inspect (ACTIVE)')
-  })
-})

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

@@ -1,76 +0,0 @@
-import { Response as PonyfillResponse } from '@whatwg-node/fetch'
-import { Acryl } from '../../../acryl-router/src/index.ts'
-
-export const app = new Acryl()
-
-app.get('/', (c) => c.text('Hello! Node!'))
-app.get('/url', (c) => c.text(c.req.url))
-
-app.get('/posts', (c) => {
-  return c.text(`Page ${c.req.query('page')}`)
-})
-app.get('/user-agent', (c) => {
-  return c.text(c.req.header('user-agent') as string)
-})
-app.post('/posts', (c) => {
-  return c.redirect('/posts')
-})
-app.post('/body-consumed', async (c) => {
-  return c.text(`Body length: ${(await c.req.text()).length}`)
-})
-app.post('/no-body-consumed', (c) => {
-  if (!c.req.raw.body) {
-    // force create new request object
-    throw new Error('No body consumed')
-  }
-  return c.text('No body consumed')
-})
-app.post('/body-cancelled', (c) => {
-  if (!c.req.raw.body) {
-    // force create new request object
-    throw new Error('No body consumed')
-  }
-  c.req.raw.body.cancel()
-  return c.text('Body cancelled')
-})
-app.post('/partially-consumed', async (c) => {
-  if (!c.req.raw.body) {
-    // force create new request object
-    throw new Error('No body consumed')
-  }
-  const reader = c.req.raw.body.getReader()
-  await reader.read() // read only one chunk
-  return c.text('Partially consumed')
-})
-app.post('/partially-consumed-and-cancelled', async (c) => {
-  if (!c.req.raw.body) {
-    // force create new request object
-    throw new Error('No body consumed')
-  }
-  const reader = c.req.raw.body.getReader()
-  await reader.read() // read only one chunk
-  reader.cancel()
-  return c.text('Partially consumed and cancelled')
-})
-app.post('/early-413', (c) => {
-  if (!c.req.raw.body) {
-    // force create new request object
-    throw new Error('No body consumed')
-  }
-  return c.text('Payload Too Large', 413)
-})
-app.delete('/posts/:id', (c) => {
-  return c.text(`DELETE ${c.req.param('id')}`)
-})
-// @ts-expect-error the response is string
-app.get('/invalid', () => {
-  return '<h1>HTML</h1>'
-})
-app.get('/ponyfill', () => {
-  return new PonyfillResponse('Pony')
-})
-
-app.on('trace', '/', (c) => {
-  const headers = c.req.raw.headers // build new request object
-  return c.text(`headers: ${JSON.stringify(headers)}`)
-})

package/plugins/acryl-node-server/tests/adapter/assets/.static/plain.txt

@@ -1 +0,0 @@
-This is plain.txt

package/plugins/acryl-node-server/tests/adapter/assets/secret.txt

@@ -1 +0,0 @@
-secret

package/plugins/acryl-node-server/tests/adapter/assets/static/acryl.html

@@ -1 +0,0 @@
-<h1>This is Acryl.html</h1>

package/plugins/acryl-node-server/tests/adapter/assets/static/admin/secret.txt

@@ -1 +0,0 @@
-secret

package/plugins/acryl-node-server/tests/adapter/assets/static/data.json

@@ -1,5 +0,0 @@
-{
-    "id": 1,
-    "name": "Foo Bar",
-    "flag": true
-}

package/plugins/acryl-node-server/tests/adapter/assets/static/extensionless

@@ -1 +0,0 @@
-Extensionless

package/plugins/acryl-node-server/tests/adapter/assets/static/index.html

@@ -1 +0,0 @@
-<h1>Hello Acryl</h1>

package/plugins/acryl-node-server/tests/adapter/assets/static/plain.txt

@@ -1 +0,0 @@
-This is plain.txt

package/plugins/acryl-node-server/tests/adapter/assets/static-with-context-path/plain.txt

@@ -1 +0,0 @@
-This is plain.txt

package/plugins/acryl-node-server/tests/adapter/assets/static-with-precompressed/hello.bin

@@ -1 +0,0 @@
-Hello Not Compressed

package/plugins/acryl-node-server/tests/adapter/assets/static-with-precompressed/hello.bin.br

@@ -1 +0,0 @@
-Hello br Compressed

package/plugins/acryl-node-server/tests/adapter/assets/static-with-precompressed/hello.txt

@@ -1 +0,0 @@
-Hello Not Compressed

package/plugins/acryl-node-server/tests/adapter/assets/static-with-precompressed/hello.txt.br

@@ -1 +0,0 @@
-Hello br Compressed

package/plugins/acryl-node-server/tests/adapter/assets/static-with-precompressed/hello.txt.zst

@@ -1 +0,0 @@
-Hello zstd Compressed

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

@@ -1,34 +0,0 @@
-import { Acryl } from '../../../acryl-router/src/index.ts'
-import type { AddressType, ConnInfo } from '../../../acryl-router/src/helpers/index.ts'
-import { getConnInfo } from '../../src/adapter/conninfo.ts'
-
-describe('ConnInfo', () => {
-  it('Should works', async () => {
-    const app = new Acryl().get('/', (c) => c.json(getConnInfo(c)))
-
-    const socket = {
-      remoteAddress: '0.0.0.0',
-      remoteFamily: 'IPv4',
-      remotePort: 3030,
-    }
-    expect(
-      await (
-        await app.request(
-          '/',
-          {},
-          {
-            incoming: {
-              socket,
-            },
-          }
-        )
-      ).json()
-    ).toEqual({
-      remote: {
-        address: socket.remoteAddress,
-        addressType: socket.remoteFamily as AddressType,
-        port: socket.remotePort,
-      },
-    } satisfies ConnInfo)
-  })
-})

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()
-    }
-  })
-})