hono 0.5.9 → 1.1.0

package/README.md

@@ -1,20 +1,26 @@
-# Hono\[炎\]
+<div align="center">
+  <a href="https://github.com/honojs/hono">
+    <img src="https://raw.githubusercontent.com/honojs/hono/master/docs/images/hono-title.png" width="500" height="auto" alt="Hono"/>
+  </a>
+</div>
+
+<hr />
 
 <p>
-<a href="https://github.com/yusukebe/hono/blob/master/README.md">English</a>
+<a href="https://github.com/honojs/hono/blob/master/README.md">English</a>
 &#x000B7;
-<a href="https://github.com/yusukebe/hono/blob/master/docs/README.ja.md">日本語</a>
+<a href="https://github.com/honojs/hono/blob/master/docs/README.ja.md">日本語</a>
 </p>
 
-[![GitHub Workflow Status](https://img.shields.io/github/workflow/status/yusukebe/hono/ci)](https://github.com/yusukebe/hono/actions)
-[![GitHub](https://img.shields.io/github/license/yusukebe/hono)](https://github.com/yusukebe/hono/blob/master/LICENSE)
+[![GitHub Workflow Status](https://img.shields.io/github/workflow/status/honojs/hono/ci)](https://github.com/honojs/hono/actions)
+[![GitHub](https://img.shields.io/github/license/honojs/hono)](https://github.com/honojs/hono/blob/master/LICENSE)
 [![npm](https://img.shields.io/npm/v/hono)](https://www.npmjs.com/package/hono)
 [![npm](https://img.shields.io/npm/dm/hono)](https://www.npmjs.com/package/hono)
 [![npm type definitions](https://img.shields.io/npm/types/hono)](https://www.npmjs.com/package/hono)
-[![GitHub commit activity](https://img.shields.io/github/commit-activity/m/yusukebe/hono)](https://github.com/yusukebe/hono/pulse)
-[![GitHub last commit](https://img.shields.io/github/last-commit/yusukebe/hono)](https://github.com/yusukebe/hono/commits/master)
+[![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/master)
 
-Hono[炎] - _**means flame🔥 in Japanese**_ - is small, simple, and ultrafast web framework for Cloudflare Workers and Fastly Compute@Edge.
+Hono - _**[炎] means flame🔥 in Japanese**_ - is a small, simple, and ultrafast web framework for Cloudflare Workers and Service Worker based serverless such as Fastly Compute@Edge.
 
 ```js
 import { Hono } from 'hono'
@@ -30,7 +36,8 @@ app.fire()
 - **Ultrafast** - the router does not use linear loops.
 - **Zero-dependencies** - using only Service Worker and Web standard API.
 - **Middleware** - built-in middleware and ability to extend with your own middleware.
-- **Optimized** - for Cloudflare Workers.
+- **TypeScript** - first-class TypeScript support.
+- **Optimized** - for Cloudflare Workers and Fastly Compute@Edge.
 
 ## Benchmark
 
@@ -51,7 +58,42 @@ A demonstration to create an application for Cloudflare Workers with Hono.
 
 ![Demo](https://user-images.githubusercontent.com/10682/151973526-342644f9-71c5-4fee-81f4-64a7558bb192.gif)
 
-Now, the named path parameter has types.
+## Not only fast
+
+Hono is fast. But not only fast.
+
+### Write Less, do more
+
+Built-in middleware make _"**Write Less, do more**"_ in reality. You can use a lot of middleware without writing code from scratch. Below are examples.
+
+- [Basic Authentication](https://github.com/honojs/hono/tree/master/src/middleware/basic-auth/)
+- [Cookie parsing / serializing](https://github.com/honojs/hono/tree/master/src/middleware/cookie/)
+- [CORS](https://github.com/honojs/hono/tree/master/src/middleware/cors/)
+- [ETag](https://github.com/honojs/hono/tree/master/src/middleware/etag/)
+- [GraphQL Server](https://github.com/honojs/hono/tree/master/src/middleware/graphql-server/)
+- [JWT Authentication](https://github.com/honojs/hono/tree/master/src/middleware/jwt/)
+- [Logger](https://github.com/honojs/hono/tree/master/src/middleware/logger/)
+- [Mustache template engine](https://github.com/honojs/hono/tree/master/src/middleware/mustache/) (Only for Cloudflare Workers)
+- [JSON pretty printing](https://github.com/honojs/hono/tree/master/src/middleware/pretty-json/)
+- [Serving static files](https://github.com/honojs/hono/tree/master/src/middleware/serve-static/) (Only for Cloudflare Workers)
+
+You can enable logger and CORS middleware with just this code.
+
+```js
+import { Hono } from 'hono'
+import { cors } from 'hono/cors'
+import { logger } from 'hono/logger'
+
+const app = new Hono()
+app.use('*', cors()).use(logger())
+```
+
+### Developer Experience
+
+And Hono provides fine _"**Developer Experience**"_. Easy access to Request/Response thanks to the `Context` object.
+Above all, Hono is written in TypeScript. So, Hono has _"**Types**"_!
+
+For example, the named path parameters will be literal types.
 
 ![Demo](https://user-images.githubusercontent.com/10682/154179671-9e491597-6778-44ac-a8e6-4483d7ad5393.png)
 
@@ -59,24 +101,24 @@ Now, the named path parameter has types.
 
 You can install Hono from the npm registry.
 
-```
-$ yarn add hono
+```sh
+yarn add hono
 ```
 
 or
 
-```
-$ npm install hono
+```sh
+npm install hono
 ```
 
 ## Methods
 
 An instance of `Hono` has these methods.
 
-- app.**HTTP_METHOD**(path, handler)
-- app.**all**(path, handler)
+- app.**HTTP_METHOD**(\[path,\] handler)
+- app.**all**(\[path,\] handler)
 - app.**route**(path)
-- app.**use**(path, middleware)
+- app.**use**(\[path,\] middleware)
 - app.**notFound**(handler)
 - app.**onError**(err, handler)
 - app.**fire**()
@@ -120,6 +162,21 @@ app.get('/post/:date{[0-9]+}/:title{[a-z]+}', (c) => {
 })
 ```
 
+### Chained route
+
+```js
+app
+  .get('/endpoint', (c) => {
+    return c.text('GET /endpoint')
+  })
+  .post((c) => {
+    return c.text('POST /endpoint')
+  })
+  .delete((c) => {
+    return c.text('DELETE /endpoint')
+  })
+```
+
 ### Nested route
 
 ```js
@@ -168,6 +225,9 @@ const app = new Hono()
 
 app.use('*', poweredBy())
 app.use('*', logger())
+// Or you can write:
+// app.use('*', poweredBy()).use(logger())
+
 app.use(
   '/auth/*',
   basicAuth({
@@ -177,7 +237,7 @@ app.use(
 )
 ```
 
-Available built-in middleware is listed on [src/middleware](https://github.com/yusukebe/hono/tree/master/src/middleware).
+Available built-in middleware is listed on [src/middleware](https://github.com/honojs/hono/tree/master/src/middleware).
 
 ### Custom Middleware
 
@@ -412,7 +472,7 @@ Let's write your first code for Cloudflare Workers with Hono.
 **Wrangler 1.x** does not support importing middleware. We recommend two ways:
 
 1. Use [Wragler 2.0 Beta](https://github.com/cloudflare/wrangler2).
-2. Build without webpack 4.x. For example, you can use esbuild. See [the starter template](https://github.com/yusukebe/hono-minimal).
+2. Build without webpack 4.x. For example, you can use esbuild. See [the starter template](https://github.com/honojs/hono-minimal).
 
 ---
 
@@ -420,18 +480,18 @@ Let's write your first code for Cloudflare Workers with Hono.
 
 Make a npm skeleton directory.
 
-```
-$ mkdir hono-example
-$ cd hono-example
-$ npm init -y
+```sh
+mkdir hono-example
+cd hono-example
+npm init -y
 ```
 
 ### 2. `wrangler init`
 
 Initialize as a wrangler project.
 
-```
-$ npx wrangler@beta init
+```sh
+npx wrangler@beta init
 ```
 
 Answer the questions. If you want, you can answer `y`.
@@ -446,8 +506,8 @@ Would you like to create a Worker at src/index.js? (y/n) <--- n
 
 Install `hono` from the npm registry.
 
-```
-$ npm i hono
+```sh
+npm i hono
 ```
 
 ### 4. Write your app
@@ -468,43 +528,47 @@ app.fire()
 
 Run the development server locally. Then, access `http://127.0.0.1:8787/` in your Web browser.
 
-```
-$ npx wrangler@beta dev index.js
+```sh
+npx wrangler@beta dev index.js
 ```
 
 ### 6. Publish
 
 Deploy to Cloudflare. That's all!
 
-```
-$ npx wrangler@beta publish index.js
+```sh
+npx wrangler@beta publish index.js
 ```
 
 ## Starter template
 
-You can start making your Cloudflare Workers application with [the starter template](https://github.com/yusukebe/hono-minimal). It is really minimal using TypeScript, esbuild, and Miniflare.
+You can start making your Cloudflare Workers application with [the starter template](https://github.com/honojs/hono-minimal). It is really minimal using TypeScript, esbuild, Miniflare, and Jest.
 
 To generate a project skelton, run this command.
 
+```sh
+wrangler generate my-app https://github.com/honojs/hono-minimal
 ```
-$ wrangler generate my-app https://github.com/yusukebe/hono-minimal
-```
+
+## Examples
+
+- Hono Examples - <https://github.com/honojs/examples>
 
 ## Related projects
 
 Implementation of the original router `TrieRouter` is inspired by [goblin](https://github.com/bmf-san/goblin). `RegExpRouter` is inspired by [Router::Boom](https://github.com/tokuhirom/Router-Boom). API design is inspired by [express](https://github.com/expressjs/express) and [koa](https://github.com/koajs/koa). [itty-router](https://github.com/kwhitley/itty-router), [Sunder](https://github.com/SunderJS/sunder), and [worktop](https://github.com/lukeed/worktop) are the other routers or frameworks for Cloudflare Workers.
 
-- express <https://github.com/expressjs/express>
-- koa <https://github.com/koajs/koa>
-- itty-router <https://github.com/kwhitley/itty-router>
-- Sunder <https://github.com/SunderJS/sunder>
-- goblin <https://github.com/bmf-san/goblin>
-- worktop <https://github.com/lukeed/worktop>
-- Router::Boom <https://github.com/tokuhirom/Router-Boom>
+- express - <https://github.com/expressjs/express>
+- koa - <https://github.com/koajs/koa>
+- itty-router - <https://github.com/kwhitley/itty-router>
+- Sunder - <https://github.com/SunderJS/sunder>
+- goblin - <https://github.com/bmf-san/goblin>
+- worktop - <https://github.com/lukeed/worktop>
+- Router::Boom - <https://github.com/tokuhirom/Router-Boom>
 
 ## Contributing
 
-Contributions Welcome! You can contribute by the following way.
+Contributions Welcome! You can contribute in the following ways.
 
 - Write or fix documents
 - Write code of middleware
@@ -512,11 +576,9 @@ Contributions Welcome! You can contribute by the following way.
 - Refactor the code
 - etc.
 
-Let's make Hono together!
-
 ## Contributors
 
-Thanks to [all contributors](https://github.com/yusukebe/hono/graphs/contributors)!
+Thanks to [all contributors](https://github.com/honojs/hono/graphs/contributors)!
 
 ## Author
 

package/dist/context.d.ts

@@ -1,17 +1,15 @@
 /// <reference types="@cloudflare/workers-types" />
+import type { StatusCode } from './utils/http-status';
 declare type Headers = Record<string, string>;
 declare type Data = string | ArrayBuffer | ReadableStream;
 export interface Env {
 }
 export declare class Context<RequestParamKeyType = string> {
+    #private;
     req: Request<RequestParamKeyType>;
     res: Response;
     env: Env;
     event: FetchEvent;
-    private _headers;
-    private _status;
-    private _statusText;
-    private _pretty;
     render: (template: string, params?: object, options?: object) => Promise<Response>;
     notFound: () => Response | Promise<Response>;
     constructor(req: Request<RequestParamKeyType>, opts?: {
@@ -19,14 +17,15 @@ export declare class Context<RequestParamKeyType = string> {
         env: Env;
         event: FetchEvent;
     });
+    private initRequest;
     header(name: string, value: string): void;
-    status(number: number): void;
-    pretty(prettyJSON: boolean): void;
+    status(status: StatusCode): void;
+    pretty(prettyJSON: boolean, space?: number): void;
     newResponse(data: Data, init?: ResponseInit): Response;
-    body(data: Data, status?: number, headers?: Headers): Response;
-    text(text: string, status?: number, headers?: Headers): Response;
-    json(object: object, status?: number, headers?: Headers): Response;
-    html(html: string, status?: number, headers?: Headers): Response;
-    redirect(location: string, status?: number): Response;
+    body(data: Data, status?: StatusCode, headers?: Headers): Response;
+    text(text: string, status?: StatusCode, headers?: Headers): Response;
+    json(object: object, status?: StatusCode, headers?: Headers): Response;
+    html(html: string, status?: StatusCode, headers?: Headers): Response;
+    redirect(location: string, status?: StatusCode): Response;
 }
 export {};

package/dist/context.js

@@ -1,82 +1,90 @@
 "use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Context_headers, _Context_status, _Context_statusText, _Context_pretty, _Context_prettySpace;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Context = void 0;
-const url_1 = require("./utils/url");
 const http_status_1 = require("./utils/http-status");
+const url_1 = require("./utils/url");
 class Context {
     constructor(req, opts) {
-        this.req = req;
-        if (opts) {
-            this.res = opts.res;
-            this.env = opts.env;
-            this.event = opts.event;
-        }
-        this._headers = {};
+        _Context_headers.set(this, void 0);
+        _Context_status.set(this, void 0);
+        _Context_statusText.set(this, void 0);
+        _Context_pretty.set(this, void 0);
+        _Context_prettySpace.set(this, 2);
+        this.req = this.initRequest(req);
+        Object.assign(this, opts);
+        __classPrivateFieldSet(this, _Context_headers, {}, "f");
+    }
+    initRequest(req) {
+        req.header = (name) => {
+            return req.headers.get(name);
+        };
+        req.query = (key) => {
+            const url = new URL(req.url);
+            return url.searchParams.get(key);
+        };
+        return req;
     }
     header(name, value) {
-        /*
-        XXX:
-        app.use('*', (c, next) => {
-          next()
-          c.header('foo', 'bar') // => c.res.headers.set(...)
-        })
-        */
         if (this.res) {
             this.res.headers.set(name, value);
         }
-        this._headers[name] = value;
+        __classPrivateFieldGet(this, _Context_headers, "f")[name] = value;
     }
-    status(number) {
+    status(status) {
         if (this.res) {
             console.warn('c.res.status is already set.');
             return;
         }
-        this._status = number;
-        this._statusText = (0, http_status_1.getStatusText)(number);
+        __classPrivateFieldSet(this, _Context_status, status, "f");
+        __classPrivateFieldSet(this, _Context_statusText, (0, http_status_1.getStatusText)(status), "f");
     }
-    pretty(prettyJSON) {
-        this._pretty = prettyJSON;
+    pretty(prettyJSON, space = 2) {
+        __classPrivateFieldSet(this, _Context_pretty, prettyJSON, "f");
+        __classPrivateFieldSet(this, _Context_prettySpace, space, "f");
     }
     newResponse(data, init = {}) {
-        init.status = init.status || this._status || 200;
-        init.statusText = init.statusText || this._statusText || (0, http_status_1.getStatusText)(init.status);
-        init.headers = Object.assign(Object.assign({}, this._headers), init.headers);
-        // Content-Length
-        let length = 0;
-        if (data) {
-            if (data instanceof ArrayBuffer) {
-                length = data.byteLength;
-            }
-            else if (typeof data == 'string') {
-                const Encoder = new TextEncoder();
-                length = Encoder.encode(data).byteLength || 0;
-            }
-        }
-        init.headers = Object.assign(Object.assign({}, init.headers), { 'Content-Length': length.toString() });
+        init.status = init.status || __classPrivateFieldGet(this, _Context_status, "f") || 200;
+        init.statusText =
+            init.statusText || __classPrivateFieldGet(this, _Context_statusText, "f") || (0, http_status_1.getStatusText)(init.status);
+        init.headers = Object.assign(Object.assign({}, __classPrivateFieldGet(this, _Context_headers, "f")), init.headers);
         return new Response(data, init);
     }
-    body(data, status = this._status, headers = this._headers) {
+    body(data, status = __classPrivateFieldGet(this, _Context_status, "f"), headers = __classPrivateFieldGet(this, _Context_headers, "f")) {
         return this.newResponse(data, {
             status: status,
             headers: headers,
         });
     }
-    text(text, status = this._status, headers = {}) {
+    text(text, status = __classPrivateFieldGet(this, _Context_status, "f"), headers = {}) {
         if (typeof text !== 'string') {
             throw new TypeError('text method arg must be a string!');
         }
         headers['Content-Type'] || (headers['Content-Type'] = 'text/plain; charset=UTF-8');
         return this.body(text, status, headers);
     }
-    json(object, status = this._status, headers = {}) {
+    json(object, status = __classPrivateFieldGet(this, _Context_status, "f"), headers = {}) {
         if (typeof object !== 'object') {
-            throw new TypeError('json method arg must be a object!');
+            throw new TypeError('json method arg must be an object!');
         }
-        const body = this._pretty ? JSON.stringify(object, null, 2) : JSON.stringify(object);
+        const body = __classPrivateFieldGet(this, _Context_pretty, "f")
+            ? JSON.stringify(object, null, __classPrivateFieldGet(this, _Context_prettySpace, "f"))
+            : JSON.stringify(object);
         headers['Content-Type'] || (headers['Content-Type'] = 'application/json; charset=UTF-8');
         return this.body(body, status, headers);
     }
-    html(html, status = this._status, headers = {}) {
+    html(html, status = __classPrivateFieldGet(this, _Context_status, "f"), headers = {}) {
         if (typeof html !== 'string') {
             throw new TypeError('html method arg must be a string!');
         }
@@ -101,3 +109,4 @@ class Context {
     }
 }
 exports.Context = Context;
+_Context_headers = new WeakMap(), _Context_status = new WeakMap(), _Context_statusText = new WeakMap(), _Context_pretty = new WeakMap(), _Context_prettySpace = new WeakMap();

package/dist/hono.d.ts

@@ -7,50 +7,48 @@ declare global {
         param: (key: ParamKeyType) => string;
         query: (key: string) => string;
         header: (name: string) => string;
-        parsedBody: any;
     }
 }
-export declare type Handler<RequestParamKeyType = string> = (c: Context<RequestParamKeyType>, next?: Function) => Response | Promise<Response>;
-export declare type MiddlewareHandler = (c: Context, next: Function) => Promise<void>;
+export declare type Handler<RequestParamKeyType = string> = (c: Context<RequestParamKeyType>, next?: Next) => Response | Promise<Response>;
+export declare type MiddlewareHandler = (c: Context, next: Next) => Promise<void>;
 export declare type NotFoundHandler = (c: Context) => Response | Promise<Response>;
 export declare type ErrorHandler = (err: Error, c: Context) => Response;
+export declare type Next = () => Promise<void>;
 declare type ParamKeyName<NameWithPattern> = NameWithPattern extends `${infer Name}{${infer _Pattern}` ? Name : NameWithPattern;
 declare type ParamKey<Component> = Component extends `:${infer NameWithPattern}` ? ParamKeyName<NameWithPattern> : never;
 declare type ParamKeys<Path> = Path extends `${infer Component}/${infer Rest}` ? ParamKey<Component> | ParamKeys<Rest> : ParamKey<Path>;
-export declare class Hono {
-    routerClass: {
+interface HandlerInterface<T extends string> {
+    <Path extends string>(path: Path, handler: Handler<ParamKeys<Path>>): Hono<Path>;
+    <Path extends T>(handler: Handler<ParamKeys<T>>): Hono<Path>;
+}
+declare const Hono_base: new <T extends string>() => {
+    delete: HandlerInterface<T>;
+    get: HandlerInterface<T>;
+    post: HandlerInterface<T>;
+    put: HandlerInterface<T>;
+    head: HandlerInterface<T>;
+    options: HandlerInterface<T>;
+    patch: HandlerInterface<T>;
+    all: HandlerInterface<T>;
+};
+export declare class Hono<P extends string> extends Hono_base<P> {
+    #private;
+    readonly routerClass: {
         new (): Router<any>;
     };
-    strict: boolean;
-    router: Router<Handler>;
-    middlewareRouters: Router<MiddlewareHandler>[];
-    tempPath: string;
-    constructor(init?: Partial<Pick<Hono, 'routerClass' | 'strict'>>);
+    readonly strict: boolean;
+    private path;
+    constructor(init?: Partial<Pick<Hono<P>, 'routerClass' | 'strict'>>);
     private notFoundHandler;
     private errorHandler;
-    get<Path extends string>(path: Path, handler: Handler<ParamKeys<Path>>): Hono;
-    get(path: string, handler: Handler<string>): Hono;
-    post<Path extends string>(path: Path, handler: Handler<ParamKeys<Path>>): Hono;
-    post(path: string, handler: Handler<string>): Hono;
-    put<Path extends string>(path: Path, handler: Handler<ParamKeys<Path>>): Hono;
-    put(path: string, handler: Handler<string>): Hono;
-    head<Path extends string>(path: Path, handler: Handler<ParamKeys<Path>>): Hono;
-    head(path: string, handler: Handler<string>): Hono;
-    delete<Path extends string>(path: Path, handler: Handler<ParamKeys<Path>>): Hono;
-    delete(path: string, handler: Handler<string>): Hono;
-    options<Path extends string>(path: Path, handler: Handler<ParamKeys<Path>>): Hono;
-    options(path: string, handler: Handler<string>): Hono;
-    patch<Path extends string>(path: Path, handler: Handler<ParamKeys<Path>>): Hono;
-    patch(path: string, handler: Handler<string>): Hono;
-    all<Path extends string>(path: Path, handler: Handler<ParamKeys<Path>>): Hono;
-    all(path: string, handler: Handler<string>): Hono;
-    route(path: string): Hono;
-    use(path: string, middleware: MiddlewareHandler): void;
-    onError(handler: ErrorHandler): Hono;
-    notFound(handler: NotFoundHandler): Hono;
+    route(path: string): Hono<P>;
+    use(path: string, middleware: MiddlewareHandler): Hono<P>;
+    use(middleware: MiddlewareHandler): Hono<P>;
+    onError(handler: ErrorHandler): Hono<P>;
+    notFound(handler: NotFoundHandler): Hono<P>;
     private addRoute;
     private matchRoute;
-    dispatch(request: Request, env?: Env, event?: FetchEvent): Promise<Response>;
+    private dispatch;
     handleEvent(event: FetchEvent): Promise<Response>;
     fetch(request: Request, env?: Env, event?: FetchEvent): Promise<Response>;
     request(input: RequestInfo, requestInit?: RequestInit): Promise<Response>;