galbe 0.2.0 → 0.4.1

package/test/requests.test.ts

@@ -1,18 +1,9 @@
 import { expect, test, describe, beforeAll } from 'bun:test'
 import { Galbe, $T } from '../src'
-import {
-  formdata,
-  type Case,
-  fileHash,
-  schema_objectBase,
-  schema_object,
-  handleBody,
-  isAsyncIterator,
-  handleUrlFormStream
-} from './test.utils'
+import { formdata, type Case, fileHash, handleBody, isAsyncIterator } from './test.utils'
 
 const port = 7358
-const METHODS = ['get', 'post', 'put', 'patch', 'delete', 'options']
+const METHODS = ['get', 'post', 'put', 'patch', 'delete', 'options', 'head']
 
 describe('requests', () => {
   beforeAll(async () => {
@@ -24,6 +15,7 @@ describe('requests', () => {
     galbe.patch('/test', () => {})
     galbe.delete('/test', () => {})
     galbe.options('/test', () => {})
+    galbe.head('/test', () => {})
 
     galbe.get('/headers', ctx => {
       return ctx.headers
@@ -76,7 +68,8 @@ describe('requests', () => {
           p2: $T.number(),
           p3: $T.boolean(),
           p4: $T.union([$T.number(), $T.boolean()]),
-          p5: $T.optional($T.string())
+          p5: $T.optional($T.string()),
+          p6: $T.array($T.union([$T.string()]))
         }
       },
       ctx => {

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

@@ -35,4 +35,24 @@ export default (g: Galbe) => {
    * @other Hello Mom!
    */
   g.put('/test', { body: $T.object({ foo: $T.string() }) }, [() => {}], _ => {})
+
+  /**
+   * patch method
+   */
+  g.patch('/test', _ => {})
+
+  /**
+   * options method
+   */
+  g.options('/test', _ => {})
+
+  /**
+   * delete method
+   */
+  g.delete('/test', _ => {})
+
+  /**
+   * head method
+   */
+  g.head('/test', _ => {})
 }

package/test/responses.test.ts

@@ -21,12 +21,14 @@ const rsTxt = (text: string) => {
   })
 }
 
+const handleResp = ctx => ctx.body
+
 describe('responses', () => {
   beforeAll(async () => {
     const galbe = new Galbe()
 
     galbe.post(
-      '/response',
+      '/none',
       {
         body: $T.optional($T.object($T.any())),
         query: { text: $T.optional($T.string()), stream: $T.optional($T.string()) }
@@ -42,20 +44,29 @@ describe('responses', () => {
       }
     )
 
-    galbe.get('/error', _ => {
-      return { next: () => {} }
-    })
+    galbe.post('', { response: { test: '' } }, () => {})
 
-    galbe.onError(_ => {
-      throw new Error()
-    })
+    galbe.post('/ba', { response: { 200: $T.byteArray() } }, handleResp)
+    galbe.post('/bool', { response: { 200: $T.boolean() } }, handleResp)
+    galbe.post('/num', { response: { 200: $T.number() } }, handleResp)
+    galbe.post('/str', { response: { 200: $T.string() } }, handleResp)
+    galbe.post('/json/bool', { response: { 200: $T.json($T.boolean()) } }, handleResp)
+    galbe.post('/json/num', { response: { 200: $T.json($T.number()) } }, handleResp)
+    galbe.post('/json/str', { response: { 200: $T.json($T.string()) } }, handleResp)
+    galbe.post('/json/obj', { response: { 200: $T.json($T.object()) } }, handleResp)
+    galbe.post('/arr', { response: { 200: $T.array() } }, handleResp)
+    galbe.post('/obj', { response: { 200: $T.object($T.any()) } }, handleResp)
+    galbe.post('/stream/ba', { response: { 200: $T.stream($T.byteArray()) } }, ctx =>
+      ctx.body ? genTxt(ctx.body) : ''
+    )
+    galbe.post('/stream/str', { response: { 200: $T.stream($T.string()) } }, ctx => (ctx.body ? genTxt(ctx.body) : 42))
 
     await galbe.listen(port)
   })
 
-  test('response, string', async () => {
+  test('response, no schema, string', async () => {
     const reqTxt = 'Hello Mom!'
-    let resp = await fetch(`http://localhost:${port}/response?text=${reqTxt}`, {
+    let resp = await fetch(`http://localhost:${port}/none?text=${reqTxt}`, {
       method: 'POST'
     })
 
@@ -66,9 +77,9 @@ describe('responses', () => {
     expect(body).toBe(reqTxt)
   })
 
-  test('response, object', async () => {
+  test('response, no schema, object', async () => {
     const reqBody = { foo: 'bar' }
-    let resp = await fetch(`http://localhost:${port}/response`, {
+    let resp = await fetch(`http://localhost:${port}/none`, {
       method: 'POST',
       body: JSON.stringify(reqBody),
       headers: {
@@ -83,12 +94,12 @@ describe('responses', () => {
     expect(body).toEqual(reqBody)
   })
 
-  test('response, stream', async () => {
+  test('response, no schema, 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}`, {
+      let resp = await fetch(`http://localhost:${port}/none?text=${reqTxt}&stream=${c.stream}`, {
         method: 'POST',
         headers: {
           'content-type': 'application/json'
@@ -106,4 +117,366 @@ describe('responses', () => {
       expect(body).toMatch(new RegExp(`id:${UUID_RGX}\ndata:Hello\n\nid:${UUID_RGX}\ndata:Mom!\n\n`))
     }
   })
+
+  test('response, ba, validation OK', async () => {
+    let bodyStr = 'Hello mom!'
+    let reqBody = new TextEncoder().encode(bodyStr)
+
+    let resp = await fetch(`http://localhost:${port}/ba`, {
+      method: 'POST',
+      body: bodyStr,
+      headers: {
+        'content-type': 'application/octet-stream'
+      }
+    })
+
+    const reader = resp.body?.getReader()
+    let body = new Uint8Array()
+    while (reader) {
+      const { value, done } = await reader.read()
+      if (done) break
+      let buff = new Uint8Array(body.length + value.length)
+      buff.set(body)
+      buff.set(value, body.length)
+      body = buff
+    }
+
+    expect(resp.status).toBe(200)
+    expect(resp.headers.get('content-type')).toBe('application/octet-stream')
+    expect(body).toEqual(reqBody)
+  })
+
+  test('response, ba, validation error', async () => {
+    let bodyStr = 'Hello mom!'
+
+    let resp = await fetch(`http://localhost:${port}/ba`, {
+      method: 'POST',
+      body: bodyStr,
+      headers: {
+        'content-type': 'text/plain'
+      }
+    })
+
+    expect(resp.status).toBe(500)
+  })
+
+  test('response, bool, validation OK', async () => {
+    let bodyStr = 'true'
+    let reqBody = true
+
+    let resp = await fetch(`http://localhost:${port}/bool`, {
+      method: 'POST',
+      body: bodyStr,
+      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, bool, validation error', async () => {
+    let bodyStr = 'true'
+
+    let resp = await fetch(`http://localhost:${port}/bool`, {
+      method: 'POST',
+      body: bodyStr,
+      headers: {
+        'content-type': 'text/plain'
+      }
+    })
+
+    expect(resp.status).toBe(500)
+  })
+
+  test('response, num, validation OK', async () => {
+    let bodyStr = '42'
+    let reqBody = 42
+
+    let resp = await fetch(`http://localhost:${port}/num`, {
+      method: 'POST',
+      body: bodyStr,
+      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, num, validation error', async () => {
+    let bodyStr = '"test"'
+
+    let resp = await fetch(`http://localhost:${port}/num`, {
+      method: 'POST',
+      body: bodyStr,
+      headers: {
+        'content-type': 'application/json'
+      }
+    })
+
+    expect(resp.status).toBe(500)
+  })
+
+  test('response, str, validation OK', async () => {
+    let bodyStr = 'Hello Mom!'
+
+    let resp = await fetch(`http://localhost:${port}/str`, {
+      method: 'POST',
+      body: bodyStr,
+      headers: {
+        'content-type': 'text/plain'
+      }
+    })
+
+    const body = await resp.text()
+
+    expect(resp.status).toBe(200)
+    expect(resp.headers.get('content-type')).toBe('text/plain')
+    expect(body).toEqual(bodyStr)
+  })
+
+  test('response, json bool, validation OK', async () => {
+    let bodyStr = 'false'
+    let reqBody = false
+
+    let resp = await fetch(`http://localhost:${port}/json/bool`, {
+      method: 'POST',
+      body: bodyStr,
+      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, json bool, validation error', async () => {
+    let bodyStr = '3.14'
+
+    let resp = await fetch(`http://localhost:${port}/json/bool`, {
+      method: 'POST',
+      body: bodyStr,
+      headers: {
+        'content-type': 'application/json'
+      }
+    })
+
+    expect(resp.status).toBe(500)
+  })
+
+  test('response, json num, validation OK', async () => {
+    let bodyStr = '42'
+    let reqBody = 42
+
+    let resp = await fetch(`http://localhost:${port}/json/num`, {
+      method: 'POST',
+      body: bodyStr,
+      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, json num, validation error', async () => {
+    let bodyStr = '"Hi"'
+
+    let resp = await fetch(`http://localhost:${port}/json/bool`, {
+      method: 'POST',
+      body: bodyStr,
+      headers: {
+        'content-type': 'application/json'
+      }
+    })
+
+    expect(resp.status).toBe(500)
+  })
+
+  test('response, json str, validation OK', async () => {
+    let bodyStr = '"Hello Mom!"'
+    let reqBody = 'Hello Mom!'
+
+    let resp = await fetch(`http://localhost:${port}/json/str`, {
+      method: 'POST',
+      body: bodyStr,
+      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, json str, validation error', async () => {
+    let bodyStr = '3.14'
+
+    let resp = await fetch(`http://localhost:${port}/json/str`, {
+      method: 'POST',
+      body: bodyStr,
+      headers: {
+        'content-type': 'application/json'
+      }
+    })
+
+    expect(resp.status).toBe(500)
+  })
+
+  test('response, array, validation OK', async () => {
+    let bodyStr = '[false, "one", 2]'
+    let reqBody = [false, 'one', 2]
+
+    let resp = await fetch(`http://localhost:${port}/arr`, {
+      method: 'POST',
+      body: bodyStr,
+      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, array, validation error', async () => {
+    let bodyStr = '0'
+
+    let resp = await fetch(`http://localhost:${port}/arr`, {
+      method: 'POST',
+      body: bodyStr,
+      headers: {
+        'content-type': 'application/json'
+      }
+    })
+
+    expect(resp.status).toBe(500)
+  })
+
+  test('response, object, validation OK', async () => {
+    let bodyStr = '{"str":"str", "num":0, "arr":[1,2,3], "nested": {"foo":"bar"}}'
+    let reqBody = { str: 'str', num: 0, arr: [1, 2, 3], nested: { foo: 'bar' } }
+
+    let resp = await fetch(`http://localhost:${port}/obj`, {
+      method: 'POST',
+      body: bodyStr,
+      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, object, validation error', async () => {
+    let bodyStr = '"This"'
+
+    let resp = await fetch(`http://localhost:${port}/obj`, {
+      method: 'POST',
+      body: bodyStr,
+      headers: {
+        'content-type': 'application/json'
+      }
+    })
+
+    expect(resp.status).toBe(500)
+  })
+
+  test('response, stream ba, validation OK', async () => {
+    let bodyStr = 'Hello Mom!'
+
+    let resp = await fetch(`http://localhost:${port}/stream/ba`, {
+      method: 'POST',
+      body: bodyStr,
+      headers: {
+        'content-type': 'text/plain'
+      }
+    })
+
+    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`))
+  })
+
+  test('response, stream ba, validation error', async () => {
+    let bodyStr = ''
+
+    let resp = await fetch(`http://localhost:${port}/stream/ba`, {
+      method: 'POST',
+      body: bodyStr
+    })
+
+    expect(resp.status).toBe(500)
+  })
+
+  test('response, stream str, validation OK', async () => {
+    let bodyStr = 'Hello Mom!'
+
+    let resp = await fetch(`http://localhost:${port}/stream/str`, {
+      method: 'POST',
+      body: bodyStr,
+      headers: {
+        'content-type': 'text/plain'
+      }
+    })
+
+    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`))
+  })
+
+  test('response, stream str, validation error', async () => {
+    let bodyStr = '0'
+
+    let resp = await fetch(`http://localhost:${port}/stream/str`, {
+      method: 'POST',
+      body: bodyStr,
+      headers: {
+        'content-type': 'application/json'
+      }
+    })
+
+    expect(resp.status).toBe(500)
+  })
 })

package/test/routeFiles.test.ts

@@ -49,6 +49,18 @@ describe('routeFiles', () => {
           put: {
             tags: 'tag1, tag2',
             other: 'Hello Mom!'
+          },
+          patch: {
+            head: 'patch method'
+          },
+          options: {
+            head: 'options method'
+          },
+          delete: {
+            head: 'delete method'
+          },
+          head: {
+            head: 'head method'
           }
         }
       }
@@ -59,12 +71,7 @@ describe('routeFiles', () => {
     const k = new Galbe()
     await defineRoutes({}, k)
     expect(k.router.routes).toEqual({
-      GET: {},
-      POST: {},
-      PUT: {},
-      PATCH: {},
-      DELETE: {},
-      OPTIONS: {}
+      routes: {}
     })
   })
 
@@ -72,12 +79,7 @@ describe('routeFiles', () => {
     const k = new Galbe({ routes: false })
     await defineRoutes({}, k)
     expect(k.router.routes).toEqual({
-      GET: {},
-      POST: {},
-      PUT: {},
-      PATCH: {},
-      DELETE: {},
-      OPTIONS: {}
+      routes: {}
     })
   })
 
@@ -85,12 +87,7 @@ describe('routeFiles', () => {
     const k = new Galbe()
     await defineRoutes({ routes: 'unexisting_route' }, k)
     expect(k.router.routes).toEqual({
-      GET: {},
-      POST: {},
-      PUT: {},
-      PATCH: {},
-      DELETE: {},
-      OPTIONS: {}
+      routes: {}
     })
   })
 
@@ -100,17 +97,17 @@ describe('routeFiles', () => {
     await defineRoutes({ routes: 'test/resources/test.route.empty.ts' }, k)
 
     const r = k.router.routes
-    expect(r.GET?.children?.one?.route).toMatchObject({
+    expect(r?.children?.one?.routes.get).toMatchObject({
       method: 'get',
       path: '/one',
       handler: () => {}
     })
-    expect(r.POST?.children?.two?.route).toMatchObject({
+    expect(r?.children?.two?.routes.post).toMatchObject({
       method: 'post',
       path: '/two',
       handler: () => {}
     })
-    expect(r.PUT?.children?.three?.route).toMatchObject({
+    expect(r?.children?.three?.routes.put).toMatchObject({
       method: 'put',
       path: '/three',
       handler: () => {}
@@ -140,36 +137,56 @@ describe('routeFiles', () => {
     await defineRoutes({ routes: ['test/resources/test.route.*.ts'] }, k)
 
     const r = k.router.routes
-    expect(r.GET?.children?.one?.route).toMatchObject({
+    expect(r?.children?.one?.routes.get).toMatchObject({
       method: 'get',
       path: '/one',
       handler: () => {}
     })
-    expect(r.POST?.children?.two?.route).toMatchObject({
+    expect(r?.children?.two?.routes.post).toMatchObject({
       method: 'post',
       path: '/two',
       handler: () => {}
     })
-    expect(r.PUT?.children?.three?.route).toMatchObject({
+    expect(r?.children?.three?.routes.put).toMatchObject({
       method: 'put',
       path: '/three',
       handler: () => {}
     })
-    expect(r.GET?.children?.test?.param?.route).toMatchObject({
+    expect(r?.children?.test?.param?.routes.get).toMatchObject({
       method: 'get',
       path: '/test/:param1',
       handler: () => {}
     })
-    expect(r.POST?.children?.test?.route).toMatchObject({
+    expect(r?.children?.test?.routes.post).toMatchObject({
       method: 'post',
       path: '/test',
       handler: () => {}
     })
-    expect(r.PUT?.children?.test?.route).toMatchObject({
+    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: {},