galbe 0.12.1 → 0.12.2

package/test/routeFiles.test.ts

@@ -1,239 +0,0 @@
-import { expect, test, describe } from 'bun:test'
-import { defineRoutes, GalbeProxy, metaAnalysis } from '../src/routes'
-import { Galbe } from '../src'
-
-describe('routeFiles', () => {
-  test('meta analysis, empty', async () => {
-    let meta = await metaAnalysis('./test/resources/test.route.empty.ts')
-    expect(meta).toEqual({
-      header: {},
-      routes: {
-        '/one': {
-          get: {}
-        },
-        '/two': {
-          post: {}
-        },
-        '/three': {
-          put: {}
-        }
-      }
-    })
-  })
-
-  test('meta analysis, comments', async () => {
-    let meta = await metaAnalysis('./test/resources/test.route.comment.ts')
-    expect(meta).toEqual({
-      header: {
-        head: 'description\nmultiline',
-        tag: 'test'
-      },
-      routes: {
-        '/test/:param1': {
-          get: {
-            head: 'This part\nhere',
-            tags: 'tag1, tag2, tag3',
-            summary: 'short summary',
-            description: 'longer description example',
-            deprecated: true,
-            param: ['{path} param1 description', '{query} param2 description']
-          }
-        },
-        '/test': {
-          post: {
-            tags: 'tag1, tag2, tag3',
-            summary: 'short summary',
-            description: 'longer description example',
-            body: 'body descripton'
-          },
-          put: {
-            tags: 'tag1, tag2',
-            other: 'Hello Mom!'
-          },
-          patch: {
-            head: 'patch method'
-          },
-          options: {
-            head: 'options method'
-          },
-          delete: {
-            head: 'delete method'
-          },
-          head: {
-            head: 'head method'
-          }
-        }
-      }
-    })
-  })
-
-  test('define routes, no route', async () => {
-    const k = new GalbeProxy(new Galbe())
-    await defineRoutes({}, k)
-    expect(k.router.routes).toEqual({
-      routes: {}
-    })
-  })
-
-  test('define routes, no route (false)', async () => {
-    const k = new GalbeProxy(new Galbe({ routes: false }))
-    await defineRoutes({}, k)
-    expect(k.router.routes).toEqual({
-      routes: {}
-    })
-  })
-
-  test('define routes, no route found', async () => {
-    const k = new GalbeProxy(new Galbe())
-    await defineRoutes({ routes: 'unexisting_route' }, k)
-    expect(k.router.routes).toEqual({
-      routes: {}
-    })
-  })
-
-  test('define routes, route.empty', async () => {
-    const k = new GalbeProxy(new Galbe())
-
-    await defineRoutes({ routes: 'test/resources/test.route.empty.ts' }, k)
-
-    const r = k.router.routes
-    expect(r?.children?.one?.routes.get).toMatchObject({
-      method: 'get',
-      path: '/one',
-      handler: () => {}
-    })
-    expect(r?.children?.two?.routes.post).toMatchObject({
-      method: 'post',
-      path: '/two',
-      handler: () => {}
-    })
-    expect(r?.children?.three?.routes.put).toMatchObject({
-      method: 'put',
-      path: '/three',
-      handler: () => {}
-    })
-    expect(k.meta).toMatchObject([
-      {
-        header: {},
-        routes: {
-          '/one': {
-            get: {}
-          },
-          '/two': {
-            post: {}
-          },
-          '/three': {
-            put: {}
-          }
-        }
-      }
-    ])
-    expect(k.meta?.[0].file).toMatch(/test\.route\.empty\.ts$/)
-  })
-
-  test('define routes, all', async () => {
-    const k = new GalbeProxy(new Galbe())
-
-    await defineRoutes({ routes: ['test/resources/test.route.*.ts'] }, k)
-
-    const r = k.router.routes
-    expect(r?.children?.one?.routes.get).toMatchObject({
-      method: 'get',
-      path: '/one',
-      handler: () => {}
-    })
-    expect(r?.children?.two?.routes.post).toMatchObject({
-      method: 'post',
-      path: '/two',
-      handler: () => {}
-    })
-    expect(r?.children?.three?.routes.put).toMatchObject({
-      method: 'put',
-      path: '/three',
-      handler: () => {}
-    })
-    expect(r?.children?.test?.param?.routes.get).toMatchObject({
-      method: 'get',
-      path: '/test/:param1',
-      handler: () => {}
-    })
-    expect(r?.children?.test?.routes.post).toMatchObject({
-      method: 'post',
-      path: '/test',
-      handler: () => {}
-    })
-    expect(r?.children?.test?.routes.put).toMatchObject({
-      method: 'put',
-      path: '/test',
-      handler: () => {}
-    })
-    expect(r?.children?.test?.routes.patch).toMatchObject({
-      method: 'patch',
-      path: '/test',
-      handler: () => {}
-    })
-    expect(r?.children?.test?.routes.options).toMatchObject({
-      method: 'options',
-      path: '/test',
-      handler: () => {}
-    })
-    expect(r?.children?.test?.routes.delete).toMatchObject({
-      method: 'delete',
-      path: '/test',
-      handler: () => {}
-    })
-    expect(r?.children?.test?.routes.head).toMatchObject({
-      method: 'head',
-      path: '/test',
-      handler: () => {}
-    })
-    expect(k.meta?.sort((a, b) => (a.file < b.file ? 1 : -1))).toMatchObject([
-      {
-        header: {},
-        routes: {
-          '/one': {
-            get: {}
-          },
-          '/two': {
-            post: {}
-          },
-          '/three': {
-            put: {}
-          }
-        }
-      },
-      {
-        header: {
-          head: 'description\nmultiline',
-          tag: 'test'
-        },
-        routes: {
-          '/test/:param1': {
-            get: {
-              head: 'This part\nhere',
-              tags: 'tag1, tag2, tag3',
-              summary: 'short summary',
-              description: 'longer description example',
-              deprecated: true,
-              param: ['{path} param1 description', '{query} param2 description']
-            }
-          },
-          '/test': {
-            post: {
-              tags: 'tag1, tag2, tag3',
-              summary: 'short summary',
-              description: 'longer description example',
-              body: 'body descripton'
-            },
-            put: {
-              tags: 'tag1, tag2',
-              other: 'Hello Mom!'
-            }
-          }
-        }
-      }
-    ])
-    expect(k.meta?.[0].file).toMatch(/test\.route\..*$/)
-    expect(k.meta?.[1].file).toMatch(/test\.route\..*$/)
-  })
-})

