galbe 0.1.7 → 0.1.13

package/docs/schemas.md

@@ -1,12 +1,10 @@
 # Shemas
 
-Galbe offers a custom Schema Type processor that provides type safety along with data parsing and validation.
-
-The prime intention of that features is to offer an easy way to manage automatically request inputs validation and error handling. Moreover, it also greatly improve developper's experience by infering static Typescript types from schema definitions.
+Galbe provides a custom Schema Type processor that offers type safety, data parsing, and validation. The primary purpose of this feature is to simplify request input validation and error handling automatically. Additionally, it enhances the developer's experience by inferring static TypeScript types from schema definitions.
 
 ## Schema Types
 
-To get started with Schema defintion, just import `$T` from `galbe` library:
+To start using Schema definitions, import `$T` from the `galbe` library:
 
 ```js
 import { $T } from 'galbe'
@@ -62,32 +60,32 @@ Schema Type matching `array` values.
 const arraySchema = $T.array($T.any(), options)
 ```
 
-#### Union
+#### Optional
 
-Creates an union of Schema Types. .
+Makes any type optional. This allows for `undefined` values.
 
 ```ts
-const unionSchema = $T.union([$T.string(), $T.number()])
+const optionalSchema = $T.optional($T.string())
 ```
 
-#### TOptional
+#### Union
 
-Makes any type optional. In practice, this allows for `undefined` values.
+Creates an union of Schema Types.
 
 ```ts
-const optionalSchema = $T.optional($T.string())
+const unionSchema = $T.union([$T.string(), $T.number()])
 ```
 
 ## Request Schema definition
 
