galbe 0.1.4 → 0.1.7

package/docs/schemas.md

@@ -0,0 +1,244 @@
+# Shemas
+
+Galbe offers a custom Schema Type processor that provides type safety along with data parsing and validation.
+
+The prime intention of that features is to offer an easy way to manage automatically request inputs validation and error handling. Moreover, it also greatly improve developper's experience by infering static Typescript types from schema definitions.
+
+## Schema Types
+
+To get started with Schema defintion, just import `$T` from `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)
+```
+
+#### Union
+
+Creates an union of Schema Types. .
+
+```ts
+const unionSchema = $T.union([$T.string(), $T.number()])
+```
+
+#### TOptional
+
+Makes any type optional. In practice, this allows for `undefined` values.
+
+```ts
+const optionalSchema = $T.optional($T.string())
+```
+
+## Request Schema definition
+
+The Request Schema definition allows you to define a schema for your request on your [Route Definition](). It must be defined right after the [path]() of your route.
+
+```js
+const schema = {}
+galbe.get('/foo/:bar', schema, ctx => {})
+```
+
+The Request Schema has 4 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 the Schema associated.
+
+**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 the Schema associated.
+
+**Example**:
+
+```ts
+const schema = {
+  params: {
+    name: $T.string(),
+    age: $T.integer({ min: 0 })
+  }
+}
+```
+
+> [!WARNING]
+> Every key should match an existing [route path]() parameter. Otherwise Typescript will show you 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 the Schema associated.
+
+**Example**:
+
+```ts
+const schema = {
+  query: {
+    name: $T.literal('Galbe'),
+    list: $T.array($T.number())
+  }
+}
+```
+
+### body
+
+```ts
+body: STByteArray | STString | STBoolean | STNumber | STInteger | STLiteral | STObject | STMulripartForm | STUrlForm
+```
+
+#### Json
+
+To define an `application/json` request body. You must 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. You must 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. You must 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. 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 see a concrete example where that could be usefull. Imagine you want a `multipart/form-data` body request that has two properties `username` and `heavyImageFile`. In the normal case you would define something like that:
+
+```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. Inducing unnecessary time and resource consumption.
+
+The `STStream` Schema Type wrapper was created to remediate to that 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'll 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.4",
+  "version": "0.1.7",
   "description": "Fast, lightweight and highly customizable JavaScript web framework based on Bun",
   "author": "Pierre Caillaud M (https://github.com/pierre-cm)",
   "type": "module",
@@ -30,20 +30,30 @@
     "build": "bun ./scripts/build.ts",
     "clean": "rm -rf dist",
     "test": "bun test",
-    "postinstall": "bun run ./scripts/postinstall.ts"
+    "postinstall": "bun run ./scripts/postinstall.ts",
+    "release": "release-it"
   },
   "devDependencies": {
-    "@types/bun": "^1.0.4"
+    "@types/bun": "^1.0.4",
+    "release-it": "^17.1.1"
   },
   "peerDependencies": {
     "typescript": "^5.0.0"
   },
   "dependencies": {
-    "@sinclair/typebox": "^0.31.28",
     "@swc/core": "^1.3.107",
     "@swc/wasm": "^1.4.0",
     "acorn": "^8.11.2",
     "acorn-walk": "^8.3.0",
     "commander": "^11.1.0"
+  },
+  "release-it": {
+    "git": {
+      "pushRepo": "git@github.com:pierre-cm/galbe.git"
+    },
+    "github": {
+      "requireBranch": "main",
+      "release": "true"
+    }
   }
-}
+}

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))
 }