galbe 0.1.0

package/test/resources/object.badSyntax.json

@@ -0,0 +1,8 @@
+{
+    "string": "test"
+    "number": 3.14,
+    "bool": true,
+    "arrayStr": ["un", "deux", "trois"],
+    "arrayNumber": [0],
+    "arrayBool": [true, false]
+}

package/test/resources/object.json

@@ -0,0 +1,8 @@
+{
+    "string": "test",
+    "number": 3.14,
+    "bool": true,
+    "arrayStr": ["un", "deux", "trois"],
+    "arrayNumber": [0],
+    "arrayBool": [true, false]
+}

package/test/resources/object.missing.json

@@ -0,0 +1,6 @@
+{
+    "string": "test",
+    "number": 3.14,
+    "bool": true,
+    "arrayNumber": [0]
+}

package/test/resources/test.route.comment.ts

@@ -0,0 +1,38 @@
+import type { Galbe } from '../../src'
+import { T } from '../../src'
+
+/**
+ * description
+ * multiline
+ * @tag test
+ * ok
+ */
+export default (g: Galbe) => {
+  /**
+   * This part
+   * here
+   * @tags tag1, tag2, tag3
+   * @summary short summary
+   * @description longer description example
+   * @deprecated
+   * @param {path} param1 description
+   * @param  {query} param2 description
+   */
+  g.get('/test/:param1', _ => {})
+
+  // Comment between enpoints
+
+  /**
+   * @tags tag1, tag2, tag3
+   * @summary short summary
+   * @description longer description example
+   * @body body descripton
+   */
+  g.post('/test', { body: T.Object({ foo: T.String() }) }, _ => {})
+
+  /**
+   * @tags tag1, tag2
+   * @other Hello Mom!
+   */
+  g.put('/test', { body: T.Object({ foo: T.String() }) }, [() => {}], _ => {})
+}

package/test/resources/test.route.empty.ts

@@ -0,0 +1,9 @@
+import type { Galbe } from '../../src'
+
+export default (g: Galbe) => {
+  g.get('/one', _ => {})
+  // Comment between enpoints
+  g.post('/two', _ => {})
+
+  g.put('/three', _ => {})
+}

package/test/responses.test.ts

@@ -0,0 +1,109 @@
+import { expect, test, describe, beforeAll } from 'bun:test'
+import { Galbe, T } from '../src'
+import { decoder } from './test.utils'
+
+const port = 7359
+
+const UUID_RGX = '[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}'
+
+function* genTxt(text: string) {
+  const words = text.split(' ')
+  for (const w of words) yield w
+}
+
+const rsTxt = (text: string) => {
+  return new ReadableStream({
+    async start(controller) {
+      const words = text.split(' ')
+      for (const w of words) controller.enqueue(w)
+      controller.close()
+    }
+  })
+}
+
+describe('responses', () => {
+  beforeAll(async () => {
+    const galbe = new Galbe()
+
+    galbe.post(
+      '/response',
+      {
+        body: T.Optional(T.Object(T.Any())),
+        query: { text: T.Optional(T.String()), stream: T.Optional(T.String()) }
+      },
+      ctx => {
+        if (ctx.query.text) {
+          if (ctx.query.stream === 'generatorFunction') return genTxt(ctx.query.text)
+          if (ctx.query.stream === 'readableStream') return rsTxt(ctx.query.text)
+          else return ctx.query.text
+        } else if (ctx.body) return ctx.body
+
+        return null
+      }
+    )
+
+    galbe.get('/error', _ => {
+      return { next: () => {} }
+    })
+
+    galbe.onError(_ => {
+      throw new Error()
+    })
+
+    await galbe.listen(port)
+  })
+
+  test('response, string', async () => {
+    const reqTxt = 'Hello Mom!'
+    let resp = await fetch(`http://localhost:${port}/response?text=${reqTxt}`, {
+      method: 'POST'
+    })
+
+    const body = await resp.text()
+
+    expect(resp.status).toBe(200)
+    expect(resp.headers.get('content-type')).toBe('text/plain')
+    expect(body).toBe(reqTxt)
+  })
+
+  test('response, object', async () => {
+    const reqBody = { foo: 'bar' }
+    let resp = await fetch(`http://localhost:${port}/response`, {
+      method: 'POST',
+      body: JSON.stringify(reqBody),
+      headers: {
+        'content-type': 'application/json'
+      }
+    })
+
+    const body = await resp.json()
+
+    expect(resp.status).toBe(200)
+    expect(resp.headers.get('content-type')).toBe('application/json')
+    expect(body).toEqual(reqBody)
+  })
+
+  test('response, stream', async () => {
+    const reqTxt = 'Hello Mom!'
+    const cases = [{ stream: 'generatorFunction' }, { stream: 'readableStream' }]
+
+    for (const c of cases) {
+      let resp = await fetch(`http://localhost:${port}/response?text=${reqTxt}&stream=${c.stream}`, {
+        method: 'POST',
+        headers: {
+          'content-type': 'application/json'
+        }
+      })
+      const reader = resp.body?.getReader()
+      let body = ''
+      while (reader) {
+        const { value, done } = await reader.read()
+        if (done) break
+        body += decoder.decode(value)
+      }
+      expect(resp.status).toBe(200)
+      expect(resp.headers.get('content-type')).toBe('text/event-stream')
+      expect(body).toMatch(new RegExp(`id:${UUID_RGX}\ndata:Hello\n\nid:${UUID_RGX}\ndata:Mom!\n\n`))
+    }
+  })
+})

package/test/routeFiles.test.ts

