hono 1.1.1 → 1.2.2

package/dist/context.test.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const context_1 = require("./context");
+describe('Context', () => {
+    const req = new Request('http://localhost/');
+    let c;
+    beforeEach(() => {
+        c = new context_1.Context(req);
+    });
+    it('c.text()', async () => {
+        const res = c.text('text in c', 201, { 'X-Custom': 'Message' });
+        expect(res.status).toBe(201);
+        expect(res.headers.get('Content-Type')).toBe('text/plain; charset=UTF-8');
+        expect(await res.text()).toBe('text in c');
+        expect(res.headers.get('X-Custom')).toBe('Message');
+    });
+    it('c.json()', async () => {
+        const res = c.json({ message: 'Hello' }, 201, { 'X-Custom': 'Message' });
+        expect(res.status).toBe(201);
+        expect(res.headers.get('Content-Type')).toMatch('application/json; charset=UTF-8');
+        const text = await res.text();
+        expect(text).toBe('{"message":"Hello"}');
+        expect(res.headers.get('X-Custom')).toBe('Message');
+    });
+    it('c.json() with c.pretty(true)', async () => {
+        c.pretty(true);
+        const res = c.json({ message: 'Hello' });
+        const text = await res.text();
+        expect(text).toBe(`{
+  "message": "Hello"
+}`);
+    });
+    it('c.json() with c.pretty(true, 4)', async () => {
+        c.pretty(true, 4);
+        const res = c.json({ message: 'Hello' });
+        const text = await res.text();
+        expect(text).toBe(`{
+    "message": "Hello"
+}`);
+    });
+    it('c.html()', async () => {
+        const res = c.html('<h1>Hello! Hono!</h1>', 201, { 'X-Custom': 'Message' });
+        expect(res.status).toBe(201);
+        expect(res.headers.get('Content-Type')).toMatch('text/html');
+        expect(await res.text()).toBe('<h1>Hello! Hono!</h1>');
+        expect(res.headers.get('X-Custom')).toBe('Message');
+    });
+    it('c.redirect()', async () => {
+        let res = c.redirect('/destination');
+        expect(res.status).toBe(302);
+        expect(res.headers.get('Location')).toMatch(/^https?:\/\/.+\/destination$/);
+        res = c.redirect('https://example.com/destination');
+        expect(res.status).toBe(302);
+        expect(res.headers.get('Location')).toBe('https://example.com/destination');
+    });
+    it('c.header()', async () => {
+        c.header('X-Foo', 'Bar');
+        const res = c.body('Hi');
+        const foo = res.headers.get('X-Foo');
+        expect(foo).toBe('Bar');
+    });
+    it('c.status() and c.statusText()', async () => {
+        c.status(201);
+        const res = c.body('Hi');
+        expect(res.status).toBe(201);
+        expect(res.statusText).toBe('Created');
+    });
+    it('Complex pattern', async () => {
+        c.status(404);
+        const res = c.json({ hono: 'great app' });
+        expect(res.status).toBe(404);
+        expect(res.statusText).toBe('Not Found');
+        expect(res.headers.get('Content-Type')).toMatch('application/json; charset=UTF-8');
+        const obj = await res.json();
+        expect(obj['hono']).toBe('great app');
+    });
+    it('Has headers, status, and statusText', async () => {
+        c.header('X-Custom1', 'Message1');
+        c.header('X-Custom2', 'Message2');
+        c.status(200);
+        const res = c.newResponse('this is body', {
+            status: 201,
+            headers: {
+                'X-Custom3': 'Message3',
+                'X-Custom2': 'Message2-Override',
+            },
+        });
+        expect(res.headers.get('X-Custom1')).toBe('Message1');
+        expect(res.headers.get('X-Custom2')).toBe('Message2-Override');
+        expect(res.headers.get('X-Custom3')).toBe('Message3');
+        expect(res.status).toBe(201);
+        expect(await res.text()).toBe('this is body');
+        // res is already set.
+        c.res = res;
+        c.header('X-Custom4', 'Message4');
+        c.status(202);
+        expect(c.res.headers.get('X-Custom4')).toBe('Message4');
+        expect(c.res.status).toBe(201);
+        expect(c.res.statusText).toBe('OK');
+    });
+    it('Should return 200 response', async () => {
+        const res = c.text('Text');
+        expect(res.status).toBe(200);
+        expect(res.statusText).toBe('OK');
+    });
+    it('Should be able read env', async () => {
+        const req = new Request('http://localhost/');
+        const key = 'a-secret-key';
+        const ctx = new context_1.Context(req, {
+            env: {
+                API_KEY: key,
+            },
+            res: null,
+            event: null,
+        });
+        expect(ctx.env.API_KEY).toBe(key);
+    });
+    it('set and set', async () => {
+        const ctx = new context_1.Context(req);
+        expect(ctx.get('k-foo')).toEqual(undefined);
+        ctx.set('k-foo', 'v-foo');
+        expect(ctx.get('k-foo')).toEqual('v-foo');
+        expect(ctx.get('k-bar')).toEqual(undefined);
+        ctx.set('k-bar', { k: 'v' });
+        expect(ctx.get('k-bar')).toEqual({ k: 'v' });
+    });
+});

