galbe 0.2.0 → 0.4.1

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

@@ -11,6 +11,7 @@ import type {
   ErrorHandler,
   GalbePlugin,
   STBody,
+  STResponse,
   STParams,
   STHeaders,
   STQuery
@@ -18,26 +19,28 @@ import type {
 
 import server from './server'
 import { GalbeRouter } from './router'
-import { defineRoutes } from './routes'
-import { 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>>,
   Q extends STQuery,
-  B extends STBody
+  B extends STBody,
+  R extends STResponse
 >(
   galbe: Galbe,
-  method: Method,
+  method: M,
   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<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') {
@@ -53,26 +56,31 @@ const overloadDiscriminer = <
   throw new Error('Undefined route signature')
 }
 const galbeMethod = <
+  M extends Method,
   Path extends string,
   H extends STHeaders,
   P extends Partial<STParams<Path>>,
   Q extends STQuery,
-  B extends STBody
+  B extends STBody,
+  R extends STResponse
 >(
   _galbe: Galbe,
-  method: Method,
+  method: M,
   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<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 {
@@ -92,11 +100,11 @@ 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'
 
-const indexRoutes: { method: string; path: string }[] = []
 /**
  * #### Galbe Server
  * Instanciate a Galbe web server
@@ -116,7 +124,6 @@ export class Galbe {
   router: GalbeRouter
   errorHandler?: ErrorHandler
   listening: boolean = false
-  #prepare: boolean = false
   server?: Server
   plugins: GalbePlugin[] = []
   constructor(config?: GalbeConfig) {
@@ -126,35 +133,32 @@ 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)
-    }
+    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)
-      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() {
@@ -163,96 +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>
-      | 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<'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
+    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<'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
+    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<'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
+    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<'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
+    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<'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
+    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<'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'