hono 0.0.12 → 0.0.16

package/README.md

@@ -1,9 +1,9 @@
 # Hono
 
-Hono [炎] - Tiny web framework for Cloudflare Workers and others.
+Hono[炎] - _**means flame🔥 in Japanese**_ - is small, simple, and ultrafast web flamework for a Service Workers API based serverless such as Cloudflare Workers and Fastly Compute@Edge.
 
 ```js
-const { Hono } = require('hono')
+import { Hono } from 'hono'
 const app = new Hono()
 
 app.get('/', (c) => c.text('Hono!!'))
@@ -11,26 +11,24 @@ app.get('/', (c) => c.text('Hono!!'))
 app.fire()
 ```
 
-Hono[炎] - _**means flame🔥 in Japanese**_ - is small, fast and simple web flamework for a Service Workers API based serverless such as **Cloudflare Workers** and **Fastly Compute@Edge**. Hono does not depend on any npm packages. However, Hono has a router, context object, and middleware including the builtins. It's easy to make a web application.
-
 ## Features
 
-- **Fast** - the router is implemented with Trie-Tree structure.
-- **Tiny** - zero dependencies, using Web standard API.
-- **Flexible** - you can make your own middleware.
-- **Easy** - simple API, builtin middleware, and written in TypeScript.
-- **Optimized** - for Cloudflare Workers or Fastly Compute@Edge.
+- **Ultra fast** - the router is implemented with Trie-Tree structure.
+- **Zero dependencies** - using only Web standard API.
+- **Middleware** - builtin middleware, and you can make your own middleware.
+- **Optimized** - for Cloudflare Workers.
 
 ## Benchmark
 
 **Hono is fastest** compared to other routers for Cloudflare Workers.
 
-```
-hono x 758,264 ops/sec ±5.41% (75 runs sampled)
-itty-router x 158,359 ops/sec ±3.21% (89 runs sampled)
-sunder x 297,581 ops/sec ±4.74% (83 runs sampled)
+```plain
+hono x 748,188 ops/sec ±5.40% (77 runs sampled)
+itty-router x 158,817 ops/sec ±3.62% (87 runs sampled)
+sunder x 332,339 ops/sec ±1.11% (95 runs sampled)
+worktop x 205,906 ops/sec ±4.43% (83 runs sampled)
 Fastest is hono
-✨  Done in 42.84s.
+✨  Done in 52.79s.
 ```
 
 ## Hono in 1 minute
@@ -43,14 +41,14 @@ Below is a demonstration to create an application of Cloudflare Workers with Hon
 
 You can install from npm registry:
 
-```
-$ yarn add hono
+```sh
+yarn add hono
 ```
 
 or
 
 ```sh
-$ npm install hono
+npm install hono
 ```
 
 ## Methods
@@ -62,6 +60,7 @@ Instance of `Hono` has these methods:
 - app.**route**(path)
 - app.**use**(path, middleware)
 - app.**fire**()
+- app.**fetch**(request, env, event)
 
 ## Routing
 
@@ -71,12 +70,12 @@ Instance of `Hono` has these methods:
 
 ```js
 // HTTP Methods
-app.get('/', () => new Response('GET /'))
-app.post('/', () => new Response('POST /'))
+app.get('/', (c) => c.text('GET /'))
+app.post('/', (c) => c.text('POST /'))
 
 // Wildcard
-app.get('/wild/*/card', () => {
-  return new Response('GET /wild/*/card')
+app.get('/wild/*/card', (c) => {
+  return c.text('GET /wild/*/card')
 })
 ```
 
