galbe 0.1.0

package/.github/workflows/build_test.yml

@@ -0,0 +1,19 @@
+name: Build & Test
+on:
+  push:
+  pull_request:
+jobs:
+  build:
+    name: Build & Test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: oven-sh/setup-bun@v1
+        with:
+          bun-version: latest
+      - name: Install
+        run: bun install
+      - name: Build
+        run: bun run build
+      - name: Test
+        run: bun test

package/.github/workflows/deploy_website.yml

@@ -0,0 +1,20 @@
+name: Redeploy website
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'docs/**'
+jobs:
+  redeploy_website:
+    name: Update website with new doc
+    runs-on: ubuntu-latest
+    steps:
+      - name: Trigger website deployment
+        run: |
+          curl -L \
+          -X POST \
+          -H "Accept: application/vnd.github+json" \
+          -H "Authorization: Bearer ${{ secrets.GH_WEBSITE_TOKEN }}" \
+          -H "X-GitHub-Api-Version: 2022-11-28" \
+          https://api.github.com/repos/pierre-cm/galbe-website/actions/workflows/ci.yml/dispatches \
+          -d '{"ref":"main"}'

package/.prettierrc

@@ -0,0 +1,10 @@
+tabWidth: 2
+useTabs: false
+trailingComma: none
+semi: false
+singleQuote: true
+bracketSpacing: true
+arrowParens: avoid
+printWidth: 120
+jsxSingleQuote: true
+endOfLine: lf

package/README.md

@@ -0,0 +1,39 @@
+# Todos
+
+- [x] Params and QueryParams as {} instead of Type.Object({})
+- [x] Body validator (/ parser?)
+- [x] Hooks
+- [x] Export limited version of Typebox
+- [x] Headers
+- [x] Details
+- [x] Build
+
+- Own Framework
+
+  - [x] Types
+  - [x] errorHandler
+  - [x] plugin use()
+  - [ ] jsdoc
+  - [x] on the fly body request validation (REST handle parsing of Multipart arrays + Multipart static )
+
+- [ ] Unit tests
+
+- Todo api example
+
+  - [x] Create
+  - [x] GetList
+  - [x] Get
+  - [x] Update
+  - [x] Delete
+  - [ ] Bulk create from file
+  - [ ] Dl as file
+
+- Hooks
+
+  - [ ] Headers authentication pos/update/delete
+
+- [ ] Documentation
+
+- [ ] create-kadre
+
+- [ ] Website

package/bin/cli.ts

