hono 1.2.1 → 1.3.1

package/README.md

@@ -52,7 +52,7 @@ Fastest is hono - regexp-router
 Routers used in Hono are really smart.
 
 - **TrieRouter**(default) - Implemented with Trie tree structure.
-- **RegExpRouter** - Match routes with one big Regex made before dispatching at once.
+- **RegExpRouter** - Match the route with using one big Regex made before dispatch.
 
 ## Hono in 1 minute
 
@@ -87,22 +87,20 @@ import { etag } from 'hono/etag'
 import { logger } from 'hono/logger'
 
 const app = new Hono()
-app.use('*', etag(), (logger())
+app.use('*', etag(), logger())
 ```
 
 And, the routing of Hono is so flexible. It's easy to construct large web applications.
 
 ```ts
-import { Hono, Route } from 'hono'
-import { cors } from 'hono/cors'
-
-const app = new Hono()
+import { Hono } from 'hono'
+import { basicAuth } from 'hono/basic-auth'
 
-const v1 = new Route()
+const v1 = new Hono()
 v1.get('/posts', (c) => {
   return c.text('list pots')
 })
-  .post('/posts', cors(), (c) => {
+  .post(basicAuth({ username, password }), (c) => {
     return c.text('created!', 201)
   })
   .get('/posts/:id', (c) => {
@@ -110,6 +108,7 @@ v1.get('/posts', (c) => {
     return c.text(`your id is ${id}`)
   })
 
+const app = new Hono()
 app.route('/v1', v1)
 ```
 
@@ -140,7 +139,7 @@ An instance of `Hono` has these methods.
 
 - app.**HTTP_METHOD**(\[path,\] handler|middleware...)
 - app.**all**(\[path,\] handler|middleware...)
-- app.**route**(path, \[Route\])
+- app.**route**(path, \[app\])
 - app.**use**(\[path,\] middleware)
 - app.**notFound**(handler)
 - app.**onError**(err, handler)
@@ -156,6 +155,8 @@ An instance of `Hono` has these methods.
 // HTTP Methods
 app.get('/', (c) => c.text('GET /'))
 app.post('/', (c) => c.text('POST /'))
+app.put('/', (c) => c.text('PUT /'))
+app.delete('/', (c) => c.text('DELETE /'))
 
 // Wildcard
 app.get('/wild/*/card', (c) => {
@@ -175,12 +176,20 @@ app.get('/user/:name', (c) => {
 })
 ```
 
+or all parameters at once:
+
+```ts
+app.get('/posts/:id/comment/:comment_id', (c) => {
+  const { id, comment_id } = c.req.param()
+  ...
+})
+```
+
 ### Regexp
 
 ```ts
 app.get('/post/:date{[0-9]+}/:title{[a-z]+}', (c) => {
-  const date = c.req.param('date')
-  const title = c.req.param('title')
+  const { date, title } = c.req.param()
   ...
 })
 ```
@@ -219,12 +228,12 @@ app.get('/fetch-url', async (c) => {
 })
 ```
 
-## Route
+## Grouping
 
-`Route` object enables Nested route.
+Group the routes with `Hono` instance and add them to the main app with `route` method.
 
 ```ts
-const book = new Route()
+const book = new Hono()
 
 book.get('/', (c) => c.text('List Books')) // GET /book
 book.get('/:id', (c) => {
@@ -234,6 +243,7 @@ book.get('/:id', (c) => {
 })
 book.post('/', (c) => c.text('Create Book')) // POST /book
 
+const app = new Hono()
 app.route('/book', book)
 ```
 
@@ -338,6 +348,12 @@ app.get('/search', (c) => {
   ...
 })
 
+// Get all params at once
+app.get('/search', (c) => {
+  const { q, limit, offset } = c.req.query()
+  ...
+})
+
 // Captured params
 app.get('/entry/:id', (c) => {
   const id = c.req.param('id')
@@ -427,8 +443,8 @@ app.get('/redirect-permanently', (c) => c.redirect('/', 301))
 
 ```ts
 // Response object
-app.use('/', (c, next) => {
-  next()
+app.use('/', async (c, next) => {
+  await next()
   c.res.headers.append('X-Debug', 'Debug message')
 })
 ```
@@ -437,11 +453,11 @@ app.use('/', (c, next) => {
 
 ```ts
 // FetchEvent object
-app.use('*', async (c, next) => {
+app.get('/foo', async (c) => {
   c.event.waitUntil(
-    ...
+    c.env.KV.put(key, data)
   )
-  await next()
+  ...
 })
 ```
 
@@ -559,7 +575,62 @@ To generate a project skelton, run this command.
 npx create-cloudflare my-app https://github.com/honojs/hono-minimal
 ```
 
-## Examples
+## Practical Example
+
+How about writing web API with Hono?
+
+```ts
+import { Hono } from 'hono'
+import { cors } from 'hono/cors'
+import { basicAuth } from 'hono/basic-auth'
+import { prettyJSON } from 'hono/pretty-json'
+import { getPosts, getPosts, createPost } from './model'
+
+const app = new Hono()
+app.get('/', (c) => c.text('Pretty Blog API'))
+app.use('*', prettyJSON())
+app.notFound((c) => c.json({ message: 'Not Found', ok: false }, 404))
+
+export interface Bindings {
+  USERNAME: string
+  PASSWORD: string
+}
+
+const api = new Hono<Bindings>()
+
+api.get('/posts', (c) => {
+  const { limit, offset } = c.req.query()
+  const posts = getPosts({ limit, offset })
+  return c.json({ posts })
+})
+
+api.get('/posts/:id', (c) => {
+  const id = c.req.param('id')
+  const post = getPost({ id })
+  return c.json({ post })
+})
+
+api.post(
+  '/posts',
+  async (c, next) => {
+    const auth = basicAuth({ username: c.env.USERNAME, password: c.env.PASSWORD })
+    await auth(c, next)
+  },
+  async (c) => {
+    const post = await c.req.json<POST>()
+    const ok = createPost({ post })
+    return c.json({ ok })
+  }
+)
+
+app.use('/posts/*', cors())
+
+app.route('/api', api)
+
+export default app
+```
+
+## Other Examples
 
 - Hono Examples - <https://github.com/honojs/examples>
 

package/dist/context.d.ts

@@ -3,7 +3,7 @@ import type { StatusCode } from './utils/http-status';
 declare type Headers = Record<string, string>;
 declare type Data = string | ArrayBuffer | ReadableStream;
 export declare type Env = Record<string, any>;
-export declare class Context<RequestParamKeyType = string, E = Env> {
+export declare class Context<RequestParamKeyType extends string = string, E = Env> {
     req: Request<RequestParamKeyType>;
     res: Response;
     env: E;

package/dist/context.js

@@ -16,13 +16,31 @@ class Context {
         Object.assign(this, opts);
     }
     initRequest(req) {
-        req.header = (name) => {
-            return req.headers.get(name);
-        };
-        req.query = (key) => {
+        req.header = ((name) => {
+            if (name) {
+                return req.headers.get(name);
+            }
+            else {
+                const result = {};
+                for (const [key, value] of req.headers) {
+                    result[key] = value;
+                }
+                return result;
+            }
+        });
+        req.query = ((key) => {
             const url = new URL(req.url);
-            return url.searchParams.get(key);
-        };
+            if (key) {
+                return url.searchParams.get(key);
+            }
+            else {
+                const result = {};
+                for (const [key, value] of url.searchParams) {
+                    result[key] = value;
+                }
+                return result;
+            }
+        });
         return req;
     }
     header(name, value) {

package/dist/hono.d.ts

@@ -2,15 +2,23 @@
 import { Context } from './context';
 import type { Env } from './context';
 import type { Router } from './router';
-import { METHOD_NAME_ALL_LOWERCASE } from './router';
 declare global {
-    interface Request<ParamKeyType = string> {
-        param: (key: ParamKeyType) => string;
-        query: (key: string) => string;
-        header: (name: string) => string;
+    interface Request<ParamKeyType extends string = string> {
+        param: {
+            (key: ParamKeyType): string;
+            (): Record<ParamKeyType, string>;
+        };
+        query: {
+            (key: string): string;
+            (): Record<string, string>;
+        };
+        header: {
+            (name: string): string;
+            (): Record<string, string>;
+        };
     }
 }
-export declare type Handler<RequestParamKeyType = string, E = Env> = (c: Context<RequestParamKeyType, E>, next?: Next) => Response | Promise<Response> | void | Promise<void>;
+export declare type Handler<RequestParamKeyType extends string = string, E = Env> = (c: Context<RequestParamKeyType, E>, next: Next) => Response | Promise<Response> | void | Promise<void>;
 export declare type NotFoundHandler<E = Env> = (c: Context<string, E>) => Response;
 export declare type ErrorHandler<E = Env> = (err: Error, c: Context<string, E>) => Response;
 export declare type Next = () => Promise<void>;
@@ -23,29 +31,11 @@ interface HandlerInterface<T extends string, E = Env, U = Hono<E, T>> {
     <Path extends string>(...handlers: Handler<ParamKeys<Path> extends never ? string : ParamKeys<Path>, E>[]): U;
     (...handlers: Handler<string, E>[]): U;
 }
-declare const methods: readonly ["get", "post", "put", "delete", "head", "options", "patch"];
-declare type Methods = typeof methods[number] | typeof METHOD_NAME_ALL_LOWERCASE;
-interface Routing<E extends Env> {
+interface Route<E extends Env> {
     path: string;
-    method: Methods;
+    method: string;
     handler: Handler<string, E>;
 }
-declare const Route_base: new <E_1 extends Env, T extends string, U>() => {
-    delete: HandlerInterface<T, E_1, U>;
-    get: HandlerInterface<T, E_1, U>;
-    all: HandlerInterface<T, E_1, U>;
-    post: HandlerInterface<T, E_1, U>;
-    put: HandlerInterface<T, E_1, U>;
-    head: HandlerInterface<T, E_1, U>;
-    options: HandlerInterface<T, E_1, U>;
-    patch: HandlerInterface<T, E_1, U>;
-};
-export declare class Route<E = Env, P extends string = ''> extends Route_base<E, P, Route<E, P>> {
-    #private;
-    routes: Routing<E>[];
-    constructor();
-    private add;
-}
 declare const Hono_base: new <E_1 extends Env, T extends string, U>() => {
     delete: HandlerInterface<T, E_1, U>;
     get: HandlerInterface<T, E_1, U>;
@@ -56,17 +46,19 @@ declare const Hono_base: new <E_1 extends Env, T extends string, U>() => {
     options: HandlerInterface<T, E_1, U>;
     patch: HandlerInterface<T, E_1, U>;
 };
-export declare class Hono<E = Env, P extends string = ''> extends Hono_base<E, P, Hono<E, P>> {
-    #private;
+export declare class Hono<E = Env, P extends string = '/'> extends Hono_base<E, P, Hono<E, P>> {
     readonly routerClass: {
         new (): Router<any>;
     };
     readonly strict: boolean;
+    private _router;
+    private _tempPath;
     private path;
+    routes: Route<E>[];
     constructor(init?: Partial<Pick<Hono, 'routerClass' | 'strict'>>);
     private notFoundHandler;
     private errorHandler;
-    route(path: string, route?: Route): Hono<E, P>;
+    route(path: string, app?: Hono<any>): Hono<E, P>;
     use(path: string, ...middleware: Handler<string, E>[]): Hono<E, P>;
     use(...middleware: Handler<string, E>[]): Hono<E, P>;
     onError(handler: ErrorHandler<E>): Hono<E, P>;

package/dist/hono.js

@@ -1,18 +1,6 @@
 "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 _Route_path, _Hono_router, _Hono_tempPath;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Hono = exports.Route = void 0;
+exports.Hono = void 0;
 const compose_1 = require("./compose");
 const context_1 = require("./context");
 const router_1 = require("./router");
@@ -24,44 +12,13 @@ function defineDynamicClass() {
     return class {
     };
 }
-class Route extends defineDynamicClass() {
-    constructor() {
-        super();
-        this.routes = [];
-        _Route_path.set(this, '');
-        const allMethods = [...methods, router_2.METHOD_NAME_ALL_LOWERCASE];
-        allMethods.map((method) => {
-            this[method] = (args1, ...args) => {
-                if (typeof args1 === 'string') {
-                    __classPrivateFieldSet(this, _Route_path, args1, "f");
-                }
-                else {
-                    this.add(method, __classPrivateFieldGet(this, _Route_path, "f"), args1);
-                }
-                args.map((handler) => {
-                    if (typeof handler !== 'string') {
-                        this.add(method, __classPrivateFieldGet(this, _Route_path, "f"), handler);
-                    }
-                });
-                return this;
-            };
-        });
-    }
-    add(method, path, handler) {
-        const r = { path: path, method: method, handler: handler };
-        this.routes.push(r);
-        return this;
-    }
-}
-exports.Route = Route;
-_Route_path = new WeakMap();
 class Hono extends defineDynamicClass() {
     constructor(init = {}) {
         super();
         this.routerClass = trie_router_1.TrieRouter;
         this.strict = true; // strict routing - default is true
-        _Hono_router.set(this, void 0);
-        _Hono_tempPath.set(this, void 0);
+        this.path = '/';
+        this.routes = [];
         this.notFoundHandler = (c) => {
             const message = '404 Not Found';
             return c.text(message, 404);
@@ -89,19 +46,17 @@ class Hono extends defineDynamicClass() {
             };
         });
         Object.assign(this, init);
-        __classPrivateFieldSet(this, _Hono_router, new this.routerClass(), "f");
-        __classPrivateFieldSet(this, _Hono_tempPath, null, "f");
+        this._router = new this.routerClass();
+        this._tempPath = null;
     }
-    route(path, route) {
-        const newHono = new Hono();
-        __classPrivateFieldSet(newHono, _Hono_tempPath, path, "f");
-        __classPrivateFieldSet(newHono, _Hono_router, __classPrivateFieldGet(this, _Hono_router, "f"), "f");
-        if (route) {
-            route.routes.map((r) => {
-                newHono.addRoute(r.method, r.path, r.handler);
+    route(path, app) {
+        this._tempPath = path;
+        if (app) {
+            app.routes.map((r) => {
+                this.addRoute(r.method, r.path, r.handler);
             });
         }
-        return newHono;
+        return this;
     }
     use(arg1, ...handlers) {
         if (typeof arg1 === 'string') {
@@ -125,22 +80,30 @@ class Hono extends defineDynamicClass() {
     }
     addRoute(method, path, handler) {
         method = method.toUpperCase();
-        if (__classPrivateFieldGet(this, _Hono_tempPath, "f")) {
-            path = (0, url_1.mergePath)(__classPrivateFieldGet(this, _Hono_tempPath, "f"), path);
+        if (this._tempPath) {
+            path = (0, url_1.mergePath)(this._tempPath, path);
         }
-        __classPrivateFieldGet(this, _Hono_router, "f").add(method, path, handler);
+        this._router.add(method, path, handler);
+        const r = { path: path, method: method, handler: handler };
+        this.routes.push(r);
     }
     async matchRoute(method, path) {
-        return __classPrivateFieldGet(this, _Hono_router, "f").match(method, path);
+        return this._router.match(method, path);
     }
     async dispatch(request, event, env) {
         const path = (0, url_1.getPathFromURL)(request.url, { strict: this.strict });
         const method = request.method;
         const result = await this.matchRoute(method, path);
-        request.param = (key) => {
-            if (result)
-                return result.params[key];
-        };
+        request.param = ((key) => {
+            if (result) {
+                if (key) {
+                    return result.params[key];
+                }
+                else {
+                    return result.params;
+                }
+            }
+        });
         const handlers = result ? result.handlers : [this.notFoundHandler];
         const c = new context_1.Context(request, { env: env, event: event, res: undefined });
         c.notFound = () => this.notFoundHandler(c);
@@ -175,4 +138,3 @@ class Hono extends defineDynamicClass() {
     }
 }
 exports.Hono = Hono;
-_Hono_router = new WeakMap(), _Hono_tempPath = new WeakMap();

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { Hono, Route } from './hono';
+export { Hono } from './hono';
 export type { Handler, Next } from './hono';
 export { Context } from './context';
 export type { Env } from './context';

package/dist/index.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Context = exports.Route = exports.Hono = void 0;
+exports.Context = exports.Hono = void 0;
 var hono_1 = require("./hono");
 Object.defineProperty(exports, "Hono", { enumerable: true, get: function () { return hono_1.Hono; } });
-Object.defineProperty(exports, "Route", { enumerable: true, get: function () { return hono_1.Route; } });
 var context_1 = require("./context");
 Object.defineProperty(exports, "Context", { enumerable: true, get: function () { return context_1.Context; } });

package/dist/middleware/cookie/index.d.ts

@@ -2,10 +2,13 @@ import type { Context } from '../../context';
 import type { Next } from '../../hono';
 declare global {
     interface Request {
-        cookie: (name: string) => string;
+        cookie: {
+            (name: string): string;
+            (): Record<string, string>;
+        };
     }
 }
-declare module '@/context' {
+declare module '../../context' {
     interface Context {
         cookie: (name: string, value: string, options?: CookieOptions) => void;
     }

package/dist/middleware/cookie/index.js

@@ -3,12 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.cookie = void 0;
 const cookie = () => {
     return async (c, next) => {
-        c.req.cookie = (name) => {
+        c.req.cookie = ((name) => {
             const cookie = c.req.headers.get('Cookie');
             const obj = parse(cookie);
-            const value = obj[name];
-            return value;
-        };
+            if (name) {
+                const value = obj[name];
+                return value;
+            }
+            else {
+                return obj;
+            }
+        });
         c.cookie = (name, value, opt) => {
             const cookie = serialize(name, value, opt);
             c.header('Set-Cookie', cookie);

package/dist/middleware/graphql-server/index.js

@@ -4,7 +4,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.errorMessages = exports.getGraphQLParams = exports.graphqlServer = void 0;
 const graphql_1 = require("graphql");
-const parse_body_1 = require("../../middleware/graphql-server/parse-body");
+const parse_body_1 = require("./parse-body");
 const graphqlServer = (options) => {
     var _a, _b;
     const schema = options.schema;

package/dist/router/reg-exp-router/index.d.ts

@@ -1 +1 @@
-export { RegExpRouter } from '../../router/reg-exp-router/router';
+export { RegExpRouter } from './router';

package/dist/router/reg-exp-router/index.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RegExpRouter = void 0;
-var router_1 = require("../../router/reg-exp-router/router");
+var router_1 = require("./router");
 Object.defineProperty(exports, "RegExpRouter", { enumerable: true, get: function () { return router_1.RegExpRouter; } });

package/dist/router/reg-exp-router/router.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RegExpRouter = void 0;
 const router_1 = require("../../router");
-const trie_1 = require("../../router/reg-exp-router/trie");
+const trie_1 = require("./trie");
 const emptyParam = {};
 const nullMatcher = [/^$/, []];
 function initHint(path) {

package/dist/router/reg-exp-router/trie.d.ts

@@ -1,6 +1,6 @@
-import type { ParamMap, Context } from '../../router/reg-exp-router/node';
-import { Node } from '../../router/reg-exp-router/node';
-export type { ParamMap } from '../../router/reg-exp-router/node';
+import type { ParamMap, Context } from './node';
+import { Node } from './node';
+export type { ParamMap } from './node';
 export declare type ReplacementMap = number[];
 interface InitOptions {
     reverse: boolean;

package/dist/router/reg-exp-router/trie.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Trie = void 0;
-const node_1 = require("../../router/reg-exp-router/node");
+const node_1 = require("./node");
 class Trie {
     constructor({ reverse } = { reverse: false }) {
         this.context = { varIndex: 0 };

package/dist/router/trie-router/index.d.ts

@@ -1 +1 @@
-export { TrieRouter } from '../../router/trie-router/router';
+export { TrieRouter } from './router';

package/dist/router/trie-router/index.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TrieRouter = void 0;
-var router_1 = require("../../router/trie-router/router");
+var router_1 = require("./router");
 Object.defineProperty(exports, "TrieRouter", { enumerable: true, get: function () { return router_1.TrieRouter; } });

package/dist/router/trie-router/router.d.ts

@@ -1,6 +1,6 @@
 import { Router } from '../../router';
 import type { Result } from '../../router';
-import { Node } from '../../router/trie-router/node';
+import { Node } from './node';
 export declare class TrieRouter<T> extends Router<T> {
     node: Node<T>;
     constructor();

package/dist/router/trie-router/router.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TrieRouter = void 0;
 const router_1 = require("../../router");
-const node_1 = require("../../router/trie-router/node");
+const node_1 = require("./node");
 class TrieRouter extends router_1.Router {
     constructor() {
         super();

package/dist/utils/buffer.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.bufferToString = exports.timingSafeEqual = exports.equal = void 0;
-const crypto_1 = require("../utils/crypto");
+const crypto_1 = require("./crypto");
 const equal = (a, b) => {
     if (a === b) {
         return true;

package/dist/utils/url.js

@@ -75,6 +75,10 @@ const mergePath = (...paths) => {
         else if (path !== '/') {
             p = `${p}${path}`;
         }
+        /* ['/', '/'] => `/` */
+        if (path === '/' && p === '') {
+            p = '/';
+        }
     }
     return p;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "1.2.1",
+  "version": "1.3.1",
   "description": "Ultrafast web framework for Cloudflare Workers.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -11,8 +11,8 @@
     "test": "jest",
     "lint": "eslint --ext js,ts src .eslintrc.js",
     "lint:fix": "eslint --ext js,ts src .eslintrc.js --fix",
-    "build": "rimraf dist && tsc --project tsconfig.build.json && tsc-alias -p tsconfig.build.json",
-    "watch": "tsc -w --project tsconfig.build.json & tsc-alias -w -p tsconfig.build.json",
+    "build": "rimraf dist && tsc --project tsconfig.build.json",
+    "watch": "tsc --project tsconfig.build.json -w",
     "prepublishOnly": "yarn build"
   },
   "exports": {
@@ -131,7 +131,6 @@
     "prettier-plugin-md-nocjsp": "^1.2.0",
     "rimraf": "^3.0.2",
     "ts-jest": "^27.1.4",
-    "tsc-alias": "^1.6.7",
     "typescript": "^4.6.3"
   },
   "engines": {