galbe 0.7.0 → 0.9.0

package/src/routes.ts

@@ -1,4 +1,5 @@
-import type { GalbeConfig, Method, Route } from './types'
+import { cpSync } from 'fs'
+import type { GalbeConfig, GalbePlugin, Method, Route } from './types'
 
 import { readdir, lstat } from 'fs/promises'
 import { extname } from 'path'
@@ -10,10 +11,15 @@ import { Glob } from 'bun'
 
 export const DEFAULT_ROUTE_PATTERN = 'src/**/*.route.{js,ts}'
 
-export type RouteMeta = { head?: string } & Record<string, boolean | string | string[]>
+const IGNORE_COMMENT_RGX = /^\s*\@galbe-ignore\s*$/
+const HIDE_COMMENT_RGX = /^\s*\@galbe-hide\s*$/
+
+export type RouteMeta = { head?: string, ignore?: boolean, hide?: boolean } & Record<string, boolean | string | string[]>
 export type RoutesMeta = {
   header: Record<string, boolean | string | string[]>
-  routes: Record<string, Partial<Record<Method, RouteMeta>>>
+  routes: Record<string, Partial<Record<Method | 'static', RouteMeta>>>
+  ignore?: boolean
+  hide?: boolean
 }
 export type RouteInstanciationCallback = <T extends 'add' | 'error'>(event: {
   type: T
@@ -26,98 +32,89 @@ export type RouteFileMeta = {
   file: string
 } & RoutesMeta
 
-class GalbeProxy {
+export class GalbeProxy {
   #g: Galbe
-  #cb?: RouteInstanciationCallback
-  filepath?: string
-  meta?: RoutesMeta
+  #plugins: GalbePlugin[] = []
+  _cb?: RouteInstanciationCallback
+  _metaTmp?: RoutesMeta
+  _filepath?: string
+  _meta: Array<RouteFileMeta> = []
   constructor(g: Galbe, cb?: RouteInstanciationCallback) {
     this.#g = g
-    this.#cb = cb
+    this._cb = cb
+    this.#plugins = g.plugins
   }
-  async get(...args: any[]) {
+  get server() {
+    return this.#g.server
+  }
+  get router() {
+    return this.#g.router
+  }
+  get config() {
+    return this.#g.config
+  }
+  get meta() {
+    return this._meta
+  }
+  set meta(meta: Array<RouteFileMeta>) {
+    this._meta = meta
+    this.#g.meta = meta
+  }
+  async init() {
+    for (const p of this.#plugins) {
+      // @ts-ignore
+      if (p.init) await p.init(this.#g.config?.plugin?.[p.name] || {}, this)
+    }
+  }
+  private async handleRoute(method: Method | 'static', ...args: any[]): Promise<Route | undefined> {
+    let path = args[0]
+    let meta = {
+      ...this._metaTmp?.routes?.[path]?.[method],
+      ...(this._metaTmp?.hide ? { hide: true } : {}),
+      ...(this._metaTmp?.ignore ? { ignore: true } : {})
+    }
+    if (meta?.ignore) return
+
     //@ts-ignore
-    const route = this.#g.get(...args) as Route
-    if (this.#cb)
-      await this.#cb({
+    const route = this.#g[method](...args) as Route
+
+    if (this._cb && !meta?.ignore) {
+      await this._cb({
         type: 'add',
         route,
-        filepath: this.filepath || '',
-        meta: this.meta?.routes?.[route.path]?.[route.method] || {}
+        filepath: this._filepath || '',
+        meta
       })
+    }
     return route
   }
+  async get(...args: any[]) {
+    return this.handleRoute('get', ...args)
+  }
   async post(...args: any[]) {
-    //@ts-ignore
-    const route = this.#g.post(...args) as Route
-    if (this.#cb)
-      await this.#cb({
-        type: 'add',
-        route,
-        filepath: this.filepath,
-        meta: this.meta?.routes?.[route.path]?.[route.method] || {}
-      })
-    return route
+    return this.handleRoute('post', ...args)
   }
   async put(...args: any[]) {
-    //@ts-ignore
-    const route = this.#g.put(...args) as Route
-    if (this.#cb)
-      await this.#cb({
-        type: 'add',
-        route,
-        filepath: this.filepath,
-        meta: this.meta?.routes?.[route.path]?.[route.method] || {}
-      })
-    return route
+    return this.handleRoute('put', ...args)
   }
   async patch(...args: any[]) {
-    //@ts-ignore
-    const route = this.#g.patch(...args) as Route
-    if (this.#cb)
-      await this.#cb({
-        type: 'add',
-        route,
-        filepath: this.filepath,
-        meta: this.meta?.routes?.[route.path]?.[route.method] || {}
-      })
-    return route
+    return this.handleRoute('patch', ...args)
   }
   async delete(...args: any[]) {
-    //@ts-ignore
-    const route = this.#g.delete(...args) as Route
-    if (this.#cb)
-      await this.#cb({
-        type: 'add',
-        route,
-        filepath: this.filepath,
-        meta: this.meta?.routes?.[route.path]?.[route.method] || {}
-      })
-    return route
+    return this.handleRoute('delete', ...args)
   }
   async options(...args: any[]) {
-    //@ts-ignore
-    const route = this.#g.options(...args) as Route
-    if (this.#cb)
-      await this.#cb({
-        type: 'add',
-        route,
-        filepath: this.filepath,
-        meta: this.meta?.routes?.[route.path]?.[route.method] || {}
-      })
-    return route
+    return this.handleRoute('options', ...args)
   }
   async head(...args: any[]) {
-    //@ts-ignore
-    const route = this.#g.head(...args) as Route
-    if (this.#cb)
-      await this.#cb({
-        type: 'add',
-        route,
-        filepath: this.filepath,
-        meta: this.meta?.routes?.[route.path]?.[route.method] || {}
-      })
-    return route
+    return this.handleRoute('head', ...args)
+  }
+  async static(...args: any[]) {
+    if (!!Bun.env.GALBE_BUILD_OUT) {
+      let [_, target] = args
+      cpSync(target, `${Bun.env.GALBE_BUILD_OUT}/static-${Bun.env.GALBE_BUILD}/${target}`, { recursive: true, dereference: true })
+    }
+    return this.handleRoute('static', ...args)
   }
 }
 
