acrylblends 0.6.1 → 0.6.2

package/plugins/acryl-router/src/core/helper/dev/index.test.ts

@@ -0,0 +1,181 @@
+import { getRouterName, inspectRoutes, showRoutes } from './index.ts'
+import { Acryl } from '../../app.ts'
+import { RegExpRouter } from '../../router/reg-exp-router/index.ts'
+import type { Handler, MiddlewareHandler } from '../../types.ts'
+
+const namedMiddleware: MiddlewareHandler = (_, next) => next()
+const namedHandler: Handler = (c) => c.text('hi')
+const app = new Acryl()
+  .use('*', (_c, next) => next())
+  .get(
+    '/',
+    (_, next) => next(),
+    (c) => c.text('hi')
+  )
+  .get('/named', namedMiddleware, namedHandler)
+  .post('/', (c) => c.text('hi'))
+  .put('/', (c) => c.text('hi'))
+  .patch('/', (c) => c.text('hi'))
+  .delete('/', (c) => c.text('hi'))
+  .options('/', (c) => c.text('hi'))
+  .get('/static', () => new Response('hi'))
+
+describe('inspectRoutes()', () => {
+  it('should return correct data', async () => {
+    expect(inspectRoutes(app)).toEqual([
+      { path: '/*', method: 'ALL', name: '[middleware]', isMiddleware: true },
+      { path: '/', method: 'GET', name: '[middleware]', isMiddleware: true },
+      { path: '/', method: 'GET', name: '[handler]', isMiddleware: false },
+      { path: '/named', method: 'GET', name: 'namedMiddleware', isMiddleware: true },
+      { path: '/named', method: 'GET', name: 'namedHandler', isMiddleware: false },
+      { path: '/', method: 'POST', name: '[handler]', isMiddleware: false },
+      { path: '/', method: 'PUT', name: '[handler]', isMiddleware: false },
+      { path: '/', method: 'PATCH', name: '[handler]', isMiddleware: false },
+      { path: '/', method: 'DELETE', name: '[handler]', isMiddleware: false },
+      { path: '/', method: 'OPTIONS', name: '[handler]', isMiddleware: false },
+      { path: '/static', method: 'GET', name: '[handler]', isMiddleware: false },
+    ])
+  })
+
+  it('should return [handler] also for sub app', async () => {
+    const subApp = new Acryl()
+
+    subApp.get('/', (c) => c.json(0))
+    subApp.onError((_, c) => c.json(0))
+
+    const mainApp = new Acryl()
+    mainApp.route('/', subApp)
+    expect(inspectRoutes(mainApp)).toEqual([
+      {
+        isMiddleware: false,
+        method: 'GET',
+        name: '[handler]',
+        path: '/',
+      },
+    ])
+  })
+})
+
+describe('showRoutes()', () => {
+  let logs: string[] = []
+
+  let originalLog: typeof console.log
+  beforeAll(() => {
+    originalLog = console.log
+    console.log = (...args) => logs.push(...args)
+  })
+  afterAll(() => {
+    console.log = originalLog
+  })
+
+  beforeEach(() => {
+    logs = []
+  })
+  it('should render simple output', async () => {
+    showRoutes(app)
+    expect(logs).toEqual([
+      '\x1b[32mGET\x1b[0m      /',
+      '\x1b[32mGET\x1b[0m      /named',
+      '\x1b[32mPOST\x1b[0m     /',
+      '\x1b[32mPUT\x1b[0m      /',
+      '\x1b[32mPATCH\x1b[0m    /',
+      '\x1b[32mDELETE\x1b[0m   /',
+      '\x1b[32mOPTIONS\x1b[0m  /',
+      '\x1b[32mGET\x1b[0m      /static',
+    ])
+  })
+
+  it('should render output includes handlers and middlewares', async () => {
+    showRoutes(app, { verbose: true })
+    expect(logs).toEqual([
+      '\x1b[32mALL\x1b[0m      /*',
+      '           [middleware]',
+      '\x1b[32mGET\x1b[0m      /',
+      '           [middleware]',
+      '           [handler]',
+      '\x1b[32mGET\x1b[0m      /named',
+      '           namedMiddleware',
+      '           namedHandler',
+      '\x1b[32mPOST\x1b[0m     /',
+      '           [handler]',
+      '\x1b[32mPUT\x1b[0m      /',
+      '           [handler]',
+      '\x1b[32mPATCH\x1b[0m    /',
+      '           [handler]',
+      '\x1b[32mDELETE\x1b[0m   /',
+      '           [handler]',
+      '\x1b[32mOPTIONS\x1b[0m  /',
+      '           [handler]',
+      '\x1b[32mGET\x1b[0m      /static',
+      '           [handler]',
+    ])
+  })
+
+  it('should render not colorized output', async () => {
+    showRoutes(app, { colorize: false })
+    expect(logs).toEqual([
+      'GET      /',
+      'GET      /named',
+      'POST     /',
+      'PUT      /',
+      'PATCH    /',
+      'DELETE   /',
+      'OPTIONS  /',
+      'GET      /static',
+    ])
+  })
+})
+
+describe('showRoutes() in NO_COLOR', () => {
+  let logs: string[] = []
+
+  let originalLog: typeof console.log
+  beforeAll(() => {
+    vi.stubEnv('NO_COLOR', '1')
+    originalLog = console.log
+    console.log = (...args) => logs.push(...args)
+  })
+  afterAll(() => {
+    vi.unstubAllEnvs()
+    console.log = originalLog
+  })
+
+  beforeEach(() => {
+    logs = []
+  })
+  it('should render not colorized output', async () => {
+    showRoutes(app)
+    expect(logs).toEqual([
+      'GET      /',
+      'GET      /named',
+      'POST     /',
+      'PUT      /',
+      'PATCH    /',
+      'DELETE   /',
+      'OPTIONS  /',
+      'GET      /static',
+    ])
+  })
+  it('should render colorized output if colorize: true', async () => {
+    showRoutes(app, { colorize: true })
+    expect(logs).toEqual([
+      '\x1b[32mGET\x1b[0m      /',
+      '\x1b[32mGET\x1b[0m      /named',
+      '\x1b[32mPOST\x1b[0m     /',
+      '\x1b[32mPUT\x1b[0m      /',
+      '\x1b[32mPATCH\x1b[0m    /',
+      '\x1b[32mDELETE\x1b[0m   /',
+      '\x1b[32mOPTIONS\x1b[0m  /',
+      '\x1b[32mGET\x1b[0m      /static',
+    ])
+  })
+})
+
+describe('getRouterName()', () => {
+  it('Should return the correct router name', async () => {
+    const app = new Acryl({
+      router: new RegExpRouter(),
+    })
+    expect(getRouterName(app)).toBe('RegExpRouter')
+  })
+})