package/test/router.test.ts

@@ -1,231 +0,0 @@
-import { expect, test, describe } from 'bun:test'
-import { Galbe, MethodNotAllowedError, NotFoundError, type RouteNode } from '../src'
-
-describe('router', () => {
-  test('empty', async () => {
-    const galbe = new Galbe()
-    const router = galbe.router
-
-    expect(router.prefix).toBe('')
-    expect(router.routes).toEqual({ routes: {} })
-  })
-
-  test('routes, bad syntax', async () => {
-    const galbe = new Galbe()
-
-    const invalidPaths = ['.', '/@', '/-ta', '/test/-ta', '/hell@/w0rld', '/last-', '../', './x', '/hello?']
-
-    for (const p of invalidPaths) {
-      try {
-        galbe.get(p, () => {})
-        expect.unreachable()
-      } catch (err) {
-        expect(err).toBeInstanceOf(SyntaxError)
-      }
-    }
-  })
-
-  test('chaining routes', async () => {
-    const galbe = new Galbe()
-    const router = galbe.router
-
-    expect(router.routes).toEqual({ routes: {} })
-
-    galbe.get('/', () => {})
-    let r: RouteNode | undefined = router.routes
-
-    expect(r?.routes.get?.method).toBe('get')
-    expect(r?.routes.get?.path).toBe('/')
-    expect(r?.param).toBeUndefined()
-    expect(r?.children).toBeUndefined()
-
-    const mockHandler = () => {}
-    galbe.get('/test', mockHandler)
-    r = r?.children?.test
-
-    expect(r?.routes.get?.method).toBe('get')
-    expect(r?.routes.get?.path).toBe('/test')
-    expect(r?.param).toBeUndefined()
-    expect(r?.children).toBeUndefined()
-    expect(r?.routes.get?.handler).toBe(mockHandler)
-
-    const mockHandler2 = () => {}
-    galbe.get('/test/:foo', mockHandler2)
-    r = r?.param
-
-    expect(r?.routes.get?.method).toBe('get')
-    expect(r?.routes.get?.path).toBe('/test/:foo')
-    expect(r?.param).toBeUndefined()
-    expect(r?.children).toBeUndefined()
-    expect(r?.routes.get?.handler).toBe(mockHandler2)
-
-    const mockHandler3 = () => {}
-    galbe.get('/test/:foo/bar', mockHandler3)
-
-    expect(r?.children).toHaveProperty('bar')
-    expect(r?.param).toBeUndefined()
-    expect(r?.children?.bar?.routes.get?.handler).toBe(mockHandler3)
-  })
-
-  test('redefining root', async () => {
-    const galbe = new Galbe()
-    const router = galbe.router
-
-    const [h1, h2, h3] = [() => {}, () => {}, () => {}]
-
-    galbe.get('/', h1)
-    galbe.get('/test', h2)
-    galbe.get('/', h3)
-
-    let r: RouteNode | undefined = router.routes
-    expect(router.prefix).toBe('')
-    expect(r?.routes.get?.method).toBe('get')
-    expect(r?.routes.get?.path).toBe('/')
-    expect(r?.routes.get?.handler).toBe(h3)
-    expect(r?.children?.test?.routes.get?.method).toBe('get')
-    expect(r?.children?.test?.routes.get?.handler).toBe(h2)
-
-    const [h4, h5] = [() => {}, () => {}]
-
-    galbe.get('/foo/bar', h4)
-    galbe.get('/foo', h5)
-
-    r = router?.routes?.children?.foo
-    expect(r?.routes.get?.method).toBe('get')
-    expect(r?.routes.get?.path).toBe('/foo')
-    expect(r?.routes.get?.handler).toBe(h5)
-    expect(r?.children?.bar?.routes.get?.method).toBe('get')
-    expect(r?.children?.bar?.routes.get?.path).toBe('/foo/bar')
-    expect(r?.children?.bar?.routes.get?.handler).toBe(h4)
-  })
-
-  test('find route', async () => {
-    const galbe = new Galbe()
-    const router = galbe.router
-
-    const [h1, h3, h4] = [() => {}, () => {}, () => {}, () => {}]
-
-    galbe.get('/', h1)
-    galbe.get('/test/foo', h3)
-    galbe.get('/test/foo/bar', h4)
-
-    let r1 = router.find('get', '/')
-    expect(r1.path).toBe('/')
-    expect(r1.handler).toBe(h1)
-    let r2 = router.find('get', '/test/foo')
-    expect(r2.path).toBe('/test/foo')
-    expect(r2.handler).toBe(h3)
-    let r3 = router.find('get', '/test/foo/bar')
-    expect(r3.path).toBe('/test/foo/bar')
-    expect(r3.handler).toBe(h4)
-
-    try {
-      router.find('get', '/test')
-      expect.unreachable()
-    } catch (err: any) {
-      expect(err).toBeInstanceOf(NotFoundError)
-      expect(err.status).toBe(404)
-      expect(err.payload).toBe('Not Found')
-    }
-
-    try {
-      router.find('get', '/test/bar/bar')
-      expect.unreachable()
-    } catch (err: any) {
-      expect(err).toBeInstanceOf(NotFoundError)
-      expect(err.status).toBe(404)
-      expect(err.payload).toBe('Not Found')
-    }
-  })
-
-  test('find route param', async () => {
-    const galbe = new Galbe()
-    const router = galbe.router
-
-    const [h1, h2] = [() => {}, () => {}]
-
-    galbe.get('/test/:foo', h1)
-    galbe.get('/test/test', h2)
-
-    let r1 = router.find('get', '/test/42')
-    expect(r1.path).toBe('/test/:foo')
-    expect(r1.handler).toBe(h1)
-
-    let r2 = router.find('get', '/test/test')
-    expect(r2.path).toBe('/test/test')
-    expect(r2.handler).toBe(h2)
-  })
-
-  test('wildcard routes', async () => {
-    const galbe = new Galbe()
-    const router = galbe.router
-
-    const [h1, h2, h3, h4] = [() => {}, () => {}, () => {}, () => {}]
-
-    galbe.get('/test/foo/*', h1)
-    galbe.get('/test/foo/bar', h2)
-    galbe.get('/test/foo/:p/bar', h3)
-
-    galbe.get('/test/foo/*/lol', h4)
-
-    let r1 = router.find('get', '/test/foo/bar/42')
-    expect(r1.path).toBe('/test/foo/*')
-    expect(r1.handler).toBe(h1)
-
-    let r3 = router.find('get', '/test/foo/bar/bar')
-    expect(r3.path).toBe('/test/foo/:p/bar')
-    expect(r3.handler).toBe(h3)
-
-    let r4 = router.find('get', '/test/foo/foo')
-    expect(r4.path).toBe('/test/foo/*')
-    expect(r4.handler).toBe(h1)
-
-    let r5 = router.find('get', '/test/foo/toto/lol')
-    expect(r5.path).toBe('/test/foo/*/lol')
-    expect(r5.handler).toBe(h4)
-  })
-
-  test('method not allowed', async () => {
-    const galbe = new Galbe()
-    const router = galbe.router
-
-    const [h1, h2] = [() => {}, () => {}]
-
-    galbe.put('/test/foo', h1)
-    galbe.post('/test/bar/*', h2)
-
-    let r1 = router.find('put', '/test/foo')
-    expect(r1.path).toBe('/test/foo')
-    expect(r1.handler).toBe(h1)
-    try {
-      router.find('get', '/test/foo')
-      expect.unreachable()
-    } catch (err) {
-      expect(err).toBeInstanceOf(MethodNotAllowedError)
-    }
-
-    let r2 = router.find('post', '/test/bar/tender')
-    expect(r2.path).toBe('/test/bar/*')
-    expect(r2.handler).toBe(h2)
-    try {
-      router.find('delete', '/test/bar/toto/titi')
-      expect.unreachable()
-    } catch (err) {
-      expect(err).toBeInstanceOf(MethodNotAllowedError)
-    }
-  })
-
-  test('trailing slash routes', async () => {
-    const galbe = new Galbe()
-    const router = galbe.router
-
-    const handler = () => {}
-    galbe.get('/test/', handler)
-
-    expect(router.routes.children?.test?.routes.get?.handler).toBe(handler)
-
-    const r = router.find('get', '/test')
-    expect(r.path).toBe('/test/')
-    expect(r.handler).toBe(handler)
-  })
-})