@@ -0,0 +1,114 @@
+#!/usr/bin/env bun
+
+import { $ } from 'bun'
+import type { RouteMeta } from '../src/routes'
+import { program } from 'commander'
+import { relative, resolve } from 'path'
+import { mkdir, readdir, rm } from 'fs/promises'
+import { metaAnalysis } from '../src/routes'
+import { randomUUID } from 'crypto'
+import { glob } from 'glob'
+import { Galbe } from '../src'
+
+const ROOT = process.cwd()
+const BUILD_ID = randomUUID()
+
+Bun.env.FORCE_COLOR = '1'
+
+const parseRoutes = async (routes?: string | string[]): Promise<{ path: string; meta: RouteMeta }[]> => {
+  if (!routes) return []
+  let files: { path: string; meta: RouteMeta }[] = []
+  if (typeof routes === 'string') {
+    let filePaths = await glob(routes, { cwd: ROOT, withFileTypes: true, ignore: 'node_modules/**' })
+    for (const file of filePaths.map(f => ({ name: f.name, path: f.path, type: f.getType() }))) {
+      const path = `${file.path}/${file.name}`
+      if (file.type === 'File') files.push({ path, meta: await metaAnalysis(path) })
+      else if (file.type === 'Directory') {
+        files = files.concat(
+          await Promise.all(
+            (
+              await readdir(`${file.path}/${file.name}`)
+            ).map(async f => ({
+              path: `${file.path}/${f}`,
+              meta: await metaAnalysis(`${file.path}/${f}`)
+            }))
+          )
+        )
+      }
+    }
+  }
+  if (Array.isArray(routes)) for (const r of routes) files = files.concat(await parseRoutes(r))
+  return files
+}
+
+const createBuildIndex = async (indexPath: string, routes: { path: string; meta: RouteMeta }[]) => {
+  const buildPath = resolve(ROOT, '.galbe', 'build', BUILD_ID)
+  await mkdir(buildPath, { recursive: true })
+  await Bun.write(
+    resolve(buildPath, 'index.ts'),
+    `import galbe from '${relative(buildPath, indexPath)}';
+${routes.map((r, idx) => `import _${idx} from '${relative(buildPath, r.path)}'`).join(';\n')}
+${routes
+  .map(
+    (r, idx) => `galbe.routesMetadata = {...${JSON.stringify(r.meta)}}
+_${idx}(galbe)`
+  )
+  .join(';\n')}
+galbe.listen();
+`
+  )
+  return resolve(buildPath, 'index.ts')
+}
+
+program.name('galbe').description('CLI to execute galbe utilities').version('0.1.0')
+
+program
+  .command('dev')
+  .description('Run a dev server running your galbe API')
+  .argument('<string>', 'filename')
+  .option('-p, --port <number>', 'port number', '')
+  .action(async (fileName, props) => {
+    const { port } = props
+    const devRoot = resolve(ROOT, '.galbe', 'dev')
+    await mkdir(devRoot, { recursive: true })
+    await Bun.write(
+      resolve(devRoot, 'index.ts'),
+      `import galbe from '${relative(devRoot, fileName)}';galbe.listen(${port});`
+    )
+    process.on('SIGINT', async () => {
+      await rm(resolve(ROOT, '.galbe', 'dev'), { recursive: true })
+    })
+
+    await $`BUN_ENV=development bun run --watch ${resolve(devRoot, 'index.ts')}`.cwd(ROOT)
+  })
+
+program
+  .command('build')
+  .description('Build your galbe API')
+  .argument('<string>', 'filename')
+  .option('-o, --out <string>', 'output file', '')
+  .option('-c, --compile', 'standalone executable', false)
+  .action(async (fileName, props) => {
+    const { out, compile } = props
+    const g: Galbe = (await import(resolve(ROOT, fileName))).default
+    const routes = await parseRoutes(g?.config?.routes)
+    const buildIndex = await createBuildIndex(fileName, routes)
+
+    const cmds = [
+      'bun',
+      'build',
+      buildIndex,
+      '--target',
+      'bun',
+      ...(compile ? ['--compile', '--outfile', out ? out : 'api'] : ['--outdir', out ? out : 'dist'])
+    ].filter(c => c)
+    Bun.spawn(cmds, {
+      cwd: ROOT,
+      stdout: 'inherit',
+      async onExit() {
+        await rm(resolve(ROOT, '.galbe', 'build', BUILD_ID), { recursive: true })
+      }
+    })
+  })
+
+program.parse()

package/docs/Getting Started/basic.md

@@ -0,0 +1 @@
+TODO

package/docs/Guides/routes.md

@@ -0,0 +1 @@
+TODO: Routes documentation

package/docs/getting-started.md

@@ -0,0 +1,5 @@
+### Create a project
+
+```shell
+    bun create pierre-cm/create-galbe
+```

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "galbe",
+  "version": "0.1.0",
+  "description": "Fast, lightweight and highly customizable JavaScript web framework based on Bun",
+  "author": "Pierre Caillaud M (https://github.com/pierre-cm)",
+  "type": "module",
+  "bin": "./bin/cli.ts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./*": "./dist/*.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pierre-cm/galbe"
+  },
+  "bugs": "https://github.com/pierre-cm/galbe/issues",
+  "homepage": "https://galbe.dev",
+  "keywords": [
+    "bun",
+    "http",
+    "web",
+    "framework",
+    "server",
+    "api"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "build": "bun ./scripts/build.ts",
+    "clean": "rm -rf dist",
+    "test": "bun test",
+    "postinstall": "bun run ./scripts/postinstall.ts"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.0.4"
+  },
+  "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"
+  }
+}

package/scripts/build.ts

@@ -0,0 +1,14 @@
+import { $ } from 'bun'
+
+await Bun.build({
+  entrypoints: ['./src/index.ts'],
+  outdir: './dist',
+  minify: true,
+  target: 'bun',
+  sourcemap: 'external',
+  external: ['bun']
+})
+
+await $`bun x tsc --outdir ./dist`
+
+process.exit()

package/scripts/hooks/prepare-commit-msg