@@ -172,15 +169,22 @@ export const metaAnalysis = async (filePath: string): Promise<RoutesMeta> => {
   }
 
   const comments: Record<number, Record<number, string>> = {}
-
+  const ignoredLines = new Set<number>()
+  const hideLines = new Set<number>()
   const ast = parse(content, {
     ecmaVersion: 'latest',
     sourceType: 'module',
     locations: true,
-    onComment: (isBlock, text, _start, _end, _locStart, locEnd) => {
-      if (isBlock && locEnd?.line !== undefined && locEnd?.column !== undefined) {
+    onComment: (_isBlock, text, _start, _end, _locStart, locEnd) => {
+      if (locEnd?.line !== undefined && locEnd?.column !== undefined) {
         if (!comments?.[locEnd.line]) comments[locEnd.line] = []
-        comments[locEnd.line][locEnd.column] = text
+        if (IGNORE_COMMENT_RGX.test(text)) {
+          ignoredLines.add(locEnd.line + 1)
+        }
+        else if (HIDE_COMMENT_RGX.test(text)) {
+          hideLines.add(locEnd.line + 1)
+        }
+        else comments[locEnd.line][locEnd.column] = text
       }
     }
   })
@@ -189,6 +193,12 @@ export const metaAnalysis = async (filePath: string): Promise<RoutesMeta> => {
       const headerLine = node.loc?.start.line || -1
       const headerCol = node.loc?.start.column || -1
       const headerCom = comments?.[headerLine]?.[headerCol - 1] ? comments[headerLine][headerCol - 1] : ''
+      const hide = hideLines.has(headerLine)
+      if (hide) meta.hide = true
+      if (ignoredLines.has(headerLine)) {
+        meta.ignore = true
+        return meta
+      }
       const headerRef = parseComment(headerCom)
       meta.header = headerRef
 
@@ -202,17 +212,16 @@ export const metaAnalysis = async (filePath: string): Promise<RoutesMeta> => {
           // @ts-ignore
           if (node?.callee?.object?.name === galbeIdentifier) {
             // @ts-ignore
-            const path = node.arguments[0].value
+            let path = node.arguments[0].value
+            if (!path?.startsWith("/")) path = `/${path}`
             // @ts-ignore
             const method = node.callee.property.name as Method
             const line = node.loc?.start.line || -1
             const col = node.loc?.start.column || -1
             const com = comments?.[line]?.[col - 1] ? comments[line][col - 1] : ''
-
-            const routeRefs = parseComment(com)
-
+            const routeRefs = ignoredLines.has(line) ? { ignore: true } : { ...parseComment(com), ...(hide || hideLines.has(line) ? { hide: true } : {}) }
             if (!(path in meta.routes)) meta.routes[path] = {}
-            if (!(method in meta.routes[path])) meta.routes[path][method] = routeRefs
+            if (!(method in meta.routes[path])) meta.routes[path][method] = routeRefs as RouteMeta
           }
         }
       })
@@ -223,11 +232,9 @@ export const metaAnalysis = async (filePath: string): Promise<RoutesMeta> => {
 
 export const defineRoutes = async (
   options: Pick<GalbeConfig, 'routes'>,
-  galbe: Galbe,
-  cb?: RouteInstanciationCallback
+  proxy: GalbeProxy,
 ) => {
   const routes = options?.routes === true ? DEFAULT_ROUTE_PATTERN : options?.routes
-  const proxy = new GalbeProxy(galbe, cb)
   if (!routes) return
   const root = process.cwd()
   if (typeof routes === 'string') {
@@ -240,22 +247,23 @@ export const defineRoutes = async (
       for (const f of files) {
         try {
           const metadata = await metaAnalysis(f)
-          proxy.filepath = f
-          proxy.meta = metadata
-          galbe.meta?.push({ file: path, ...metadata })
+          if (metadata?.ignore) continue
+          proxy._filepath = f
+          proxy._metaTmp = metadata
+          proxy.meta = [...proxy.meta, { file: path, ...metadata }]
           const imported = await import(f)
           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(proxy)
         } catch (err: any) {
-          if (cb) await cb({ type: 'error', error: err, filepath: f, route: undefined, meta: undefined })
+          if (proxy._cb) await proxy._cb({ type: 'error', error: err, filepath: f, route: undefined, meta: undefined })
         }
       }
     }
   } else if (Array.isArray(routes)) {
     for (const r of routes) {
-      await defineRoutes({ routes: r }, galbe, cb)
+      await defineRoutes({ routes: r }, proxy)
     }
   }
 }

package/src/server.ts

@@ -28,7 +28,7 @@ export default async (galbe: Galbe, port?: number, hostname?: string) => {
     galbe.config.basePath = `/${galbe?.config?.basePath}`
   let pluginsCb = setupPluginCallbacks(galbe)
 
-  return Bun.serve({
+  const server = Bun.serve({
     port: port || galbe.config?.port || 3000,
     hostname: hostname || galbe.config?.hostname || 'localhost',
     tls: galbe.config?.tls,
@@ -37,7 +37,8 @@ export default async (galbe: Galbe, port?: number, hostname?: string) => {
       if (!METHODS.includes(req.method)) return new Response('', { status: 501 })
       const context = {
         request: req,
-        set: { headers: {} },
+        remoteAddress: server.requestIP(req),
+        set: { headers: { 'set-cookie': [] } },
         state: {}
       } as MakeOptional<Context, 'headers' | 'params' | 'query' | 'body'>
       for (const p of pluginsCb.onFetch) {
@@ -128,12 +129,12 @@ export default async (galbe: Galbe, port?: number, hostname?: string) => {
               if (nextCalled) console.error('Hook already called - ignored')
               else {
                 nextCalled = true
-                await callChain[idx + 1].call()
+                return await callChain[idx + 1].call()
               }
             }
             let r = await hook(context as Context, next)
             if (r) return r
-            if (!nextCalled && !handlerCalled) await next()
+            if (!nextCalled && !handlerCalled) return await next()
           }
         }))
         callChain.push({
@@ -175,7 +176,7 @@ export default async (galbe: Galbe, port?: number, hostname?: string) => {
           if (typeof error.payload === 'string') payload = error.payload
           try {
             payload = JSON.stringify(error.payload)
-          } catch (err) {}
+          } catch (err) { }
           return new Response(payload, {
             status: error.status,
             headers: { 'Content-Type': 'application/json' }
@@ -199,4 +200,5 @@ export default async (galbe: Galbe, port?: number, hostname?: string) => {
       })
     }
   })
+  return server
 }

package/src/types.ts

@@ -1,4 +1,4 @@
-import type { ServeOptions, TLSOptions, TLSServeOptions } from 'bun'
+import type { ServeOptions, SocketAddress, TLSOptions, TLSServeOptions } from 'bun'
 import type {
   STAny,
   STArray,
@@ -8,6 +8,7 @@ import type {
   STJson,
   STLiteral,
   STMultipartForm,
+  STNull,
   STNumber,
   STObject,
   STOptional,
@@ -19,6 +20,7 @@ import type {
   Static
 } from './schema'
 import type { Galbe } from './index'
+import { HttpStatus } from './util'
 
 export type STBody =
   | STByteArray
@@ -33,6 +35,7 @@ export type STBody =
   | STMultipartForm
   | STUnion
   | STStream
+  | STAny
   | undefined
 
 export type STResponseValue =
@@ -48,7 +51,8 @@ export type STResponseValue =
   | STUnion
   | STStream
   | STAny
-export type STResponse = Record<number, STResponseValue>
+  | STNull
+export type STResponse = Record<number | 'default', STResponseValue>
 
 export type MaybeArray<T> = T | T[]
 export type MaybeSTArray<T extends STSchema> = T | STArray<T>
@@ -132,7 +136,7 @@ export type RequestSchema<
   P extends Partial<STParams<Path>> = Partial<STParams<Path>>,
   Q extends STQuery = STQuery,
   B extends STBody = STBody,
-  R extends STResponse = STResponse
+  R extends Partial<STResponse> = Partial<STResponse>
 > = {
   headers?: H
   params?: P
@@ -145,9 +149,9 @@ type OmitNotDefined<S extends RequestSchema> = {
   [K in keyof Exclude<S['params'], undefined> as Exclude<S['params'], undefined>[K] extends Required<
     Exclude<S['params'], undefined>
   >[K]
-    ? K
-    : //@ts-ignore
-      never]: Static<STObject<Exclude<S['params'], undefined>>>[K]
+  ? K
+  : //@ts-ignore
+  never]: Static<STObject<Exclude<S['params'], undefined>>>[K]
 }
 type StaticBody<T extends STSchema> = T extends STOptional<STSchema> ? Static<T> | null : Static<T>
 export type Context<
@@ -162,16 +166,18 @@ export type Context<
   query: Static<STObject<Exclude<S['query'], undefined>>>
   body: M extends 'get' | 'options' | 'head' ? null : StaticBody<Exclude<S['body'], undefined>>
   request: Request
+  remoteAddress: SocketAddress | null
   route?: Route
   state: Record<string, any>
   set: {
     headers: {
-      [header: string]: string
+      'set-cookie': string[]
+      [header: string]: string | string[]
     }
     status?: number
   }
 }
-export type Next = () => void | Promise<void>
+export type Next = () => void | Promise<any>
 export type Hook<M extends Method = Method, Path extends string = string, S extends RequestSchema = RequestSchema> = (
   ctx: Context<M, Path, S>,
   next: Next
@@ -188,49 +194,54 @@ export type Endpoint<M extends Method> = {
     H extends STHeaders = any,
     Q extends STQuery = any,
     B extends STBody = any,
-    R extends STResponse = STResponse
+    R extends Partial<STResponse> = Partial<STResponse>
   >(
     path: Path,
     schema: RequestSchema<M, Path, H, P, Q, B, R>,
     hooks: Hook<M, Path, RequestSchema<M, Path, H, P, Q, B, R>>[],
     handler: Handler<M, Path, RequestSchema<M, Path, H, P, Q, B, R>>
-  ): void
+  ): Route<M, Path, P, H, Q, B, R>
   <
     Path extends string,
     P extends Partial<STParams<Path>>,
     H extends STHeaders = any,
     Q extends STQuery = any,
     B extends STBody = any,
-    R extends STResponse = STResponse
+    R extends Partial<STResponse> = Partial<STResponse>
   >(
     path: Path,
     schema: RequestSchema<M, Path, H, P, Q, B, R>,
     handler: Handler<M, Path, RequestSchema<M, Path, H, P, Q, B, R>>
-  ): void
+  ): Route<M, Path, P, H, Q, B, R>
   <
     Path extends string,
     P extends Partial<STParams<Path>>,
     H extends STHeaders = any,
     Q extends STQuery = any,
     B extends STBody = any,
-    R extends STResponse = STResponse
+    R extends Partial<STResponse> = Partial<STResponse>
   >(
     path: Path,
     hooks: Hook<M, Path, RequestSchema<M, Path, H, P, Q, B, R>>[],
     handler: Handler<M, Path, RequestSchema<M, Path, H, P, Q, B, R>>
-  ): void
+  ): Route<M, Path, P, H, Q, B, R>
   <
     Path extends string,
     P extends Partial<STParams<Path>>,
     H extends STHeaders = any,
     Q extends STQuery = any,
     B extends STBody = any,
-    R extends STResponse = STResponse
+    R extends Partial<STResponse> = Partial<STResponse>
   >(
     path: Path,
     handler: Handler<M, Path, RequestSchema<M, Path, H, P, Q, B, R>>
-  ): void
+  ): Route<M, Path, P, H, Q, B, R>
+}
+
+export type StaticEndpointOptions = {
+  resolve?: (path: string, target: string) => string | null | undefined | void
 }
+export type StaticEndpoint<P extends string = string, T extends string = string> = (path: P, target: T, options?: StaticEndpointOptions) => Route<"get", P, {}, {}, {}, STBody, STResponse, T>
 
 export class RequestError {
   status: number
@@ -256,31 +267,40 @@ export type Route<
   H extends STHeaders = STHeaders,
   Q extends STQuery = STQuery,
   B extends STBody = STBody,
-  R extends STResponse = STResponse
+  R extends Partial<STResponse> = Partial<STResponse>,
+  SP extends string = string,
+  SR extends string = string
 > = {
   method: M
   path: Path
   schema: RequestSchema<M, Path, H, P, Q, B, R>
   context: Context<M, Path, RequestSchema<M, Path, H, P, Q, B, R>>
-  hooks: Hook[]
+  hooks: Hook<M, Path, RequestSchema<M, Path, H, P, Q, B, R>>[]
   handler: Handler<M, Path, RequestSchema<M, Path, H, P, Q, B, R>>
+  static?: { path: SP, root: SR }
 }
 
 export class NotFoundError extends RequestError {
   constructor(message?: any) {
-    super({ status: 404, payload: message ?? 'Not found' })
+    super({ status: 404, payload: message ?? HttpStatus[404] })
   }
 }
 
 export class MethodNotAllowedError extends RequestError {
   constructor(message?: any) {
-    super({ status: 405, payload: message ?? 'Method not allowed' })
+    super({ status: 405, payload: message ?? HttpStatus[405] })
   }
 }
 
 export class InternalError extends RequestError {
   constructor(message?: any) {
-    super({ status: 500, payload: message ?? 'Internal Server Error' })
+    super({ status: 500, payload: message ?? HttpStatus[500] })
+  }
+}
+
+export class NotImplementedError extends RequestError {
+  constructor(message?: any) {
+    super({ status: 501, payload: message ?? HttpStatus[501] })
   }
 }
 

package/src/util.ts

@@ -13,16 +13,30 @@ const METHOD_COLOR: Record<string, string> = {
 const ansiRegex = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g
 
 export const logRoute = (
-  r: { method: string; path: string },
+  r: { method: string; path: string, static?: { path: string, root: string } },
   meta?: RouteMeta,
   format?: { maxPathLength?: number }
 ) => {
-  let color = METHOD_COLOR?.[r.method] || ''
-  let routeLog = `[${color}${`${r.method.toUpperCase()}\x1b[0m]`.padEnd(12, ' ')} ${r.path
-    .padEnd(format?.maxPathLength ?? r.path.length, ' ')
-    .replaceAll(/:([^\/]+)/g, '\x1b[0;33m:$1\x1b[0m')}${meta?.head ? `  ${meta.head}` : ''}\x1b[0m`
-  if (meta?.deprecated) routeLog = `\x1b[0;9m\x1b[38;5;244m${routeLog.replaceAll(ansiRegex, '')}\x1b[0m`
-  console.log(`    ${routeLog}`)
+  let path = r.path === '' ? '/' : r.path
+  let method = r.method
+
+  let routeLog = ''
+
+  if (r?.static) {
+    routeLog = `[\x1b[0;33m${`STATIC\x1b[0m]`.padEnd(12, ' ')} ${path
+      .padEnd(format?.maxPathLength ?? path.length, ' ')} \x1b[0;33m⇒\x1b[0m  ${r.static.path}\x1b[0m`
+    if (meta?.deprecated) routeLog = `\x1b[0;9m\x1b[38;5;244m${routeLog.replaceAll(ansiRegex, '')}\x1b[0m`
+  } else {
+    let color = METHOD_COLOR?.[method] || ''
+    let [_, summary, _description] = meta?.head?.match(/^([^\n]*)\n\n(.*)/) || []
+    if(!summary) _description = meta?.head || ''
+    routeLog = `[${color}${`${method.toUpperCase()}\x1b[0m]`.padEnd(12, ' ')} ${path
+      .padEnd(format?.maxPathLength ?? path.length, ' ')
+      .replaceAll(/:([^\/]+)/g, '\x1b[0;33m:$1\x1b[0m')}${(summary?`  ${summary}`:'').replace(/\n/, '')}\x1b[0m`
+    if (meta?.deprecated) routeLog = `\x1b[0;9m\x1b[38;5;244m${routeLog.replaceAll(ansiRegex, '')}\x1b[0m`
+  }
+
+  if (routeLog) console.log(`    ${routeLog}`)
 }
 
 /**

package/src/validator.ts

@@ -15,29 +15,29 @@ export const validate = (elt: any, schema: STSchema, parse = false): any => {
       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'`
+    if (elt !== true && elt !== false) throw `Not a valid boolean. Should be 'true' or 'false'`
   } else if (schema[Kind] === 'integer') {
     if (parse && typeof elt === 'string') elt = Number(elt)
-    if (!Number.isInteger(elt)) throw `${iElt} is not a valid integer`
+    if (!Number.isInteger(elt)) throw `Not a valid integer`
     schemaValidation(elt, schema)
   } else if (schema[Kind] === 'number') {
     if (parse && typeof elt === 'string') elt = Number(elt)
-    if (!Number.isFinite(elt)) throw `${iElt} is not a valid number`
+    if (!Number.isFinite(elt)) throw `Not a valid number`
     schemaValidation(elt, schema)
   } else if (schema[Kind] === 'string') {
-    if (!(typeof elt === 'string')) throw `${iElt} is not a valid string`
+    if (!(typeof elt === 'string')) throw `Not a valid string`
     schemaValidation(elt, schema)
   } else if (schema[Kind] === 'literal') {
-    if (elt !== schema.value) throw `${iElt} is not a valid value`
+    if (elt !== schema.value) throw `Not a valid value`
   } else if (schema[Kind] === 'object') {
     if (parse && typeof elt === 'string') {
       try {
         elt = JSON.parse(elt)
       } catch {
-        throw `${iElt} is not a valid object`
+        throw `Not a valid object`
       }
     }
-    if (typeof elt !== 'object') throw `${iElt} is not a valid object`
+    if (typeof elt !== 'object') throw `Not a valid object`
     if (Array.isArray(elt)) throw `Expected an object, not an array`
     const err: ValidationError = {}
     Object.entries(schema.props as STProps).forEach(([k, s]) => {
@@ -81,7 +81,7 @@ export const validate = (elt: any, schema: STSchema, parse = false): any => {
       }
     }
     // @ts-ignore
-    if (!valid) throw `${elt} could not be parsed to any of: ${union.map(u => u?.value ?? u[Kind]).join(', ')}`
+    if (!valid) throw `Could not be parsed to any of [${union.map(u => u?.value ?? u[Kind]).join(', ')}]`
   } else if (schema[Kind] === 'any') {
   } else {
     throw `Unsupported schema type ${schema[Kind]}`
@@ -95,7 +95,7 @@ export const validate = (elt: any, schema: STSchema, parse = false): any => {
 
 export const validateResponse = (response: any, schema: STResponse, status: number) => {
   if (!(status in schema)) return
-  const s = schema[status]
+  const s = schema?.[status] || schema?.['default']
   if (response instanceof ReadableStream) {
     if (!s[Stream]) throw new InternalError(`Expected ${s[Kind]} response, but got ReadableStream`)
   } else if (isIterator(response)) {
@@ -113,20 +113,20 @@ const schemaValidation = (value: any, schema: STSchema) => {
   const errors = []
   if (schema[Kind] === 'integer' || schema[Kind] === 'number') {
     if (schema.exclusiveMin !== undefined)
-      if ((value as number) <= schema.exclusiveMin) errors.push(`${value} is less or equal to ${schema.exclusiveMin}`)
+      if ((value as number) <= schema.exclusiveMin) errors.push(`Is less or equal to ${schema.exclusiveMin}`)
     if (schema.exclusiveMax !== undefined)
       if ((value as number) >= schema.exclusiveMax)
-        errors.push(`${value} is greater or equal to ${schema.exclusiveMax}`)
-    if (schema.min !== undefined) if ((value as number) < schema.min) errors.push(`${value} is less than ${schema.min}`)
+        errors.push(`Is greater or equal to ${schema.exclusiveMax}`)
+    if (schema.min !== undefined) if ((value as number) < schema.min) errors.push(`Is less than ${schema.min}`)
     if (schema.max !== undefined)
-      if ((value as number) > schema.max) errors.push(`${value} is greater than ${schema.max}`)
+      if ((value as number) > schema.max) errors.push(`Is greater than ${schema.max}`)
   } else if (schema[Kind] === 'string') {
     if (schema.minLength !== undefined && (value as string).length < schema.minLength)
-      errors.push(`${value} length is too small (${schema.minLength} char min)`)
+      errors.push(`Length is too small (${schema.minLength} char min)`)
     if (schema.maxLength !== undefined && (value as string).length > schema.maxLength)
-      errors.push(`${value} length is too large (${schema.maxLength} char max)`)
+      errors.push(`Length is too large (${schema.maxLength} char max)`)
     if (schema.pattern !== undefined && !(value as string).match(schema.pattern))
-      errors.push(`${value} does not match pattern ${schema.pattern}`)
+      errors.push(`Does not match pattern ${schema.pattern}`)
   } else if (schema[Kind] === 'array') {
     if (schema.minItems !== undefined && (value as any[]).length < schema.minItems)
       errors.push(`Must contain at least ${schema.minItems} item${schema.minItems > 1 ? 's' : ''}`)