hono 2.1.4 → 2.2.1

package/README.md

@@ -21,7 +21,7 @@
 [![GitHub commit activity](https://img.shields.io/github/commit-activity/m/honojs/hono)](https://github.com/honojs/hono/pulse)
 [![GitHub last commit](https://img.shields.io/github/last-commit/honojs/hono)](https://github.com/honojs/hono/commits/main)
 [![Deno badge](https://img.shields.io/endpoint?url=https%3A%2F%2Fdeno-visualizer.danopia.net%2Fshields%2Flatest-version%2Fx%2Fhono%2Fmod.ts)](https://doc.deno.land/https/deno.land/x/hono/mod.ts)
-[![Discord badge](https://img.shields.io/discord/1011308539819597844?label=Discord&logo=Discord)](https://discord.gg/KVYKWmfD)
+[![Discord badge](https://img.shields.io/discord/1011308539819597844?label=Discord&logo=Discord)](https://discord.gg/KMh2eNSdxV)
 
 Hono - _**[炎] means flame🔥 in Japanese**_ - is a small, simple, and ultrafast web framework for Cloudflare Workers, Deno, Bun, and others.
 
@@ -36,24 +36,23 @@ export default app
 
 ## Features
 
-- **Ultrafast** - the router does not use linear loops.
-- **Zero-dependencies** - using only Service Worker and Web Standard API.
-- **Middleware** - built-in middleware, custom middleware, and third-party middleware.
-- **TypeScript** - first-class TypeScript support.
-- **Multi-platform** - works on Cloudflare Workers, Fastly Compute@Edge, Deno, or Bun.
+- **Ultrafast** - The routers are really smart. Not using linear loops. The fastest one will be selected from three routers.
+- **Zero-dependencies** - Using only Web Standard API. Does not depend on other npm or Deno libraries.
+- **Middleware** - Hono has built-in middleware, custom middleware, and third-party middleware. Batteries included.
+- **TypeScript** - First-class TypeScript support. Now, we've got "Types".
+- **Multi-runtime** - Works on Cloudflare Workers, Fastly Compute@Edge, Deno, Bun, or Node.js. The same code runs on all platforms.
 
 ## Benchmarks
 
 **Hono is fastest**, compared to other routers for Cloudflare Workers.
 
 ```plain
-hono - trie-router(default) x 482,004 ops/sec ±5.00% (79 runs sampled)
-hono - regexp-router x 604,006 ops/sec ±4.80% (81 runs sampled)
-itty-router x 203,623 ops/sec ±2.10% (94 runs sampled)
-sunder x 306,457 ops/sec ±2.49% (89 runs sampled)
-worktop x 189,450 ops/sec ±3.14% (88 runs sampled)
-Fastest is hono - regexp-router
-✨  Done in 36.79s.
+Hono x 616,464 ops/sec ±4.76% (83 runs sampled)
+itty-router x 203,074 ops/sec ±3.66% (88 runs sampled)
+sunder x 314,306 ops/sec ±2.28% (87 runs sampled)
+worktop x 194,111 ops/sec ±2.78% (81 runs sampled)
+Fastest is Hono
+✨  Done in 30.77s.
 ```
 
 ## Documentation
@@ -66,7 +65,7 @@ Migration guide is available on [docs/MIGRATION.md](docs/MIGRATION.md).
 
 ## Communication
 
-[Twitter](https://twitter.com/honojs) and [Discord channel](https://discord.gg/KVYKWmfD) are available.
+[Twitter](https://twitter.com/honojs) and [Discord channel](https://discord.gg/KMh2eNSdxV) are available.
 
 ## Contributing
 

package/dist/cjs/compose.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compose = void 0;
+const context_1 = require("./context");
+// Based on the code in the MIT licensed `koa-compose` package.
+const compose = (middleware, onNotFound) => {
+    const middlewareLength = middleware.length;
+    return (context, next) => {
+        let index = -1;
+        return dispatch(0);
+        function dispatch(i) {
+            if (i <= index) {
+                throw new Error('next() called multiple times');
+            }
+            let handler = middleware[i];
+            index = i;
+            if (i === middlewareLength && next)
+                handler = next;
+            let res;
+            if (!handler) {
+                if (context instanceof context_1.HonoContext && context.finalized === false && onNotFound) {
+                    res = onNotFound(context);
+                }
+            }
+            else {
+                res = handler(context, () => {
+                    const dispatchRes = dispatch(i + 1);
+                    return dispatchRes instanceof Promise ? dispatchRes : Promise.resolve(dispatchRes);
+                });
+            }
+            if (!(res instanceof Promise)) {
+                if (res && context.finalized === false) {
+                    context.res = res;
+                }
+                return context;
+            }
+            else {
+                return res.then((res) => {
+                    if (res && context.finalized === false) {
+                        context.res = res;
+                    }
+                    return context;
+                });
+            }
+        }
+    };
+};
+exports.compose = compose;

package/dist/cjs/context.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HonoContext = void 0;
+const cookie_1 = require("./utils/cookie");
+class HonoContext {
+    constructor(req, env = undefined, executionCtx = undefined, notFoundHandler = () => new Response()) {
+        this._status = 200;
+        this._pretty = false;
+        this._prettySpace = 2;
+        this._executionCtx = executionCtx;
+        this.req = req;
+        this.env = env || {};
+        this.notFoundHandler = notFoundHandler;
+        this.finalized = false;
+    }
+    get event() {
+        if (this._executionCtx instanceof FetchEvent) {
+            return this._executionCtx;
+        }
+        else {
+            throw Error('This context has no FetchEvent');
+        }
+    }
+    get executionCtx() {
+        if (this._executionCtx) {
+            return this._executionCtx;
+        }
+        else {
+            throw Error('This context has no ExecutionContext');
+        }
+    }
+    get res() {
+        return (this._res || (this._res = new Response('404 Not Found', { status: 404 })));
+    }
+    set res(_res) {
+        this._res = _res;
+        this.finalized = true;
+    }
+    header(name, value, options) {
+        this._headers || (this._headers = {});
+        const key = name.toLowerCase();
+        let shouldAppend = false;
+        if (options && options.append) {
+            const vAlreadySet = this._headers[key];
+            if (vAlreadySet && vAlreadySet.length) {
+                shouldAppend = true;
+            }
+        }
+        if (shouldAppend) {
+            this._headers[key].push(value);
+        }
+        else {
+            this._headers[key] = [value];
+        }
+        if (this.finalized) {
+            if (shouldAppend) {
+                this.res.headers.append(name, value);
+            }
+            else {
+                this.res.headers.set(name, value);
+            }
+        }
+    }
+    status(status) {
+        this._status = status;
+    }
+    set(key, value) {
+        this._map || (this._map = {});
+        this._map[key] = value;
+    }
+    get(key) {
+        if (!this._map) {
+            return undefined;
+        }
+        return this._map[key];
+    }
+    pretty(prettyJSON, space = 2) {
+        this._pretty = prettyJSON;
+        this._prettySpace = space;
+    }
+    newResponse(data, status, headers = {}) {
+        return new Response(data, {
+            status: status || this._status || 200,
+            headers: this._finalizeHeaders(headers),
+        });
+    }
+    _finalizeHeaders(incomingHeaders) {
+        const finalizedHeaders = [];
+        const headersKv = this._headers || {};
+        // If Response is already set
+        if (this._res) {
+            this._res.headers.forEach((v, k) => {
+                headersKv[k] = [v];
+            });
+        }
+        for (const key of Object.keys(incomingHeaders)) {
+            const value = incomingHeaders[key];
+            if (typeof value === 'string') {
+                finalizedHeaders.push([key, value]);
+            }
+            else {
+                for (const v of value) {
+                    finalizedHeaders.push([key, v]);
+                }
+            }
+            delete headersKv[key];
+        }
+        for (const key of Object.keys(headersKv)) {
+            for (const value of headersKv[key]) {
+                const kv = [key, value];
+                finalizedHeaders.push(kv);
+            }
+        }
+        return finalizedHeaders;
+    }
+    body(data, status = this._status, headers = {}) {
+        return this.newResponse(data, status, headers);
+    }
+    text(text, status = this._status, headers = {}) {
+        headers['content-type'] = 'text/plain; charset=UTF-8';
+        return this.body(text, status, headers);
+    }
+    json(object, status = this._status, headers = {}) {
+        const body = this._pretty
+            ? JSON.stringify(object, null, this._prettySpace)
+            : JSON.stringify(object);
+        headers['content-type'] = 'application/json; charset=UTF-8';
+        return this.body(body, status, headers);
+    }
+    html(html, status = this._status, headers = {}) {
+        headers['content-type'] = 'text/html; charset=UTF-8';
+        return this.body(html, status, headers);
+    }
+    redirect(location, status = 302) {
+        return this.newResponse(null, status, {
+            Location: location,
+        });
+    }
+    cookie(name, value, opt) {
+        const cookie = (0, cookie_1.serialize)(name, value, opt);
+        this.header('set-cookie', cookie, { append: true });
+    }
+    notFound() {
+        return this.notFoundHandler(this);
+    }
+}
+exports.HonoContext = HonoContext;

package/dist/cjs/hono.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Hono = void 0;
+const compose_1 = require("./compose");
+const context_1 = require("./context");
+const request_1 = require("./request");
+const router_1 = require("./router");
+const router_2 = require("./router");
+const reg_exp_router_1 = require("./router/reg-exp-router");
+const smart_router_1 = require("./router/smart-router");
+const static_router_1 = require("./router/static-router");
+const trie_router_1 = require("./router/trie-router");
+const url_1 = require("./utils/url");
+function defineDynamicClass() {
+    return class {
+    };
+}
+class Hono extends defineDynamicClass() {
+    constructor(init = {}) {
+        super();
+        this.router = new smart_router_1.SmartRouter({
+            routers: [new static_router_1.StaticRouter(), new reg_exp_router_1.RegExpRouter(), new trie_router_1.TrieRouter()],
+        });
+        this.strict = true; // strict routing - default is true
+        this._tempPath = '';
+        this.path = '/';
+        this.routes = [];
+        this.notFoundHandler = (c) => {
+            return c.text('404 Not Found', 404);
+        };
+        this.errorHandler = (err, c) => {
+            console.error(`${err.stack || err.message}`);
+            const message = 'Internal Server Error';
+            return c.text(message, 500);
+        };
+        this.fetch = (request, Environment, executionCtx) => {
+            return this.dispatch(request, executionCtx, Environment);
+        };
+        (0, request_1.extendRequestPrototype)();
+        const allMethods = [...router_1.METHODS, router_2.METHOD_NAME_ALL_LOWERCASE];
+        allMethods.map((method) => {
+            this[method] = (args1, ...args) => {
+                if (typeof args1 === 'string') {
+                    this.path = args1;
+                }
+                else {
+                    this.addRoute(method, this.path, args1);
+                }
+                args.map((handler) => {
+                    if (typeof handler !== 'string') {
+                        this.addRoute(method, this.path, handler);
+                    }
+                });
+                return this;
+            };
+        });
+        Object.assign(this, init);
+    }
+    route(path, app) {
+        this._tempPath = path;
+        if (app) {
+            app.routes.map((r) => {
+                this.addRoute(r.method, r.path, r.handler);
+            });
+            this._tempPath = '';
+        }
+        return this;
+    }
+    use(arg1, ...handlers) {
+        if (typeof arg1 === 'string') {
+            this.path = arg1;
+        }
+        else {
+            handlers.unshift(arg1);
+        }
+        handlers.map((handler) => {
+            this.addRoute(router_2.METHOD_NAME_ALL, this.path, handler);
+        });
+        return this;
+    }
+    onError(handler) {
+        this.errorHandler = handler;
+        return this;
+    }
+    notFound(handler) {
+        this.notFoundHandler = handler;
+        return this;
+    }
+    addRoute(method, path, handler) {
+        method = method.toUpperCase();
+        if (this._tempPath) {
+            path = (0, url_1.mergePath)(this._tempPath, path);
+        }
+        this.router.add(method, path, handler);
+        const r = { path: path, method: method, handler: handler };
+        this.routes.push(r);
+    }
+    matchRoute(method, path) {
+        return this.router.match(method, path);
+    }
+    async dispatch(request, eventOrExecutionCtx, env) {
+        const path = (0, url_1.getPathFromURL)(request.url, this.strict);
+        const method = request.method;
+        const result = this.matchRoute(method, path);
+        request.paramData = result?.params;
+        const c = new context_1.HonoContext(request, env, eventOrExecutionCtx, this.notFoundHandler);
+        // Do not `compose` if it has only one handler
+        if (result && result.handlers.length === 1) {
+            const handler = result.handlers[0];
+            try {
+                const res = handler(c, async () => { });
+                if (res) {
+                    const awaited = res instanceof Promise ? await res : res;
+                    if (awaited)
+                        return awaited;
+                }
+                return this.notFoundHandler(c);
+            }
+            catch (err) {
+                if (err instanceof Error) {
+                    return this.errorHandler(err, c);
+                }
+                throw err;
+            }
+        }
+        const handlers = result ? result.handlers : [this.notFoundHandler];
+        const composed = (0, compose_1.compose)(handlers, this.notFoundHandler);
+        let context;
+        try {
+            const tmp = composed(c);
+            context = tmp instanceof Promise ? await tmp : tmp;
+            if (!context.finalized) {
+                throw new Error('Context is not finalized. You may forget returning Response object or `await next()`');
+            }
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                return this.errorHandler(err, c);
+            }
+            throw err;
+        }
+        return context.res;
+    }
+    handleEvent(event) {
+        return this.dispatch(event.request, event);
+    }
+    request(input, requestInit) {
+        const req = input instanceof Request ? input : new Request(input, requestInit);
+        return this.dispatch(req);
+    }
+}
+exports.Hono = Hono;

package/dist/cjs/index.js

@@ -0,0 +1,13 @@
+"use strict";
+// @denoify-ignore
+// eslint-disable-next-line @typescript-eslint/triple-slash-reference
+/// <reference path="./request.ts" /> Import "declare global" for the Request interface.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Hono = void 0;
+const hono_1 = require("./hono");
+Object.defineProperty(exports, "Hono", { enumerable: true, get: function () { return hono_1.Hono; } });
+hono_1.Hono.prototype.fire = function () {
+    addEventListener('fetch', (event) => {
+        void event.respondWith(this.handleEvent(event));
+    });
+};

package/dist/cjs/middleware/basic-auth/index.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.basicAuth = void 0;
+const buffer_1 = require("../../utils/buffer");
+const encode_1 = require("../../utils/encode");
+const CREDENTIALS_REGEXP = /^ *(?:[Bb][Aa][Ss][Ii][Cc]) +([A-Za-z0-9._~+/-]+=*) *$/;
+const USER_PASS_REGEXP = /^([^:]*):(.*)$/;
+const auth = (req) => {
+    const match = CREDENTIALS_REGEXP.exec(req.headers.get('Authorization') || '');
+    if (!match) {
+        return undefined;
+    }
+    const userPass = USER_PASS_REGEXP.exec((0, encode_1.decodeBase64)(match[1]));
+    if (!userPass) {
+        return undefined;
+    }
+    return { username: userPass[1], password: userPass[2] };
+};
+const basicAuth = (options, ...users) => {
+    if (!options) {
+        throw new Error('basic auth middleware requires options for "username and password"');
+    }
+    if (!options.realm) {
+        options.realm = 'Secure Area';
+    }
+    users.unshift({ username: options.username, password: options.password });
+    return async (ctx, next) => {
+        const requestUser = auth(ctx.req);
+        if (requestUser) {
+            for (const user of users) {
+                const usernameEqual = await (0, buffer_1.timingSafeEqual)(user.username, requestUser.username, options.hashFunction);
+                const passwordEqual = await (0, buffer_1.timingSafeEqual)(user.password, requestUser.password, options.hashFunction);
+                if (usernameEqual && passwordEqual) {
+                    await next();
+                    return;
+                }
+            }
+        }
+        ctx.res = new Response('Unauthorized', {
+            status: 401,
+            headers: {
+                'WWW-Authenticate': 'Basic realm="' + options.realm?.replace(/"/g, '\\"') + '"',
+            },
+        });
+        await next();
+    };
+};
+exports.basicAuth = basicAuth;

package/dist/cjs/middleware/bearer-auth/index.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bearerAuth = void 0;
+const buffer_1 = require("../../utils/buffer");
+const TOKEN_STRINGS = '[A-Za-z0-9._~+/-]+=*';
+const PREFIX = 'Bearer';
+const bearerAuth = (options) => {
+    if (!options.token) {
+        throw new Error('bearer auth middleware requires options for "token"');
+    }
+    if (!options.realm) {
+        options.realm = '';
+    }
+    if (!options.prefix) {
+        options.prefix = PREFIX;
+    }
+    const realm = options.realm?.replace(/"/g, '\\"');
+    return async (c, next) => {
+        const headerToken = c.req.headers.get('Authorization');
+        if (!headerToken) {
+            // No Authorization header
+            c.res = new Response('Unauthorized', {
+                status: 401,
+                headers: {
+                    'WWW-Authenticate': `${options.prefix} realm="` + realm + '"',
+                },
+            });
+        }
+        else {
+            const regexp = new RegExp('^' + options.prefix + ' +(' + TOKEN_STRINGS + ') *$');
+            const match = regexp.exec(headerToken);
+            if (!match) {
+                // Invalid Request
+                c.res = new Response('Bad Request', {
+                    status: 400,
+                    headers: {
+                        'WWW-Authenticate': `${options.prefix} error="invalid_request"`,
+                    },
+                });
+            }
+            else {
+                const equal = await (0, buffer_1.timingSafeEqual)(options.token, match[1], options.hashFunction);
+                if (!equal) {
+                    // Invalid Token
+                    c.res = new Response('Unauthorized', {
+                        status: 401,
+                        headers: {
+                            'WWW-Authenticate': `${options.prefix} error="invalid_token"`,
+                        },
+                    });
+                }
+            }
+        }
+        await next();
+    };
+};
+exports.bearerAuth = bearerAuth;

package/dist/cjs/middleware/cache/index.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cache = void 0;
+const cache = (options) => {
+    if (options.wait === undefined) {
+        options.wait = false;
+    }
+    const addHeader = (response) => {
+        if (options.cacheControl)
+            response.headers.append('Cache-Control', options.cacheControl);
+    };
+    return async (c, next) => {
+        const key = c.req;
+        const cache = await caches.open(options.cacheName);
+        const response = await cache.match(key);
+        if (!response) {
+            await next();
+            addHeader(c.res);
+            const response = c.res.clone();
+            if (options.wait) {
+                await cache.put(key, response);
+            }
+            else {
+                c.executionCtx.waitUntil(cache.put(key, response));
+            }
+        }
+        else {
+            return response;
+        }
+    };
+};
+exports.cache = cache;

package/dist/cjs/middleware/compress/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compress = void 0;
+const compress = (options) => {
+    return async (ctx, next) => {
+        await next();
+        const accepted = ctx.req.headers.get('Accept-Encoding');
+        const pattern = options?.encoding ?? /gzip|deflate/;
+        const match = accepted?.match(pattern);
+        if (!accepted || !match || !ctx.res.body) {
+            return;
+        }
+        const encoding = match[0];
+        const stream = new CompressionStream(encoding);
+        ctx.res = new Response(ctx.res.body.pipeThrough(stream), ctx.res.clone());
+        ctx.res.headers.set('Content-Encoding', encoding);
+    };
+};
+exports.compress = compress;

package/dist/cjs/middleware/cors/index.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cors = void 0;
+const cors = (options) => {
+    const defaults = {
+        origin: '*',
+        allowMethods: ['GET', 'HEAD', 'PUT', 'POST', 'DELETE', 'PATCH'],
+        allowHeaders: [],
+        exposeHeaders: [],
+    };
+    const opts = {
+        ...defaults,
+        ...options,
+    };
+    const findAllowOrigin = ((optsOrigin) => {
+        if (typeof optsOrigin === 'string') {
+            return () => optsOrigin;
+        }
+        else if (typeof optsOrigin === 'function') {
+            return optsOrigin;
+        }
+        else {
+            return (origin) => (optsOrigin.includes(origin) ? origin : optsOrigin[0]);
+        }
+    })(opts.origin);
+    return async (c, next) => {
+        await next();
+        function set(key, value) {
+            c.res.headers.append(key, value);
+        }
+        const allowOrigin = findAllowOrigin(c.req.headers.get('origin') || '');
+        if (allowOrigin) {
+            set('Access-Control-Allow-Origin', allowOrigin);
+        }
+        // Suppose the server sends a response with an Access-Control-Allow-Origin value with an explicit origin (rather than the "*" wildcard).
+        // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Origin
+        if (opts.origin !== '*') {
+            set('Vary', 'Origin');
+        }
+        if (opts.credentials) {
+            set('Access-Control-Allow-Credentials', 'true');
+        }
+        if (opts.exposeHeaders?.length) {
+            set('Access-Control-Expose-Headers', opts.exposeHeaders.join(','));
+        }
+        if (c.req.method === 'OPTIONS') {
+            // Preflight
+            if (opts.maxAge != null) {
+                set('Access-Control-Max-Age', opts.maxAge.toString());
+            }
+            if (opts.allowMethods?.length) {
+                set('Access-Control-Allow-Methods', opts.allowMethods.join(','));
+            }
+            let headers = opts.allowHeaders;
+            if (!headers?.length) {
+                const requestHeaders = c.req.headers.get('Access-Control-Request-Headers');
+                if (requestHeaders) {
+                    headers = requestHeaders.split(/\s*,\s*/);
+                }
+            }
+            if (headers?.length) {
+                set('Access-Control-Allow-Headers', headers.join(','));
+                set('Vary', 'Access-Control-Request-Headers');
+            }
+            c.res.headers.delete('Content-Length');
+            c.res.headers.delete('Content-Type');
+            c.res = new Response(null, {
+                headers: c.res.headers,
+                status: 204,
+                statusText: c.res.statusText,
+            });
+        }
+    };
+};
+exports.cors = cors;

package/dist/cjs/middleware/etag/index.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.etag = void 0;
+const crypto_1 = require("../../utils/crypto");
+const etag = (options = { weak: false }) => {
+    return async (c, next) => {
+        const ifNoneMatch = c.req.header('If-None-Match') || c.req.header('if-none-match');
+        await next();
+        const res = c.res;
+        const clone = res.clone();
+        const hash = await (0, crypto_1.sha1)(res.body || '');
+        const etag = options.weak ? `W/"${hash}"` : `"${hash}"`;
+        if (ifNoneMatch && ifNoneMatch === etag) {
+            await clone.blob(); // Force using body
+            c.res = new Response(null, {
+                status: 304,
+                statusText: 'Not Modified',
+            });
+            c.res.headers.delete('Content-Length');
+        }
+        else {
+            c.res = new Response(clone.body, clone);
+            c.res.headers.append('ETag', etag);
+        }
+    };
+};
+exports.etag = etag;