deno.land / x / hono@v4.2.5 / hono-base.ts
نووسراو ببینە
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424import { compose } from './compose.ts'import { Context } from './context.ts'import type { ExecutionContext } from './context.ts'import { HTTPException } from './http-exception.ts'import { HonoRequest } from './request.ts'import type { Router } from './router.ts'import { METHOD_NAME_ALL, METHOD_NAME_ALL_LOWERCASE, METHODS } from './router.ts'import type { Env, ErrorHandler, H, HandlerInterface, MiddlewareHandler, MiddlewareHandlerInterface, Next, NotFoundHandler, OnHandlerInterface, MergePath, MergeSchemaPath, FetchEventLike, Schema, RouterRoute,} from './types.ts'import { getPath, getPathNoStrict, getQueryStrings, mergePath } from './utils/url.ts'
export const COMPOSED_HANDLER = Symbol('composedHandler')
type Methods = (typeof METHODS)[number] | typeof METHOD_NAME_ALL_LOWERCASE
function defineDynamicClass(): { new <E extends Env = Env, S extends Schema = {}, BasePath extends string = '/'>(): { [M in Methods]: HandlerInterface<E, M, S, BasePath> } & { on: OnHandlerInterface<E, S, BasePath> } & { use: MiddlewareHandlerInterface<E, S, BasePath> }} { return class {} as never}
const notFoundHandler = (c: Context) => { return c.text('404 Not Found', 404)}
const errorHandler = (err: Error, c: Context) => { if (err instanceof HTTPException) { return err.getResponse() } console.error(err) return c.text('Internal Server Error', 500)}
type GetPath<E extends Env> = (request: Request, options?: { env?: E['Bindings'] }) => string
export type HonoOptions<E extends Env> = { /** * `strict` option specifies whether to distinguish whether the last path is a directory or not. * @default true * @see https://hono.dev/api/hono#strict-mode */ strict?: boolean /** * `router` option specifices which router to use. * ```ts * const app = new Hono({ router: new RegExpRouter() }) * ``` * @see https://hono.dev/api/hono#router-option */ router?: Router<[H, RouterRoute]> /** * `getPath` can handle the host header value. * @example * ```ts * const app = new Hono({ * getPath: (req) => * '/' + req.headers.get('host') + req.url.replace(/^https?:\/\/[^/]+(\/[^?]*)/, '$1'), * }) * * app.get('/www1.example.com/hello', () => c.text('hello www1')) * * // A following request will match the route: * // new Request('http://www1.example.com/hello', { * // headers: { host: 'www1.example.com' }, * // }) * ``` * @see https://hono.dev/api/routing#routing-with-host-header-value */ getPath?: GetPath<E>}
class Hono< E extends Env = Env, S extends Schema = {}, BasePath extends string = '/'> extends defineDynamicClass()<E, S, BasePath> { /* This class is like an abstract class and does not have a router. To use it, inherit the class and implement router in the constructor. */ router!: Router<[H, RouterRoute]> readonly getPath: GetPath<E> // Cannot use `#` because it requires visibility at JavaScript runtime. private _basePath: string = '/' #path: string = '/'
routes: RouterRoute[] = []
constructor(options: HonoOptions<E> = {}) { super()
// Implementation of app.get(...handlers[]) or app.get(path, ...handlers[]) const allMethods = [...METHODS, METHOD_NAME_ALL_LOWERCASE] allMethods.forEach((method) => { this[method] = (args1: string | H, ...args: H[]) => { if (typeof args1 === 'string') { this.#path = args1 } else { this.addRoute(method, this.#path, args1) } args.forEach((handler) => { if (typeof handler !== 'string') { this.addRoute(method, this.#path, handler) } }) // eslint-disable-next-line @typescript-eslint/no-explicit-any return this as any } })
// Implementation of app.on(method, path, ...handlers[]) this.on = (method: string | string[], path: string | string[], ...handlers: H[]) => { if (!method) { return this } for (const p of [path].flat()) { this.#path = p for (const m of [method].flat()) { handlers.map((handler) => { this.addRoute(m.toUpperCase(), this.#path, handler) }) } } // eslint-disable-next-line @typescript-eslint/no-explicit-any return this as any }
// Implementation of app.use(...handlers[]) or app.use(path, ...handlers[]) // eslint-disable-next-line @typescript-eslint/no-explicit-any this.use = (arg1: string | MiddlewareHandler<any>, ...handlers: MiddlewareHandler<any>[]) => { if (typeof arg1 === 'string') { this.#path = arg1 } else { this.#path = '*' handlers.unshift(arg1) } handlers.forEach((handler) => { this.addRoute(METHOD_NAME_ALL, this.#path, handler) }) // eslint-disable-next-line @typescript-eslint/no-explicit-any return this as any }
const strict = options.strict ?? true delete options.strict Object.assign(this, options) this.getPath = strict ? options.getPath ?? getPath : getPathNoStrict }
private clone(): Hono<E, S, BasePath> { const clone = new Hono<E, S, BasePath>({ router: this.router, getPath: this.getPath, }) clone.routes = this.routes return clone }
private notFoundHandler: NotFoundHandler = notFoundHandler private errorHandler: ErrorHandler = errorHandler
route< SubPath extends string, SubEnv extends Env, SubSchema extends Schema, SubBasePath extends string >( path: SubPath, app?: Hono<SubEnv, SubSchema, SubBasePath> ): Hono<E, MergeSchemaPath<SubSchema, MergePath<BasePath, SubPath>> & S, BasePath> { const subApp = this.basePath(path)
if (!app) { return subApp }
app.routes.map((r) => { let handler if (app.errorHandler === errorHandler) { handler = r.handler } else { handler = async (c: Context, next: Next) => (await compose<Context>([], app.errorHandler)(c, () => r.handler(c, next))).res // eslint-disable-next-line @typescript-eslint/no-explicit-any ;(handler as any)[COMPOSED_HANDLER] = r.handler }
subApp.addRoute(r.method, r.path, handler) }) return this }
/** * `.basePath()` allows base paths to be specified. * @example * ```ts * const api = new Hono().basePath('/api') * ``` * @see https://hono.dev/api/routing#base-path */ basePath<SubPath extends string>(path: SubPath): Hono<E, S, MergePath<BasePath, SubPath>> { const subApp = this.clone() subApp._basePath = mergePath(this._basePath, path) return subApp }
/** * `.onError()` handles an error and returns a customized Response. * ```ts * app.onError((err, c) => { * console.error(`${err}`) * return c.text('Custom Error Message', 500) * }) * ``` */ onError = (handler: ErrorHandler<E>) => { this.errorHandler = handler return this }
/** * `.notFound()` allows you to customize a Not Found Response. * ```ts * app.notFound((c) => { * return c.text('Custom 404 Message', 404) * }) * ``` * @see https://hono.dev/api/hono#not-found */ notFound = (handler: NotFoundHandler<E>) => { this.notFoundHandler = handler return this }
mount( path: string, // eslint-disable-next-line @typescript-eslint/no-explicit-any applicationHandler: (request: Request, ...args: any) => Response | Promise<Response>, optionHandler?: (c: Context) => unknown ): Hono<E, S, BasePath> { const mergedPath = mergePath(this._basePath, path) const pathPrefixLength = mergedPath === '/' ? 0 : mergedPath.length
const handler: MiddlewareHandler = async (c, next) => { let executionContext: ExecutionContext | undefined = undefined try { executionContext = c.executionCtx } catch {} // Do nothing const options = optionHandler ? optionHandler(c) : [c.env, executionContext] const optionsArray = Array.isArray(options) ? options : [options]
const queryStrings = getQueryStrings(c.req.url) const res = await applicationHandler( new Request( new URL((c.req.path.slice(pathPrefixLength) || '/') + queryStrings, c.req.url), c.req.raw ), ...optionsArray )
if (res) { return res }
await next() } this.addRoute(METHOD_NAME_ALL, mergePath(path, '*'), handler) return this }
private addRoute(method: string, path: string, handler: H) { method = method.toUpperCase() path = mergePath(this._basePath, path) const r: RouterRoute = { path: path, method: method, handler: handler } this.router.add(method, path, [handler, r]) this.routes.push(r) }
private matchRoute(method: string, path: string) { return this.router.match(method, path) }
private handleError(err: unknown, c: Context<E>) { if (err instanceof Error) { return this.errorHandler(err, c) } throw err }
private dispatch( request: Request, executionCtx: ExecutionContext | FetchEventLike | undefined, env: E['Bindings'], method: string ): Response | Promise<Response> { // Handle HEAD method if (method === 'HEAD') { return (async () => new Response(null, await this.dispatch(request, executionCtx, env, 'GET')))() }
const path = this.getPath(request, { env }) const matchResult = this.matchRoute(method, path)
const c = new Context(new HonoRequest(request, path, matchResult), { env, executionCtx, notFoundHandler: this.notFoundHandler, })
// Do not `compose` if it has only one handler if (matchResult[0].length === 1) { let res: ReturnType<H> try { res = matchResult[0][0][0][0](c, async () => { c.res = await this.notFoundHandler(c) }) } catch (err) { return this.handleError(err, c) }
return res instanceof Promise ? res .then( (resolved: Response | undefined) => resolved || (c.finalized ? c.res : this.notFoundHandler(c)) ) .catch((err: Error) => this.handleError(err, c)) : res }
const composed = compose<Context>(matchResult[0], this.errorHandler, this.notFoundHandler)
return (async () => { try { const context = await composed(c) if (!context.finalized) { throw new Error( 'Context is not finalized. You may forget returning Response object or `await next()`' ) }
return context.res } catch (err) { return this.handleError(err, c) } })() }
/** * `.fetch()` will be entry point of your app. * @see https://hono.dev/api/hono#fetch */ fetch = (request: Request, Env?: E['Bindings'] | {}, executionCtx?: ExecutionContext) => { return this.dispatch(request, executionCtx, Env, request.method) }
/** * `.request()` is a useful method for testing. * You can pass a URL or pathname to send a GET request. * app will return a Response object. * ```ts * test('GET /hello is ok', async () => { * const res = await app.request('/hello') * expect(res.status).toBe(200) * }) * ``` * @see https://hono.dev/api/hono#request */ request = ( input: RequestInfo | URL, requestInit?: RequestInit, Env?: E['Bindings'] | {}, executionCtx?: ExecutionContext ) => { if (input instanceof Request) { if (requestInit !== undefined) { input = new Request(input, requestInit) } return this.fetch(input, Env, executionCtx) } input = input.toString() const path = /^https?:\/\//.test(input) ? input : `http://localhost${mergePath('/', input)}` const req = new Request(path, requestInit) return this.fetch(req, Env, executionCtx) }
/** * `.fire()` automatically adds a global fetch event listener. * This can be useful for environments that adhere to the Service Worker API, such as non-ES module Cloudflare Workers. * @see https://hono.dev/api/hono#fire * @see https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API * @see https://developers.cloudflare.com/workers/reference/migrate-to-module-workers/ */ fire = () => { // @ts-expect-error `event` is not the type expected by addEventListener addEventListener('fetch', (event: FetchEventLike): void => { event.respondWith(this.dispatch(event.request, event, undefined, event.request.method)) }) }}
export { Hono as HonoBase }
hono
Version Info
a week ago
