galbe 0.3.0 → 0.5.0

package/src/extras/spec/openapi.serializer.ts

@@ -0,0 +1,264 @@
+import type { STArray, STJson, STLiteral, STObject, STProps, STSchema, STUnion } from '../../../src/schema'
+
+import { Galbe } from '../../../src'
+import { walkRoutes, HttpStatus } from '../../../src/util'
+import { Kind, Optional } from '../../../src/schema'
+
+import { OpenAPIV3 } from 'openapi-types'
+
+type SchemaType = { type: string; format: string; isJson: boolean }
+
+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'
+    : '*/*'
+
+export const OpenAPISerializer = async (g: Galbe, version = '3.0.3'): Promise<OpenAPIV3.Document> => {
+  let paths: any = {}
+  let components: OpenAPIV3.ComponentsObject = {
+    securitySchemes: {},
+    schemas: {},
+    parameters: {},
+    requestBodies: {},
+    responses: {}
+  }
+
+  const schemaToOpenapi = (
+    schema: STSchema
+  ): { schema: OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject; isJson?: boolean } => {
+    let s = {}
+    let kind = schema[Kind]
+    let isJson = false
+
+    let pattern = schema?.pattern?.toString()
+    if (pattern) pattern = pattern.substring(1, pattern.length - 1)
+
+    let minLength = schema?.minLength
+    let maxLength = schema?.maxLength
+    let minimum = schema?.min
+    let maximum = schema?.max
+    let exclusiveMinimum = schema?.exclusiveMin
+    let exclusiveMaximum = schema?.exclusiveMax
+    let minItems = schema?.minItems
+    let maxItems = schema?.maxItems
+    let uniqueItems = schema?.unique
+
+    if (components.schemas && (schema.id as string) in components.schemas) {
+      //@ts-ignore
+      return { schema: { $ref: `#/components/schemas/${schema.id}` } }
+    }
+    // TODO add constraints min, max etc.
+    if (kind === 'boolean') s = { type: 'boolean' }
+    else if (kind === 'byteArray') s = { type: 'string', format: 'byte' }
+    else if (kind === 'number')
+      s = {
+        type: 'number',
+        ...(exclusiveMinimum ? { exclusiveMinimum } : {}),
+        ...(exclusiveMaximum ? { exclusiveMaximum } : {}),
+        ...(minimum ? { minimum } : {}),
+        ...(maximum ? { maximum } : {})
+      }
+    else if (kind === 'integer')
+      s = {
+        type: 'integer',
+        ...(exclusiveMinimum ? { exclusiveMinimum } : {}),
+        ...(exclusiveMaximum ? { exclusiveMaximum } : {}),
+        ...(minimum ? { minimum } : {}),
+        ...(maximum ? { maximum } : {})
+      }
+    else if (kind === 'string')
+      s = {
+        type: 'string',
+        ...(pattern ? { pattern } : {}),
+        ...(minLength ? { minLength } : {}),
+        ...(maxLength ? { maxLength } : {})
+      }
+    else if (kind === 'any') s = { type: 'string' }
+    else if (kind === 'literal') {
+      let value = (schema as STLiteral).value
+      s = { type: 'string', enum: [value] }
+    } else if (kind === 'array') {
+      s = {
+        type: 'array',
+        items: schemaToOpenapi((schema as STArray).items).schema,
+        ...(minItems ? { minItems } : {}),
+        ...(maxItems ? { maxItems } : {}),
+        ...(uniqueItems ? { uniqueItems } : {})
+      }
+    } else if (kind === 'object') {
+      let props = (schema as STObject).props || {}
+      let required = Object.entries(props)
+        .filter(([_, v]) => !v?.[Optional])
+        .map(([k, _]) => k)
+      s = {
+        type: 'object',
+        properties: Object.fromEntries(Object.entries(props).map(([k, v]) => [k, schemaToOpenapi(v).schema])),
+        ...(required.length ? { required } : {})
+      }
+    } else if (kind === 'json') {
+      let props = ((schema as STJson).props || {}) as STProps
+      let type = (schema as STJson).type
+      if (type === 'unknown') type = 'object'
+      let required = Object.entries(props)
+        .filter(([_, v]) => !v?.[Optional])
+        .map(([k, _]) => k)
+      isJson = true
+      s = {
+        type: type,
+        ...(type === 'object'
+          ? {
+              properties: Object.fromEntries(Object.entries(props).map(([k, v]) => [k, schemaToOpenapi(v).schema])),
+              ...(required.length ? { required } : {})
+            }
+          : {})
+      }
+    } else if (kind === 'union') {
+      let anyOf = (schema as STUnion).anyOf
+      s = {
+        anyOf: anyOf.map(s => schemaToOpenapi(s).schema)
+      }
+    }
+    s = { title: schema.title, description: schema.description, ...s }
+    if (components.schemas && schema.id) {
+      components.schemas[schema.id] = s
+      return { schema: { $ref: `#/components/schemas/${schema.id}` } }
+    }
+    return { schema: s, isJson }
+  }
+
+  const resolveRef = (schema: OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject): OpenAPIV3.SchemaObject => {
+    if (!(schema as OpenAPIV3.ReferenceObject)?.$ref) return schema as OpenAPIV3.SchemaObject
+    let ref = (schema as OpenAPIV3.ReferenceObject)?.$ref
+    let match = ref.match('^#/components/(schemas|requestBodies|responses)/(.*)$')
+    if (!match) throw new Error(`Invalid schema ref ${ref}`)
+    let [_, kind, refPath] = match as [string, keyof typeof components, string]
+    //@ts-ignore
+    return refPath.split('/').reduce((c, k) => {
+      if (c && k in c) return c[k]
+      else return undefined
+    }, components[kind])
+  }
+
+  const parseParam = (key: string, param: STSchema, kind: 'query' | 'header' | 'path' | 'cookie') => {
+    let { schema } = schemaToOpenapi({ ...param, [Optional]: false })
+    let p: OpenAPIV3.ParameterObject = {
+      name: key,
+      in: kind,
+      description: param?.description,
+      required: kind === 'path' ? true : !param[Optional] || undefined,
+      deprecated: param.deprecated,
+      schema
+    }
+    if (components.parameters && param.id) components.parameters[param.id] = p
+    return p
+  }
+
+  const metaRoutes = g.meta?.reduce(
+    (routes, c) => ({ ...routes, ...c.routes }),
+    {} as Record<string, Record<string, Record<string, any>>>
+  )
+  walkRoutes(g.router.routes, r => {
+    let meta = metaRoutes?.[r.path]?.[r.method]
+    let path = r.path.replaceAll(/:([^\/]+)/g, '{$1}')
+    if (!(path in paths)) paths[path] = {}
+    let tags = [...(meta?.tags?.split(' ')?.map((t: string) => t.trim()) || []), ...(meta?.tag || [])]
+    let security: Record<string, any> = []
+
+    let pathParam = r.schema?.params
+      ? Object.entries(r.schema?.params as Record<string, STSchema>).map(([k, v]) => parseParam(k, v, 'path'))
+      : []
+    let queryParam = r.schema?.query
+      ? Object.entries(r.schema?.query as Record<string, STSchema>).map(([k, v]) => parseParam(k, v, 'query'))
+      : []
+    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
+              }
+            }
+            return p
+          })
+          .filter(p => p)
+      : []
+    // TODO cookieParam
+    let parameters = [...pathParam, ...queryParam, ...headerParam]
+
+    let requestBody
+    if (r.schema.body) {
+      let { schema, isJson } = schemaToOpenapi(r.schema.body)
+      let { type, format } = resolveRef(schema)
+      let media = schemaToMedia({ type, format, isJson } as SchemaType)
+      requestBody = {
+        description: r.schema.body.description,
+        required: !r.schema.body[Optional],
+        content: {
+          [media]: { schema }
+        }
+      }
+      if (r.schema.body.id && components.requestBodies) {
+        components.requestBodies[r.schema.body.id] = requestBody
+        requestBody = { $ref: `#/components/requestBodies/${r.schema.body.id}` }
+      }
+    }
+    let responses
+    if (r.schema.response && Object.keys(r.schema.response).length) {
+      responses = Object.fromEntries(
+        Object.entries(r.schema.response).map(([status, v]) => {
+          let s = Number(status) as keyof typeof HttpStatus
+          let { schema, isJson } = schemaToOpenapi(v)
+          let { type, format } = resolveRef(schema)
+          let media = schemaToMedia({ type, format, isJson } as SchemaType)
+          let response: OpenAPIV3.ResponseObject = {
+            description: v.description || HttpStatus[Number(s) as keyof typeof HttpStatus] || 'Response',
+            content: { [media]: { schema: schema } }
+          }
+          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}` }
+          }
+          return [s, response]
+        })
+      )
+    } else {
+      responses = {
+        default: { description: HttpStatus[200] }
+      }
+    }
+    paths[path][r.method] = {
+      tags: tags.length ? tags : undefined,
+      summary: meta?.head,
+      operationId: meta?.operationId,
+      parameters: parameters.length ? parameters : undefined,
+      requestBody,
+      responses,
+      ...(security.length ? { security } : {}),
+      deprecated: meta?.deprecated ? true : undefined
+    }
+  })
+
+  //@ts-ignore
+  components = Object.entries(components).reduce((p, [k, v]) => {
+    if (Object.keys(v).length) p[k] = v
+    return p
+  }, {} as Record<string, OpenAPIV3.ComponentsObject>)
+  return {
+    openapi: version,
+    info: {
+      title: 'Galbe app',
+      version: '0.1.0'
+    },
+    paths,
+    components: Object.keys(components)?.length ? components : undefined
+  }
+}

package/src/extras.ts

@@ -0,0 +1 @@
+export { OpenAPISerializer } from './extras/spec/openapi.serializer'

package/src/index.ts

@@ -19,11 +19,10 @@ import type {
 
 import server from './server'
 import { GalbeRouter } from './router'
-import { defineRoutes } from './routes'
-import { extractMetaRoute, logRoute } from './util'
 import { SchemaType, type STObject, type Static } from './schema'
 
 const overloadDiscriminer = <
+  M extends Method,
   Path extends string,
   H extends STHeaders,
   P extends Partial<STParams<Path>>,
@@ -32,14 +31,16 @@ const overloadDiscriminer = <
   R extends STResponse
 >(
   galbe: Galbe,
-  method: Method,
+  method: M,
   path: Path,
   arg2:
-    | 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>>
+    | RequestSchema<M, Path, H, P, Q, B, R>
+    | Hook<M, Path, RequestSchema<M, Path, H, P, Q, B, R>>[]
+    | Handler<M, Path, RequestSchema<M, Path, H, P, Q, B, R>>,
+  arg3?:
+    | 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>>
 ) => {
   const defaultSchema = {}
   if (typeof arg2 === 'function') {
@@ -55,6 +56,7 @@ const overloadDiscriminer = <
   throw new Error('Undefined route signature')
 }
 const galbeMethod = <
+  M extends Method,
   Path extends string,
   H extends STHeaders,
   P extends Partial<STParams<Path>>,
@@ -63,19 +65,22 @@ const galbeMethod = <
   R extends STResponse
 >(
   _galbe: Galbe,
-  method: Method,
+  method: M,
   path: Path,
-  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: 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>>
 ) => {
   schema = schema ?? {}
   hooks = hooks || []
-  const context: Context<Path, typeof schema> = {
+  const context: Context<M, Path, typeof schema> = {
     headers: {} as Static<STObject<Exclude<(typeof schema)['headers'], undefined>>>,
     params: {} as any,
     query: {} as Static<STObject<Exclude<(typeof schema)['query'], undefined>>>,
-    body: {} as Static<Exclude<(typeof schema)['body'], undefined>>,
+    //@ts-ignore
+    body: ['get', 'options', 'head'].includes(method)
+      ? null
+      : ({} as Static<Exclude<(typeof schema)['body'], undefined>>),
     request: {} as Request,
     state: {},
     set: {} as {
@@ -100,7 +105,6 @@ export const $T = new SchemaType()
 
 export { RequestError } from './types'
 
-const indexRoutes: { method: string; path: string }[] = []
 /**
  * #### Galbe Server
  * Instanciate a Galbe web server
@@ -120,7 +124,6 @@ export class Galbe {
   router: GalbeRouter
   errorHandler?: ErrorHandler
   listening: boolean = false
-  #prepare: boolean = false
   server?: Server
   plugins: GalbePlugin[] = []
   constructor(config?: GalbeConfig) {
@@ -135,32 +138,27 @@ export class Galbe {
   }
   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, extractMetaRoute(route, this.meta))
-    }
+    return route
   }
   async use(plugin: GalbePlugin) {
     this.plugins.push(plugin)
   }
+  async init() {
+    for (const p of this.plugins) {
+      if (p.init) await p.init(this.config?.plugin?.[p.name] || {}, this)
+    }
+  }
   async listen(port?: number) {
     port = port || this.config?.port || 3000
     this.config.port = port
     if (this.listening) this.stop()
+    await this.init()
+    this.server = await server(this, port)
     if (Bun.env.BUN_ENV === 'development') {
-      this.#prepare = true
-      console.log('🏗️  \x1b[1;30mConstructing routes\x1b[0m')
-      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)
       const url = `http://localhost:${port}${this.config?.basePath || ''}`
-      console.log(`\n\x1b[1;30m🚀 API running at\x1b[0m \x1b[4;34m${url}\x1b[0m`)
-    } else {
-      this.server = await server(this, port)
+      console.log(`\x1b[1;30m🚀 Server running at\x1b[0m \x1b[4;34m${url}\x1b[0m\n`)
     }
     this.listening = true
-    this.#prepare = false
     return this.server
   }
   stop() {
@@ -169,102 +167,134 @@ export class Galbe {
   onError(handler: ErrorHandler) {
     this.errorHandler = handler
   }
-  get: Endpoint = <
+  get: Endpoint<'get'> = <
     Path extends string,
-    H extends STHeaders,
     P extends Partial<STParams<Path>>,
+    H extends STHeaders,
     Q extends STQuery,
-    B extends STBody,
+    B extends undefined,
     R extends STResponse
   >(
     path: Path,
     arg2:
-      | 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>>
+      | RequestSchema<'get', Path, H, P, Q, B, R>
+      | Hook<'get', Path, RequestSchema<'get', Path, H, P, Q, B, R>>[]
+      | Handler<'get', Path, RequestSchema<'get', Path, H, P, Q, B, R>>,
+    arg3?:
+      | Hook<'get', Path, RequestSchema<'get', Path, H, P, Q, B, R>>[]
+      | Handler<'get', Path, RequestSchema<'get', Path, H, P, Q, B, R>>,
+    arg4?: Handler<'get', Path, RequestSchema<'get', Path, H, P, Q, B, R>>
+    //@ts-ignore
   ) => this.add(overloadDiscriminer(this, 'get', path, arg2, arg3, arg4))
-  post: Endpoint = <
+  post: Endpoint<'post'> = <
     Path extends string,
-    H extends STHeaders,
     P extends Partial<STParams<Path>>,
+    H extends STHeaders,
     Q extends STQuery,
     B extends STBody,
     R extends STResponse
   >(
     path: Path,
     arg2:
-      | 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>>
+      | RequestSchema<'post', Path, H, P, Q, B, R>
+      | Hook<'post', Path, RequestSchema<'post', Path, H, P, Q, B, R>>[]
+      | Handler<'post', Path, RequestSchema<'post', Path, H, P, Q, B, R>>,
+    arg3?:
+      | Hook<'post', Path, RequestSchema<'post', Path, H, P, Q, B, R>>[]
+      | Handler<'post', Path, RequestSchema<'post', Path, H, P, Q, B, R>>,
+    arg4?: Handler<'post', Path, RequestSchema<'post', Path, H, P, Q, B, R>>
+    //@ts-ignore
   ) => this.add(overloadDiscriminer(this, 'post', path, arg2, arg3, arg4))
-  put: Endpoint = <
+  put: Endpoint<'put'> = <
     Path extends string,
-    H extends STHeaders,
     P extends Partial<STParams<Path>>,
+    H extends STHeaders,
     Q extends STQuery,
     B extends STBody,
     R extends STResponse
   >(
     path: Path,
     arg2:
-      | 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>>
+      | RequestSchema<'put', Path, H, P, Q, B, R>
+      | Hook<'put', Path, RequestSchema<'put', Path, H, P, Q, B, R>>[]
+      | Handler<'put', Path, RequestSchema<'put', Path, H, P, Q, B, R>>,
+    arg3?:
+      | Hook<'put', Path, RequestSchema<'put', Path, H, P, Q, B, R>>[]
+      | Handler<'put', Path, RequestSchema<'put', Path, H, P, Q, B, R>>,
+    arg4?: Handler<'put', Path, RequestSchema<'put', Path, H, P, Q, B, R>>
   ) => this.add(overloadDiscriminer(this, 'put', path, arg2, arg3, arg4))
-  patch: Endpoint = <
+  patch: Endpoint<'patch'> = <
     Path extends string,
-    H extends STHeaders,
     P extends Partial<STParams<Path>>,
+    H extends STHeaders,
     Q extends STQuery,
     B extends STBody,
     R extends STResponse
   >(
     path: Path,
     arg2:
-      | 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>>
+      | RequestSchema<'patch', Path, H, P, Q, B, R>
+      | Hook<'patch', Path, RequestSchema<'patch', Path, H, P, Q, B, R>>[]
+      | Handler<'patch', Path, RequestSchema<'patch', Path, H, P, Q, B, R>>,
+    arg3?:
+      | Hook<'patch', Path, RequestSchema<'patch', Path, H, P, Q, B, R>>[]
+      | Handler<'patch', Path, RequestSchema<'patch', Path, H, P, Q, B, R>>,
+    arg4?: Handler<'patch', Path, RequestSchema<'patch', Path, H, P, Q, B, R>>
   ) => this.add(overloadDiscriminer(this, 'patch', path, arg2, arg3, arg4))
-  delete: Endpoint = <
+  delete: Endpoint<'delete'> = <
     Path extends string,
-    H extends STHeaders,
     P extends Partial<STParams<Path>>,
+    H extends STHeaders,
     Q extends STQuery,
     B extends STBody,
     R extends STResponse
   >(
     path: Path,
     arg2:
-      | 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>>
+      | RequestSchema<'delete', Path, H, P, Q, B, R>
+      | Hook<'delete', Path, RequestSchema<'delete', Path, H, P, Q, B, R>>[]
+      | Handler<'delete', Path, RequestSchema<'delete', Path, H, P, Q, B, R>>,
+    arg3?:
+      | Hook<'delete', Path, RequestSchema<'delete', Path, H, P, Q, B, R>>[]
+      | Handler<'delete', Path, RequestSchema<'delete', Path, H, P, Q, B, R>>,
+    arg4?: Handler<'delete', Path, RequestSchema<'delete', Path, H, P, Q, B, R>>
   ) => this.add(overloadDiscriminer(this, 'delete', path, arg2, arg3, arg4))
-  options: Endpoint = <
+  options: Endpoint<'options'> = <
     Path extends string,
-    H extends STHeaders,
     P extends Partial<STParams<Path>>,
+    H extends STHeaders,
     Q extends STQuery,
     B extends STBody,
     R extends STResponse
   >(
     path: Path,
     arg2:
-      | 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>>
+      | RequestSchema<'options', Path, H, P, Q, B, R>
+      | Hook<'options', Path, RequestSchema<'options', Path, H, P, Q, B, R>>[]
+      | Handler<'options', Path, RequestSchema<'options', Path, H, P, Q, B, R>>,
+    arg3?:
+      | Hook<'options', Path, RequestSchema<'options', Path, H, P, Q, B, R>>[]
+      | Handler<'options', Path, RequestSchema<'options', Path, H, P, Q, B, R>>,
+    arg4?: Handler<'options', Path, RequestSchema<'options', Path, H, P, Q, B, R>>
   ) => this.add(overloadDiscriminer(this, 'options', path, arg2, arg3, arg4))
+  head: Endpoint<'head'> = <
+    Path extends string,
+    P extends Partial<STParams<Path>>,
+    H extends STHeaders,
+    Q extends STQuery,
+    B extends STBody,
+    R extends STResponse
+  >(
+    path: Path,
+    arg2:
+      | RequestSchema<'head', Path, H, P, Q, B, R>
+      | Hook<'head', Path, RequestSchema<'head', Path, H, P, Q, B, R>>[]
+      | Handler<'head', Path, RequestSchema<'head', Path, H, P, Q, B, R>>,
+    arg3?:
+      | Hook<'head', Path, RequestSchema<'head', Path, H, P, Q, B, R>>[]
+      | 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))
 }
 
 export * from './types'

package/src/parser.ts

@@ -1,4 +1,4 @@
-import type { MaybeArray, STBody, Context } from './index'
+import type { MaybeArray, STBody, Context, STResponse } from './index'
 import type {
   STStream,
   STUrlForm,
@@ -283,6 +283,7 @@ const streamToUrlForm = async (body: ReadableStream<Uint8Array>, schema?: STUrlF
 }
 async function* $streamToMultipartForm(data: ReadableStream<Uint8Array>, boundary: string, schema?: STMultipartForm) {
   const bound = textEncoder.encode(boundary)
+  const delimiter = textEncoder.encode('\r\n\r\n')
   let rest = new Uint8Array()
   let bK: Uint8Array = new Uint8Array()
   let bV: Uint8Array = new Uint8Array()
@@ -294,6 +295,7 @@ async function* $streamToMultipartForm(data: ReadableStream<Uint8Array>, boundar
     start = 0
     for (let i = 0; i < chunk.length; i++) {
       let matchBound = true
+      let matchDelimiter = true
       for (let b = 0; b < bound.length; b++) {
         if (chunk[i + b] === bound[b]) continue
         else {
@@ -301,6 +303,15 @@ async function* $streamToMultipartForm(data: ReadableStream<Uint8Array>, boundar
           break
         }
       }
+      if (!matchBound) {
+        for (let b = 0; b < delimiter.length; b++) {
+          if (chunk[i + b] === delimiter[b]) continue
+          else {
+            matchDelimiter = false
+            break
+          }
+        }
+      }
       if (matchBound) {
         bV = new Uint8Array(rest.length + i - start)
         bV.set(rest)
@@ -324,7 +335,7 @@ async function* $streamToMultipartForm(data: ReadableStream<Uint8Array>, boundar
         start = i + bound.length
         rest = new Uint8Array()
         i = start
-      } else if (chunk[i] === 0x0d && chunk[i + 1] === 0x0a && chunk[i + 2] === 0x0d) {
+      } else if (matchDelimiter) {
         bK = new Uint8Array(rest.length + i - start)
         bK.set(rest)
         bK.set(chunk.slice(start, i), rest.length)
@@ -630,14 +641,24 @@ export const parseEntry = <T extends STProps>(
   return parsedParams as Static<STObject<T>>
 }
 
-export const responseParser = (response: any, ctx: Context) => {
+export const responseParser = (response: any, ctx: Context, schema?: STResponse) => {
   const details = {
     status: ctx.set.status || 200,
     headers: new Headers(ctx.set.headers)
   }
   if (response instanceof Response) return response
   else if (typeof response === 'string') {
-    if (!details?.headers?.has('content-type')) details?.headers?.set('content-type', 'text/plain')
+    if (!details?.headers?.has('content-type')) {
+      if (schema?.[details.status][Kind] === 'json') {
+        details?.headers?.set('content-type', 'application/json')
+        response = `"${response}"`
+      } else details?.headers?.set('content-type', 'text/plain')
+    }
+    return new Response(response, details)
+  } else if (response instanceof Uint8Array) {
+    if (!details?.headers?.has('content-type')) {
+      details?.headers?.set('content-type', 'application/octet-stream')
+    }
     return new Response(response, details)
   }
   if (response instanceof ReadableStream) {
@@ -666,7 +687,8 @@ export const responseParser = (response: any, ctx: Context) => {
   } else {
     try {
       if (!details?.headers?.has('content-type')) details?.headers?.set('content-type', 'application/json')
-      return new Response(JSON.stringify(response), details)
+      if (details.headers.get('content-type') === 'application/json') response = JSON.stringify(response)
+      return new Response(response, details)
     } catch (error) {
       console.error(error)
       throw new InternalError()