@@ -0,0 +1,10 @@
+#!/usr/bin/env bun
+
+const COMMIT_MSG = await Bun.file(Bun.argv[2]).text()
+const COMMIT_EMOJI = { feat: '✨', fix: '🔧', doc: '📚', chore: '🧹' }
+
+const newCommitMsg = COMMIT_MSG.replace(/^(feat|fix|doc|chore):(.*)/, (_, type, msg) => {
+  return `${COMMIT_EMOJI[type]} ${type}:${msg}`
+})
+
+await Bun.write(Bun.argv[2], newCommitMsg)

package/scripts/postinstall.ts

@@ -0,0 +1,9 @@
+import { $ } from 'bun'
+import { existsSync } from 'node:fs'
+
+if (existsSync('.git')) {
+  console.log('Setting up dev environment')
+  Bun.write('.git/hooks/prepare-commit-msg', Bun.file('scripts/hooks/prepare-commit-msg'))
+  await $`chmod +x .git/hooks/prepare-commit-msg`
+  console.log('done')
+}

package/src/index.ts

@@ -0,0 +1,353 @@
+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,
+  Hook,
+  Handler,
+  Endpoint,
+  Context,
+  ErrorHandler,
+  GalbePlugin,
+  TStream,
+  TMultipartProperties,
+  TMultipartForm,
+  TUrlFormProperties,
+  TUrlForm,
+  TBody,
+  TByteArray,
+  TStreamable,
+  MultipartFormData
+} 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'
+
+const overloadDiscriminer = <H extends TProperties, P extends TProperties, Q extends TProperties, B extends TBody>(
+  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>>
+) => {
+  const defaultSchema = {}
+  if (typeof arg2 === 'function') {
+    return galbeMethod(galbe, method, path, defaultSchema, undefined, arg2)
+  } else {
+    if (Array.isArray(arg2)) {
+      if (typeof arg3 === 'function') return galbeMethod(galbe, method, path, defaultSchema, arg2, arg3)
+    } else {
+      if (Array.isArray(arg3) && arg4) return galbeMethod(galbe, method, path, arg2, arg3, arg4)
+      else if (typeof arg3 === 'function') return galbeMethod(galbe, method, path, arg2, undefined, arg3)
+    }
+  }
+  throw new Error('Undefined endpoint signature')
+}
+const galbeMethod = <H extends TProperties, P extends TProperties, Q extends TProperties, B extends TBody>(
+  _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>>
+) => {
+  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>>>,
+    body: {} as Static<Exclude<(typeof schema)['body'], undefined>>,
+    request: {} as Request,
+    state: {},
+    set: {} as {
+      headers: {
+        [header: string]: string
+      }
+      status?: number
+      redirect?: string
+    }
+  }
+  //@ts-ignore
+  return {
+    method,
+    path,
+    schema,
+    context,
+    hooks,
+    handler
+  }
+}
+
+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 { RequestError } from './types'
+
+const indexRoutes: { method: string; path: string }[] = []
+/**
+ * #### Galbe Server
+ * Instanciate a Galbe web server
+ *
+ * ---
+ * @example
+ * ```typescript
+ * import { Galbe } from 'galbe'
+ * import config from "./galbe.config"
+ *
+ * export default new Galbe(config)
+ * ```
+ */
+export class Galbe {
+  config: GalbeConfig
+  meta?: Array<RouteFileMeta> = []
+  router: GalbeRouter
+  errorHandler?: ErrorHandler
+  listening: boolean = false
+  #prepare: boolean = false
+  server?: Server
+  plugins: GalbePlugin[] = []
+  constructor(config?: GalbeConfig) {
+    this.config = config ?? {}
+    this.router = new GalbeRouter(this.config?.basePath || '')
+  }
+  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)
+    }
+  }
+  async use(plugin: GalbePlugin) {
+    this.plugins.push(plugin)
+  }
+  async listen(port?: number) {
+    port = port || this.config?.port || 3000
+    this.config.port = port
+    if (this.listening) this.stop()
+    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)
+    }
+    this.listening = true
+    this.#prepare = false
+    return this.server
+  }
+  stop() {
+    this.server?.stop(true)
+  }
+  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>>
+  ) => 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>>
+  ) => 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>>
+  ) => 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>>
+  ) => 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>>
+  ) => 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>>
+  ) => this.add(overloadDiscriminer(this, 'options', path, arg2, arg3, arg4))
+}
+
+export * from './types'