galbe 0.2.0 → 0.3.0

package/docs/getting-started.md

@@ -137,6 +137,14 @@ A Glob Pattern or a list of Glob patterns defining the route files to be analyze
 
 A property that can be used by plugins to add plugin's specific configuration. Every key should correspond to a [Unique Plugin Identifier](plugins.md).
 
+**requestValidator.enabled**
+
+Enable or disable the _request_ schema validation (See [Request Schema definition](schemas.md#request-schema-definition)). Default value is `true`.
+
+**responseValidator.enabled**
+
+Enable or disable the _response_ schema validation (See [Request Schema definition](schemas.md#request-schema-definition)). Default value is `true`.
+
 ### Examples
 
 A common way to handle server configuration is to create new file `galbe.config.(js|ts|json)` at the root of your project directory and import it in your code. Here is an example:

package/docs/hooks.md

@@ -49,7 +49,7 @@ const hook2 = context => {
   console.log('hook2 called')
 }
 
-galbe.get('example', [hook1, hook2], ctx => {
+galbe.get('/example', [hook1, hook2], ctx => {
   console.log('handler')
 })
 ```
@@ -64,18 +64,18 @@ handler
 Nested hooks declaration:
 
 ```ts
-const hook1 = (context, next) => {
+const hook1 = async (context, next) => {
   console.log('hook1 start')
   await next()
   console.log('hook1 end')
 }
-const hook2 = context => {
+const hook2 = async (context, next) => {
   console.log('hook2 start')
   await next()
   console.log('hook2 end')
 }
 
-galbe.get('example', [hook1, hook2], ctx => {
+galbe.get('/example', [hook1, hook2], ctx => {
   console.log('handler')
 })
 ```

package/docs/plugins.md

@@ -68,9 +68,7 @@ import { Galbe, type Context, type Route } from 'galbe'
 class MyPlugin {
   name = 'dev.galbe.example'
   deprecated: Record<string, string[]> = {}
-  /**
-   * Retrieve and store all route with a @deprecated flag metadata
-   */
+  // Retrieve and store all route with a @deprecated flag metadata
   init(config: any, galbe: Galbe) {
     if (config?.enabled && galbe.meta) {
       for (const f of galbe.meta) {
@@ -85,9 +83,7 @@ class MyPlugin {
       }
     }
   }
-  /**
-   * Check if the current route is deprecated, flags it as is and logs it
-   */
+  // Check if the current route is deprecated; if so, flag it as such and log it
   onRoute(context: Context) {
     let route = context.route
     if (this.deprecated?.[route.method]?.includes(route.path)) {
@@ -95,9 +91,7 @@ class MyPlugin {
       console.warn(`Call to deprecated route [${route.method}]${route.path}`)
     }
   }
-  /**
-   * Adds a header if the request has previously been flagged as deprecated
-   */
+  // Add a header if the request has previously been flagged as deprecated
   afterHandle(response: Response, context: Context) {
     if (context.state?.[this.name]?.deprecated) {
       response.headers.set('x-deprecated', 'true')

package/docs/schemas.md

@@ -152,8 +152,7 @@ const schema = {
 
 <!-- prettier-ignore -->
 ```ts
-body: STByteArray | STString | STBoolean | STNumber | STInteger | STLiteral | 
-      STObject | STMulripartForm | STUrlForm
+body: STByteArray | STString | STBoolean | STNumber | STInteger | STLiteral | STObject | STArray | STMulripartForm | STUrlForm | STStream
 ```
 
 #### Json
@@ -238,3 +237,21 @@ galbe.post(
   }
 })
 ```
+
+### response
+
+<!-- prettier-ignore -->
+```ts
+response: Record<number, STByteArray | STString | STBoolean | STNumber | STInteger | STLiteral | STObject | STArray | STStream>
+```
+
+Same as for request body validation but to validate handler responses. Every schema type must be associated to a specific response status.
+
+#### Example
+
+```ts
+const response = {
+  200: $T.object({ data: $T.array($T.number()) })
+  404: $T.literal("Not found")
+}
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "galbe",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "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

@@ -11,6 +11,7 @@ import type {
   ErrorHandler,
   GalbePlugin,
   STBody,
+  STResponse,
   STParams,
   STHeaders,
   STQuery
@@ -19,7 +20,7 @@ import type {
 import server from './server'
 import { GalbeRouter } from './router'
 import { defineRoutes } from './routes'
-import { logRoute } from './util'
+import { extractMetaRoute, logRoute } from './util'
 import { SchemaType, type STObject, type Static } from './schema'
 
 const overloadDiscriminer = <
@@ -27,17 +28,18 @@ const overloadDiscriminer = <
   H extends STHeaders,
   P extends Partial<STParams<Path>>,
   Q extends STQuery,
-  B extends STBody
+  B extends STBody,
+  R extends STResponse
 >(
   galbe: Galbe,
   method: Method,
   path: Path,
   arg2:
-    | RequestSchema<Path, H, P, Q, B>
-    | Hook<Path, RequestSchema<Path, H, P, Q, B>>[]
-    | Handler<Path, RequestSchema<Path, H, P, Q, B>>,
-  arg3?: Hook<Path, RequestSchema<Path, H, P, Q, B>>[] | Handler<Path, RequestSchema<Path, H, P, Q, B>>,
-  arg4?: Handler<Path, RequestSchema<Path, H, P, Q, B>>
+    | RequestSchema<Path, H, P, Q, B, R>
+    | Hook<Path, RequestSchema<Path, H, P, Q, B, R>>[]
+    | Handler<Path, RequestSchema<Path, H, P, Q, B, R>>,
+  arg3?: Hook<Path, RequestSchema<Path, H, P, Q, B, R>>[] | Handler<Path, RequestSchema<Path, H, P, Q, B, R>>,
+  arg4?: Handler<Path, RequestSchema<Path, H, P, Q, B, R>>
 ) => {
   const defaultSchema = {}
   if (typeof arg2 === 'function') {
@@ -57,14 +59,15 @@ const galbeMethod = <
   H extends STHeaders,
   P extends Partial<STParams<Path>>,
   Q extends STQuery,
-  B extends STBody
+  B extends STBody,
+  R extends STResponse
 >(
   _galbe: Galbe,
   method: Method,
   path: Path,
-  schema: RequestSchema<Path, H, P, Q, B> | undefined,
-  hooks: Hook<Path, RequestSchema<Path, H, P, Q, B>>[] | undefined,
-  handler: Handler<Path, RequestSchema<Path, H, P, Q, B>>
+  schema: RequestSchema<Path, H, P, Q, B, R> | undefined,
+  hooks: Hook<Path, RequestSchema<Path, H, P, Q, B, R>>[] | undefined,
+  handler: Handler<Path, RequestSchema<Path, H, P, Q, B, R>>
 ) => {
   schema = schema ?? {}
   hooks = hooks || []
@@ -92,6 +95,7 @@ const galbeMethod = <
   }
 }
 
+/** Galbe Schema Type builder. See {@link https://galbe.dev/documentation/schemas#schema-types Schema Types} */
 export const $T = new SchemaType()
 
 export { RequestError } from './types'
@@ -126,12 +130,14 @@ export class Galbe {
       prefix: this.config?.basePath || '',
       cacheEnabled: this.config?.router?.cacheEnabled
     })
+    this.config.requestValidator = config?.requestValidator ?? { enabled: true }
+    this.config.responseValidator = config?.responseValidator ?? { enabled: true }
   }
   private add(route: any) {
     this.router.add(route)
     if (Bun.env.BUN_ENV === 'development') {
       if (!this.#prepare) indexRoutes.push({ method: route.method, path: route.path })
-      else logRoute(route)
+      else logRoute(route, extractMetaRoute(route, this.meta))
     }
   }
   async use(plugin: GalbePlugin) {
@@ -144,7 +150,7 @@ export class Galbe {
     if (Bun.env.BUN_ENV === 'development') {
       this.#prepare = true
       console.log('🏗️  \x1b[1;30mConstructing routes\x1b[0m')
-      for (const r of indexRoutes) logRoute(r)
+      for (const r of indexRoutes) logRoute(r, extractMetaRoute(r, this.meta))
       await defineRoutes(this.config || {}, this)
       console.log('\n✅ \x1b[1;30mdone\x1b[0m')
       this.server = await server(this, port)
@@ -168,90 +174,96 @@ export class Galbe {
     H extends STHeaders,
     P extends Partial<STParams<Path>>,
     Q extends STQuery,
-    B extends STBody
+    B extends STBody,
+    R extends STResponse
   >(
     path: Path,
     arg2:
-      | RequestSchema<Path, H, P, Q, B>
-      | Hook<Path, RequestSchema<Path, H, P, Q, B>>[]
-      | Handler<Path, RequestSchema<Path, H, P, Q, B>>,
-    arg3?: Hook<Path, RequestSchema<Path, H, P, Q, B>>[] | Handler<Path, RequestSchema<Path, H, P, Q, B>>,
-    arg4?: Handler<Path, RequestSchema<Path, H, P, Q, B>>
+      | RequestSchema<Path, H, P, Q, B, R>
+      | Hook<Path, RequestSchema<Path, H, P, Q, B, R>>[]
+      | Handler<Path, RequestSchema<Path, H, P, Q, B, R>>,
+    arg3?: Hook<Path, RequestSchema<Path, H, P, Q, B, R>>[] | Handler<Path, RequestSchema<Path, H, P, Q, B, R>>,
+    arg4?: Handler<Path, RequestSchema<Path, H, P, Q, B, R>>
   ) => this.add(overloadDiscriminer(this, 'get', path, arg2, arg3, arg4))
   post: Endpoint = <
     Path extends string,
     H extends STHeaders,
     P extends Partial<STParams<Path>>,
     Q extends STQuery,
-    B extends STBody
+    B extends STBody,
+    R extends STResponse
   >(
     path: Path,
     arg2:
-      | RequestSchema<Path, H, P, Q, B>
-      | Hook<Path, RequestSchema<Path, H, P, Q, B>>[]
-      | Handler<Path, RequestSchema<Path, H, P, Q, B>>,
-    arg3?: Hook<Path, RequestSchema<Path, H, P, Q, B>>[] | Handler<Path, RequestSchema<Path, H, P, Q, B>>,
-    arg4?: Handler<Path, RequestSchema<Path, H, P, Q, B>>
+      | RequestSchema<Path, H, P, Q, B, R>
+      | Hook<Path, RequestSchema<Path, H, P, Q, B, R>>[]
+      | Handler<Path, RequestSchema<Path, H, P, Q, B, R>>,
+    arg3?: Hook<Path, RequestSchema<Path, H, P, Q, B, R>>[] | Handler<Path, RequestSchema<Path, H, P, Q, B, R>>,
+    arg4?: Handler<Path, RequestSchema<Path, H, P, Q, B, R>>
   ) => this.add(overloadDiscriminer(this, 'post', path, arg2, arg3, arg4))
   put: Endpoint = <
     Path extends string,
     H extends STHeaders,
     P extends Partial<STParams<Path>>,
     Q extends STQuery,
-    B extends STBody
+    B extends STBody,
+    R extends STResponse
   >(
     path: Path,
     arg2:
-      | RequestSchema<Path, H, P, Q, B>
-      | Hook<Path, RequestSchema<Path, H, P, Q, B>>[]
-      | Handler<Path, RequestSchema<Path, H, P, Q, B>>,
-    arg3?: Hook<Path, RequestSchema<Path, H, P, Q, B>>[] | Handler<Path, RequestSchema<Path, H, P, Q, B>>,
-    arg4?: Handler<Path, RequestSchema<Path, H, P, Q, B>>
+      | RequestSchema<Path, H, P, Q, B, R>
+      | Hook<Path, RequestSchema<Path, H, P, Q, B, R>>[]
+      | Handler<Path, RequestSchema<Path, H, P, Q, B, R>>,
+    arg3?: Hook<Path, RequestSchema<Path, H, P, Q, B, R>>[] | Handler<Path, RequestSchema<Path, H, P, Q, B, R>>,
+    arg4?: Handler<Path, RequestSchema<Path, H, P, Q, B, R>>
   ) => this.add(overloadDiscriminer(this, 'put', path, arg2, arg3, arg4))
   patch: Endpoint = <
     Path extends string,
     H extends STHeaders,
     P extends Partial<STParams<Path>>,
     Q extends STQuery,
-    B extends STBody
+    B extends STBody,
+    R extends STResponse
   >(
     path: Path,
     arg2:
-      | RequestSchema<Path, H, P, Q, B>
-      | Hook<Path, RequestSchema<Path, H, P, Q, B>>[]
-      | Handler<Path, RequestSchema<Path, H, P, Q, B>>,
-    arg3?: Hook<Path, RequestSchema<Path, H, P, Q, B>>[] | Handler<Path, RequestSchema<Path, H, P, Q, B>>,
-    arg4?: Handler<Path, RequestSchema<Path, H, P, Q, B>>
+      | RequestSchema<Path, H, P, Q, B, R>
+      | Hook<Path, RequestSchema<Path, H, P, Q, B, R>>[]
+      | Handler<Path, RequestSchema<Path, H, P, Q, B, R>>,
+    arg3?: Hook<Path, RequestSchema<Path, H, P, Q, B, R>>[] | Handler<Path, RequestSchema<Path, H, P, Q, B, R>>,
+    arg4?: Handler<Path, RequestSchema<Path, H, P, Q, B, R>>
   ) => this.add(overloadDiscriminer(this, 'patch', path, arg2, arg3, arg4))
   delete: Endpoint = <
     Path extends string,
     H extends STHeaders,
     P extends Partial<STParams<Path>>,
     Q extends STQuery,
-    B extends STBody
+    B extends STBody,
+    R extends STResponse
   >(
     path: Path,
     arg2:
-      | RequestSchema<Path, H, P, Q, B>
-      | Hook<Path, RequestSchema<Path, H, P, Q, B>>[]
-      | Handler<Path, RequestSchema<Path, H, P, Q, B>>,
-    arg3?: Hook<Path, RequestSchema<Path, H, P, Q, B>>[] | Handler<Path, RequestSchema<Path, H, P, Q, B>>,
-    arg4?: Handler<Path, RequestSchema<Path, H, P, Q, B>>
+      | RequestSchema<Path, H, P, Q, B, R>
+      | Hook<Path, RequestSchema<Path, H, P, Q, B, R>>[]
+      | Handler<Path, RequestSchema<Path, H, P, Q, B, R>>,
+    arg3?: Hook<Path, RequestSchema<Path, H, P, Q, B, R>>[] | Handler<Path, RequestSchema<Path, H, P, Q, B, R>>,
+    arg4?: Handler<Path, RequestSchema<Path, H, P, Q, B, R>>
   ) => this.add(overloadDiscriminer(this, 'delete', path, arg2, arg3, arg4))
   options: Endpoint = <
     Path extends string,
     H extends STHeaders,
     P extends Partial<STParams<Path>>,
     Q extends STQuery,
-    B extends STBody
+    B extends STBody,
+    R extends STResponse
   >(
     path: Path,
     arg2:
-      | RequestSchema<Path, H, P, Q, B>
-      | Hook<Path, RequestSchema<Path, H, P, Q, B>>[]
-      | Handler<Path, RequestSchema<Path, H, P, Q, B>>,
-    arg3?: Hook<Path, RequestSchema<Path, H, P, Q, B>>[] | Handler<Path, RequestSchema<Path, H, P, Q, B>>,
-    arg4?: Handler<Path, RequestSchema<Path, H, P, Q, B>>
+      | RequestSchema<Path, H, P, Q, B, R>
+      | Hook<Path, RequestSchema<Path, H, P, Q, B, R>>[]
+      | Handler<Path, RequestSchema<Path, H, P, Q, B, R>>,
+    arg3?: Hook<Path, RequestSchema<Path, H, P, Q, B, R>>[] | Handler<Path, RequestSchema<Path, H, P, Q, B, R>>,
+    arg4?: Handler<Path, RequestSchema<Path, H, P, Q, B, R>>
   ) => this.add(overloadDiscriminer(this, 'options', path, arg2, arg3, arg4))
 }
 

package/src/parser.ts

@@ -17,6 +17,7 @@ import { readableStreamToArrayBuffer } from 'bun'
 import { Kind, Optional, Stream } from './schema'
 import { validate } from './validator'
 import { InternalError, RequestError } from './index'
+import { isIterator } from './util'
 
 const textDecoder = new TextDecoder()
 const textEncoder = new TextEncoder()
@@ -594,7 +595,7 @@ export const requestPathParser = (input: string, path: string) => {
 }
 
 export const parseEntry = <T extends STProps>(
-  params: { [key: string]: string | string[] },
+  params: { [key: string]: any },
   schema: T,
   options?: { name?: string; i?: boolean }
 ): Static<STObject<T>> => {
@@ -629,8 +630,6 @@ export const parseEntry = <T extends STProps>(
   return parsedParams as Static<STObject<T>>
 }
 
-const isIterator = (obj: any) => typeof obj?.next === 'function'
-
 export const responseParser = (response: any, ctx: Context) => {
   const details = {
     status: ctx.set.status || 200,

package/src/router.ts

@@ -89,6 +89,7 @@ export class GalbeRouter {
     }
   }
   find(method: string, path: string) {
+    method = method.toUpperCase()
     const staticRoute = this.cachedRoutes.get(`[${method}]${path}`)
     if (staticRoute === null) throw new NotFoundError()
     if (staticRoute !== undefined) return staticRoute

package/src/routes.ts

@@ -1,7 +1,7 @@
 import type { GalbeConfig } from './types'
 
 import { readdir, lstat } from 'fs/promises'
-import { extname } from 'path'
+import { extname, relative } from 'path'
 import { parse } from 'acorn'
 import { simple } from 'acorn-walk'
 import { Galbe } from './index'
@@ -81,13 +81,15 @@ export const metaAnalysis = async (filePath: string): Promise<RouteMeta> => {
   })
   simple(ast, {
     ExportDefaultDeclaration(node) {
-      // @ts-ignore
-      let galbeIdentifier = node.declaration.params[0].name
-
       const headerLine = node.loc?.start.line
       const headerCom = headerLine !== undefined && comments?.[headerLine] ? comments[headerLine] : ''
       const headerRef = parseComment(headerCom)
       meta.header = headerRef
+
+      // @ts-ignore
+      let galbeIdentifier = node.declaration?.params?.[0]?.name
+      if (!galbeIdentifier) return meta
+
       // @ts-ignore
       simple(node.declaration.body, {
         CallExpression(node) {
@@ -113,7 +115,10 @@ export const metaAnalysis = async (filePath: string): Promise<RouteMeta> => {
 }
 
 const importRoutes = async (filePath: string, galbe: Galbe) => {
-  const routes = (await import(filePath)).default
+  const imported = await import(filePath)
+  if (!imported?.default) throw new Error('No default export function')
+  if (typeof imported.default !== 'function') throw new Error('Default export must be a function')
+  const routes = imported.default
   routes(galbe)
 }
 
@@ -138,16 +143,14 @@ export const defineRoutes = async (options: GalbeConfig, galbe: Galbe) => {
         try {
           const metadata = await metaAnalysis(f)
           galbe.meta?.push({ file: path, ...metadata })
-          console.log(`\n\x1b\[0;36m    ${f}\x1b[0m`)
+          console.log(`\n\x1b\[0;36m    ${relative('.', f)}\x1b[0m`)
           await importRoutes(f, galbe)
-        } catch (err) {
-          // console.log(`\x1b\[0;31m    ${f}\x1b[0m`)
-          throw err
+        } catch (err: any) {
+          console.log(`\x1b\[0;31m    Error: ${err?.message}\x1b[0m`)
         }
       }
     }
     if (noRouteFound) {
-      process.stdout.write('\r\x1b[K')
       console.log(`\x1b\[38;5;245m    No route found\x1b[0m`)
       return
     }

package/src/schema.ts

@@ -63,6 +63,16 @@ export type STPropsValue =
 export type STProps = Record<string | number, STPropsValue>
 
 type Evaluate<T> = T extends infer O ? { [K in keyof O]: O[K] } : never
+
+/**
+ * Infer the static TypeScript type from a {@link https://galbe.dev/documentation/schemas#schema-types Schema Type}
+ * @example
+ * ```ts
+ * const schema = $T.object({ foo: $T.string() })
+ * type T = Static<typeof schema>
+ * //   ^? type T = { foo: string }
+ * ```
+ */
 export type Static<T extends STSchema, P extends unknown[] = unknown[]> = (T & { params: P })['static']
 
 // Utils

package/src/server.ts

@@ -3,6 +3,9 @@ import type { Context, Route } from './types'
 import { InternalError, RequestError } from './types'
 import { parseEntry, requestBodyParser, requestPathParser, responseParser } from './parser'
 import { Galbe } from './index'
+import { validateResponse } from './validator'
+
+const LOADABLE_METHODS = ['POST', 'PUT', 'PATCH']
 
 const handleInternalError = (error: any) => {
   console.error(error)
@@ -69,37 +72,41 @@ export default async (galbe: Galbe, port?: number) => {
         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)
+        context.body = LOADABLE_METHODS.includes(req.method)
+          ? await requestBodyParser(req.body, inHeaders, schema.body)
+          : null
         context.headers = inHeaders
         context.query = inQuery
         context.params = inParams
 
         // request validation
-        let errors: RequestError[] = []
-        try {
-          if (schema?.headers)
-            context.headers = {
-              ...context.headers,
-              ...parseEntry(context.headers, schema.headers, { name: 'headers', i: true })
-            }
-        } catch (error) {
-          if (error instanceof RequestError) errors.push(error)
-          else throw handleInternalError(error)
-        }
-        try {
-          if (schema?.query) context.query = parseEntry(context.query, schema.query, { name: 'query' })
-        } catch (error) {
-          if (error instanceof RequestError) errors.push(error)
-          else throw handleInternalError(error)
-        }
-        try {
-          if (schema?.params) context.params = parseEntry(context.params, schema.params, { name: 'params' })
-        } catch (error) {
-          if (error instanceof RequestError) errors.push(error)
-          else throw handleInternalError(error)
-        }
-        if (errors.length) {
-          throw new RequestError({ status: 400, payload: errors.reduce((acc, c) => ({ ...acc, ...c.payload }), {}) })
+        if (galbe.config?.requestValidator?.enabled) {
+          let errors: RequestError[] = []
+          try {
+            if (schema?.headers)
+              context.headers = {
+                ...context.headers,
+                ...parseEntry(context.headers, schema.headers, { name: 'headers', i: true })
+              }
+          } catch (error) {
+            if (error instanceof RequestError) errors.push(error)
+            else throw handleInternalError(error)
+          }
+          try {
+            if (schema?.query) context.query = parseEntry(context.query, schema.query, { name: 'query' })
+          } catch (error) {
+            if (error instanceof RequestError) errors.push(error)
+            else throw handleInternalError(error)
+          }
+          try {
+            if (schema?.params) context.params = parseEntry(context.params, schema.params, { name: 'params' })
+          } catch (error) {
+            if (error instanceof RequestError) errors.push(error)
+            else throw handleInternalError(error)
+          }
+          if (errors.length) {
+            throw new RequestError({ status: 400, payload: errors.reduce((acc, c) => ({ ...acc, ...c.payload }), {}) })
+          }
         }
 
         for (const p of pluginsCb.beforeHandle) {
@@ -142,6 +149,9 @@ export default async (galbe: Galbe, port?: number) => {
 
         const parsedResponse = responseParser(response, context)
 
+        if (galbe.config?.responseValidator?.enabled && schema.response)
+          validateResponse(response, schema.response, context.set.status || 200)
+
         for (const p of pluginsCb.afterHandle) {
           //@ts-ignore
           const r = await p.afterHandle(parsedResponse, context)
@@ -154,8 +164,19 @@ export default async (galbe: Galbe, port?: number) => {
         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.payload), {
+        if (error instanceof InternalError) {
+          console.log(`Internal Error`, error?.payload || '')
+          return new Response('Internal Server Error', {
+            status: error.status,
+            headers: { 'Content-Type': 'application/json' }
+          })
+        } else if (error instanceof RequestError) {
+          let payload = ''
+          if (typeof error.payload === 'string') payload = error.payload
+          try {
+            payload = JSON.stringify(error.payload)
+          } catch (err) {}
+          return new Response(payload, {
             status: error.status,
             headers: { 'Content-Type': 'application/json' }
           })

package/src/types.ts

@@ -22,12 +22,27 @@ export type STBody =
   | STBoolean
   | STNumber
   | STInteger
+  | STLiteral
   | STObject
   | STArray
   | STUrlForm
   | STMultipartForm
   | STUnion
   | STStream
+
+export type STResponseValue =
+  | STByteArray
+  | STString
+  | STBoolean
+  | STNumber
+  | STInteger
+  | STLiteral
+  | STObject
+  | STArray
+  | STUnion
+  | STStream
+export type STResponse = Record<number, STResponseValue>
+
 export type MaybeArray<T> = T | T[]
 
 export type Method = 'get' | 'post' | 'put' | 'delete' | 'patch' | 'options'
@@ -74,6 +89,8 @@ export type GalbeConfig = {
   routes?: boolean | string | string[]
   router?: { cacheEnabled: boolean }
   plugin?: Record<string, any>
+  requestValidator?: { enabled: boolean }
+  responseValidator?: { enabled: boolean }
 }
 /**
  * #### Schema
@@ -96,15 +113,17 @@ export type GalbeConfig = {
  */
 export type RequestSchema<
   Path extends string = string,
-  H extends STHeaders = {},
-  P extends Partial<STParams<Path>> = {},
-  Q extends STQuery = {},
-  B extends STBody = STBody
+  H extends STHeaders = STHeaders,
+  P extends Partial<STParams<Path>> = Partial<STParams<Path>>,
+  Q extends STQuery = STQuery,
+  B extends STBody = STBody,
+  R extends STResponse = STResponse
 > = {
   headers?: H
   params?: P
   query?: Q
   body?: B
+  response?: R
 }
 
 type OmitNotDefined<S extends RequestSchema> = {
@@ -147,44 +166,48 @@ export type Endpoint = {
     H extends STHeaders,
     P extends Partial<STParams<Path>>,
     Q extends STQuery,
-    B extends STBody = any
+    B extends STBody = any,
+    R extends STResponse = STResponse
   >(
     path: Path,
-    schema: RequestSchema<Path, H, P, Q, B>,
-    hooks: Hook<Path, RequestSchema<Path, H, P, Q, B>>[],
-    handler: Handler<Path, RequestSchema<Path, H, P, Q, B>>
+    schema: RequestSchema<Path, H, P, Q, B, R>,
+    hooks: Hook<Path, RequestSchema<Path, H, P, Q, B, R>>[],
+    handler: Handler<Path, RequestSchema<Path, H, P, Q, B, R>>
   ): void
   <
     Path extends string,
     H extends STHeaders,
     P extends Partial<STParams<Path>>,
     Q extends STQuery,
-    B extends STBody = any
+    B extends STBody = any,
+    R extends STResponse = STResponse
   >(
     path: Path,
-    schema: RequestSchema<Path, H, P, Q, B>,
-    handler: Handler<Path, RequestSchema<Path, H, P, Q, B>>
+    schema: RequestSchema<Path, H, P, Q, B, R>,
+    handler: Handler<Path, RequestSchema<Path, H, P, Q, B, R>>
   ): void
   <
     Path extends string,
     H extends STHeaders,
     P extends Partial<STParams<Path>>,
     Q extends STQuery,
-    B extends STBody = any
+    B extends STBody = any,
+    R extends STResponse = STResponse
   >(
     path: Path,
-    hooks: Hook<Path, RequestSchema<Path, H, P, Q, B>>[],
-    handler: Handler<Path, RequestSchema<Path, H, P, Q, B>>
+    hooks: Hook<Path, RequestSchema<Path, H, P, Q, B, R>>[],
+    handler: Handler<Path, RequestSchema<Path, H, P, Q, B, R>>
   ): void
   <
     Path extends string,
     H extends STHeaders,
     P extends Partial<STParams<Path>>,
     Q extends STQuery,
-    B extends STBody = any
+    B extends STBody = any,
+    R extends STResponse = STResponse
   >(
     path: Path,
-    handler: Handler<Path, RequestSchema<Path, H, P, Q, B>>
+    handler: Handler<Path, RequestSchema<Path, H, P, Q, B, R>>
   ): void
 }
 
@@ -193,7 +216,7 @@ export class RequestError {
   payload: any
   constructor(options: { status?: number; payload?: any }) {
     this.status = options.status ?? 500
-    this.payload = options.payload ?? 'Internal server error'
+    this.payload = options.payload
   }
 }
 
@@ -210,14 +233,15 @@ export type Route<
   H extends STHeaders = {},
   P extends Partial<STParams<Path>> = {},
   Q extends STQuery = {},
-  B extends STBody = STBody
+  B extends STBody = STBody,
+  R extends STResponse = STResponse
 > = {
   method: Method
   path: Path
-  schema: RequestSchema<Path, H, P, Q, B>
-  context: Context<Path, RequestSchema<Path, H, P, Q, B>>
+  schema: RequestSchema<Path, H, P, Q, B, R>
+  context: Context<Path, RequestSchema<Path, H, P, Q, B, R>>
   hooks: Hook[]
-  handler: Handler<Path, RequestSchema<Path, H, P, Q, B>>
+  handler: Handler<Path, RequestSchema<Path, H, P, Q, B, R>>
 }
 
 export type RouteTree = {
@@ -225,13 +249,13 @@ export type RouteTree = {
 }
 
 export class NotFoundError extends RequestError {
-  constructor(message?: string) {
+  constructor(message?: any) {
     super({ status: 404, payload: message ?? 'Not found' })
   }
 }
 
 export class InternalError extends RequestError {
-  constructor(message?: string) {
+  constructor(message?: any) {
     super({ status: 500, payload: message ?? 'Internal Server Error' })
   }
 }

package/src/util.ts

@@ -1,3 +1,5 @@
+import type { RouteFileMeta } from './routes'
+
 const METHOD_COLOR: Record<string, string> = {
   get: '\x1b[32m',
   post: '\x1b[34m',
@@ -6,7 +8,21 @@ const METHOD_COLOR: Record<string, string> = {
   delete: '\x1b[31m',
   options: ''
 }
-export const logRoute = (r: { method: string; path: string }) => {
+
+export const extractMetaRoute = (route: { path: string; method: string }, meta?: Array<RouteFileMeta>) => {
+  return meta?.map(e => (route.path in e.routes ? e.routes[route.path]?.[route.method] : null)).filter(e => e)?.[0]
+}
+
+export const logRoute = (
+  r: { method: string; path: string },
+  meta?: Record<string, boolean | string | string[]> | null
+) => {
   let color = METHOD_COLOR?.[r.method] || ''
-  console.log(`    [${color}${`${r.method.toUpperCase()}\x1b[0m]`.padEnd(12, ' ')} ${r.path}`)
+  console.log(
+    `    [${color}${`${r.method.toUpperCase()}\x1b[0m]`.padEnd(12, ' ')} ${r.path}${
+      meta?.head ? ` - ${meta.head}` : ''
+    }`
+  )
 }
+
+export const isIterator = (obj: any) => typeof obj?.next === 'function'

package/src/validator.ts

@@ -1,5 +1,7 @@
+import { InternalError, type STResponse } from './index'
 import type { STSchema, STProps, STUnion } from './schema'
-import { Kind, Optional } from './schema'
+import { Kind, Optional, Stream } from './schema'
+import { isIterator } from './util'
 
 export const validate = (elt: any, schema: STSchema, parse = false): any => {
   type ValidationError = string | string[] | { [key: string]: ValidationError }
@@ -7,7 +9,10 @@ export const validate = (elt: any, schema: STSchema, parse = false): any => {
   const iElt = elt
 
   if (schema[Kind] === 'boolean') {
-    if (parse && typeof elt === 'string') elt = elt === 'true' ? true : elt === 'false' ? false : null
+    if (typeof elt === 'string') {
+      if (parse) elt = elt === 'true' ? true : elt === 'false' ? false : null
+      else throw `Expected boolean, got string.`
+    }
     if (elt !== true && elt !== false) throw `${iElt} is not a valid boolean. Should be 'true' or 'false'`
   } else if (schema[Kind] === 'integer') {
     if (parse && typeof elt === 'string') elt = Number(elt)
@@ -84,6 +89,22 @@ export const validate = (elt: any, schema: STSchema, parse = false): any => {
   return elt
 }
 
+export const validateResponse = (response: any, schema: STResponse, status: number) => {
+  if (!(status in schema)) return
+  const s = schema[status]
+  if (response instanceof ReadableStream) {
+    if (!s[Stream]) throw new InternalError(`Expected ${s[Kind]} response, but got ReadableStream`)
+  } else if (isIterator(response)) {
+    if (!s[Stream]) throw new InternalError(`Expected ${s[Kind]} response, but got Iterator`)
+  } else {
+    try {
+      validate(response, s)
+    } catch (error) {
+      throw new InternalError({ ResponseValidationError: error })
+    }
+  }
+}
+
 const schemaValidation = (value: any, schema: STSchema) => {
   const errors = []
   if (schema[Kind] === 'integer' || schema[Kind] === 'number') {
@@ -92,9 +113,8 @@ const schemaValidation = (value: any, schema: STSchema) => {
     if (schema.exclusiveMax !== undefined)
       if ((value as number) >= schema.exclusiveMax)
         errors.push(`${value} is greater or equal to ${schema.exclusiveMax}`)
-    if (schema.minimum !== undefined)
-      if ((value as number) < schema.min) errors.push(`${value} is less than ${schema.min}`)
-    if (schema.maximum !== undefined)
+    if (schema.min !== undefined) if ((value as number) < schema.min) errors.push(`${value} is less than ${schema.min}`)
+    if (schema.max !== undefined)
       if ((value as number) > schema.max) errors.push(`${value} is greater than ${schema.max}`)
   } else if (schema[Kind] === 'string') {
     if (schema.minLength !== undefined && (value as string).length < schema.minLength)

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,25 @@ 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('/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 +73,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 +90,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 +113,272 @@ 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 body = await resp.json()
+
+    expect(resp.status).toBe(200)
+    expect(resp.headers.get('content-type')).toBe('application/json')
+    expect(body).toEqual(reqBody)
+  })
+
+  test('response, ba, validation failed', 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 failed', 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 failed', 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, str, validation failed', async () => {
+    let bodyStr = '3.14'
+
+    let resp = await fetch(`http://localhost:${port}/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 failed', 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 failed', 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 failed', 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 failed', 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)
+  })
 })