-The Request Schema definition allows you to define a schema for your request on your [Route Definition](). It must be defined right after the [path]() of your route.
+The Request Schema definition allows you to define a schema for your request on your [Route Definition](routes.md#route-defintion). It must be defined right after the path of your route.
 
 ```js
 const schema = {}
 galbe.get('/foo/:bar', schema, ctx => {})
 ```
 
-The Request Schema has 4 optional properties
+The Request Schema has four optional properties:
 
 ### headers
 
@@ -95,7 +93,7 @@ The Request Schema has 4 optional properties
 headers: { [key: string]: STString | STBoolean | STNumber | STInteger | STLiteral }
 ```
 
-This is a key-value object where each key represents a request `header` name and the value the Schema associated.
+This is a key-value object where each key represents a request header name, and the value is the associated Schema.
 
 **Example**:
 
@@ -113,7 +111,7 @@ const schema = {
 params: { [key: string]: STString | STBoolean | STNumber | STInteger | STLiteral }
 ```
 
-This is a key-value object where each key represents a request `path parameter` name and the value the Schema associated.
+This is a key-value object where each key represents a request path parameter name, and the value is the associated Schema.
 
 **Example**:
 
@@ -127,7 +125,7 @@ const schema = {
 ```
 
 > [!WARNING]
-> Every key should match an existing [route path]() parameter. Otherwise Typescript will show you an error.
+> Every key should match an existing [route path](routes.md#route-defintion) parameter. Otherwise Typescript will show an error.
 >
 > By default, if no schema is defined for a given parameter. Galbe will assume it is of type `string`.
 
@@ -137,7 +135,7 @@ const schema = {
 query: { [key: string]: STString | STBoolean | STNumber | STInteger | STLiteral }
 ```
 
-This is a key-value object where each key represents a request `query parameter` name and the value the Schema associated.
+This is a key-value object where each key represents a request query parameter name, and the value is the associated Schema.
 
 **Example**:
 
@@ -152,13 +150,15 @@ const schema = {
 
 ### body
 
+<!-- prettier-ignore -->
 ```ts
-body: STByteArray | STString | STBoolean | STNumber | STInteger | STLiteral | STObject | STMulripartForm | STUrlForm
+body: STByteArray | STString | STBoolean | STNumber | STInteger | STLiteral | 
+      STObject | STMulripartForm | STUrlForm
 ```
 
 #### Json
 
-To define an `application/json` request body. You must use `STObject` Schema Type. Example:
+To define an `application/json` request body, use `STObject` Schema Type. Example:
 
 ```ts
 const jsonBody = $T.object({
@@ -169,7 +169,7 @@ const jsonBody = $T.object({
 
 #### Multipart
 
-To define a `multipart/form-data` request body. You must use `TMultipartForm` Schema Type. Example:
+To define a `multipart/form-data` request body, use `TMultipartForm` Schema Type. Example:
 
 ```ts
 const multipartBody = $T.multipartForm({
@@ -180,7 +180,7 @@ const multipartBody = $T.multipartForm({
 
 #### Url Form
 
-To define an `application/x-www-form-urlencoded` request body. You must use `TUrlForm` Schema Type. Example:
+To define an `application/x-www-form-urlencoded` request body, use `TUrlForm` Schema Type. Example:
 
 ```ts
 const urlBody = $T.urlForm({
@@ -191,11 +191,9 @@ const urlBody = $T.urlForm({
 
 #### Stream
 
-Some body request types can be streamed by using `STStream` Schema Type wrapper. Streamable Schema Types are `STByteArray`, `STString`, `STUrlForm` and `STMultipartForm`.
+Some body request types can be streamed by using `STStream` Schema Type wrapper. The streamable Schema Types are `STByteArray`, `STString`, `STUrlForm` and `STMultipartForm`. This can be usefull to imporve performances in case you have heavy body payloads and you want to perform early validations on the body.
 
-This can be usefull to imporve performances in case you have heavy body payloads and you want to perform early validations on the body.
-
-Let's see a concrete example where that could be usefull. Imagine you want a `multipart/form-data` body request that has two properties `username` and `heavyImageFile`. In the normal case you would define something like that:
+Let's look at a concrete example where this could be useful. Imagine you want a `multipart/form-data` body request that has two properties: `username` and `heavyImageFile`. In a normal case, you would define something like this:
 
 ```ts
 galbe.post(
@@ -215,11 +213,9 @@ galbe.post(
 })
 ```
 
-This means that in the case where the username wouldn't pass the validation, the full request body including the `heavyImageFile` would have been processed for nothing as it is not used. Inducing unnecessary time and resource consumption.
-
-The `STStream` Schema Type wrapper was created to remediate to that issue. In practice it allows you to perform validations on the fly.
+This means that in the case where the username wouldn't pass the validation, the full request body, including the `heavyImageFile`, would have been processed for nothing, as it is not used. This would induce unnecessary time and resource consumption.
 
-Now in your handler, instead of receiving an object as ctx.body, you'll receive an [AsyncGenerator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AsyncGenerator).
+The `STStream` Schema Type wrapper was created to remediate to remediate this issue. In practice it allows you to perform validations on the fly. Now in your handler, instead of receiving an object as `ctx.body`, you will receive an [AsyncGenerator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AsyncGenerator).
 
 ```ts
 galbe.post(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "galbe",
-  "version": "0.1.7",
+  "version": "0.1.13",
   "description": "Fast, lightweight and highly customizable JavaScript web framework based on Bun",
   "author": "Pierre Caillaud M (https://github.com/pierre-cm)",
   "type": "module",

package/src/index.ts

@@ -80,7 +80,6 @@ const galbeMethod = <
         [header: string]: string
       }
       status?: number
-      redirect?: string
     }
   }
   return {
@@ -123,7 +122,10 @@ export class Galbe {
   constructor(config?: GalbeConfig) {
     this.config = config ?? {}
     this.config.routes = this.config.routes ?? true
-    this.router = new GalbeRouter(this.config?.basePath || '')
+    this.router = new GalbeRouter({
+      prefix: this.config?.basePath || '',
+      cacheEnabled: this.config?.router?.cacheEnabled
+    })
   }
   private add(route: any) {
     this.router.add(route)

package/src/parser.ts

@@ -9,16 +9,14 @@ import type {
   MultipartFormData,
   STUrlFormValues,
   STMultipartFormValues,
-  STUnion,
   STLiteral,
-  STArray,
   STSchema
 } from './schema'
 
 import { readableStreamToArrayBuffer } from 'bun'
 import { Kind, Optional, Stream } from './schema'
 import { validate } from './validator'
-import { RequestError, $T } from './index'
+import { InternalError, RequestError } from './index'
 
 const textDecoder = new TextDecoder()
 const textEncoder = new TextEncoder()
@@ -39,10 +37,10 @@ const MP_HEADER_RX = /^multipart\/form-data/
 
 export const requestBodyParser = async (
   body: ReadableStream | null,
-  headers: { 'content-type'?: string; 'content-length'?: string },
+  headers: Record<string, string>,
   schema?: STBody
 ) => {
-  const { 'content-type': contentType, 'content-length': _contentLength } = headers
+  const contentType = headers?.['content-type']
   const kind = schema?.[Kind]
   const isStream = schema && Stream in schema
   try {
@@ -60,19 +58,19 @@ export const requestBodyParser = async (
         } else if (schema?.[Optional]) {
           return null
         } else {
-          throw new RequestError({ status: 400, error: { body: `Not a valid ${kind}` } })
+          throw new RequestError({ status: 400, payload: { body: `Not a valid ${kind}` } })
         }
       } else {
         if (contentType === BA_HEADER) {
           return new Uint8Array()
         } else if (contentType === JSON_HEADER) {
-          throw new RequestError({ status: 400, error: { body: 'Not a valid json' } })
+          throw new RequestError({ status: 400, payload: { body: 'Not a valid json' } })
         } else if (contentType?.match(TXT_HEADER_RX)) {
-          throw new RequestError({ status: 400, error: { body: 'Not a valid text' } })
+          throw new RequestError({ status: 400, payload: { body: 'Not a valid text' } })
         } else if (contentType?.match(FORM_HEADER_RX)) {
-          throw new RequestError({ status: 400, error: { body: 'Not a valid form' } })
+          throw new RequestError({ status: 400, payload: { body: 'Not a valid form' } })
         } else if (contentType?.match(MP_HEADER_RX)) {
-          throw new RequestError({ status: 400, error: { body: 'Not a valid multipart form' } })
+          throw new RequestError({ status: 400, payload: { body: 'Not a valid multipart form' } })
         } else return null
       }
     } else {
@@ -91,7 +89,7 @@ export const requestBodyParser = async (
           : contentType?.match(MP_HEADER_RX)
           ? 'multipartForm'
           : contentType
-        throw new RequestError({ status: 400, error: { body: `Expected ${kind}, received ${received}` } })
+        throw new RequestError({ status: 400, payload: { body: `Expected ${kind}, received ${received}` } })
       } else if (!contentType || contentType === BA_HEADER) {
         if (!schema) {
           if (isStream) return rsToAsyncIterator(body)
@@ -104,7 +102,14 @@ export const requestBodyParser = async (
         }
       } else if (contentType === JSON_HEADER) {
         if (!schema) {
-          return await streamToString(body, $T.object($T.any()))
+          try {
+            return JSON.parse(await streamToString(body))
+          } catch (err: any) {
+            throw new RequestError({
+              status: 400,
+              payload: { body: err?.message ?? 'Parsing error' }
+            })
+          }
         } else {
           const str = await streamToString(body)
           let json
@@ -113,7 +118,7 @@ export const requestBodyParser = async (
           } catch (err: any) {
             throw new RequestError({
               status: 400,
-              error: { body: err?.message ?? 'Parsing error' }
+              payload: { body: err?.message ?? 'Parsing error' }
             })
           }
           return validate(json, schema, true)
@@ -129,7 +134,7 @@ export const requestBodyParser = async (
           return await streamToUrlForm(body)
         } else {
           if (kind !== 'urlForm')
-            throw new RequestError({ status: 400, error: { body: `Expected ${kind}, received urlForm` } })
+            throw new RequestError({ status: 400, payload: { body: `Expected ${kind}, received urlForm` } })
           if (isStream) return $streamToUrlForm(body, schema as STStream<STUrlForm>)
           else return await streamToUrlForm(body, schema as STUrlForm)
         }
@@ -139,7 +144,7 @@ export const requestBodyParser = async (
           return await streamToMultipartForm(body, boundary)
         } else {
           if (kind !== 'multipartForm')
-            throw new RequestError({ status: 400, error: { body: `Expected ${kind}, received MultipartForm` } })
+            throw new RequestError({ status: 400, payload: { body: `Expected ${kind}, received MultipartForm` } })
           if (isStream) return $streamToMultipartForm(body, boundary, schema as STStream<STMultipartForm>)
           else {
             return streamToMultipartForm(body, boundary, schema as STMultipartForm)
@@ -151,7 +156,7 @@ export const requestBodyParser = async (
     }
   } catch (error) {
     if (error instanceof RequestError) throw error
-    else throw new RequestError({ status: 400, error: { body: error } })
+    else throw new RequestError({ status: 400, payload: { body: error } })
   }
 }
 async function* $streamToString(body: ReadableStream) {
@@ -189,7 +194,7 @@ async function* $streamToUrlForm(
           let s = schema?.props?.[key]?.[Kind] === 'array' ? schema?.props?.[key].items : schema?.props?.[key]
           val = s ? paramParser(val, s) : val
         } catch (error) {
-          throw new RequestError({ status: 400, error: { body: { [key]: error } } })
+          throw new RequestError({ status: 400, payload: { body: { [key]: error } } })
         }
         delete required[key]
         yield [key, val]
@@ -220,7 +225,7 @@ async function* $streamToUrlForm(
     let s = schema?.props?.[key]?.[Kind] === 'array' ? schema?.props?.[key].items : schema?.props?.[key]
     val = s ? paramParser(val, s) : val
   } catch (error) {
-    throw new RequestError({ status: 400, error: { body: { [key]: error } } })
+    throw new RequestError({ status: 400, payload: { body: { [key]: error } } })
   }
   delete required[key]
   yield [key, val]
@@ -234,7 +239,7 @@ async function* $streamToUrlForm(
   if (reqKeys.length > 0)
     throw new RequestError({
       status: 400,
-      error: { body: `Missing field${reqKeys.length > 1 ? 's' : ''}: ${reqKeys.join(', ')}` }
+      payload: { body: `Missing field${reqKeys.length > 1 ? 's' : ''}: ${reqKeys.join(', ')}` }
     })
 }
 const streamToUrlForm = async (body: ReadableStream<Uint8Array>, schema?: STUrlForm) => {
@@ -260,7 +265,7 @@ const streamToUrlForm = async (body: ReadableStream<Uint8Array>, schema?: STUrlF
         errors[k] = k in errors ? [...errors[k], error] : error
       }
     }
-  if (Object.keys(errors).length) throw new RequestError({ status: 400, error: { body: errors } })
+  if (Object.keys(errors).length) throw new RequestError({ status: 400, payload: { body: errors } })
   for (const [k, s] of Object.entries(required)) {
     if (s[Kind] === 'array') {
       object[k] = []
@@ -271,7 +276,7 @@ const streamToUrlForm = async (body: ReadableStream<Uint8Array>, schema?: STUrlF
   if (reqKeys.length > 0)
     throw new RequestError({
       status: 400,
-      error: { body: `Missing field${reqKeys.length > 1 ? 's' : ''}: ${reqKeys.join(', ')}` }
+      payload: { body: `Missing field${reqKeys.length > 1 ? 's' : ''}: ${reqKeys.join(', ')}` }
     })
   return object
 }
@@ -310,7 +315,7 @@ async function* $streamToMultipartForm(data: ReadableStream<Uint8Array>, boundar
             }
           } catch (err) {
             if (err instanceof RequestError) throw err
-            throw new RequestError({ status: 400, error: { body: { [headers.name]: err } } })
+            throw new RequestError({ status: 400, payload: { body: { [headers.name]: err } } })
           }
         }
         bK = new Uint8Array()
@@ -343,7 +348,7 @@ async function* $streamToMultipartForm(data: ReadableStream<Uint8Array>, boundar
         content: parseMultipartContent(bV, headers, schema)
       }
     } catch (err) {
-      throw new RequestError({ status: 400, error: { body: { [headers.name]: err } } })
+      throw new RequestError({ status: 400, payload: { body: { [headers.name]: err } } })
     }
   }
   for (const [k, s] of Object.entries(required)) {
@@ -356,7 +361,7 @@ async function* $streamToMultipartForm(data: ReadableStream<Uint8Array>, boundar
   if (reqKeys.length > 0)
     throw new RequestError({
       status: 400,
-      error: { body: `Missing field${reqKeys.length > 1 ? 's' : ''}: ${reqKeys.join(', ')}` }
+      payload: { body: `Missing field${reqKeys.length > 1 ? 's' : ''}: ${reqKeys.join(', ')}` }
     })
 }
 const parseMultipartHeader = (header: string): { name: string; [key: string]: string } | null => {
@@ -394,19 +399,22 @@ const parseMultipartContent = (
       try {
         result = JSON.parse(textDecoder.decode(content).trim())
       } catch (err: any) {
-        throw new RequestError({ status: 400, error: { body: { [headers.name]: err?.message || 'Parsing error' } } })
+        throw new RequestError({ status: 400, payload: { body: { [headers.name]: err?.message || 'Parsing error' } } })
       }
     } else if (schema?.props) {
       if (schema?.props[headers.name][Kind] === 'object') {
         try {
           result = JSON.parse(textDecoder.decode(content).trim())
         } catch (err: any) {
-          throw new RequestError({ status: 400, error: { body: { [headers.name]: err?.message || 'Parsing error' } } })
+          throw new RequestError({
+            status: 400,
+            payload: { body: { [headers.name]: err?.message || 'Parsing error' } }
+          })
         }
         try {
           validate(result, schema?.props[headers.name])
         } catch (err) {
-          throw new RequestError({ status: 400, error: { body: { [headers.name]: err } } })
+          throw new RequestError({ status: 400, payload: { body: { [headers.name]: err } } })
         }
       } else if (schema?.props[headers.name][Kind] === 'byteArray') {
         return content
@@ -415,7 +423,7 @@ const parseMultipartContent = (
       } else {
         throw new RequestError({
           status: 400,
-          error: { body: { [headers.name]: `Expect ${schema?.props[headers.name][Kind]} found json` } }
+          payload: { body: { [headers.name]: `Expect ${schema?.props[headers.name][Kind]} found json` } }
         })
       }
     }
@@ -424,7 +432,7 @@ const parseMultipartContent = (
       let s = schema?.props[headers.name]
       validate(result, s?.[Kind] === 'array' ? s?.items : s)
     } catch (err) {
-      throw new RequestError({ status: 400, error: { body: { [headers.name]: err } } })
+      throw new RequestError({ status: 400, payload: { body: { [headers.name]: err } } })
     }
   }
   return result
@@ -473,7 +481,7 @@ const streamToMultipartForm = async (data: ReadableStream<Uint8Array>, boundary:
   if (Object.keys(errors).length)
     throw new RequestError({
       status: 400,
-      error: { body: errors }
+      payload: { body: errors }
     })
   for (const [k, s] of Object.entries(required)) {
     if (s[Kind] === 'array') {
@@ -485,7 +493,7 @@ const streamToMultipartForm = async (data: ReadableStream<Uint8Array>, boundary:
   if (reqKeys.length > 0)
     throw new RequestError({
       status: 400,
-      error: { body: `Missing field${reqKeys.length > 1 ? 's' : ''}: ${reqKeys.join(', ')}` }
+      payload: { body: `Missing field${reqKeys.length > 1 ? 's' : ''}: ${reqKeys.join(', ')}` }
     })
   return res
 }
@@ -559,14 +567,28 @@ const paramParser = (
 }
 
 export const requestPathParser = (input: string, path: string) => {
-  let pPath = path.replace(/^\/$(.*)\/?$/, '$1').split('/')
-  let pInput = input.replace(/^\/$(.*)\/?$/, '$1').split('/')
+  let pInput = input.split('/')
   let params: Record<string, any> = {}
-  pPath.shift()
-  pInput.shift()
-  for (const [i, p] of pPath.entries()) {
-    const match = p.match(/^:(.*)/)
-    if (match) params[match[1]] = pInput[i]
+  let idx = 0
+  for (let i = 0; i < path.length; i++) {
+    let c = path[i]
+    if (c === '/') {
+      idx++
+      continue
+    }
+    if (c === ':') {
+      let name = ''
+      while (true) {
+        i++
+        c = path[i]
+        if (c === '/' || i >= path.length) {
+          i--
+          break
+        }
+        name += c
+      }
+      params[name] = pInput[idx]
+    }
   }
   return params
 }
@@ -601,7 +623,7 @@ export const parseEntry = <T extends STProps>(
   })
 
   if (Object.keys(errors).length) {
-    throw new RequestError({ status: 400, error: options?.name ? { [options.name]: errors } : errors })
+    throw new RequestError({ status: 400, payload: options?.name ? { [options.name]: errors } : errors })
   }
 
   return parsedParams as Static<STObject<T>>
@@ -631,7 +653,7 @@ export const responseParser = (response: any, ctx: Context) => {
           let data = `id:${id}\ndata:${r}\n\n`
           try {
             await controller.write(data)
-            // await controller.flush()
+            await controller.flush()
           } catch (err) {
             console.error(err)
           }
@@ -648,7 +670,7 @@ export const responseParser = (response: any, ctx: Context) => {
       return new Response(JSON.stringify(response), details)
     } catch (error) {
       console.error(error)
-      throw new RequestError({ status: 500, error: 'Internal Server Error' })
+      throw new InternalError()
     }
   }
 }

package/src/router.ts

@@ -44,19 +44,21 @@ const walkRoutes = (path: string[], node: RouteNode, alts: RouteNode[] = []): Ro
 export class GalbeRouter {
   routes: RouteTree
   prefix: string
-  staticRoutes: Map<string, Route>
-  constructor(prefix?: string) {
+  cacheEnabled: boolean
+  cachedRoutes: Map<string, Route | null>
+  constructor(options?: { prefix?: string; cacheEnabled?: boolean }) {
     this.routes = { GET: {}, POST: {}, PUT: {}, PATCH: {}, DELETE: {}, OPTIONS: {} }
-    prefix = prefix || ''
+    let prefix = options?.prefix || ''
     if (prefix && !prefix.match(/^\//)) prefix = `/${prefix}`
     this.prefix = prefix
-    this.staticRoutes = new Map()
+    this.cachedRoutes = new Map()
+    this.cacheEnabled = options?.cacheEnabled ?? false
   }
   add(route: Route) {
     route.path = route?.path?.[0] === '/' ? route.path : `/${route.path}`
     if (!route.path.match(ROUTE_REGEX)) throw new SyntaxError(`${route.path} is not a valid route path.`)
     const isStatic = !route.path.match(/(:[\w\d-]+|\*)/)
-    if (isStatic) this.staticRoutes.set(`[${route.method.toUpperCase()}]${route.path}`, route)
+    if (isStatic) this.cachedRoutes.set(`[${route.method.toUpperCase()}]${route.path}`, route)
     route.path = `${this.prefix || ''}${route.path}`
     let path = route.path.replace(/^\/$(.*)\/?$/, '$1').split('/')
     path.shift()
@@ -87,14 +89,16 @@ export class GalbeRouter {
     }
   }
   find(method: string, path: string) {
-    const staticRoute = this.staticRoutes.get(`[${method}]${path}`)
+    const staticRoute = this.cachedRoutes.get(`[${method}]${path}`)
+    if (staticRoute === null) throw new NotFoundError()
     if (staticRoute !== undefined) return staticRoute
-    let parts = path
-      .replace(/\/+/g, '/')
-      .replace(/^\/$(.*)\/?$/, '$1')
-      .split('/')
+    let parts = path.split('/')
     const route = walkRoutes(parts, this.routes[method]).route
-    if (!route) throw new NotFoundError()
+    if (!route) {
+      if (this.cacheEnabled) this.cachedRoutes.set(`[${method}]${path}`, null)
+      throw new NotFoundError()
+    }
+    if (this.cacheEnabled) this.cachedRoutes.set(`[${method}]${path}`, route)
     return route
   }
 }

package/src/server.ts

@@ -1,12 +1,12 @@
 import type { Context, Route } from './types'
 
-import { NotFoundError, RequestError } from './types'
+import { InternalError, RequestError } from './types'
 import { parseEntry, requestBodyParser, requestPathParser, responseParser } from './parser'
 import { Galbe } from './index'
 
 const handleInternalError = (error: any) => {
   console.error(error)
-  return new RequestError({ status: 500, error: 'Internal Server Error' })
+  return new InternalError()
 }
 
 const setupPluginCallbacks = (galbe: Galbe) => ({
@@ -60,7 +60,6 @@ export default async (galbe: Galbe, port?: number) => {
       let response: any = ''
       try {
         // find route
-        if (!url.pathname.match(new RegExp(`^${galbe.config?.basePath || ''}`))) throw new NotFoundError()
         try {
           route = router.find(req.method, url.pathname)
         } catch (error) {
@@ -75,8 +74,10 @@ export default async (galbe: Galbe, port?: number) => {
 
         // parse request
         const schema = route.schema
-        let inHeaders = Object.fromEntries(req.headers.entries())
-        let inQuery = Object.fromEntries(url.searchParams.entries())
+        const inHeaders: Record<string, any> = {}
+        for (let [k, v] of req.headers) inHeaders[k] = v
+        let inQuery: Record<string, any> = {}
+        for (let [k, v] of url.searchParams) inQuery[k] = v
         let inParams = requestPathParser(url.pathname, route.path)
 
         context.body = await requestBodyParser(req.body, inHeaders, schema.body)
@@ -109,7 +110,7 @@ export default async (galbe: Galbe, port?: number) => {
           else throw handleInternalError(error)
         }
         if (errors.length) {
-          throw new RequestError({ status: 400, error: errors.reduce((acc, c) => ({ ...acc, ...c.error }), {}) })
+          throw new RequestError({ status: 400, payload: errors.reduce((acc, c) => ({ ...acc, ...c.payload }), {}) })
         }
 
         for (const cb of pluginsCb.beforeHandle) {
@@ -123,13 +124,18 @@ export default async (galbe: Galbe, port?: number) => {
           handlerCalled = true
           return route.handler(context)
         }
-        const callChain = route.hooks.map((hook, idx) => ({
+        const callChain: { call: () => any }[] = route.hooks.map((hook, idx) => ({
           call: async () => {
             let nextCalled = false
             let next = async () => {
-              await callChain[idx + 1].call()
+              if (nextCalled) console.error('Hook already called - ignored')
+              else {
+                nextCalled = true
+                await callChain[idx + 1].call()
+              }
             }
-            await hook(context, next)
+            let r = await hook(context, next)
+            if (r) return r
             if (!nextCalled && !handlerCalled) await next()
           }
         }))
@@ -139,8 +145,11 @@ export default async (galbe: Galbe, port?: number) => {
             context.set.status = response instanceof Response ? response.status : 200
           }
         })
-        if (callChain.length > 1) await callChain[0].call()
-        else response = await handlerWrapper(context)
+        if (callChain.length > 1) {
+          let r = await callChain[0].call()
+          if (r) response = r
+        } else response = await handlerWrapper(context)
+
         const parsedResponse = responseParser(response, context)
 
         for (const cb of pluginsCb.afterHandle) {
@@ -151,22 +160,29 @@ export default async (galbe: Galbe, port?: number) => {
         return parsedResponse
       } catch (error) {
         context.set.status = error instanceof RequestError ? error.status : 500
-        if (galbe.errorHandler) return galbe.errorHandler(error, context)
+        let customError
+        if (galbe.errorHandler) customError = responseParser(galbe.errorHandler(error, context), context)
+        if (customError) return customError
         if (error instanceof RequestError) {
-          return new Response(JSON.stringify(error.error), {
+          return new Response(JSON.stringify(error.payload), {
             status: error.status,
             headers: { 'Content-Type': 'application/json' }
           })
         }
-        return new Response('Internal Server Error', { status: 500 })
+        return new Response('"Internal Server Error"', {
+          status: 500,
+          headers: {
+            'content-type': 'application/json'
+          }
+        })
       }
     },
     error(error) {
       console.error(error)
-      return new Response('Internal Server Error', {
+      return new Response('"Internal Server Error"', {
         status: 500,
         headers: {
-          'Content-Type': 'text/plain'
+          'content-type': 'application/json'
         }
       })
     }