package/dist/hono.d.ts

@@ -2,6 +2,7 @@
 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;
@@ -9,31 +10,53 @@ declare global {
         header: (name: string) => string;
     }
 }
-export declare type Handler<RequestParamKeyType = string, E = Env> = (c: Context<RequestParamKeyType, E>) => Response | Promise<Response>;
-export declare type MiddlewareHandler<E = Env> = (c: Context<string, E>, next: Next) => Promise<void>;
-export declare type NotFoundHandler<E = Env> = (c: Context<string, E>) => Response | Promise<Response>;
+export declare type Handler<RequestParamKeyType = 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>;
 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>;
-interface HandlerInterface<T extends string, E = Env> {
-    <Path extends string>(path: Path, handler: Handler<ParamKeys<Path>, E>): Hono<E, Path>;
-    (path: string, handler: Handler<string, E>): Hono<E, T>;
-    <Path extends T>(handler: Handler<ParamKeys<T>, E>): Hono<E, Path>;
-    (handler: Handler<string, E>): Hono<E, T>;
+interface HandlerInterface<T extends string, E = Env, U = Hono<E, T>> {
+    <Path extends string>(path: Path, ...handlers: Handler<ParamKeys<Path> extends never ? string : ParamKeys<Path>, E>[]): U;
+    (path: string, ...handlers: Handler<string, E>[]): U;
+    <Path extends string>(...handlers: Handler<ParamKeys<Path> extends never ? string : ParamKeys<Path>, E>[]): U;
+    (...handlers: Handler<string, E>[]): U;
 }
-declare const Hono_base: new <E_1 extends Env, T extends string>() => {
-    delete: HandlerInterface<T, E_1>;
-    get: HandlerInterface<T, E_1>;
-    post: HandlerInterface<T, E_1>;
-    put: HandlerInterface<T, E_1>;
-    head: HandlerInterface<T, E_1>;
-    options: HandlerInterface<T, E_1>;
-    patch: HandlerInterface<T, E_1>;
-    all: HandlerInterface<T, E_1>;
+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> {
+    path: string;
+    method: Methods;
+    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>;
+    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 Hono<E = Env, P extends string = ''> extends Hono_base<E, P> {
+export declare class Hono<E = Env, P extends string = ''> extends Hono_base<E, P, Hono<E, P>> {
     #private;
     readonly routerClass: {
         new (): Router<any>;
@@ -43,9 +66,9 @@ export declare class Hono<E = Env, P extends string = ''> extends Hono_base<E, P
     constructor(init?: Partial<Pick<Hono, 'routerClass' | 'strict'>>);
     private notFoundHandler;
     private errorHandler;
-    route(path: string): Hono<E, P>;
-    use(path: string, middleware: MiddlewareHandler<E>): Hono<E, P>;
-    use(middleware: MiddlewareHandler<E>): Hono<E, P>;
+    route(path: string, route?: Route): 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>;
     notFound(handler: NotFoundHandler<E>): Hono<E, P>;
     private addRoute;

package/dist/hono.js

@@ -10,26 +10,57 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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 _Hono_router, _Hono_middlewareRouters, _Hono_tempPath;
+var _Route_path, _Hono_router, _Hono_tempPath;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Hono = void 0;
+exports.Hono = exports.Route = void 0;
 const compose_1 = require("./compose");
 const context_1 = require("./context");
 const router_1 = require("./router");
+const router_2 = require("./router");
 const trie_router_1 = require("./router/trie-router"); // Default Router
 const url_1 = require("./utils/url");
-const methods = ['get', 'post', 'put', 'delete', 'head', 'options', 'patch', 'all'];
+const methods = ['get', 'post', 'put', 'delete', 'head', 'options', 'patch'];
 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_middlewareRouters.set(this, void 0);
         _Hono_tempPath.set(this, void 0);
         this.notFoundHandler = (c) => {
             const message = '404 Not Found';
@@ -40,41 +71,48 @@ class Hono extends defineDynamicClass() {
             const message = 'Internal Server Error';
             return c.text(message, 500);
         };
-        methods.map((method) => {
-            this[method] = (arg1, arg2) => {
-                if (typeof arg1 === 'string') {
-                    this.path = arg1;
-                    return this.addRoute(method, this.path, arg2);
+        const allMethods = [...methods, router_2.METHOD_NAME_ALL_LOWERCASE];
+        allMethods.map((method) => {
+            this[method] = (args1, ...args) => {
+                if (typeof args1 === 'string') {
+                    this.path = args1;
                 }
-                return this.addRoute(method, this.path, arg1);
+                else {
+                    this.addRoute(method, this.path, args1);
+                }
+                args.map((handler) => {
+                    if (typeof handler !== 'string') {
+                        this.addRoute(method, this.path, handler);
+                    }
+                });
+                return this;
             };
         });
         Object.assign(this, init);
         __classPrivateFieldSet(this, _Hono_router, new this.routerClass(), "f");
-        __classPrivateFieldSet(this, _Hono_middlewareRouters, [], "f");
         __classPrivateFieldSet(this, _Hono_tempPath, null, "f");
     }
-    route(path) {
+    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);
+            });
+        }
         return newHono;
     }
-    use(arg1, arg2) {
-        let handler;
+    use(arg1, ...handlers) {
         if (typeof arg1 === 'string') {
             this.path = arg1;
-            handler = arg2;
         }
         else {
-            handler = arg1;
-        }
-        if (handler.constructor.name !== 'AsyncFunction') {
-            throw new TypeError('middleware must be a async function!');
+            handlers.unshift(arg1);
         }
-        const router = new this.routerClass();
-        router.add(router_1.METHOD_NAME_OF_ALL, this.path, handler);
-        __classPrivateFieldGet(this, _Hono_middlewareRouters, "f").push(router);
+        handlers.map((handler) => {
+            this.addRoute(router_1.METHOD_NAME_ALL, this.path, handler);
+        });
         return this;
     }
     onError(handler) {
@@ -91,7 +129,6 @@ class Hono extends defineDynamicClass() {
             path = (0, url_1.mergePath)(__classPrivateFieldGet(this, _Hono_tempPath, "f"), path);
         }
         __classPrivateFieldGet(this, _Hono_router, "f").add(method, path, handler);
-        return this;
     }
     async matchRoute(method, path) {
         return __classPrivateFieldGet(this, _Hono_router, "f").match(method, path);
@@ -100,31 +137,25 @@ class Hono extends defineDynamicClass() {
         const path = (0, url_1.getPathFromURL)(request.url, { strict: this.strict });
         const method = request.method;
         const result = await this.matchRoute(method, path);
-        // Methods for Request object
         request.param = (key) => {
             if (result)
                 return result.params[key];
         };
-        const handler = result ? result.handler : this.notFoundHandler;
-        const middleware = [];
-        for (const mr of __classPrivateFieldGet(this, _Hono_middlewareRouters, "f")) {
-            const mwResult = mr.match(router_1.METHOD_NAME_OF_ALL, path);
-            if (mwResult)
-                middleware.push(mwResult.handler);
+        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);
+        const composed = (0, compose_1.compose)(handlers, this.errorHandler, this.notFoundHandler);
+        let context;
+        try {
+            context = await composed(c);
         }
-        const wrappedHandler = async (context, next) => {
-            const res = await handler(context);
-            if (!(res instanceof Response)) {
-                throw new TypeError('response must be a instance of Response');
+        catch (err) {
+            if (err instanceof Error) {
+                return this.errorHandler(err, c);
             }
-            context.res = res;
-            await next();
-        };
-        middleware.push(wrappedHandler);
-        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.notFoundHandler(c);
-        const context = await composed(c);
+        }
+        if (!context.res)
+            return context.notFound();
         return context.res;
     }
     async handleEvent(event) {
@@ -144,4 +175,4 @@ class Hono extends defineDynamicClass() {
     }
 }
 exports.Hono = Hono;
-_Hono_router = new WeakMap(), _Hono_middlewareRouters = new WeakMap(), _Hono_tempPath = new WeakMap();
+_Hono_router = new WeakMap(), _Hono_tempPath = new WeakMap();

package/dist/hono.test.d.ts

@@ -0,0 +1 @@
+export {};