package/plugins/acryl-router/src/core/helper/dev/index.ts

@@ -0,0 +1,79 @@
+/**
+ * @module
+ * Dev Helper for Acryl.
+ */
+
+import type { Acryl } from '../../app.ts'
+import type { Env, RouterRoute } from '../../types.ts'
+import { getColorEnabled } from '../../utils/color.ts'
+import { findTargetHandler, isMiddleware } from '../../utils/handler.ts'
+
+interface ShowRoutesOptions {
+  verbose?: boolean
+  colorize?: boolean
+}
+
+interface RouteData {
+  path: string
+  method: string
+  name: string
+  isMiddleware: boolean
+}
+
+const handlerName = (handler: Function): string => {
+  return handler.name || (isMiddleware(handler) ? '[middleware]' : '[handler]')
+}
+
+export const inspectRoutes = <E extends Env>(acryl: Acryl<E>): RouteData[] => {
+  return acryl.routes.map(({ path, method, handler }: RouterRoute) => {
+    const targetHandler = findTargetHandler(handler)
+    return {
+      path,
+      method,
+      name: handlerName(targetHandler),
+      isMiddleware: isMiddleware(targetHandler),
+    }
+  })
+}
+
+export const showRoutes = <E extends Env>(acryl: Acryl<E>, opts?: ShowRoutesOptions): void => {
+  const colorEnabled = opts?.colorize ?? getColorEnabled()
+  const routeData: Record<string, RouteData[]> = {}
+  let maxMethodLength = 0
+  let maxPathLength = 0
+
+  inspectRoutes(acryl)
+    .filter(({ isMiddleware }) => opts?.verbose || !isMiddleware)
+    .map((route) => {
+      const key = `${route.method}-${route.path}`
+      ;(routeData[key] ||= []).push(route)
+      if (routeData[key].length > 1) {
+        return
+      }
+      maxMethodLength = Math.max(maxMethodLength, route.method.length)
+      maxPathLength = Math.max(maxPathLength, route.path.length)
+      return { method: route.method, path: route.path, routes: routeData[key] }
+    })
+    .forEach((data) => {
+      if (!data) {
+        return
+      }
+      const { method, path, routes } = data
+
+      const methodStr = colorEnabled ? `\x1b[32m${method}\x1b[0m` : method
+      console.log(`${methodStr} ${' '.repeat(maxMethodLength - method.length)} ${path}`)
+
+      if (!opts?.verbose) {
+        return
+      }
+
+      routes.forEach(({ name }) => {
+        console.log(`${' '.repeat(maxMethodLength + 3)} ${name}`)
+      })
+    })
+}
+
+export const getRouterName = <E extends Env>(app: Acryl<E>): string => {
+  app.router.match('GET', '/')
+  return app.router.name
+}