@@ -0,0 +1,209 @@
+import { expect, test, describe } from 'bun:test'
+import { defineRoutes, 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!'
+          }
+        }
+      }
+    })
+  })
+
+  test('define routes, no route', async () => {
+    const k = new Galbe()
+    await defineRoutes({}, k)
+    expect(k.router.routes).toEqual({
+      GET: {},
+      POST: {},
+      PUT: {},
+      PATCH: {},
+      DELETE: {},
+      OPTIONS: {}
+    })
+  })
+
+  test('define routes, no route found', async () => {
+    const k = new Galbe()
+    await defineRoutes({ routes: 'unexisting_route' }, k)
+    expect(k.router.routes).toEqual({
+      GET: {},
+      POST: {},
+      PUT: {},
+      PATCH: {},
+      DELETE: {},
+      OPTIONS: {}
+    })
+  })
+
+  test('define routes, route.empty', async () => {
+    const k = new Galbe()
+
+    await defineRoutes({ routes: 'test/resources/test.route.empty.ts' }, k)
+
+    const r = k.router.routes
+    expect(r.GET?.children?.one?.route).toMatchObject({
+      method: 'get',
+      path: '/one',
+      handler: () => {}
+    })
+    expect(r.POST?.children?.two?.route).toMatchObject({
+      method: 'post',
+      path: '/two',
+      handler: () => {}
+    })
+    expect(r.PUT?.children?.three?.route).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 Galbe()
+
+    await defineRoutes({ routes: ['test/resources/test.route.*.ts'] }, k)
+
+    const r = k.router.routes
+    expect(r.GET?.children?.one?.route).toMatchObject({
+      method: 'get',
+      path: '/one',
+      handler: () => {}
+    })
+    expect(r.POST?.children?.two?.route).toMatchObject({
+      method: 'post',
+      path: '/two',
+      handler: () => {}
+    })
+    expect(r.PUT?.children?.three?.route).toMatchObject({
+      method: 'put',
+      path: '/three',
+      handler: () => {}
+    })
+    expect(r.GET?.children?.test?.param?.route).toMatchObject({
+      method: 'get',
+      path: '/test/:param1',
+      handler: () => {}
+    })
+    expect(r.POST?.children?.test?.route).toMatchObject({
+      method: 'post',
+      path: '/test',
+      handler: () => {}
+    })
+    expect(r.PUT?.children?.test?.route).toMatchObject({
+      method: 'put',
+      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

@@ -0,0 +1,207 @@
+import { expect, test, describe } from 'bun:test'
+import { Galbe, 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.GET).toEqual({})
+    expect(router.routes.POST).toEqual({})
+    expect(router.routes.PUT).toEqual({})
+    expect(router.routes.PATCH).toEqual({})
+    expect(router.routes.DELETE).toEqual({})
+    expect(router.routes.OPTIONS).toEqual({})
+  })
+
+  test('routes, bad syntax', async () => {
+    const galbe = new Galbe()
+
+    const invalidPaths = [
+      '.',
+      '/@',
+      '/-ta',
+      '/test/-ta',
+      '/test/my.path',
+      '/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.GET).toEqual({})
+
+    galbe.get('/', () => {})
+    let r: RouteNode | undefined = router.routes.GET
+
+    expect(r?.route?.method).toBe('get')
+    expect(r?.route?.path).toBe('/')
+    expect(r?.param).toBeUndefined()
+    expect(r?.children).toBeUndefined()
+
+    const mockHandler = () => {}
+    galbe.get('/test', mockHandler)
+    r = r?.children?.test
+
+    expect(r?.route?.method).toBe('get')
+    expect(r?.route?.path).toBe('/test')
+    expect(r?.param).toBeUndefined()
+    expect(r?.children).toBeUndefined()
+    expect(r?.route?.handler).toBe(mockHandler)
+
+    const mockHandler2 = () => {}
+    galbe.get('/test/:foo', mockHandler2)
+    r = r?.param
+
+    expect(r?.route?.method).toBe('get')
+    expect(r?.route?.path).toBe('/test/:foo')
+    expect(r?.param).toBeUndefined()
+    expect(r?.children).toBeUndefined()
+    expect(r?.route?.handler).toBe(mockHandler2)
+
+    const mockHandler3 = () => {}
+    galbe.get('/test/:foo/bar', mockHandler3)
+
+    expect(r?.children).toHaveProperty('bar')
+    expect(r?.param).toBeUndefined()
+    expect(r?.children?.bar?.route?.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.GET
+    expect(router.prefix).toBe('')
+    expect(r?.route?.method).toBe('get')
+    expect(r?.route?.path).toBe('/')
+    expect(r?.route?.handler).toBe(h3)
+    expect(r?.children?.test?.route?.method).toBe('get')
+    expect(r?.children?.test?.route?.handler).toBe(h2)
+
+    const [h4, h5] = [() => {}, () => {}]
+
+    galbe.get('/foo/bar', h4)
+    galbe.get('/foo', h5)
+
+    r = router?.routes?.GET?.children?.foo
+    expect(r?.route?.method).toBe('get')
+    expect(r?.route?.path).toBe('/foo')
+    expect(r?.route?.handler).toBe(h5)
+    expect(r?.children?.bar?.route?.method).toBe('get')
+    expect(r?.children?.bar?.route?.path).toBe('/foo/bar')
+    expect(r?.children?.bar?.route?.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.error).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.error).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 r2 = router.find('GET', '/test//foo/bar')
+    expect(r2.path).toBe('/test/foo/bar')
+    expect(r2.handler).toBe(h2)
+
+    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)
+  })
+})

package/test/test.utils.ts

@@ -0,0 +1,102 @@
+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(T.Any())
+}
+
+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'
+    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> = {}
+  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 }
+}