@@ -84,7 +83,7 @@ app.get('/wild/*/card', () => {
 
 ```js
 // Any HTTP methods
-app.all('/hello', () => new Response('ALL Method /hello'))
+app.all('/hello', (c) => c.text('Any Method /hello'))
 ```
 
 ### Named Parameter
@@ -118,9 +117,9 @@ app
 ## async/await
 
 ```js
-app.get('/fetch-url', async () => {
+app.get('/fetch-url', async (c) => {
   const response = await fetch('https://example.com/')
-  return new Response(`Status is ${response.status}`)
+  return c.text(`Status is ${response.status}`)
 })
 ```
 
@@ -129,10 +128,12 @@ app.get('/fetch-url', async () => {
 ### Builtin Middleware
 
 ```js
-const { Hono, Middleware } = require('hono')
+import { Hono, Middleware } from 'hono'
 
 ...
 
+app.use('*', Middleware.poweredBy())
+app.use('*', Middleware.logger())
 app.use(
   '/auth/*',
   Middleware.basicAuth({
@@ -161,7 +162,7 @@ app.use('/message/*', async (c, next) => {
   await c.res.headers.add('x-message', 'This is middleware!')
 })
 
-app.get('/message/hello', () => 'Hello Middleware!')
+app.get('/message/hello', (c) => c.text('Hello Middleware!'))
 ```
 
 ### Custom 404 Response
@@ -177,6 +178,19 @@ app.use('*', async (c, next) => {
 })
 ```
 
+### Handling Error
+
+```js
+app.use('*', async (c, next) => {
+  try {
+    await next()
+  } catch (err) {
+    console.error(`${err}`)
+    c.res = new Response('Custom Error Message', { status: 500 })
+  }
+})
+```
+
 ### Complex Pattern
 
 You can also do this:
@@ -235,6 +249,28 @@ app.use('/', (c, next) => {
 })
 ```
 
+### c.event
+
+```js
+// FetchEvent object
+app.use('*', async (c, next) => {
+  c.event.waitUntil(
+    ...
+  )
+  await next()
+})
+```
+
+### c.env
+
+```js
+// Environment object for Cloudflare Workers
+app.get('*', async c => {
+  const counter = c.env.COUNTER
+  ...
+})
+```
+
 ### c.text()
 
 Render text as `Content-Type:text/plain`:
@@ -260,11 +296,20 @@ app.get('/api', (c) => {
 Render HTML as `Content-Type:text/html`:
 
 ```js
-app.get('/api', (c) => {
+app.get('/', (c) => {
   return c.html('<h1>Hello! Hono!</h1>')
 })
 ```
 
+### c.redirect()
+
+Redirect, default status code is `302`:
+
+```js
+app.get('/redirect', (c) => c.redirect('/'))
+app.get('/redirect-permanently', (c) => c.redirect('/', 301))
+```
+
 ## fire
 
 `app.fire()` do:
@@ -275,6 +320,18 @@ addEventListener('fetch', (event) => {
 })
 ```
 
+## fetch
+
+`app.fetch()` is for Cloudflare Module Worker syntax.
+
+```js
+export default {
+  fetch(request: Request, env: Env, event: FetchEvent) {
+    return app.fetch(request, env, event)
+  },
+}
+```
+
 ## Cloudflare Workers with Hono
 
 Using `wrangler` or `miniflare`, you can develop the application locally and publish it with few commands.
@@ -286,7 +343,7 @@ Let's write your first code for Cloudflare Workers with Hono.
 Install Cloudflare Command Line "[Wrangler](https://github.com/cloudflare/wrangler)"
 
 ```sh
-$ npm i @cloudflare/wrangler -g
+npm i @cloudflare/wrangler -g
 ```
 
 ### 2. `npm init`
@@ -294,9 +351,9 @@ $ npm i @cloudflare/wrangler -g
 Make npm skeleton directory.
 
 ```sh
-$ mkdir hono-example
-$ ch hono-example
-$ npm init -y
+mkdir hono-example
+cd hono-example
+npm init -y
 ```
 
 ### 3. `wrangler init`
@@ -304,15 +361,15 @@ $ npm init -y
 Init as a wrangler project.
 
 ```sh
-$ wrangler init
+wrangler init
 ```
 
 ### 4. `npm install hono`
 
 Install `hono` from npm registry.
 
-```
-$ npm i hono
+```sh
+npm i hono
 ```
 
 ### 5. Write your app
@@ -320,7 +377,7 @@ $ npm i hono
 Only 4 lines!!
 
 ```js
-const { Hono } = require('hono')
+import { Hono } from 'hono'
 const app = new Hono()
 
 app.get('/', (c) => c.text('Hello! Hono!'))
@@ -333,7 +390,7 @@ app.fire()
 Run the development server locally. Then, access like `http://127.0.0.1:8787/` in your Web browser.
 
 ```sh
-$ wrangler dev
+wrangler dev
 ```
 
 ### Publish
@@ -341,18 +398,19 @@ $ wrangler dev
 Deploy to Cloudflare. That's all!
 
 ```sh
-$ wrangler publish
+wrangler publish
 ```
 
 ## 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) and [Sunder](https://github.com/SunderJS/sunder) are the other routers or frameworks for Cloudflare Workers.
+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.
 
 - 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>
 
 ## Contributing
 

package/dist/context.d.ts

@@ -1,9 +1,23 @@
+/// <reference types="@cloudflare/workers-types" />
+declare type Headers = {
+    [key: string]: string;
+};
+export interface Env {
+}
 export declare class Context {
     req: Request;
     res: Response;
-    constructor(req: Request, res: Response);
+    env: Env;
+    event: FetchEvent;
+    constructor(req: Request, opts?: {
+        res: Response;
+        env: Env;
+        event: FetchEvent;
+    });
     newResponse(body?: BodyInit | null | undefined, init?: ResponseInit | undefined): Response;
-    text(body: string): Response;
-    json(object: object, replacer?: (string | number)[], space?: string | number): Response;
-    html(body: string): 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;
 }
+export {};

package/dist/context.js

@@ -1,45 +1,63 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Context = void 0;
+const util_1 = require("./util");
 class Context {
-    constructor(req, res) {
+    constructor(req, opts) {
         this.req = req;
-        this.res = res;
+        if (opts) {
+            this.res = opts.res;
+            this.env = opts.env;
+            this.event = opts.event;
+        }
     }
     newResponse(body, init) {
         return new Response(body, init);
     }
-    text(body) {
-        if (typeof body !== 'string') {
+    text(text, status = 200, headers = {}) {
+        if (typeof text !== 'string') {
             throw new TypeError('text method arg must be a string!');
         }
-        return this.newResponse(body, {
-            status: 200,
-            headers: {
-                'Content-Type': 'text/plain',
-            },
+        headers['Content-Type'] = 'text/plain';
+        return this.newResponse(text, {
+            status: status,
+            headers: headers,
         });
     }
-    json(object, replacer, space) {
+    json(object, status = 200, headers = {}) {
         if (typeof object !== 'object') {
             throw new TypeError('json method arg must be a object!');
         }
-        const body = JSON.stringify(object, replacer, space);
+        const body = JSON.stringify(object);
+        headers['Content-Type'] = 'application/json; charset=UTF-8';
         return this.newResponse(body, {
-            status: 200,
-            headers: {
-                'Content-Type': 'application/json; charset=UTF-8',
-            },
+            status: status,
+            headers: headers,
         });
     }
-    html(body) {
-        if (typeof body !== 'string') {
+    html(html, status = 200, headers = {}) {
+        if (typeof html !== 'string') {
             throw new TypeError('html method arg must be a string!');
         }
-        return this.newResponse(body, {
-            status: 200,
+        headers['Content-Type'] = 'text/html; charset=UTF-8';
+        return this.newResponse(html, {
+            status: status,
+            headers: headers,
+        });
+    }
+    redirect(location, status = 302) {
+        if (typeof location !== 'string') {
+            throw new TypeError('location must be a string!');
+        }
+        if (!(0, util_1.isAbsoluteURL)(location)) {
+            const url = new URL(this.req.url);
+            url.pathname = location;
+            location = url.toString();
+        }
+        return this.newResponse(null, {
+            status: status,
             headers: {
-                'Content-Type': 'text/html; charset=UTF-8',
+                Location: location,
             },
         });
     }

package/dist/hono.d.ts

@@ -1,17 +1,17 @@
 /// <reference types="@cloudflare/workers-types" />
 import type { Result } from './node';
 import { Node } from './node';
-import { Middleware } from './middleware';
 import { Context } from './context';
-export { Middleware };
+import type { Env } from './context';
 declare global {
     interface Request {
-        params: (key: string) => any;
+        params: (key: string) => string;
         query: (key: string) => string | null;
+        parsedBody: any;
     }
 }
-declare type Handler = (c: Context, next?: Function) => Response | Promise<Response>;
-declare type MiddlwareHandler = (c: Context, next: Function) => Promise<void>;
+export declare type Handler = (c: Context, next?: Function) => Response | Promise<Response>;
+export declare type MiddlewareHandler = (c: Context, next: Function) => Promise<void>;
 export declare class Router<T> {
     node: Node<T>;
     constructor();
@@ -20,7 +20,7 @@ export declare class Router<T> {
 }
 export declare class Hono {
     router: Router<Handler[]>;
-    middlewareRouters: Router<MiddlwareHandler>[];
+    middlewareRouters: Router<MiddlewareHandler>[];
     tempPath: string;
     constructor();
     get(arg: string | Handler, ...args: Handler[]): Hono;
@@ -32,11 +32,13 @@ export declare class Hono {
     patch(arg: string | Handler, ...args: Handler[]): Hono;
     all(arg: string | Handler, ...args: Handler[]): Hono;
     route(path: string): Hono;
-    use(path: string, middleware: MiddlwareHandler): void;
+    use(path: string, middleware: MiddlewareHandler): void;
     addRoute(method: string, arg: string | Handler, ...args: Handler[]): Hono;
     matchRoute(method: string, path: string): Promise<Result<Handler[]>>;
-    dispatch(request: Request, response?: Response): Promise<Response>;
+    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: any): Response;
     notFound(): Response;
 }

package/dist/hono.js

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Hono = exports.Router = exports.Middleware = void 0;
+exports.Hono = exports.Router = void 0;
 const node_1 = require("./node");
 const compose_1 = require("./compose");
 const util_1 = require("./util");
 const middleware_1 = require("./middleware");
-Object.defineProperty(exports, "Middleware", { enumerable: true, get: function () { return middleware_1.Middleware; } });
 const context_1 = require("./context");
 const METHOD_NAME_OF_ALL = 'ALL';
 class Router {
@@ -94,7 +93,7 @@ class Hono {
     async matchRoute(method, path) {
         return this.router.match(method, path);
     }
-    async dispatch(request, response) {
+    async dispatch(request, env, event) {
         const [method, path] = [request.method, (0, util_1.getPathFromURL)(request.url)];
         const result = await this.matchRoute(method, path);
         request.params = (key) => {
@@ -115,21 +114,32 @@ class Hono {
             context.res = await handler(context);
             await next();
         };
-        middleware.push(middleware_1.Middleware.defaultFilter);
+        middleware.push(middleware_1.Middleware.default);
         middleware.push(wrappedHandler);
         const composed = (0, compose_1.compose)(middleware);
-        const c = new context_1.Context(request, response);
+        const c = new context_1.Context(request, { env: env, event: event, res: null });
         await composed(c);
         return c.res;
     }
     async handleEvent(event) {
-        return this.dispatch(event.request);
+        return this.dispatch(event.request, {}, event).catch((err) => {
+            return this.onError(err);
+        });
+    }
+    async fetch(request, env, event) {
+        return this.dispatch(request, env, event).catch((err) => {
+            return this.onError(err);
+        });
     }
     fire() {
         addEventListener('fetch', (event) => {
             event.respondWith(this.handleEvent(event));
         });
     }
+    onError(err) {
+        console.error(err);
+        return new Response('Internal Server Error', { status: 500 });
+    }
     notFound() {
         return new Response('Not Found', { status: 404 });
     }

package/dist/index.d.ts

@@ -1,2 +1,5 @@
-export { Hono, Middleware } from './hono';
+export { Hono } from './hono';
+export type { Handler, MiddlewareHandler } from './hono';
+export { Middleware } from './middleware';
 export { Context } from './context';
+export type { Env } from './context';

package/dist/index.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Context = exports.Middleware = exports.Hono = void 0;
 var hono_1 = require("./hono");
 Object.defineProperty(exports, "Hono", { enumerable: true, get: function () { return hono_1.Hono; } });
-Object.defineProperty(exports, "Middleware", { enumerable: true, get: function () { return hono_1.Middleware; } });
+var middleware_1 = require("./middleware");
+Object.defineProperty(exports, "Middleware", { enumerable: true, get: function () { return middleware_1.Middleware; } });
 var context_1 = require("./context");
 Object.defineProperty(exports, "Context", { enumerable: true, get: function () { return context_1.Context; } });

package/dist/middleware/body-parse/body-parse.d.ts

@@ -0,0 +1,2 @@
+import type { Context } from '../../context';
+export declare const bodyParse: () => (ctx: Context, next: Function) => Promise<void>;

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bodyParse = void 0;
+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;
+        }
+        await next();
+    };
+};
+exports.bodyParse = bodyParse;

package/dist/middleware/cors/cors.d.ts

@@ -0,0 +1,11 @@
+import type { Context } from '../../context';
+declare type CORSOptions = {
+    origin: string;
+    allowMethods?: string[];
+    allowHeaders?: string[];
+    maxAge?: number;
+    credentials?: boolean;
+    exposeHeaders?: string[];
+};
+export declare const cors: (options?: CORSOptions) => (c: Context, next: Function) => Promise<void>;
+export {};

package/dist/middleware/cors/cors.js

@@ -0,0 +1,56 @@
+"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 = Object.assign(Object.assign({}, defaults), options);
+    return async (c, next) => {
+        await next();
+        function set(key, value) {
+            c.res.headers.append(key, value);
+        }
+        set('Access-Control-Allow-Origin', opts.origin);
+        // 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 = new Response(null, {
+                headers: c.res.headers,
+                status: 204,
+                statusText: c.res.statusText,
+            });
+        }
+    };
+};
+exports.cors = cors;

package/dist/middleware/default.d.ts

@@ -0,0 +1,2 @@
+import type { Context } from '../context';
+export declare const defaultMiddleware: (c: Context, next: Function) => Promise<void>;

package/dist/middleware/default.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultMiddleware = void 0;
+const defaultMiddleware = async (c, next) => {
+    c.req.query = (key) => {
+        // eslint-disable-next-line
+        const url = new URL(c.req.url);
+        return url.searchParams.get(key);
+    };
+    await next();
+    /*
+    TODO:
+    Adding Content-Length header make it more slower.
+    This should not be default middleware...
+    if (c.res.body) {
+      // Do not clone Response, ex: c.res.clone().arrayBuffer()
+      const response = new Response(c.res.body, {
+        status: c.res.status,
+        statusText: c.res.statusText,
+        headers: c.res.headers,
+      })
+      c.res = response
+      const buff = await c.res.clone().arrayBuffer()
+      c.res.headers.append('Content-Length', buff.byteLength.toString())
+    }
+    */
+};
+exports.defaultMiddleware = defaultMiddleware;

package/dist/middleware.d.ts

@@ -1,5 +1,5 @@
 export declare class Middleware {
-    static defaultFilter: (c: import("./context").Context, next: Function) => Promise<void>;
+    static default: (c: import("./context").Context, next: Function) => Promise<void>;
     static poweredBy: () => (c: import("./context").Context, next: Function) => Promise<void>;
     static logger: (fn?: {
         (...data: any[]): void;
@@ -11,4 +11,13 @@ export declare class Middleware {
         password: string;
         realm?: string;
     }) => (ctx: import("./context").Context, next: Function) => Promise<any>;
+    static bodyParse: () => (ctx: import("./context").Context, next: Function) => Promise<void>;
+    static cors: (options?: {
+        origin: string;
+        allowMethods?: string[];
+        allowHeaders?: string[];
+        maxAge?: number;
+        credentials?: boolean;
+        exposeHeaders?: string[];
+    }) => (c: import("./context").Context, next: Function) => Promise<void>;
 }

package/dist/middleware.js

@@ -1,14 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Middleware = void 0;
-const defaultFilter_1 = require("./middleware/defaultFilter");
-const poweredBy_1 = require("./middleware/poweredBy/poweredBy");
+const default_1 = require("./middleware/default");
+const powered_by_1 = require("./middleware/powered-by/powered-by");
 const logger_1 = require("./middleware/logger/logger");
 const basic_auth_1 = require("./middleware/basic-auth/basic-auth");
+const body_parse_1 = require("./middleware/body-parse/body-parse");
+const cors_1 = require("./middleware/cors/cors");
 class Middleware {
 }
 exports.Middleware = Middleware;
-Middleware.defaultFilter = defaultFilter_1.defaultFilter;
-Middleware.poweredBy = poweredBy_1.poweredBy;
+Middleware.default = default_1.defaultMiddleware;
+Middleware.poweredBy = powered_by_1.poweredBy;
 Middleware.logger = logger_1.logger;
 Middleware.basicAuth = basic_auth_1.basicAuth;
+Middleware.bodyParse = body_parse_1.bodyParse;
+Middleware.cors = cors_1.cors;

package/dist/node.js

@@ -46,7 +46,8 @@ class Node {
         for (let i = 0, len = parts.length; i < len; i++) {
             const p = parts[i];
             // '*' => match any path
-            if (curNode.children['*']) {
+            // /api/* => default wildcard match
+            if (curNode.children['*'] && !curNode.children[p]) {
                 const astNode = curNode.children['*'];
                 if (Object.keys(astNode.children).length === 0) {
                     curNode = astNode;

package/dist/util.d.ts

@@ -1,4 +1,5 @@
 export declare const splitPath: (path: string) => string[];
 export declare const getPattern: (label: string) => string[] | null;
 export declare const getPathFromURL: (url: string) => string;
+export declare const isAbsoluteURL: (url: string) => boolean;
 export declare const timingSafeEqual: (a: any, b: any) => Promise<boolean>;

package/dist/util.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.timingSafeEqual = exports.getPathFromURL = exports.getPattern = exports.splitPath = void 0;
+exports.timingSafeEqual = exports.isAbsoluteURL = exports.getPathFromURL = exports.getPattern = exports.splitPath = void 0;
+const URL_REGEXP = /^(([^:\/?#]+):)?(\/\/([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/;
 const splitPath = (path) => {
     const paths = path.split(/\//); // faster than path.split('/')
     if (paths[0] === '') {
@@ -27,13 +28,21 @@ const getPattern = (label) => {
 exports.getPattern = getPattern;
 const getPathFromURL = (url) => {
     // XXX
-    const match = url.match(/^(([^:\/?#]+):)?(\/\/([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/);
+    const match = url.match(URL_REGEXP);
     if (match) {
         return match[5];
     }
     return '';
 };
 exports.getPathFromURL = getPathFromURL;
+const isAbsoluteURL = (url) => {
+    const match = url.match(URL_REGEXP);
+    if (match && match[1]) {
+        return true;
+    }
+    return false;
+};
+exports.isAbsoluteURL = isAbsoluteURL;
 const bufferEqual = (a, b) => {
     if (a === b) {
         return true;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hono",
-  "version": "0.0.12",
-  "description": "Tiny web framework for Cloudflare Workers and others.",
+  "version": "0.0.16",
+  "description": "[炎] Ultrafast web framework for Cloudflare Workers.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
@@ -37,8 +37,8 @@
     "@cloudflare/workers-types": "^3.3.0",
     "@types/jest": "^27.4.0",
     "@types/node": "^17.0.8",
-    "@types/service-worker-mock": "^2.0.1",
     "@typescript-eslint/eslint-plugin": "^5.9.0",
+    "@typescript-eslint/parser": "^5.9.0",
     "eslint": "^7.26.0",
     "eslint-config-prettier": "^8.1.0",
     "eslint-define-config": "^1.2.1",
@@ -48,11 +48,11 @@
     "eslint-plugin-import": "^2.20.2",
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-prettier": "^4.0.0",
+    "form-data": "^4.0.0",
     "jest": "^27.4.5",
+    "jest-environment-miniflare": "^2.0.0",
     "rimraf": "^3.0.2",
-    "service-worker-mock": "^2.0.5",
     "ts-jest": "^27.1.2",
-    "@typescript-eslint/parser": "^5.9.0",
     "typescript": "^4.5.4"
   },
   "engines": {

package/dist/middleware/defaultFilter.d.ts

@@ -1,2 +0,0 @@
-import type { Context } from '../context';
-export declare const defaultFilter: (c: Context, next: Function) => Promise<void>;

package/dist/middleware/defaultFilter.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultFilter = void 0;
-const defaultFilter = async (c, next) => {
-    c.req.query = (key) => {
-        // eslint-disable-next-line
-        const url = new URL(c.req.url);
-        return url.searchParams.get(key);
-    };
-    await next();
-};
-exports.defaultFilter = defaultFilter;