hono 0.4.1 → 0.5.1

package/README.md

@@ -1,6 +1,14 @@
 # Hono
 
-Hono[炎] - _**means flame🔥 in Japanese**_ - is small, simple, and ultrafast web framework for a Service Workers API based serverless such as Cloudflare Workers and Fastly Compute@Edge.
+[![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)
+[![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)
+
+Hono[炎] - _**means flame🔥 in Japanese**_ - is small, simple, and ultrafast web framework for Service Worker based serverless applications like Cloudflare Workers and Fastly Compute@Edge.
 
 ```js
 import { Hono } from 'hono'
@@ -13,9 +21,9 @@ app.fire()
 
 ## Features
 
-- **Ultra fast** - the router is implemented with Trie-Tree structure. Not use loops.
-- **Zero dependencies** - using only Web standard API.
-- **Middleware** - builtin middleware, and you can make your own middleware.
+- **Ultrafast** - the router does not use linear loops.
+- **Zero-dependencies** - using only Web standard API.
+- **Middleware** - builtin middleware and your own middleware.
 - **Optimized** - for Cloudflare Workers.
 
 ## Benchmark
@@ -23,17 +31,17 @@ app.fire()
 **Hono is fastest** compared to other routers for Cloudflare Workers.
 
 ```plain
-hono x 779,197 ops/sec ±6.55% (78 runs sampled)
-itty-router x 161,813 ops/sec ±3.87% (87 runs sampled)
-sunder x 334,096 ops/sec ±1.33% (93 runs sampled)
-worktop x 212,661 ops/sec ±4.40% (81 runs sampled)
+hono x 809,503 ops/sec ±6.94% (73 runs sampled)
+itty-router x 157,310 ops/sec ±4.31% (87 runs sampled)
+sunder x 328,350 ops/sec ±2.30% (95 runs sampled)
+worktop x 209,758 ops/sec ±4.28% (83 runs sampled)
 Fastest is hono
-✨  Done in 58.29s.
+✨  Done in 60.66s.
 ```
 
 ## Hono in 1 minute
 
-Below is a demonstration to create an application of Cloudflare Workers with Hono.
+A demonstration to create an application of Cloudflare Workers with Hono.
 
 ![Demo](https://user-images.githubusercontent.com/10682/151973526-342644f9-71c5-4fee-81f4-64a7558bb192.gif)
 
@@ -43,26 +51,28 @@ Now, the named path parameter has types.
 
 ## Install
 
-You can install Hono from npm registry:
+You can install Hono from the npm registry.
 
 ```sh
-yarn add hono
+$ yarn add hono
 ```
 
 or
 
 ```sh
-npm install hono
+$ npm install hono
 ```
 
 ## Methods
 
-An instance of `Hono` has these methods:
+An instance of `Hono` has these methods.
 
 - app.**HTTP_METHOD**(path, handler)
 - app.**all**(path, handler)
 - app.**route**(path)
 - app.**use**(path, middleware)
+- app.**notFound**(handler)
+- app.**onError**(err, handler)
 - app.**fire**()
 - app.**fetch**(request, env, event)
 
@@ -70,8 +80,6 @@ An instance of `Hono` has these methods:
 
 ### Basic
 
-`app.HTTP_METHOD`
-
 ```js
 // HTTP Methods
 app.get('/', (c) => c.text('GET /'))
@@ -81,11 +89,7 @@ app.post('/', (c) => c.text('POST /'))
 app.get('/wild/*/card', (c) => {
   return c.text('GET /wild/*/card')
 })
-```
 
-`app.all`
-
-```js
 // Any HTTP methods
 app.all('/hello', (c) => c.text('Any Method /hello'))
 ```
@@ -106,33 +110,32 @@ app.get('/post/:date{[0-9]+}/:title{[a-z]+}', (c) => {
   const date = c.req.param('date')
   const title = c.req.param('title')
   ...
+})
 ```
 
 ### Nested route
 
 ```js
 const book = app.route('/book')
-book.get('/', (c) => c.text('List Books')) // => GET /book
+book.get('/', (c) => c.text('List Books')) // GET /book
 book.get('/:id', (c) => {
-  // => GET /book/:id
+  // GET /book/:id
   const id = c.req.param('id')
   return c.text('Get Book: ' + id)
 })
-book.post('/', (c) => c.text('Create Book')) // => POST /book
+book.post('/', (c) => c.text('Create Book')) // POST /book
 ```
 
 ### no strict
 
-If `strict` is set `false`, `/hello`and`/hello/` are treated the same:
+If `strict` is set false, `/hello`and`/hello/` are treated the same.
 
 ```js
-const app = new Hono({ strict: false })
+const app = new Hono({ strict: false }) // Default is true
 
 app.get('/hello', (c) => c.text('/hello or /hello/'))
 ```
 
-Default is `true`.
-
 ### async/await
 
 ```js
@@ -156,14 +159,20 @@ const app = new Hono()
 
 app.use('*', poweredBy())
 app.use('*', logger())
-app.use('/auth/*', basicAuth({ username: 'hono', password: 'acoolproject' }))
+app.use(
+  '/auth/*',
+  basicAuth({
+    username: 'hono',
+    password: 'acoolproject',
+  })
+)
 ```
 
 Available builtin middleware are listed on [src/middleware](https://github.com/yusukebe/hono/tree/master/src/middleware).
 
 ### Custom Middleware
 
-You can write your own middleware:
+You can write your own middleware.
 
 ```js
 // Custom logger
@@ -175,15 +184,36 @@ app.use('*', async (c, next) => {
 // Add a custom header
 app.use('/message/*', async (c, next) => {
   await next()
-  await c.header('x-message', 'This is middleware!')
+  c.header('x-message', 'This is middleware!')
 })
 
 app.get('/message/hello', (c) => c.text('Hello Middleware!'))
 ```
 
+## Not Found
+
+`app.notFound` for customizing Not Found Response.
+
+```js
+app.notFound((c) => {
+  return c.text('Custom 404 Message', 404)
+})
+```
+
+## Error Handling
+
+`app.onError` handle the error and return the customized Response.
+
+```js
+app.onError((err, c) => {
+  console.error(`${err}`)
+  return c.text('Custom Error Message', 500)
+})
+```
+
 ## Context
 
-To handle Request and Reponse, you can use Context object:
+To handle Request and Reponse, you can use Context object.
 
 ### c.req
 
@@ -217,30 +247,33 @@ app.get('/entry/:id', (c) => {
 
 ```js
 app.get('/welcome', (c) => {
+  // Set headers
   c.header('X-Message', 'Hello!')
   c.header('Content-Type', 'text/plain')
+  // Set HTTP status code
   c.status(201)
-
+  // Return the response body
   return c.body('Thank you for comming')
+})
+```
 
-  /*
-  Same as:
-  return new Response('Thank you for comming', {
-    status: 201,
-    statusText: 'Created',
-    headers: {
-      'X-Message': 'Hello',
-      'Content-Type': 'text/plain',
-      'Content-Length: '22'
-    }
-  })
-  */
+The Response is the same as below.
+
+```js
+new Response('Thank you for comming', {
+  status: 201,
+  statusText: 'Created',
+  headers: {
+    'X-Message': 'Hello',
+    'Content-Type': 'text/plain',
+    'Content-Length': '22',
+  },
 })
 ```
 
 ### c.text()
 
-Render text as `Content-Type:text/plain`:
+Render texts as `Content-Type:text/plain`.
 
 ```js
 app.get('/say', (c) => {
@@ -250,7 +283,7 @@ app.get('/say', (c) => {
 
 ### c.json()
 
-Render JSON as `Content-Type:application/json`:
+Render JSON as `Content-Type:application/json`.
 
 ```js
 app.get('/api', (c) => {
@@ -260,7 +293,7 @@ app.get('/api', (c) => {
 
 ### c.html()
 
-Render HTML as `Content-Type:text/html`:
+Render HTML as `Content-Type:text/html`.
 
 ```js
 app.get('/', (c) => {
@@ -270,7 +303,7 @@ app.get('/', (c) => {
 
 ### c.notFound()
 
-Return the default `404 Not Found` Response:
+Return the `404 Not Found` Response.
 
 ```js
 app.get('/notfound', (c) => {
@@ -280,7 +313,7 @@ app.get('/notfound', (c) => {
 
 ### c.redirect()
 
-Redirect, default status code is `302`:
+Redirect, default status code is `302`.
 
 ```js
 app.get('/redirect', (c) => c.redirect('/'))
@@ -319,29 +352,9 @@ app.get('*', async c => {
 })
 ```
 
-## Not Found
-
-If you want, you can set the default `404 Not Found` Response:
-
-```js
-app.notFound = (c) => {
-  return c.text('This is default 404 Not Found', 404)
-}
-```
-
-## Error handling
-
-You can handle errors in your way:
-
-```js
-app.onError = (err, c) => {
-  return c.text(`This is error message: ${err.mssage}`, 500)
-}
-```
-
 ## fire
 
-`app.fire()` do:
+`app.fire()` do this.
 
 ```js
 addEventListener('fetch', (event) => {
@@ -351,7 +364,7 @@ addEventListener('fetch', (event) => {
 
 ## fetch
 
-`app.fetch()` is for Cloudflare Module Worker syntax.
+`app.fetch` for Cloudflare Module Worker syntax.
 
 ```js
 export default {
@@ -361,7 +374,7 @@ export default {
 }
 
 /*
-or just do this:
+or just do:
 export default app
 */
 ```
@@ -374,15 +387,15 @@ Let's write your first code for Cloudflare Workers with Hono.
 
 ### 1. Install Wrangler
 
-Install Cloudflare Command Line "[Wrangler](https://github.com/cloudflare/wrangler)"
+Install Cloudflare Command Line "[Wrangler](https://github.com/cloudflare/wrangler)".
 
 ```sh
-npm i @cloudflare/wrangler -g
+$ npm i @cloudflare/wrangler -g
 ```
 
 ### 2. `npm init`
 
-Make npm skeleton directory.
+Make a npm skeleton directory.
 
 ```sh
 mkdir hono-example
@@ -395,15 +408,15 @@ npm init -y
 Init as a wrangler project.
 
 ```sh
-wrangler init
+$ wrangler init
 ```
 
 ### 4. `npm install hono`
 
-Install `hono` from npm registry.
+Install `hono` from the npm registry.
 
 ```sh
-npm i hono
+$ npm i hono
 ```
 
 ### 5. Write your app
@@ -421,10 +434,10 @@ app.fire()
 
 ### 6. Run
 
-Run the development server locally. Then, access like `http://127.0.0.1:8787/` in your Web browser.
+Run the development server locally. Then, access `http://127.0.0.1:8787/` in your Web browser.
 
 ```sh
-wrangler dev
+$ wrangler dev
 ```
 
 ### 7. Publish
@@ -432,12 +445,22 @@ wrangler dev
 Deploy to Cloudflare. That's all!
 
 ```sh
-wrangler publish
+$ wrangler publish
+```
+
+## Starter template
+
+You can start making your application of Cloudflare Workers with [the starter template](https://github.com/yusukebe/hono-minimal). It is a realy minimal using TypeScript, esbuild, and Miniflare.
+
+To generate a project skelton, run this command.
+
+```
+$ wrangler generate my-app https://github.com/yusukebe/hono-minimal
 ```
 
 ## Related projects
 
-Implementation of the router is inspired by [goblin](https://github.com/bmf-san/goblin). 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.
+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>
@@ -445,10 +468,11 @@ Implementation of the router is inspired by [goblin](https://github.com/bmf-san/
 - 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 by the following way.
 
 - Write or fix documents
 - Write code of middleware
@@ -456,7 +480,7 @@ Contributions Welcome! You can contribute by the following way:
 - Refactor the code
 - etc.
 
-If you can, let's make Hono together!
+Let's make Hono together!
 
 ## Contributors
 

package/dist/compose.d.ts

@@ -1 +1,2 @@
-export declare const compose: <T>(middleware: Function[], onError?: Function) => (context: T, next?: Function) => Promise<void | object>;
+import type { ErrorHandler } from './hono';
+export declare const compose: <C>(middleware: Function[], onError?: ErrorHandler) => (context: C) => Promise<C>;

package/dist/compose.js

@@ -4,33 +4,31 @@ exports.compose = void 0;
 const context_1 = require("./context");
 // Based on the code in the MIT licensed `koa-compose` package.
 const compose = (middleware, onError) => {
-    const errors = [];
-    return function (context, next) {
+    return function (context) {
         let index = -1;
         return dispatch(0);
         async function dispatch(i) {
-            if (i <= index)
-                return Promise.reject(new Error('next() called multiple times'));
-            index = i;
-            let fn = middleware[i];
-            if (i === middleware.length)
-                fn = next;
-            if (!fn)
-                return Promise.resolve();
-            try {
-                return Promise.resolve(fn(context, dispatch.bind(null, i + 1))).catch((e) => {
-                    errors.push(e);
-                    if (onError && context instanceof context_1.Context) {
-                        context.res = onError(errors[0], context);
-                    }
-                    else {
-                        throw errors[0];
-                    }
-                });
+            if (i === middleware.length) {
+                return context;
             }
-            catch (err) {
-                return Promise.reject(err);
+            if (i <= index) {
+                return Promise.reject(new Error('next() called multiple times'));
             }
+            const handler = middleware[i];
+            index = i;
+            return Promise.resolve(handler(context, dispatch.bind(null, i + 1)))
+                .then(() => {
+                return context;
+            })
+                .catch((err) => {
+                if (onError && context instanceof context_1.Context) {
+                    context.res = onError(err, context);
+                    return context;
+                }
+                else {
+                    throw err;
+                }
+            });
         }
     };
 };

package/dist/hono.d.ts

@@ -1,9 +1,7 @@
 /// <reference types="@cloudflare/workers-types" />
-import { Node } from './node';
 import { Context } from './context';
 import type { Env } from './context';
-import type { Result } from './router';
-import { Router } from './router';
+import type { Result, Router } from './router';
 declare global {
     interface Request<ParamKeyType = string> {
         param: (key: ParamKeyType) => string;
@@ -14,15 +12,11 @@ declare global {
 }
 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 NotFoundHandler = (c: Context) => Response;
+export declare type ErrorHandler = (err: Error, c: Context) => Response;
 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 TrieRouter<T> extends Router<T> {
-    node: Node<T>;
-    constructor();
-    add(method: string, path: string, handler: T): void;
-    match(method: string, path: string): Result<T> | null;
-}
 export declare class Hono {
     routerClass: {
         new (): Router<any>;
@@ -32,6 +26,8 @@ export declare class Hono {
     middlewareRouters: Router<MiddlewareHandler>[];
     tempPath: string;
     constructor(init?: Partial<Pick<Hono, 'routerClass' | 'strict'>>);
+    notFoundHandler: NotFoundHandler;
+    errorHandler: ErrorHandler;
     get<Path extends string>(path: Path, handler: Handler<ParamKeys<Path>>): Hono;
     post<Path extends string>(path: Path, handler: Handler<ParamKeys<Path>>): Hono;
     put<Path extends string>(path: Path, handler: Handler<ParamKeys<Path>>): Hono;
@@ -42,13 +38,13 @@ export declare class Hono {
     all<Path extends string>(path: Path, handler: Handler<ParamKeys<Path>>): Hono;
     route(path: string): Hono;
     use(path: string, middleware: MiddlewareHandler): void;
+    onError(handler: ErrorHandler): Hono;
+    notFound(handler: NotFoundHandler): Hono;
     addRoute(method: string, path: string, handler: Handler): Hono;
     matchRoute(method: string, path: string): Promise<Result<Handler>>;
     dispatch(request: Request, env?: Env, event?: FetchEvent): Promise<Response>;
     handleEvent(event: FetchEvent): Promise<Response>;
     fetch(request: Request, env?: Env, event?: FetchEvent): Promise<Response>;
     fire(): void;
-    onError(err: Error, c: Context): Response;
-    notFound(c: Context): Response;
 }
 export {};

package/dist/hono.js

@@ -1,28 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Hono = exports.TrieRouter = void 0;
-const node_1 = require("./node");
+exports.Hono = void 0;
 const compose_1 = require("./compose");
 const url_1 = require("./utils/url");
 const context_1 = require("./context");
 const router_1 = require("./router");
-class TrieRouter extends router_1.Router {
-    constructor() {
-        super();
-        this.node = new node_1.Node();
-    }
-    add(method, path, handler) {
-        this.node.insert(method, path, handler);
-    }
-    match(method, path) {
-        return this.node.search(method, path);
-    }
-}
-exports.TrieRouter = TrieRouter;
+const trie_router_1 = require("./router/trie-router"); // Default Router
 class Hono {
     constructor(init = {}) {
-        this.routerClass = TrieRouter;
+        this.routerClass = trie_router_1.TrieRouter;
         this.strict = true; // strict routing - default is true
+        this.notFoundHandler = (c) => {
+            const message = '404 Not Found';
+            return c.text(message, 404);
+        };
+        this.errorHandler = (err, c) => {
+            console.error(`${err.message}`);
+            const message = 'Internal Server Error';
+            return c.text(message, 500);
+        };
         Object.assign(this, init);
         this.router = new this.routerClass();
         this.middlewareRouters = [];
@@ -66,6 +62,14 @@ class Hono {
         router.add(router_1.METHOD_NAME_OF_ALL, path, middleware);
         this.middlewareRouters.push(router);
     }
+    onError(handler) {
+        this.errorHandler = handler;
+        return this;
+    }
+    notFound(handler) {
+        this.notFoundHandler = handler;
+        return this;
+    }
     // addRoute('get', '/', handler)
     addRoute(method, path, handler) {
         method = method.toUpperCase();
@@ -95,7 +99,7 @@ class Hono {
             const url = new URL(c.req.url);
             return url.searchParams.get(key);
         };
-        const handler = result ? result.handler : this.notFound;
+        const handler = result ? result.handler : this.notFoundHandler;
         const middleware = [];
         for (const mr of this.middlewareRouters) {
             const mwResult = mr.match(router_1.METHOD_NAME_OF_ALL, path);
@@ -112,11 +116,11 @@ class Hono {
             await next();
         };
         middleware.push(wrappedHandler);
-        const composed = (0, compose_1.compose)(middleware, this.onError);
+        const composed = (0, compose_1.compose)(middleware, this.errorHandler);
         const c = new context_1.Context(request, { env: env, event: event, res: null });
-        c.notFound = () => this.notFound(c);
-        await composed(c);
-        return c.res;
+        c.notFound = () => this.notFoundHandler(c);
+        const context = await composed(c);
+        return context.res;
     }
     async handleEvent(event) {
         return this.dispatch(event.request, {}, event);
@@ -129,16 +133,5 @@ class Hono {
             event.respondWith(this.handleEvent(event));
         });
     }
-    // Default error Response
-    onError(err, c) {
-        console.error(`${err.message}`);
-        const message = 'Internal Server Error';
-        return c.text(message, 500);
-    }
-    // Default 404 not found Response
-    notFound(c) {
-        const message = 'Not Found';
-        return c.text(message, 404);
-    }
 }
 exports.Hono = Hono;

package/dist/middleware/basic-auth/basic-auth.d.ts

@@ -3,4 +3,7 @@ export declare const basicAuth: (options: {
     username: string;
     password: string;
     realm?: string;
-}) => (ctx: Context, next: Function) => Promise<any>;
+}, ...users: {
+    username: string;
+    password: string;
+}[]) => (ctx: Context, next: Function) => Promise<any>;

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.basicAuth = void 0;
 const buffer_1 = require("../../utils/buffer");
+const crypto_1 = require("../../utils/crypto");
 const CREDENTIALS_REGEXP = /^ *(?:[Bb][Aa][Ss][Ii][Cc]) +([A-Za-z0-9._~+/-]+=*) *$/;
 const USER_PASS_REGEXP = /^([^:]*):(.*)$/;
 const auth = (req) => {
@@ -18,30 +19,39 @@ const auth = (req) => {
     if (!match) {
         return undefined;
     }
-    const userPass = USER_PASS_REGEXP.exec((0, buffer_1.decodeBase64)(match[1]));
+    const userPass = USER_PASS_REGEXP.exec((0, crypto_1.decodeBase64)(match[1]));
     if (!userPass) {
         return undefined;
     }
     return { username: userPass[1], password: userPass[2] };
 };
-const basicAuth = (options) => {
+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 user = auth(ctx.req);
-        const usernameEqual = user && (await (0, buffer_1.timingSafeEqual)(options.username, user.username));
-        const passwordEqual = user && (await (0, buffer_1.timingSafeEqual)(options.password, user.password));
-        if (!user || !usernameEqual || !passwordEqual) {
-            ctx.res = new Response('Unauthorized', {
-                status: 401,
-                headers: {
-                    'WWW-Authenticate': 'Basic realm="' + options.realm.replace(/"/g, '\\"') + '"',
-                },
-            });
-            return;
+        const requestUser = auth(ctx.req);
+        if (requestUser) {
+            for (const user of users) {
+                const usernameEqual = await (0, buffer_1.timingSafeEqual)(user.username, requestUser.username);
+                const passwordEqual = await (0, buffer_1.timingSafeEqual)(user.password, requestUser.password);
+                if (usernameEqual && passwordEqual) {
+                    // Authorized OK
+                    return next();
+                }
+            }
         }
-        return next();
+        ctx.res = new Response('Unauthorized', {
+            status: 401,
+            headers: {
+                'WWW-Authenticate': 'Basic realm="' + options.realm.replace(/"/g, '\\"') + '"',
+            },
+        });
+        return;
     };
 };
 exports.basicAuth = basicAuth;

package/dist/middleware/body-parse/body-parse.js

@@ -1,26 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.bodyParse = void 0;
+const body_1 = require("../../utils/body");
 const bodyParse = () => {
     return async (ctx, next) => {
-        const contentType = ctx.req.headers.get('Content-Type') || '';
-        if (contentType.includes('application/json')) {
-            ctx.req.parsedBody = await ctx.req.json();
-        }
-        else if (contentType.includes('application/text')) {
-            ctx.req.parsedBody = await ctx.req.text();
-        }
-        else if (contentType.includes('text/html')) {
-            ctx.req.parsedBody = await ctx.req.text();
-        }
-        else if (contentType.includes('form')) {
-            const form = {};
-            const data = [...(await ctx.req.formData())].reduce((acc, cur) => {
-                acc[cur[0]] = cur[1];
-                return acc;
-            }, form);
-            ctx.req.parsedBody = data;
-        }
+        ctx.req.parsedBody = await (0, body_1.parseBody)(ctx.req);
         await next();
     };
 };

package/dist/middleware/etag/etag.d.ts

@@ -0,0 +1,6 @@
+import type { Context } from '../../context';
+declare type ETagOptions = {
+    weak: boolean;
+};
+export declare const etag: (options?: ETagOptions) => (c: Context, next: Function) => Promise<void>;
+export {};

package/dist/middleware/etag/etag.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.etag = void 0;
+const crypto_1 = require("../../utils/crypto");
+const body_1 = require("../../utils/body");
+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 clone = c.res.clone();
+        const body = await (0, body_1.parseBody)(c.res);
+        const hash = await (0, crypto_1.sha1)(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;

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

@@ -1,6 +1,4 @@
-export interface ParamMap {
-    [key: string]: number;
-}
+export declare type ParamMap = Array<[string, number]>;
 export interface Context {
     varIndex: number;
 }

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

@@ -64,7 +64,7 @@ class Node {
                 }
             }
             if (name !== '') {
-                paramMap[name] = node.varIndex;
+                paramMap.push([name, node.varIndex]);
             }
         }
         else {

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

@@ -41,9 +41,8 @@ class RegExpRouter extends router_1.Router {
         const index = match.indexOf('', 1);
         const [handler, paramMap] = handlers[replacementMap[index]];
         const params = {};
-        const keys = Object.keys(paramMap);
-        for (let i = 0; i < keys.length; i++) {
-            params[keys[i]] = match[paramMap[keys[i]]];
+        for (let i = 0; i < paramMap.length; i++) {
+            params[paramMap[i][0]] = match[paramMap[i][1]];
         }
         return new router_1.Result(handler, params);
     }
@@ -68,7 +67,7 @@ class RegExpRouter extends router_1.Router {
             return;
         }
         if (routes.length === 1 && routes[0][0] === '*') {
-            this.matchers[method] = [true, null, [[routes[0][1], {}]]];
+            this.matchers[method] = [true, null, [[routes[0][1], []]]];
             return;
         }
         if (routes.length === 1 && !routes[0][0].match(/:/)) {
@@ -77,7 +76,7 @@ class RegExpRouter extends router_1.Router {
                 ? routes[0][0].replace(/\/\*$/, '(?:$|/)') // /path/to/* => /path/to(?:$|/)
                 : `${routes[0][0]}$`; // /path/to/action => /path/to/action$
             const regExpStr = `^${tmp.replace(/\*/g, '[^/]+')}`; // /prefix/*/path/to => /prefix/[^/]+/path/to
-            this.matchers[method] = [new RegExp(regExpStr), null, [[routes[0][1], {}]]];
+            this.matchers[method] = [new RegExp(regExpStr), null, [[routes[0][1], []]]];
             return;
         }
         for (let i = 0; i < routes.length; i++) {
@@ -87,9 +86,9 @@ class RegExpRouter extends router_1.Router {
         const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
         for (let i = 0; i < handlers.length; i++) {
             const paramMap = handlers[i][1];
-            Object.keys(paramMap).forEach((k) => {
-                paramMap[k] = paramReplacementMap[paramMap[k]];
-            });
+            for (let i = 0; i < paramMap.length; i++) {
+                paramMap[i][1] = paramReplacementMap[paramMap[i][1]];
+            }
         }
         this.matchers[method] = [new RegExp(regexp), indexReplacementMap, handlers];
     }

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

@@ -8,7 +8,7 @@ class Trie {
         this.root = new node_1.Node();
     }
     insert(path, index) {
-        const paramMap = {};
+        const paramMap = [];
         /**
          *  - pattern (:label, :label{0-9]+}, ...)
          *  - /* wildcard

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

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

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

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

package/dist/{node.d.ts → router/trie-router/node.d.ts}

@@ -1,5 +1,5 @@
-import type { Pattern } from './utils/url';
-import { Result } from './router';
+import type { Pattern } from '../../utils/url';
+import { Result } from '../../router';
 export declare class Node<T> {
     method: Record<string, T>;
     handler: T;

package/dist/{node.js → router/trie-router/node.js}

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Node = void 0;
-const url_1 = require("./utils/url");
-const router_1 = require("./router");
+const url_1 = require("../../utils/url");
+const router_1 = require("../../router");
 const noRoute = () => {
     return null;
 };

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

@@ -0,0 +1,9 @@
+import { Router } from '../../router';
+import type { Result } from '../../router';
+import { Node } from './node';
+export declare class TrieRouter<T> extends Router<T> {
+    node: Node<T>;
+    constructor();
+    add(method: string, path: string, handler: T): void;
+    match(method: string, path: string): Result<T> | null;
+}

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrieRouter = void 0;
+const router_1 = require("../../router");
+const node_1 = require("./node");
+class TrieRouter extends router_1.Router {
+    constructor() {
+        super();
+        this.node = new node_1.Node();
+    }
+    add(method, path, handler) {
+        this.node.insert(method, path, handler);
+    }
+    match(method, path) {
+        return this.node.search(method, path);
+    }
+}
+exports.TrieRouter = TrieRouter;

package/dist/utils/body.d.ts

@@ -0,0 +1 @@
+export declare const parseBody: (r: Request | Response) => Promise<string | object | Record<string, string | File>>;

package/dist/utils/body.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBody = void 0;
+const parseBody = async (r) => {
+    const contentType = r.headers.get('Content-Type') || '';
+    if (contentType.includes('application/json')) {
+        return await r.json();
+    }
+    else if (contentType.includes('application/text')) {
+        return r.text();
+    }
+    else if (contentType.startsWith('text')) {
+        return r.text();
+    }
+    else if (contentType.includes('form')) {
+        const form = {};
+        const data = [...(await r.formData())].reduce((acc, cur) => {
+            acc[cur[0]] = cur[1];
+            return acc;
+        }, form);
+        return data;
+    }
+};
+exports.parseBody = parseBody;

package/dist/utils/buffer.d.ts

@@ -1,4 +1,2 @@
 export declare const equal: (a: ArrayBuffer, b: ArrayBuffer) => boolean;
-export declare const decodeBase64: (str: string) => any;
-export declare const sha256: (a: string | object | boolean) => Promise<string>;
 export declare const timingSafeEqual: (a: string | object | boolean, b: string | object | boolean) => Promise<boolean>;

package/dist/utils/buffer.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.timingSafeEqual = exports.sha256 = exports.decodeBase64 = exports.equal = void 0;
+exports.timingSafeEqual = exports.equal = void 0;
+const crypto_1 = require("./crypto");
 const equal = (a, b) => {
     if (a === b) {
         return true;
@@ -19,52 +20,9 @@ const equal = (a, b) => {
     return true;
 };
 exports.equal = equal;
-const decodeBase64 = (str) => {
-    try {
-        const text = atob(str);
-        const length = text.length;
-        const bytes = new Uint8Array(length);
-        for (let i = 0; i < length; i++) {
-            bytes[i] = text.charCodeAt(i);
-        }
-        const decoder = new TextDecoder();
-        return decoder.decode(bytes);
-    }
-    catch (_a) { }
-    try {
-        const { Buffer } = require('buffer');
-        return Buffer.from(str, 'base64').toString();
-    }
-    catch (e) {
-        console.error('If you want to do "decodeBase64", polyfill "buffer" module.');
-        throw e;
-    }
-};
-exports.decodeBase64 = decodeBase64;
-const sha256 = async (a) => {
-    if (crypto && crypto.subtle) {
-        const buffer = await crypto.subtle.digest({
-            name: 'SHA-256',
-        }, new TextEncoder().encode(String(a)));
-        const hash = Array.prototype.map
-            .call(new Uint8Array(buffer), (x) => ('00' + x.toString(16)).slice(-2))
-            .join('');
-        return hash;
-    }
-    try {
-        const crypto = require('crypto');
-        const hash = crypto.createHash('sha256').update(a).digest('hex');
-        return hash;
-    }
-    catch (e) {
-        console.error('If you want to do "sha256", polyfill "crypto" module.');
-        throw e;
-    }
-};
-exports.sha256 = sha256;
 const timingSafeEqual = async (a, b) => {
-    const sa = await (0, exports.sha256)(a);
-    const sb = await (0, exports.sha256)(b);
+    const sa = await (0, crypto_1.sha256)(a);
+    const sb = await (0, crypto_1.sha256)(b);
     return sa === sb && a === b;
 };
 exports.timingSafeEqual = timingSafeEqual;

package/dist/utils/crypto.d.ts

@@ -0,0 +1,10 @@
+declare type Algorithm = {
+    name: string;
+    alias: string;
+};
+declare type Data = string | object | boolean;
+export declare const sha256: (data: Data) => Promise<string>;
+export declare const sha1: (data: Data) => Promise<string>;
+export declare const createHash: (data: Data, algorithm: Algorithm) => Promise<string>;
+export declare const decodeBase64: (str: string) => any;
+export {};

package/dist/utils/crypto.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeBase64 = exports.createHash = exports.sha1 = exports.sha256 = void 0;
+const sha256 = async (data) => {
+    const algorithm = { name: 'SHA-256', alias: 'sha256' };
+    const hash = await (0, exports.createHash)(data, algorithm);
+    return hash;
+};
+exports.sha256 = sha256;
+const sha1 = async (data) => {
+    const algorithm = { name: 'SHA-1', alias: 'sha1' };
+    const hash = await (0, exports.createHash)(data, algorithm);
+    return hash;
+};
+exports.sha1 = sha1;
+const createHash = async (data, algorithm) => {
+    if (crypto && crypto.subtle) {
+        const buffer = await crypto.subtle.digest({
+            name: algorithm.name,
+        }, new TextEncoder().encode(String(data)));
+        const hash = Array.prototype.map
+            .call(new Uint8Array(buffer), (x) => ('00' + x.toString(16)).slice(-2))
+            .join('');
+        return hash;
+    }
+    try {
+        const crypto = require('crypto');
+        const hash = crypto.createHash(algorithm.alias).update(data).digest('hex');
+        return hash;
+    }
+    catch (e) {
+        console.error(`If you want to create hash ${algorithm.name}, polyfill "crypto" module.`);
+        throw e;
+    }
+};
+exports.createHash = createHash;
+const decodeBase64 = (str) => {
+    try {
+        const text = atob(str);
+        const length = text.length;
+        const bytes = new Uint8Array(length);
+        for (let i = 0; i < length; i++) {
+            bytes[i] = text.charCodeAt(i);
+        }
+        const decoder = new TextDecoder();
+        return decoder.decode(bytes);
+    }
+    catch (_a) { }
+    try {
+        const { Buffer } = require('buffer');
+        return Buffer.from(str, 'base64').toString();
+    }
+    catch (e) {
+        console.error('If you want to do "decodeBase64", polyfill "buffer" module.');
+        throw e;
+    }
+};
+exports.decodeBase64 = decodeBase64;

package/dist/utils/mime.js

@@ -4,11 +4,10 @@ exports.getMimeType = void 0;
 const getMimeType = (filename) => {
     const regexp = /\.([a-zA-Z0-9]+?)$/;
     const match = filename.match(regexp);
-    if (!match) {
+    if (!match)
         return;
-    }
     let mimeType = mimes[match[1]];
-    if (mimeType.startsWith('text') || mimeType === 'application/json') {
+    if ((mimeType && mimeType.startsWith('text')) || mimeType === 'application/json') {
         mimeType += '; charset=utf-8';
     }
     return mimeType;
@@ -43,6 +42,7 @@ const mimes = {
     js: 'text/javascript',
     json: 'application/json',
     jsonld: 'application/ld+json',
+    map: 'application/json',
     mid: 'audio/x-midi',
     midi: 'audio/x-midi',
     mjs: 'text/javascript',

package/package.json

@@ -1,12 +1,19 @@
 {
   "name": "hono",
-  "version": "0.4.1",
+  "version": "0.5.1",
   "description": "[炎] Ultrafast web framework for Cloudflare Workers.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
     "dist"
   ],
+  "scripts": {
+    "test": "jest",
+    "lint": "eslint --ext js,ts src .eslintrc.js && prettier --check src",
+    "build": "rimraf dist && tsc",
+    "watch": "tsc -w",
+    "prepublishOnly": "yarn build"
+  },
   "exports": {
     ".": "./dist/index.js",
     "./basic-auth": "./dist/middleware/basic-auth/basic-auth.js",
@@ -17,8 +24,7 @@
     "./mustache": "./dist/middleware/mustache/mustache.js",
     "./powered-by": "./dist/middleware/powered-by/powered-by.js",
     "./serve-static": "./dist/middleware/serve-static/serve-static.js",
-    "./utils/buffer": "./dist/utils/buffer.js",
-    "./package.json": "./package.json"
+    "./router/reg-exp-router": "./dist/router/reg-exp-router/index.js"
   },
   "typesVersions": {
     "*": {
@@ -45,16 +51,12 @@
       ],
       "serve-static": [
         "./dist/middleware/serve-static/serve-static.d.ts"
+      ],
+      "router/reg-exp-router": [
+        "./dist/router/reg-exp-router/router.d.ts"
       ]
     }
   },
-  "scripts": {
-    "test": "jest",
-    "lint": "eslint --ext js,ts src .eslintrc.js test && prettier --check src",
-    "build": "rimraf dist && tsc",
-    "watch": "tsc -w",
-    "prepublishOnly": "yarn build"
-  },
   "author": "Yusuke Wada <yusuke@kamawada.com> (https://github.com/yusukebe)",
   "license": "MIT",
   "repository": {