galbe 0.1.6 → 0.1.8

package/docs/schemas.md

@@ -0,0 +1,240 @@
+# Shemas
+
+Galbe provides a custom Schema Type processor that offers type safety, data parsing, and validation. The primary purpose of this feature is to simplify request input validation and error handling automatically. Additionally, it enhances the developer's experience by inferring static TypeScript types from schema definitions.
+
+## Schema Types
+
+To start using Schema definitions, import `$T` from the `galbe` library:
+
+```js
+import { $T } from 'galbe'
+```
+
+Here the list of available Schema types in Galbe:
+
+#### Boolean
+
+Schema Type matching `boolean` values.
+
+```ts
+const boolSchema = $T.boolean()
+```
+
+#### String
+
+Schema Type matching `string` vlues.
+
+```ts
+const strSchema = $T.string(options)
+```
+
+#### Number
+
+Schema Type matching `number` values.
+
+```ts
+const numSchema = $T.number(options)
+```
+
+#### Integer
+
+Schema Type matching integer `number` values.
+
+```ts
+const intSchema = $T.integer(options)
+```
+
+#### Any
+
+Schema Type matching `any` of the previous Schema Types.
+
+```ts
+const anySchema = $T.any()
+```
+
+#### Array
+
+Schema Type matching `array` values.
+
+```ts
+const arraySchema = $T.array($T.any(), options)
+```
+
+#### Optional
+
+Makes any type optional. This allows for `undefined` values.
+
+```ts
+const optionalSchema = $T.optional($T.string())
+```
+
+#### Union
+
+Creates an union of Schema Types.
+
+```ts
+const unionSchema = $T.union([$T.string(), $T.number()])
+```
+
+## Request Schema definition
+
+The Request Schema definition allows you to define a schema for your request on your [Route Definition](routes.md#route-defintion). It must be defined right after the path of your route.
+
+```js
+const schema = {}
+galbe.get('/foo/:bar', schema, ctx => {})
+```
+
+The Request Schema has four optional properties:
+
+### headers
+
+```ts
+headers: { [key: string]: STString | STBoolean | STNumber | STInteger | STLiteral }
+```
+
+This is a key-value object where each key represents a request header name, and the value is the associated Schema.
+
+**Example**:
+
+```ts
+const schema = {
+  headers: {
+    'User-Agent': $T.optional($T.string({ pattern: '^Bun' }))
+  }
+}
+```
+
+### params
+
+```ts
+params: { [key: string]: STString | STBoolean | STNumber | STInteger | STLiteral }
+```
+
+This is a key-value object where each key represents a request path parameter name, and the value is the associated Schema.
+
+**Example**:
+
+```ts
+const schema = {
+  params: {
+    name: $T.string(),
+    age: $T.integer({ min: 0 })
+  }
+}
+```
+
+> [!WARNING]
+> Every key should match an existing [route path](routes.md#route-defintion) parameter. Otherwise Typescript will show an error.
+>
+> By default, if no schema is defined for a given parameter. Galbe will assume it is of type `string`.
+
+### query
+
+```ts
+query: { [key: string]: STString | STBoolean | STNumber | STInteger | STLiteral }
+```
+
+This is a key-value object where each key represents a request query parameter name, and the value is the associated Schema.
+
+**Example**:
+
+```ts
+const schema = {
+  query: {
+    name: $T.literal('Galbe'),
+    list: $T.array($T.number())
+  }
+}
+```
+
+### body
+
+<!-- prettier-ignore -->
+```ts
+body: STByteArray | STString | STBoolean | STNumber | STInteger | STLiteral | 
+      STObject | STMulripartForm | STUrlForm
+```
+
+#### Json
+
+To define an `application/json` request body, use `STObject` Schema Type. Example:
+
+```ts
+const jsonBody = $T.object({
+  name: $T.string(),
+  age: $T.integer({ min: 0 })
+})
+```
+
+#### Multipart
+
+To define a `multipart/form-data` request body, use `TMultipartForm` Schema Type. Example:
+
+```ts
+const multipartBody = $T.multipartForm({
+  name: $T.string(),
+  age: $T.integer({ minimum: 0 })
+})
+```
+
+#### Url Form
+
+To define an `application/x-www-form-urlencoded` request body, use `TUrlForm` Schema Type. Example:
+
+```ts
+const urlBody = $T.urlForm({
+  name: $T.string(),
+  age: $T.integer({ minimum: 0 })
+})
+```
+
+#### Stream
+
+Some body request types can be streamed by using `STStream` Schema Type wrapper. The streamable Schema Types are `STByteArray`, `STString`, `STUrlForm` and `STMultipartForm`. This can be usefull to imporve performances in case you have heavy body payloads and you want to perform early validations on the body.
+
+Let's look at a concrete example where this could be useful. Imagine you want a `multipart/form-data` body request that has two properties: `username` and `heavyImageFile`. In a normal case, you would define something like this:
+
+```ts
+galbe.post(
+  'user/create',
+  {
+    body: $T.multipartForm({
+      username: $T.string(),
+      heavyImageFile: $T.byteArray()
+    })
+  },
+  ctx => {
+    // At that point, the full body request has been processed
+    if(!isValid(ctx.body.username))
+      throw new RequestError({ status: 400 })
+    else ctx.set.status = 201
+  }
+})
+```
+
+This means that in the case where the username wouldn't pass the validation, the full request body, including the `heavyImageFile`, would have been processed for nothing, as it is not used. This would induce unnecessary time and resource consumption.
+
+The `STStream` Schema Type wrapper was created to remediate to remediate this issue. In practice it allows you to perform validations on the fly. Now in your handler, instead of receiving an object as `ctx.body`, you will receive an [AsyncGenerator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AsyncGenerator).
+
+```ts
+galbe.post(
+  'user/create',
+  {
+    body: $T.stream($T.multipartForm({
+      username: $T.string(),
+      heavyImageFile: $T.byteArray()
+    }))
+  },
+  ctx => {
+    // At that point, the body has not been processed yet.
+    for await (const [key, value] of ctx.body) {
+      if (key === "username" && !isValid(value)) {
+        // Returns an early response before heavyImageFile is processed
+        throw new RequestError({ status: 400 })
+      }
+    }
+    ctx.set.status = 201
+  }
+})
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "galbe",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Fast, lightweight and highly customizable JavaScript web framework based on Bun",
   "author": "Pierre Caillaud M (https://github.com/pierre-cm)",
   "type": "module",
@@ -41,7 +41,6 @@
     "typescript": "^5.0.0"
   },
   "dependencies": {
-    "@sinclair/typebox": "^0.31.28",
     "@swc/core": "^1.3.107",
     "@swc/wasm": "^1.4.0",
     "acorn": "^8.11.2",

package/src/index.ts

@@ -1,62 +1,43 @@
 import type { Server } from 'bun'
-import type {
-  ArrayOptions,
-  NumericOptions,
-  ObjectOptions,
-  SchemaOptions,
-  Static,
-  StringOptions,
-  TAny,
-  TArray,
-  TBoolean,
-  TInteger,
-  TLiteral,
-  TLiteralValue,
-  TNever,
-  TNumber,
-  TObject,
-  TOptional,
-  TProperties,
-  TSchema,
-  TString,
-  TUnion
-} from '@sinclair/typebox'
 import type { RouteFileMeta } from './routes'
 import type {
   GalbeConfig,
   Method,
-  Schema,
+  RequestSchema,
   Hook,
   Handler,
   Endpoint,
   Context,
   ErrorHandler,
   GalbePlugin,
-  TStream,
-  TMultipartProperties,
-  TMultipartForm,
-  TUrlFormProperties,
-  TUrlForm,
-  TBody,
-  TByteArray,
-  TStreamable,
-  MultipartFormData
+  STBody,
+  STParams,
+  STHeaders,
+  STQuery
 } from './types'
 
-import { TypeClone, Kind, TypeBuilder, Optional, TypeGuard } from '@sinclair/typebox'
 import server from './server'
 import { GalbeRouter } from './router'
 import { defineRoutes } from './routes'
-import { Stream } from './types'
 import { logRoute } from './util'
+import { SchemaType, type STObject, type Static } from './schema'
 
-const overloadDiscriminer = <H extends TProperties, P extends TProperties, Q extends TProperties, B extends TBody>(
+const overloadDiscriminer = <
+  Path extends string,
+  H extends STHeaders,
+  P extends Partial<STParams<Path>>,
+  Q extends STQuery,
+  B extends STBody
+>(
   galbe: Galbe,
   method: Method,
-  path: string,
-  arg2: Schema<H, P, Q, B> | Hook<Schema<H, P, Q, B>>[] | Handler<Schema<H, P, Q, B>>,
-  arg3?: Hook<Schema<H, P, Q, B>>[] | Handler<Schema<H, P, Q, B>>,
-  arg4?: Handler<Schema<H, P, Q, B>>
+  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>>
 ) => {
   const defaultSchema = {}
   if (typeof arg2 === 'function') {
@@ -69,22 +50,28 @@ const overloadDiscriminer = <H extends TProperties, P extends TProperties, Q ext
       else if (typeof arg3 === 'function') return galbeMethod(galbe, method, path, arg2, undefined, arg3)
     }
   }
-  throw new Error('Undefined endpoint signature')
+  throw new Error('Undefined route signature')
 }
-const galbeMethod = <H extends TProperties, P extends TProperties, Q extends TProperties, B extends TBody>(
+const galbeMethod = <
+  Path extends string,
+  H extends STHeaders,
+  P extends Partial<STParams<Path>>,
+  Q extends STQuery,
+  B extends STBody
+>(
   _galbe: Galbe,
   method: Method,
-  path: string,
-  schema: Schema<H, P, Q, B> | undefined,
-  hooks: Hook<Schema<H, P, Q, B>>[] | undefined,
-  handler: Handler<Schema<H, P, Q, B>>
+  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 = schema ?? {}
   hooks = hooks || []
-  const context: Context<typeof schema> = {
-    headers: {} as Static<TObject<Exclude<(typeof schema)['headers'], undefined>>>,
-    params: {} as Static<TObject<Exclude<(typeof schema)['params'], undefined>>>,
-    query: {} as Static<TObject<Exclude<(typeof schema)['query'], undefined>>>,
+  const context: Context<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>>,
     request: {} as Request,
     state: {},
@@ -96,7 +83,6 @@ const galbeMethod = <H extends TProperties, P extends TProperties, Q extends TPr
       redirect?: string
     }
   }
-  //@ts-ignore
   return {
     method,
     path,
@@ -107,145 +93,7 @@ const galbeMethod = <H extends TProperties, P extends TProperties, Q extends TPr
   }
 }
 
-export class TypeboxTypeBuilder extends TypeBuilder {
-  /** `[Json]` Creates an Optional property */
-  public Optional<T extends TSchema>(schema: T): TOptional<T> {
-    return { ...TypeClone.Type(schema), [Optional]: 'Optional' }
-  }
-  /** `[Json]` Creates an Any type */
-  public Any(options: SchemaOptions = {}): TAny {
-    return this.Create({ ...options, [Kind]: 'Any' })
-  }
-  /** `[Json]` Creates an Array type */
-  public Array<T extends TSchema>(schema: T, options: ArrayOptions = {}): TArray<T> {
-    return this.Create({ ...options, [Kind]: 'Array', type: 'array', items: TypeClone.Type(schema) })
-  }
-  /** `[Json]` Creates a Boolean type */
-  public Boolean(options: SchemaOptions = {}): TBoolean {
-    return this.Create({ ...options, [Kind]: 'Boolean', type: 'boolean' })
-  }
-  /** `[Json]` Creates an Integer type */
-  public Integer(options: NumericOptions<number> = {}): TInteger {
-    return this.Create({ ...options, [Kind]: 'Integer', type: 'integer' })
-  }
-  /** `[Json]` Creates a Literal type */
-  public Literal<T extends TLiteralValue>(value: T, options: SchemaOptions = {}): TLiteral<T> {
-    return this.Create({
-      ...options,
-      [Kind]: 'Literal',
-      const: value,
-      type: typeof value as 'string' | 'number' | 'boolean'
-    })
-  }
-  /** `[Json]` Creates a Number type */
-  public Number(options: NumericOptions<number> = {}): TNumber {
-    return this.Create({ ...options, [Kind]: 'Number', type: 'number' })
-  }
-  /** `[Json]` Creates an Object type */
-  public Object<T extends TProperties>(properties: T, options: ObjectOptions = {}): TObject<T> {
-    const propertyKeys = Object.getOwnPropertyNames(properties)
-    const optionalKeys = propertyKeys.filter(key => TypeGuard.TOptional(properties[key]))
-    const requiredKeys = propertyKeys.filter(name => !optionalKeys.includes(name))
-    const clonedAdditionalProperties = TypeGuard.TSchema(options.additionalProperties)
-      ? { additionalProperties: TypeClone.Type(options.additionalProperties) }
-      : {}
-    const clonedProperties = propertyKeys.reduce(
-      (acc, key) => ({ ...acc, [key]: TypeClone.Type(properties[key]) }),
-      {} as TProperties
-    )
-    return requiredKeys.length > 0
-      ? this.Create({
-          ...options,
-          ...clonedAdditionalProperties,
-          [Kind]: 'Object',
-          type: 'object',
-          properties: clonedProperties,
-          required: requiredKeys
-        })
-      : this.Create({
-          ...options,
-          ...clonedAdditionalProperties,
-          [Kind]: 'Object',
-          type: 'object',
-          properties: clonedProperties
-        })
-  }
-  /** `[Json]` Creates a String type */
-  public String(options: StringOptions = {}): TString {
-    return this.Create({ ...options, [Kind]: 'String', type: 'string' })
-  }
-  /** `[Json]` Creates a Union type */
-  public Union(anyOf: [], options?: SchemaOptions): TNever
-  /** `[Json]` Creates a Union type */
-  public Union<T extends [TSchema]>(anyOf: [...T], options?: SchemaOptions): T[0]
-  /** `[Json]` Creates a Union type */
-  public Union<T extends TSchema[]>(anyOf: [...T], options?: SchemaOptions): TUnion<T>
-  /** `[Json]` Creates a Union type */
-  public Union(union: TSchema[], options: SchemaOptions = {}) {
-    // prettier-ignore
-    return (() => {
-        const anyOf = union
-        if (anyOf.length === 0) throw new Error("Union type must decalre at least one schema")
-        if (anyOf.length === 1) return this.Create(TypeClone.Type(anyOf[0], options))
-        const clonedAnyOf = TypeClone.Rest(anyOf)
-        return this.Create({ ...options, [Kind]: 'Union', anyOf: clonedAnyOf })
-      })()
-  }
-}
-
-class GalbeTypeBuilder extends TypeboxTypeBuilder {
-  /** `[Galbe]` Creates an Stream type */
-  public Stream<T extends TUrlForm>(
-    schema: T
-  ): Omit<TStream<T>, 'static'> & { static: AsyncGenerator<[string, string | number | boolean]>; params: unknown[] }
-  public Stream<T extends TMultipartForm>(
-    schema: T
-  ): Omit<TStream<T>, 'static'> & { static: AsyncGenerator<MultipartFormData, void, unknown>; params: unknown[] }
-  public Stream<T extends TByteArray>(
-    schema: T
-  ): Omit<TStream<T>, 'static'> & { static: AsyncGenerator<Uint8Array>; params: unknown[] }
-  public Stream<T extends TString>(
-    schema: T
-  ): Omit<TStream<T>, 'static'> & { static: AsyncGenerator<string>; params: unknown[] }
-  public Stream<T extends TStreamable>(schema: T): TStream<T> {
-    return {
-      ...TypeClone.Type(schema),
-      [Stream]: 'Stream'
-    }
-  }
-  /** `[Galbe]` Creates an ByteArray type */
-  public ByteArray(): TByteArray {
-    return this.Create({ [Kind]: 'ByteArray', type: 'byteArray', params: {} })
-  }
-  /** `[Galbe]` Creates an MultipartForm type */
-  public MultipartForm<T extends TMultipartProperties>(properties?: T): TMultipartForm {
-    if (!properties) return this.Create({ [Kind]: 'MultipartForm', type: 'multipartForm' })
-    const propertyKeys = Object.getOwnPropertyNames(properties)
-    const clonedProperties = propertyKeys.reduce(
-      //@ts-ignore
-      (acc, key) => ({ ...acc, [key]: TypeClone.Type(properties[key]) }),
-      {} as TProperties
-    )
-    return this.Create({
-      [Kind]: 'MultipartForm',
-      type: 'multipartForm',
-      properties: clonedProperties
-    })
-  }
-  /** `[Galbe]` Creates an UrlForm type */
-  public UrlForm<T extends TUrlFormProperties>(properties?: T): TUrlForm {
-    if (!properties) return this.Create({ [Kind]: 'UrlForm', type: 'urlForm' })
-    const propertyKeys = Object.getOwnPropertyNames(properties)
-    const clonedProperties = propertyKeys.reduce(
-      //@ts-ignore
-      (acc, key) => ({ ...acc, [key]: TypeClone.Type(properties[key]) }),
-      {} as TProperties
-    )
-    return this.Create({ [Kind]: 'UrlForm', type: 'urlForm', properties: clonedProperties })
-  }
-}
-
-export const T = new GalbeTypeBuilder()
+export const $T = new SchemaType()
 
 export { RequestError } from './types'
 
@@ -274,6 +122,7 @@ export class Galbe {
   plugins: GalbePlugin[] = []
   constructor(config?: GalbeConfig) {
     this.config = config ?? {}
+    this.config.routes = this.config.routes ?? true
     this.router = new GalbeRouter(this.config?.basePath || '')
   }
   private add(route: any) {
@@ -312,41 +161,95 @@ export class Galbe {
   onError(handler: ErrorHandler) {
     this.errorHandler = handler
   }
-  get: Endpoint = <H extends TProperties, P extends TProperties, Q extends TProperties, B extends TBody>(
-    path: string,
-    arg2: Schema<H, P, Q, B> | Hook<Schema<H, P, Q, B>>[] | Handler<Schema<H, P, Q, B>>,
-    arg3?: Hook<Schema<H, P, Q, B>>[] | Handler<Schema<H, P, Q, B>>,
-    arg4?: Handler<Schema<H, P, Q, B>>
+  get: Endpoint = <
+    Path extends string,
+    H extends STHeaders,
+    P extends Partial<STParams<Path>>,
+    Q extends STQuery,
+    B extends STBody
+  >(
+    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>>
   ) => this.add(overloadDiscriminer(this, 'get', path, arg2, arg3, arg4))
-  post: Endpoint = <H extends TProperties, P extends TProperties, Q extends TProperties, B extends TBody>(
-    path: string,
-    arg2: Schema<H, P, Q, B> | Hook<Schema<H, P, Q, B>>[] | Handler<Schema<H, P, Q, B>>,
-    arg3?: Hook<Schema<H, P, Q, B>>[] | Handler<Schema<H, P, Q, B>>,
-    arg4?: Handler<Schema<H, P, Q, B>>
+  post: Endpoint = <
+    Path extends string,
+    H extends STHeaders,
+    P extends Partial<STParams<Path>>,
+    Q extends STQuery,
+    B extends STBody
+  >(
+    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>>
   ) => this.add(overloadDiscriminer(this, 'post', path, arg2, arg3, arg4))
-  put: Endpoint = <H extends TProperties, P extends TProperties, Q extends TProperties, B extends TBody>(
-    path: string,
-    arg2: Schema<H, P, Q, B> | Hook<Schema<H, P, Q, B>>[] | Handler<Schema<H, P, Q, B>>,
-    arg3?: Hook<Schema<H, P, Q, B>>[] | Handler<Schema<H, P, Q, B>>,
-    arg4?: Handler<Schema<H, P, Q, B>>
+  put: Endpoint = <
+    Path extends string,
+    H extends STHeaders,
+    P extends Partial<STParams<Path>>,
+    Q extends STQuery,
+    B extends STBody
+  >(
+    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>>
   ) => this.add(overloadDiscriminer(this, 'put', path, arg2, arg3, arg4))
-  patch: Endpoint = <H extends TProperties, P extends TProperties, Q extends TProperties, B extends TBody>(
-    path: string,
-    arg2: Schema<H, P, Q, B> | Hook<Schema<H, P, Q, B>>[] | Handler<Schema<H, P, Q, B>>,
-    arg3?: Hook<Schema<H, P, Q, B>>[] | Handler<Schema<H, P, Q, B>>,
-    arg4?: Handler<Schema<H, P, Q, B>>
+  patch: Endpoint = <
+    Path extends string,
+    H extends STHeaders,
+    P extends Partial<STParams<Path>>,
+    Q extends STQuery,
+    B extends STBody
+  >(
+    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>>
   ) => this.add(overloadDiscriminer(this, 'patch', path, arg2, arg3, arg4))
-  delete: Endpoint = <H extends TProperties, P extends TProperties, Q extends TProperties, B extends TBody>(
-    path: string,
-    arg2: Schema<H, P, Q, B> | Hook<Schema<H, P, Q, B>>[] | Handler<Schema<H, P, Q, B>>,
-    arg3?: Hook<Schema<H, P, Q, B>>[] | Handler<Schema<H, P, Q, B>>,
-    arg4?: Handler<Schema<H, P, Q, B>>
+  delete: Endpoint = <
+    Path extends string,
+    H extends STHeaders,
+    P extends Partial<STParams<Path>>,
+    Q extends STQuery,
+    B extends STBody
+  >(
+    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>>
   ) => this.add(overloadDiscriminer(this, 'delete', path, arg2, arg3, arg4))
-  options: Endpoint = <H extends TProperties, P extends TProperties, Q extends TProperties, B extends TBody>(
-    path: string,
-    arg2: Schema<H, P, Q, B> | Hook<Schema<H, P, Q, B>>[] | Handler<Schema<H, P, Q, B>>,
-    arg3?: Hook<Schema<H, P, Q, B>>[] | Handler<Schema<H, P, Q, B>>,
-    arg4?: Handler<Schema<H, P, Q, B>>
+  options: Endpoint = <
+    Path extends string,
+    H extends STHeaders,
+    P extends Partial<STParams<Path>>,
+    Q extends STQuery,
+    B extends STBody
+  >(
+    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>>
   ) => this.add(overloadDiscriminer(this, 'options', path, arg2, arg3, arg4))
 }