hono 0.4.2 → 0.5.0

package/README.md

@@ -71,6 +71,8 @@ An instance of `Hono` has these methods.
 - 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)
 
@@ -126,10 +128,10 @@ book.post('/', (c) => c.text('Create Book')) // POST /book
 
 ### no strict
 
-If `strict` is set `false`, `/hello`and`/hello/` are treated the same. Default is `true`.
+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/'))
 ```
@@ -188,6 +190,29 @@ app.use('/message/*', async (c, next) => {
 app.get('/message/hello', (c) => c.text('Hello Middleware!'))
 ```
 
+## Error
+
+### 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.
@@ -224,10 +249,12 @@ 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')
 })
 ```
@@ -278,7 +305,7 @@ app.get('/', (c) => {
 
 ### c.notFound()
 
-Return the default `404 Not Found` Response.
+Return the `404 Not Found` Response.
 
 ```js
 app.get('/notfound', (c) => {
@@ -327,26 +354,6 @@ app.get('*', async c => {
 })
 ```
 
-## Not Found
-
-You can write 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 this.
@@ -359,7 +366,7 @@ addEventListener('fetch', (event) => {
 
 ## fetch
 
-`app.fetch()` is for Cloudflare Module Worker syntax.
+`app.fetch` for Cloudflare Module Worker syntax.
 
 ```js
 export default {

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: <T>(middleware: Function[], onError?: ErrorHandler) => (context: T, next?: Function) => Promise<T>;

package/dist/compose.js

@@ -4,7 +4,6 @@ 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) {
         let index = -1;
         return dispatch(0);
@@ -16,15 +15,19 @@ const compose = (middleware, onError) => {
             if (i === middleware.length)
                 fn = next;
             if (!fn)
-                return Promise.resolve();
+                return context;
             try {
-                return Promise.resolve(fn(context, dispatch.bind(null, i + 1))).catch((e) => {
-                    errors.push(e);
+                return Promise.resolve(fn(context, dispatch.bind(null, i + 1)))
+                    .then(() => {
+                    return context;
+                })
+                    .catch((err) => {
                     if (onError && context instanceof context_1.Context) {
-                        context.res = onError(errors[0], context);
+                        context.res = onError(err, context);
+                        return context;
                     }
                     else {
-                        throw errors[0];
+                        throw err;
                     }
                 });
             }

package/dist/hono.d.ts

@@ -12,6 +12,8 @@ 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>;
@@ -24,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;
@@ -34,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

@@ -10,6 +10,15 @@ class Hono {
     constructor(init = {}) {
         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 = [];
@@ -53,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();
@@ -82,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);
@@ -99,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);
@@ -116,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "description": "[炎] Ultrafast web framework for Cloudflare Workers.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",