galbe 0.8.0 → 0.9.0

package/bin/res/cli.template.js

@@ -31,17 +31,17 @@ const fmtRes = (r, p = false) => {
   if (typeof r === 'object') {
     try {
       let resp = fmtObject(r, p, 2)
-      return process.stdout.write(`${resp}\n`)
+      return Bun.write(Bun.stdout, `${resp}\n`)
     } catch (err) {
       console.error(err)
-      return process.stdout.write(`${r}\n`)
+      return Bun.write(Bun.stdout, `${r}\n`)
     }
   }
-  if (!p) return process.stdout.write(`${r}\n`)
-  if (typeof r === 'boolean') return process.stdout.write(`${ansi(p, '38;2;255;128;0', r)}\n`)
-  if (typeof r === 'number') return process.stdout.write(`${ansi(p, '38;2;10;180;220', r)}\n`)
-  if (typeof r === 'string') return process.stdout.write(`${ansi(p, '38;2;125;170;0', r)}\n`)
-  return process.stdout.write(`${r}\n`)
+  if (!p) return Bun.write(Bun.stdout, `${r}\n`)
+  if (typeof r === 'boolean') return Bun.write(Bun.stdout, `${ansi(p, '38;2;255;128;0', r)}\n`)
+  if (typeof r === 'number') return Bun.write(Bun.stdout, `${ansi(p, '38;2;10;180;220', r)}\n`)
+  if (typeof r === 'string') return Bun.write(Bun.stdout, `${ansi(p, '38;2;125;170;0', r)}\n`)
+  return Bun.write(Bun.stdout, `${r}\n`)
 }
 
 const fetchApi = async (method, path, props) => {
@@ -84,9 +84,9 @@ const fetchApi = async (method, path, props) => {
     let isJson = res.headers.get('content-type') === 'application/json'
     if (isJson) fmtRes(await res.json(), format.has('p'))
     else if (res.headers.get('content-type')?.match(/^text\//)) fmtRes(await res.text(), format.has('p'))
-    else process.stdout.write(await res.arrayBuffer())
+    else Bun.write(Bun.stdout, await res.arrayBuffer())
   }
-  if (format.has('t')) process.stdout.write(`${(endTime / 1_000_000).toFixed(2)}ms\n`)
+  if (format.has('t')) Bun.write(Bun.stdout, `${(endTime / 1_000_000).toFixed(2)}ms\n`)
   process.exit(res.ok ? 0 : 1)
 }
 
@@ -100,7 +100,7 @@ const formatDefault = def =>
     : def ?? 'undefined';
 
 result = commands.map(c=>{
-  let args = c.arguments.map(a=>`.argument("${a.name}", "${a.description || a.name+' argument' || ''}")`)
+  let args = c.arguments.map(a=>`.argument("${a.name}", "${JSON.stringify(a.description).slice(1,-1) || a.name+' argument' || ''}")`)
   let optionsBase = [
     {name: '%format', short:'%f', type: '[string]', description: 'response format [\'s\',\'h\',\'b\',\'t\',\'p\']', default:["s","b","p"]},
     {name: '%header', short:'%h', type: '<string...>', description: 'request header formated as headerName=headerValue', default:[]},
@@ -108,12 +108,12 @@ result = commands.map(c=>{
     {name: '%body', short:'%b', type: '<string>', description: 'request body', default:''},
     {name: '%bodyFile', short:'%bf', type: '<path>', description: 'request body file', default:''}
   ]
-  let options = [...optionsBase,...(c.options||[])].map(o=>`.addOption(new Option("-${o.short}, --${o.name} ${o.type}", "${o.description}").default(${formatDefault(o.default)}))`)
-  let action = `.action(async (${c.arguments.map(a=>`${a.name},`)} props) => {
+  let options = [...optionsBase,...(c.options||[])].map(o=>`.addOption(new Option("-${o.short}, --${o.name} ${o.type}", "${JSON.stringify(o.description).slice(1,-1)}").default(${formatDefault(o.default)}))`)
+  let action = `.action(async (${c.arguments.map(a=>`${a.name},`).join('')} props) => {
     ${c.action ? ';('+c.action.toString()+')(props)' : ''}
     return await fetchApi("${c.route.method.toUpperCase()}",\`${c.route.pathT}\`, props)
   })`
-  return `program.command("${c.name}").description("${c.description}")${args.join('')}${options.join('')}${action}`
+  return `program.command("${c.name}").description("${JSON.stringify(c.description).slice(1,-1)}")${args.join('')}${options.join('')}${action}`
 })
 %*/
 

package/bin/res/client.template.ts

@@ -6,8 +6,8 @@ export type GalbeClientConfig = {
 export const Kind = Symbol.for('json.string')
 type Json<T> = { T: T }
 
-interface GR<S extends number = number, B = any, OKS extends number = OKStatusCode> {
-  status: S
+interface GR<S extends number | 'default' = 'default', B = any, OKS extends number = OKStatusCode> {
+  status: Exclude<S, "default">
   ok: S extends OKS ? true : false
   redirected: boolean
   statusText: string
@@ -18,16 +18,16 @@ interface GR<S extends number = number, B = any, OKS extends number = OKStatusCo
     stream?: ST
   ) => B extends Uint8Array
     ? ST extends true
-      ? Promise<AsyncGenerator<Uint8Array, void, unknown>>
-      : B extends Json<infer T>
-      ? Promise<T>
-      : Promise<B>
+    ? Promise<AsyncGenerator<Uint8Array, void, unknown>>
+    : B extends Json<infer T>
+    ? Promise<T>
+    : Promise<B>
     : B extends string
     ? ST extends true
-      ? Promise<AsyncGenerator<string, void, unknown>>
-      : B extends Json<infer T>
-      ? Promise<T>
-      : Promise<B>
+    ? Promise<AsyncGenerator<string, void, unknown>>
+    : B extends Json<infer T>
+    ? Promise<T>
+    : Promise<B>
     : B extends Json<infer T>
     ? Promise<T>
     : Promise<B>
@@ -35,9 +35,9 @@ interface GR<S extends number = number, B = any, OKS extends number = OKStatusCo
 
 export type OKStatusCode = 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 226
 // prettier-ignore
-export type HttpStatusCode = 100|101|102|103|OKStatusCode|300|301|302|303|304|305|307|308|400|401|402|403|404|405|406|407|408|409|410|411|412|413|414|415|416|417|418|421|422|423|424|426|428|429|431|451|500|501|502|503|504|505|506|507|508|510|511
+export type HttpStatusCode = 100 | 101 | 102 | 103 | OKStatusCode | 300 | 301 | 302 | 303 | 304 | 305 | 307 | 308 | 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 421 | 422 | 423 | 424 | 426 | 428 | 429 | 431 | 451 | 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511
 type PGR<
-  S extends number = number,
+  S extends number | 'default' = 'default',
   B = any,
   O extends number = 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 226
 > = Promise<GR<S, B, O>>
@@ -54,9 +54,15 @@ const DEFAULT_HEADERS = {
   'user-agent': 'Galbe//*%(()=>version)()%*/'
 }
 
+// Typescript types
+/*%
+Object.entries(types).map(([tk, t])=>{
+  return `export type ${tk} = ${t}`
+})
+%*/
+
 export default class GalbeClient {
   config?: GalbeClientConfig
-
   /*%
   Object.entries(routes).map(([method, list])=>{
     return`${method} = {\n${list.map( r => {
@@ -66,7 +72,7 @@ export default class GalbeClient {
         ''
       let oks = Object.keys(r.schemas?.response||{}).filter(s=>s>=200&&s<300)
       let responses = Object.keys(r.schemas?.response||{}).length ?
-        `${Object.entries(r.schemas.response).map(([k,v])=>`PGR<${k},${v}${oks?.length?`,${oks.join('|')}`:''}>`).join('|')}|PGR<Exclude<HttpStatusCode,${Object.keys(r.schemas.response).join('|')}>,any${oks?.length?`,${oks.join('|')}`:''}>`: 
+        `${Object.entries(r.schemas.response).filter(([s,_])=>s!=='"default"').map(([k,v])=>`PGR<${k},${v}${oks?.length?`,${oks.join('|')}`:''}>`).join('|')}|PGR<Exclude<HttpStatusCode,${Object.keys(r.schemas.response).filter(s=>s!=='"default"').join('|')}>,${'"default"' in r.schemas.response ? r.schemas.response['"default"'] : 'any'}${oks?.length?`,${oks.join('|')}`:''}>`: 
         `PGR<HttpStatusCode,any${oks?.length?`,${oks.join('|')}`:',any'}>`
       return `  '${r.path}':(${p.length?p.map(([k,v])=>`${k}:${v.type}`).join(',')+', ':''}options:RequestOptions${schemas}={})=>this.fetch(\`${r.pathT}\`,{...options,method:'${r.method.toUpperCase()}'}) as ${responses}`
     }).join(',\n')}\n}`
@@ -155,9 +161,13 @@ export default class GalbeClient {
         ''
       let oks = Object.keys(r.schemas?.response||{}).filter(s=>s>=200&&s<300)
       let responses = Object.keys(r.schemas?.response||{}).length ?
-        `${Object.entries(r.schemas.response).map(([k,v])=>`PGR<${k},${v}${oks?.length?`,${oks.join('|')}`:''}>`).join('|')}|PGR<Exclude<HttpStatusCode,${Object.keys(r.schemas.response).join('|')}>,any${oks?.length?`,${oks.join('|')}`:''}>`: 
+        `${Object.entries(r.schemas.response).filter(([s,_])=>s!=='"default"').map(([k,v])=>`PGR<${k},${v}${oks?.length?`,${oks.join('|')}`:''}>`).join('|')}|PGR<Exclude<HttpStatusCode,${Object.keys(r.schemas.response).filter(s=>s!=='"default"').join('|')}>,${'"default"' in r.schemas.response ? r.schemas.response['"default"'] : 'any'}${oks?.length?`,${oks.join('|')}`:''}>`: 
         `PGR<HttpStatusCode,any${oks?.length?`,${oks.join('|')}`:',any'}>`
-      return `${r.alias}(${p.length ? p.map(([k,v])=>`${k}: ${v.type}`).join(', ')+', ':''}options: RequestOptions${schemas} = {}){return this.fetch(\`${r.pathT}\`, {...options, method: '${r.method.toUpperCase()}'}) as ${responses}}\n`
+      let summary = r.summary ? `   * ${r.summary || ''}\n   *\n` : ''
+      let description = r.description ? `   * ${r.description.replace(/\n/g,'\n   * ')}` : ''
+      let params = Object.entries(r.schema.params || {}).map( ([k,v])=>`\n   * @param ${k} - ${v.description?.replace(/\n/g,'\n     ')}` ).join('')
+      let query = Object.entries(r.schema.query || {}).map( ([k,v])=>`\n   * @param options.query.${k} - ${v.description?.replace(/\n/g,'\n     ')}` ).join('')
+      return `/**\n${summary}${description}\n   *${params}${query}\n   *\/\n  ${r.alias}(${p.length ? p.map(([k,v])=>`${k}: ${v.type}`).join(', ')+', ':''}options: RequestOptions${schemas} = {}){return this.fetch(\`${r.pathT}\`, {...options, method: '${r.method.toUpperCase()}'}) as ${responses}}\n`
     }).join('  ')
   })
   %*/

package/bin/util.ts

@@ -2,7 +2,7 @@ import { relative } from 'path'
 import { watch } from 'chokidar'
 import { Galbe, Route } from '../src'
 import { logRoute, walkRoutes } from '../src/util'
-import { RouteMeta, defineRoutes } from '../src/routes'
+import { GalbeProxy, RouteMeta, defineRoutes } from '../src/routes'
 
 export { default as pckg } from '../package.json'
 
@@ -22,7 +22,7 @@ export const silentExec = async (fn: () => any) => {
   let consoleMock = Object.fromEntries(
     Object.entries(console)
       .filter(([_, v]) => typeof v === 'function')
-      .map(([k, _]) => [k, () => {}])
+      .map(([k, _]) => [k, () => { }])
   )
   const _console = console
   const _processStdoutWrite = process.stdout.write
@@ -30,9 +30,9 @@ export const silentExec = async (fn: () => any) => {
   //@ts-ignore
   global.console = consoleMock
   //@ts-ignore
-  process.stdout.write = function () {}
+  process.stdout.write = function () { }
   //@ts-ignore
-  process.stderr.write = function () {}
+  process.stderr.write = function () { }
   const r = await fn()
   global.console = _console
   process.stdout.write = _processStdoutWrite
@@ -65,29 +65,32 @@ export const instanciateRoutes = async (g: Galbe) => {
     hasMainRoutes = true
     logRoute(r)
   })
-  if (hasMainRoutes) process.stdout.write('\n')
+  if (hasMainRoutes) Bun.write(Bun.stdout, '\n')
   // Route Files Analysis
   let routes: Record<string, { route?: Route; meta?: RouteMeta; error?: any }[]> = {}
   let errors: Record<string, any> = {}
-  await defineRoutes({ routes: g?.config?.routes }, g, ({ type, route, error, filepath, meta }) => {
+
+  const proxy = new GalbeProxy(g, ({ type, route, error, filepath, meta }) => {
+    if (meta?.ignore || meta?.hide) return
     if (!filepath) return
     if (!(filepath in routes)) routes[filepath] = []
     if (type === 'add' && route && filepath) routes[filepath].push({ route, meta })
     if (type === 'error') errors[filepath] = error
   })
+  await defineRoutes({ routes: g?.config?.routes }, proxy)
   for (let [fp, e] of Object.entries(routes)) {
     console.log(`\x1b\[0;36m    ${relative(CWD, fp)}\x1b[0m`)
     let maxPathLength = e.reduce((p, c) => {
       return Math.max(p, c.route?.path.length || 0)
     }, 0)
     for (let r of e) {
-      if (r.route) logRoute(r.route, r.meta, { maxPathLength })
+      if (r.route && !r.meta?.ignore && !r.meta?.hide) logRoute(r.route, r.meta, { maxPathLength })
     }
     if (errors?.[fp]) {
       console.log(`\x1b\[0;31m    Error:\x1b[0m`)
       console.log(errors?.[fp])
     }
-    process.stdout.write('\n')
+    console.log("")
   }
   console.log('\x1b[1;30m\x1b[32mdone\x1b[0m\n')
 }

package/docs/error-handler.md

@@ -1,38 +1,49 @@
 # Error handler
 
-Any error happening during a request lifecycle will be intercepted by the error handler.
+Any error happening during a request lifecycle will be intercepted by the error
+handler.
 
-You can customize the default error handling behavior by defining a custom error handler using Galbe's intance `onError` method.
+You can customize the default error handling behavior by defining a custom error
+handler using Galbe's intance `onError` method.
 
 ```js
-const galbe = new Galbe()
-galbe.onError(customErrorHandler)
+const galbe = new Galbe();
+galbe.onError(customErrorHandler);
 ```
 
 ## Definition
 
-The error handler should be a function that takes two aguments: an [Error](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error) and a [Context](context.md). This function may potentially return a [Response type](handler.md#response-types).
+The error handler should be a function that takes two aguments: an
+[Error](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error)
+and a [Context](context.md). This function may potentially return a
+[Response type](handler.md#response-types).
 
 ```js
-galbe.onErrorHandler((error, ctx) => {
+galbe.onError((error, ctx) => {
   if (error.status === 500) {
-    return new Response(`Server error ❌`, { status: 500 })
+    return new Response(`Server error ❌`, { status: 500 });
   }
   if (error.status === 404) {
-    return new Response(`Not found 🔎`, { status: 404 })
+    return new Response(`Not found 🔎`, { status: 404 });
   }
-})
+});
 ```
 
-The `error` argument could be any type of error thrown by your application. If the error originates from Galbe framework, it will be an instance of [RequestError](#request-error).
+The `error` argument could be any type of error thrown by your application. If
+the error originates from Galbe framework, it will be an instance of
+[RequestError](#request-error).
 
-For instance, the [Router](router.md) will throw a `RequestError` with a `404` status if no route matches the incoming request path. Similarly, the Parser will throw a `RequestError` with a `400` status.
+For instance, the [Router](router.md) will throw a `RequestError` with a `404`
+status if no route matches the incoming request path. Similarly, the Parser will
+throw a `RequestError` with a `400` status.
 
 ## Request Error
 
-The `RequestError` class is utilized to instanciate a runtime request error in Galbe. It has two optional attributes: a `status` and a `payload`.
+The `RequestError` class is utilized to instanciate a runtime request error in
+Galbe. It has two optional attributes: a `status` and a `payload`.
 
-If your application throws a `RequestError` instance, Galbe will, by default, construct a Response from your `RequestError` and send it back to the client.
+If your application throws a `RequestError` instance, Galbe will, by default,
+construct a Response from your `RequestError` and send it back to the client.
 
 ```js
 import { Galbe, RequestError } from 'galbe'

package/docs/routes.md

@@ -111,3 +111,6 @@ export default g => {
   g.get('/foo/:bar', ctx => ctx.params.bar)
 }
 ```
+
+> [!TIP]
+> You can ignore a specific route from being analyzed by adding a `//@galbe-ignore` comment before the route definition. This is useful if you want to exclude certain routes from automatic analysis or documentation generation.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "galbe",
-  "version": "0.8.0",
+  "version": "0.9.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/extras/spec/openapi.serializer.ts

@@ -12,10 +12,10 @@ const schemaToMedia = ({ type, format, isJson }: SchemaType) =>
   isJson || (type && ['object', 'number', 'boolean', 'array'].includes(type))
     ? 'application/json'
     : format === 'byte'
-    ? 'application/octet-stream'
-    : type === 'string'
-    ? 'text/plain'
-    : '*/*'
+      ? 'application/octet-stream'
+      : type === 'string'
+        ? 'text/plain'
+        : '*/*'
 
 export const OpenAPISerializer = async (g: Galbe, version = '3.0.3'): Promise<OpenAPIV3.Document> => {
   let paths: any = {}
@@ -115,9 +115,9 @@ export const OpenAPISerializer = async (g: Galbe, version = '3.0.3'): Promise<Op
         type: type,
         ...(type === 'object'
           ? {
-              properties: Object.fromEntries(Object.entries(props).map(([k, v]) => [k, schemaToOpenapi(v).schema])),
-              ...(required.length ? { required } : {})
-            }
+            properties: Object.fromEntries(Object.entries(props).map(([k, v]) => [k, schemaToOpenapi(v).schema])),
+            ...(required.length ? { required } : {})
+          }
           : {})
       }
     } else if (kind === 'union') {
@@ -178,8 +178,13 @@ export const OpenAPISerializer = async (g: Galbe, version = '3.0.3'): Promise<Op
     (routes, c) => ({ ...routes, ...c.routes }),
     {} as Record<string, Record<string, Record<string, any>>>
   )
+  let metaStatic = Object.fromEntries(Object.entries(metaRoutes || {}).filter((([_, d]) => d?.static)))
+
   walkRoutes(g.router.routes, r => {
     let meta = metaRoutes?.[r.path]?.[r.method]
+    if (r.static?.root)
+      meta = metaStatic[r.static?.root]?.static
+    if (meta?.hide) return
     let path = r.path.replaceAll(/:([^\/]+)/g, '{$1}')
     if (!(path in paths)) paths[path] = {}
     let tags = [
@@ -196,19 +201,19 @@ export const OpenAPISerializer = async (g: Galbe, version = '3.0.3'): Promise<Op
       : []
     let headerParam = r.schema?.headers
       ? Object.entries(r.schema?.headers as Record<string, STSchema>)
-          .map(([k, v]) => {
-            let p = parseParam(k, v, 'header')
-            if (k.match(/authorization/i)) {
-              // TODO: handle other auth methods
-              if (v.pattern && v?.pattern?.toString() === '/^Bearer /') {
-                security.push({ bearerAuth: [] })
-                components.securitySchemes = { bearerAuth: { type: 'http', scheme: 'bearer' } }
-                return null
-              }
+        .map(([k, v]) => {
+          let p = parseParam(k, v, 'header')
+          if (k.match(/authorization/i)) {
+            // TODO: handle other auth methods
+            if (v.pattern && v?.pattern?.toString() === '/^Bearer /') {
+              security.push({ bearerAuth: [] })
+              components.securitySchemes = { bearerAuth: { type: 'http', scheme: 'bearer' } }
+              return null
             }
-            return p
-          })
-          .filter(p => p)
+          }
+          return p
+        })
+        .filter(p => p)
       : []
     // TODO cookieParam
     let parameters = [...pathParam, ...queryParam, ...headerParam]
@@ -242,7 +247,7 @@ export const OpenAPISerializer = async (g: Galbe, version = '3.0.3'): Promise<Op
             description: v.description || HttpStatus[Number(s) as keyof typeof HttpStatus] || 'Response',
             content: { [media]: { schema: schema } }
           }
-          if (components.responses && r.schema.response?.[s].id) {
+          if (components.responses && r.schema.response?.[s]?.id) {
             components.responses[r.schema.response?.[s].id as string] = response
             //@ts-ignore
             response = { $ref: `#/components/responses/${r.schema.response?.[s].id}` }

package/src/index.ts

@@ -14,9 +14,14 @@ import type {
   STResponse,
   STParams,
   STHeaders,
-  STQuery
+  STQuery,
+  StaticEndpoint,
+  Route,
+  StaticEndpointOptions
 } from './types'
 
+import { readdirSync, statSync } from 'fs'
+import { resolve as resolvePath } from 'path'
 import server from './server'
 import { GalbeRouter } from './router'
 import { SchemaType, type STObject, type Static } from './schema'
@@ -41,7 +46,7 @@ const overloadDiscriminer = <
     | Hook<M, Path, RequestSchema<M, Path, H, P, Q, B, R>>[]
     | Handler<M, Path, RequestSchema<M, Path, H, P, Q, B, R>>,
   arg4?: Handler<M, Path, RequestSchema<M, Path, H, P, Q, B, R>>
-) => {
+): Route<M, Path, P, H, Q, B, R> => {
   const defaultSchema = {}
   if (typeof arg2 === 'function') {
     return galbeMethod(galbe, method, path, defaultSchema, undefined, arg2)
@@ -70,7 +75,7 @@ const galbeMethod = <
   schema: RequestSchema<M, Path, H, P, Q, B, R> | undefined,
   hooks: Hook<M, Path, RequestSchema<M, Path, H, P, Q, B, R>>[] | undefined,
   handler: Handler<M, Path, RequestSchema<M, Path, H, P, Q, B, R>>
-) => {
+): Route<M, Path, P, H, Q, B, R> => {
   schema = schema ?? {}
   hooks = hooks || []
   const context: Context<M, Path, typeof schema> = {
@@ -85,7 +90,8 @@ const galbeMethod = <
     state: {},
     set: {} as {
       headers: {
-        [header: string]: string
+        'set-cookie': string[]
+        [header: string]: string | string[]
       }
       status?: number
     }
@@ -306,6 +312,40 @@ export class Galbe {
       | Handler<'head', Path, RequestSchema<'head', Path, H, P, Q, B, R>>,
     arg4?: Handler<'head', Path, RequestSchema<'head', Path, H, P, Q, B, R>>
   ) => this.add(overloadDiscriminer(this, 'head', path, arg2, arg3, arg4))
+  static: StaticEndpoint = (path: string, target: string, options?: StaticEndpointOptions) => {
+    let { resolve } = options ?? {}
+    const rootPath = path
+
+    const walkStatic = (path: string, target: string) => {
+      path = path?.[0] === '/' ? path : `/${path}`
+      path = path.endsWith('/') ? path.slice(0, -1) : path;
+
+      let t = target
+      if (Bun.env.BUN_ENV === 'production') {
+        t = resolvePath(import.meta.dir, `static-${Bun.env.GALBE_BUILD}/${target}`)
+      }
+
+      if (!statSync(t).isDirectory()) {
+        let ut: string | null | undefined | void = t
+        if (path.endsWith('.html')) path = path.slice(0, -5)
+        if (resolve) ut = resolve(path, ut)
+        if (ut) {
+          let handler = () => new Response(Bun.file(ut))
+          this.add({ ...galbeMethod(this, 'get', path, {}, undefined, handler), static: { path: ut, root: rootPath } })
+        }
+      } else {
+        let root = readdirSync(t)
+        for (let f of root) {
+          let p = f === 'index.html' ? path : `${path}/${f}`
+          walkStatic(p, `${target}/${f}`)
+        }
+      }
+
+      return { ...galbeMethod(this, 'get', path, {}, undefined, () => { }), static: { path: t, root: rootPath } }
+    }
+
+    return walkStatic(path, target)
+  }
 }
 
 export * from './types'

package/src/parser.ts

@@ -89,8 +89,8 @@ export const requestBodyParser = async (
         let received = contentType?.match(FORM_HEADER_RX)
           ? 'urlForm'
           : contentType?.match(MP_HEADER_RX)
-          ? 'multipartForm'
-          : contentType
+            ? 'multipartForm'
+            : contentType
         throw new RequestError({ status: 400, payload: { body: `Expected ${kind}, received ${received}` } })
       } else if (!contentType || contentType === BA_HEADER) {
         if (!schema) {
@@ -377,7 +377,7 @@ async function* $streamToMultipartForm(data: ReadableStream<Uint8Array>, boundar
       payload: { body: `Missing field${reqKeys.length > 1 ? 's' : ''}: ${reqKeys.join(', ')}` }
     })
 }
-const parseMultipartHeader = (header: string): { name: string; [key: string]: string } | null => {
+const parseMultipartHeader = (header: string): { name: string;[key: string]: string } | null => {
   if (!header) return null
   let disposition = 'form-data'
   const multipartHeader = [
@@ -537,24 +537,24 @@ const paramParser = (
       if (typeof value === 'boolean') return value
       if (value === 'true') return true
       if (value === 'false') return false
-      else throw `${value} is not a valid boolean. Should be 'true' or 'false'`
+      else throw `Not a valid boolean. Should be 'true' or 'false'`
     } else if (type[Kind] === 'integer') {
-      if (value === null || value === undefined) throw `${value} is not a valid integer`
+      if (value === null || value === undefined) throw `Not a valid integer`
       const parsedValue = parseInt(value, 10)
-      if (isNaN(parsedValue) || String(parsedValue) !== String(value)) throw `${value} is not a valid integer`
+      if (isNaN(parsedValue) || String(parsedValue) !== String(value)) throw `Not a valid integer`
       validate(parsedValue, type)
       return parsedValue
     } else if (type[Kind] === 'number') {
-      if (value === null || value === undefined) throw `${value} is not a valid number`
+      if (value === null || value === undefined) throw `Not a valid number`
       const parsedValue = Number(value)
-      if (isNaN(parsedValue) || String(parsedValue) !== String(value)) throw `${value} is not a valid number`
+      if (isNaN(parsedValue) || String(parsedValue) !== String(value)) throw `Not a valid number`
       validate(parsedValue, type)
       return parsedValue
     } else if (type[Kind] === 'string') {
       validate(value, type)
       return value
     } else if (type[Kind] === 'literal') {
-      if (value !== type.value) throw `${value} is not a valid value`
+      if (value !== type.value) throw `Not a valid value`
       return value
     } else if (type[Kind] === 'array') {
       return [paramParser(value, type.items as STMultipartFormValues) as Static<STUrlFormValues>]
@@ -569,9 +569,9 @@ const paramParser = (
           continue
         }
       }
-      throw `${value} could not be parsed to any of ${union
+      throw `Could not be parsed to any of [${union
         .map(u => (u as STLiteral)?.value ?? (u as STSchema)[Kind])
-        .join(', ')}`
+        .join(', ')}]`
     } else if (type[Kind] === 'any') {
       return value
     }
@@ -645,7 +645,12 @@ export const parseEntry = <T extends STProps>(
 export const responseParser = (response: any, ctx: Context, schema?: STResponse) => {
   const details = {
     status: ctx.set.status || 200,
-    headers: new Headers(ctx.set.headers)
+    headers: new Headers()
+  }
+  for (const [key, value] of Object.entries(ctx.set.headers)) {
+    if (Array.isArray(value)) {
+      value.forEach(v => details.headers.append(key, v))
+    } else details.headers.set(key, value)
   }
   if (response instanceof Response) return response
   else if (typeof response === 'string') {