package/plugins/acryl-router/src/core/helper/proxy/index.test.ts

@@ -0,0 +1,356 @@
+import { proxy } from './index.ts'
+import { Acryl } from '../../app.ts'
+
+describe('Proxy Middleware', () => {
+  describe('proxy', () => {
+    beforeEach(() => {
+      global.fetch = vi.fn().mockImplementation(async (req) => {
+        if (req.url === 'https://example.com/ok') {
+          return Promise.resolve(new Response('ok'))
+        } else if (req.url === 'https://example.com/disconnect') {
+          const reader = req.body.getReader()
+          let response
+
+          req.signal.addEventListener('abort', () => {
+            response = req.signal.reason
+            reader.cancel()
+          })
+
+          await reader.read()
+
+          return Promise.resolve(new Response(response))
+        } else if (req.url === 'https://example.com/compressed') {
+          return Promise.resolve(
+            new Response('ok', {
+              headers: {
+                'Content-Encoding': 'gzip',
+                'Content-Length': '1',
+                'Content-Range': 'bytes 0-2/1024',
+                'X-Response-Id': '456',
+              },
+            })
+          )
+        } else if (req.url === 'https://example.com/uncompressed') {
+          return Promise.resolve(
+            new Response('ok', {
+              headers: {
+                'Content-Length': '2',
+                'Content-Range': 'bytes 0-2/1024',
+                'X-Response-Id': '456',
+              },
+            })
+          )
+        } else if (req.url === 'https://example.com/post' && req.method === 'POST') {
+          return Promise.resolve(new Response(`request body: ${await req.text()}`))
+        } else if (req.url === 'https://example.com/hop-by-hop') {
+          return Promise.resolve(
+            new Response('ok', {
+              headers: {
+                'Transfer-Encoding': 'chunked',
+              },
+            })
+          )
+        } else if (req.url === 'https://example.com/connection-listed') {
+          return Promise.resolve(
+            new Response('ok', {
+              headers: {
+                Connection: 'x-connection-scoped, bad name',
+                'X-Connection-Scoped': 'should not be forwarded',
+                'X-Normal': 'kept',
+              },
+            })
+          )
+        } else if (req.url === 'https://example.com/set-cookie') {
+          return Promise.resolve(
+            new Response('ok', {
+              headers: {
+                'Set-Cookie': 'test=123',
+              },
+            })
+          )
+        }
+        return Promise.resolve(new Response('not found', { status: 404 }))
+      })
+    })
+
+    it('compressed', async () => {
+      const app = new Acryl()
+      app.get('/proxy/:path', (c) =>
+        proxy(
+          new Request(`https://example.com/${c.req.param('path')}`, {
+            headers: {
+              'X-Request-Id': '123',
+              'Accept-Encoding': 'gzip',
+            },
+          })
+        )
+      )
+      const res = await app.request('/proxy/compressed')
+      const req = (global.fetch as ReturnType<typeof vi.fn>).mock.calls[0][0]
+
+      expect(req.url).toBe('https://example.com/compressed')
+      expect(req.headers.get('X-Request-Id')).toBe('123')
+      expect(req.headers.get('Accept-Encoding')).toBeNull()
+
+      expect(res.status).toBe(200)
+      expect(res.headers.get('X-Response-Id')).toBe('456')
+      expect(res.headers.get('Content-Encoding')).toBeNull()
+      expect(res.headers.get('Content-Length')).toBeNull()
+      expect(res.headers.get('Content-Range')).toBe('bytes 0-2/1024')
+    })
+
+    it('uncompressed', async () => {
+      const app = new Acryl()
+      app.get('/proxy/:path', (c) =>
+        proxy(
+          new Request(`https://example.com/${c.req.param('path')}`, {
+            headers: {
+              'X-Request-Id': '123',
+              'Accept-Encoding': 'gzip',
+            },
+          })
+        )
+      )
+      const res = await app.request('/proxy/uncompressed')
+      const req = (global.fetch as ReturnType<typeof vi.fn>).mock.calls[0][0]
+
+      expect(req.url).toBe('https://example.com/uncompressed')
+      expect(req.headers.get('X-Request-Id')).toBe('123')
+      expect(req.headers.get('Accept-Encoding')).toBeNull()
+
+      expect(res.status).toBe(200)
+      expect(res.headers.get('X-Response-Id')).toBe('456')
+      expect(res.headers.get('Content-Length')).toBe('2')
+      expect(res.headers.get('Content-Range')).toBe('bytes 0-2/1024')
+    })
+
+    it('POST request', async () => {
+      const app = new Acryl()
+      app.all('/proxy/:path', (c) => {
+        return proxy(`https://example.com/${c.req.param('path')}`, {
+          ...c.req,
+          headers: {
+            ...c.req.header(),
+            'X-Request-Id': '123',
+            'Accept-Encoding': 'gzip',
+          },
+        })
+      })
+      const res = await app.request('/proxy/post', {
+        method: 'POST',
+        body: 'test',
+      })
+      const req = (global.fetch as ReturnType<typeof vi.fn>).mock.calls[0][0]
+
+      expect(req.url).toBe('https://example.com/post')
+
+      expect(res.status).toBe(200)
+      expect(await res.text()).toBe('request body: test')
+    })
+
+    it('remove hop-by-hop headers', async () => {
+      const app = new Acryl()
+      app.get('/proxy/:path', (c) => proxy(`https://example.com/${c.req.param('path')}`, c.req))
+
+      const res = await app.request('/proxy/hop-by-hop', {
+        headers: {
+          Host: 'example.com',
+          Connection: 'keep-alive, custom-header',
+          'Keep-Alive': 'timeout=5, max=1000',
+          'Proxy-Authorization': 'Basic 123456',
+          'Custom-Header': 'test',
+          'Allowed-Custom-Header': 'test',
+        },
+      })
+      const req = (global.fetch as ReturnType<typeof vi.fn>).mock.calls[0][0]
+
+      expect(req.headers.get('Host')).toBe('example.com')
+      expect(req.headers.get('Connection')).toBeNull()
+      expect(req.headers.get('Keep-Alive')).toBeNull()
+      expect(req.headers.get('Proxy-Authorization')).toBeNull()
+      expect(req.headers.get('Custom-Header')).toBe('test')
+      expect(req.headers.get('Allowed-Custom-Header')).toBe('test')
+
+      expect(res.headers.get('Transfer-Encoding')).toBeNull()
+    })
+
+    it('remove hop-by-hop headers with strictConnectionProcessing', async () => {
+      const app = new Acryl()
+      app.get('/proxy/:path', (c) =>
+        proxy(`https://example.com/${c.req.param('path')}`, {
+          ...c.req,
+          strictConnectionProcessing: true,
+        })
+      )
+
+      const res = await app.request('/proxy/hop-by-hop', {
+        headers: {
+          Host: 'example.com',
+          Connection: 'keep-alive, custom-header',
+          'Keep-Alive': 'timeout=5, max=1000',
+          'Proxy-Authorization': 'Basic 123456',
+          'Custom-Header': 'test',
+          'Allowed-Custom-Header': 'test',
+        },
+      })
+      const req = (global.fetch as ReturnType<typeof vi.fn>).mock.calls[0][0]
+
+      expect(req.headers.get('Host')).toBe('example.com')
+      expect(req.headers.get('Connection')).toBeNull()
+      expect(req.headers.get('Keep-Alive')).toBeNull()
+      expect(req.headers.get('Proxy-Authorization')).toBeNull()
+      expect(req.headers.get('Custom-Header')).toBeNull()
+      expect(req.headers.get('Allowed-Custom-Header')).toBe('test')
+
+      expect(res.headers.get('Transfer-Encoding')).toBeNull()
+    })
+
+    it('invalid hop-by-hop headers with strictConnectionProcessing', async () => {
+      const app = new Acryl()
+      app.get('/proxy/:path', (c) =>
+        proxy(`https://example.com/${c.req.param('path')}`, {
+          ...c.req,
+          strictConnectionProcessing: true,
+        })
+      )
+
+      const res = await app.request('/proxy/hop-by-hop', {
+        headers: {
+          Host: 'example.com',
+          Connection: 'keep-alive, invalid-header invalid-header',
+          'Keep-Alive': 'timeout=5, max=1000',
+        },
+      })
+
+      expect(res.status).toBe(400)
+    })
+
+    it('specify hop-by-hop header by options', async () => {
+      const app = new Acryl()
+      app.get('/proxy/:path', (c) =>
+        proxy(`https://example.com/${c.req.param('path')}`, {
+          headers: {
+            'Proxy-Authorization': 'Basic 123456',
+          },
+        })
+      )
+
+      const res = await app.request('/proxy/hop-by-hop')
+      const req = (global.fetch as ReturnType<typeof vi.fn>).mock.calls[0][0]
+
+      expect(req.headers.get('Proxy-Authorization')).toBe('Basic 123456')
+
+      expect(res.headers.get('Transfer-Encoding')).toBeNull()
+    })
+
+    it('remove response headers listed in the Connection header', async () => {
+      const app = new Acryl()
+      app.get('/proxy/:path', (c) => proxy(`https://example.com/${c.req.param('path')}`))
+      const res = await app.request('/proxy/connection-listed')
+      expect(res.status).toBe(200)
+      expect(res.headers.get('Connection')).toBeNull()
+      expect(res.headers.get('X-Connection-Scoped')).toBeNull()
+      expect(res.headers.get('X-Normal')).toBe('kept')
+    })
+
+    it('modify header', async () => {
+      const app = new Acryl()
+      app.get('/proxy/:path', (c) =>
+        proxy(`https://example.com/${c.req.param('path')}`, {
+          headers: {
+            'Set-Cookie': 'test=123',
+          },
+        }).then((res) => {
+          res.headers.delete('Set-Cookie')
+          res.headers.set('X-Response-Id', '456')
+          return res
+        })
+      )
+      const res = await app.request('/proxy/set-cookie')
+      expect(res.headers.get('Set-Cookie')).toBeNull()
+      expect(res.headers.get('X-Response-Id')).toBe('456')
+    })
+
+    it('does not propagate undefined request headers', async () => {
+      const app = new Acryl()
+      app.get('/proxy/:path', (c) =>
+        proxy(`https://example.com/${c.req.param('path')}`, {
+          headers: {
+            ...c.req.header(),
+            Authorization: undefined,
+          },
+        })
+      )
+      await app.request('/proxy/ok', {
+        headers: {
+          Authorization: 'Bearer 123',
+        },
+      })
+      const req = (global.fetch as ReturnType<typeof vi.fn>).mock.calls[0][0]
+      expect(req.headers.get('Authorization')).toBeNull()
+    })
+
+    it('client disconnect', async () => {
+      const app = new Acryl()
+      const controller = new AbortController()
+      app.post('/proxy/:path', (c) => proxy(`https://example.com/${c.req.param('path')}`, c.req))
+      const resPromise = app.request('/proxy/disconnect', {
+        method: 'POST',
+        body: 'test',
+        signal: controller.signal,
+      })
+      controller.abort('client disconnect')
+      const res = await resPromise
+      expect(await res.text()).toBe('client disconnect')
+    })
+
+    it('not found', async () => {
+      const app = new Acryl()
+      app.get('/proxy/:path', (c) => proxy(`https://example.com/${c.req.param('path')}`))
+      const res = await app.request('/proxy/404')
+      expect(res.status).toBe(404)
+    })
+
+    it('pass a Request object to proxyInit', async () => {
+      const app = new Acryl()
+      app.get('/proxy/:path', (c) => {
+        const req = new Request(c.req.raw, {
+          headers: {
+            'X-Request-Id': '123',
+            'Accept-Encoding': 'gzip',
+          },
+        })
+        return proxy(`https://example.com/${c.req.param('path')}`, req)
+      })
+      const res = await app.request('/proxy/compressed')
+      const req = (global.fetch as ReturnType<typeof vi.fn>).mock.calls[0][0]
+
+      expect(req.url).toBe('https://example.com/compressed')
+      expect(req.headers.get('X-Request-Id')).toBe('123')
+      expect(req.headers.get('Accept-Encoding')).toBeNull()
+
+      expect(res.status).toBe(200)
+      expect(await res.text()).toBe('ok')
+    })
+
+    it('Should call the custom fetch method when specified', async () => {
+      const customFetch = vi.fn().mockImplementation(async (req: Request) => {
+        const text = await req.text()
+        return new Response('custom fetch response. message:' + text)
+      })
+      const app = new Acryl()
+      app.post('/', (c) => {
+        return proxy(`https://example.com/`, {
+          customFetch,
+          ...c.req,
+        })
+      })
+      const res = await app.request('/', {
+        method: 'POST',
+        body: 'hi',
+      })
+      expect(res.status).toBe(200)
+      expect(await res.text()).toBe('custom fetch response. message:hi')
+    })
+  })
+})