package/test/test.utils.ts

@@ -1,109 +0,0 @@
-import { $T, type Context } from '../src'
-
-export type Case = {
-  body?: any
-  type?: string
-  schema: string
-  expected: { status: number; type?: string; resp?: any }
-}
-
-export const formdata = (data: Record<string, string | string[] | Blob>): FormData => {
-  const form = new FormData()
-  for (const [k, v] of Object.entries(data)) {
-    if (Array.isArray(v)) for (const v2 of v) form.append(k, v2)
-    else form.append(k, v)
-  }
-  return form
-}
-export const fileHash = async (ba: any) =>
-  Array.from(new Uint8Array(await crypto.subtle.digest('SHA-256', ba)))
-    .map(byte => byte.toString(16).padStart(2, '0'))
-    .join('')
-export const decoder = new TextDecoder()
-
-export const schema_objectBase = {
-  ba: $T.byteArray(),
-  string: $T.string(),
-  number: $T.number(),
-  bool: $T.boolean(),
-  any: $T.any(),
-  optional: $T.optional($T.any()),
-}
-export const schema_object = {
-  ...schema_objectBase,
-  object: $T.object($T.any()),
-  array: $T.array(),
-  null: $T.null(),
-  nullable: $T.nullable($T.string()),
-  nullish: $T.nullish($T.number()),
-}
-
-export const isAsyncIterator = (obj: any) => {
-  if (Object(obj) !== obj) return false
-  const method = obj[Symbol.asyncIterator]
-  if (typeof method != 'function') return false
-  const aIter = method.call(obj)
-  return aIter === obj
-}
-
-const parseAsyncIterator = async (body: any): Promise<any> => {
-  const chunks = []
-  let type
-  for await (const chunk of body) {
-    if (chunk instanceof Uint8Array) type = 'byteArray'
-    else if (typeof chunk === 'string') type = 'string'
-    // @ts-ignore
-    chunks.push(chunk)
-  }
-  // @ts-ignore
-  if (type === 'byteArray') return new Uint8Array(chunks.map(c => Array.from(c)).flat())
-  if (type === 'string') return chunks.join('')
-  return chunks
-}
-const parseBody = async (body: any): Promise<any> =>
-  typeof body === 'object' && body !== null && !Array.isArray(body)
-    ? Object.fromEntries(
-        await Promise.all(
-          Object.entries(body).map(async ([k, v]) => {
-            if (v instanceof Uint8Array) return [k, await fileHash(v)]
-            else return [k, await parseBody(v)]
-          })
-        )
-      )
-    : body
-export const handleBody = async (ctx: any) => {
-  if (ctx.body === undefined) {
-    return { type: 'undefined' }
-  }
-  if (ctx?.body instanceof ReadableStream) {
-    let content = ''
-    for await (const chunk of ctx.body) {
-      if (typeof chunk === 'string') content += chunk
-      else content += decoder.decode(chunk)
-    }
-    return { type: 'ReadableStream', content }
-  }
-  if (Array.isArray(ctx.body)) {
-    return { type: 'array', content: ctx.body }
-  }
-  if (ctx?.body instanceof Uint8Array) {
-    return { type: 'byteArray', content: decoder.decode(ctx.body) }
-  }
-  if (isAsyncIterator(ctx.body)) {
-    return { type: 'AsyncIterator', content: await parseAsyncIterator(ctx.body) }
-  } else {
-    return { type: typeof ctx.body, content: await parseBody(ctx.body) }
-  }
-}
-export const handleUrlFormStream = async (ctx: Context) => {
-  let resp: Record<string, any> = {}
-  // @ts-ignore
-  for await (const [k, v] of ctx.body) {
-    if (k in resp) {
-      resp[k] = Array.isArray(resp[k]) ? [...resp[k], v] : [resp[k], v]
-    } else resp[k] = v
-  }
-  return { type: 'object', content: resp }
-}
-
-export const EMPTY_BA_STR = 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855'