hono 1.2.1 → 1.2.2

package/README.md

@@ -87,7 +87,7 @@ import { etag } from 'hono/etag'
 import { logger } from 'hono/logger'
 
 const app = new Hono()
-app.use('*', etag(), (logger())
+app.use('*', etag(), logger())
 ```
 
 And, the routing of Hono is so flexible. It's easy to construct large web applications.

package/dist/compose.test.d.ts

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

package/dist/compose.test.js

@@ -0,0 +1,511 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const compose_1 = require("./compose");
+const context_1 = require("./context");
+describe('compose', () => {
+    const middleware = [];
+    const a = async (c, next) => {
+        c.req['log'] = 'log';
+        await next();
+    };
+    const b = async (c, next) => {
+        await next();
+        c.res['headers'] = 'custom-header';
+    };
+    const c = async (c, next) => {
+        c.req['xxx'] = 'yyy';
+        await next();
+        c.res['zzz'] = c.req['xxx'];
+    };
+    const handler = async (c, next) => {
+        c.req['log'] = `${c.req.log} message`;
+        await next();
+        c.res = { message: 'new response' };
+    };
+    middleware.push(a);
+    middleware.push(b);
+    middleware.push(c);
+    middleware.push(handler);
+    it('Request', async () => {
+        const c = { req: {}, res: {} };
+        const composed = (0, compose_1.compose)(middleware);
+        const context = await composed(c);
+        expect(context.req['log']).not.toBeNull();
+        expect(context.req['log']).toBe('log message');
+        expect(context.req['xxx']).toBe('yyy');
+    });
+    it('Response', async () => {
+        const c = { req: {}, res: {} };
+        const composed = (0, compose_1.compose)(middleware);
+        const context = await composed(c);
+        expect(context.res['headers']).not.toBeNull();
+        expect(context.res['headers']).toBe('custom-header');
+        expect(context.res['message']).toBe('new response');
+        expect(context.res['zzz']).toBe('yyy');
+    });
+});
+describe('Handler and middlewares', () => {
+    const middleware = [];
+    const req = new Request('http://localhost/');
+    const c = new context_1.Context(req);
+    const onError = (error, c) => {
+        return c.text('onError', 500);
+    };
+    const mHandlerFoo = async (c, next) => {
+        c.req.headers.append('x-header-foo', 'foo');
+        await next();
+    };
+    const mHandlerBar = async (c, next) => {
+        await next();
+        c.header('x-header-bar', 'bar');
+    };
+    const handler = (c) => {
+        const foo = c.req.header('x-header-foo') || '';
+        return c.text(foo);
+    };
+    middleware.push(mHandlerFoo);
+    middleware.push(mHandlerBar);
+    middleware.push(handler);
+    it('Should return 200 Response', async () => {
+        const composed = (0, compose_1.compose)(middleware, onError);
+        const context = await composed(c);
+        const res = context.res;
+        expect(res).not.toBeNull();
+        expect(res.status).toBe(200);
+        expect(await res.text()).toBe('foo');
+        expect(res.headers.get('x-header-bar')).toBe('bar');
+    });
+});
+describe('compose with Context - 200 success', () => {
+    const middleware = [];
+    const req = new Request('http://localhost/');
+    const c = new context_1.Context(req);
+    const onError = (error, c) => {
+        return c.text('onError', 500);
+    };
+    const handler = (c) => {
+        return c.text('Hello');
+    };
+    const mHandler = async (c, next) => {
+        await next();
+    };
+    middleware.push(handler);
+    middleware.push(mHandler);
+    it('Should return 200 Response', async () => {
+        const composed = (0, compose_1.compose)(middleware, onError);
+        const context = await composed(c);
+        expect(context.res).not.toBeNull();
+        expect(context.res.status).toBe(200);
+        expect(await context.res.text()).toBe('Hello');
+    });
+});
+describe('compose with Context - 404 not found', () => {
+    const middleware = [];
+    const req = new Request('http://localhost/');
+    const c = new context_1.Context(req);
+    const onError = (error, c) => {
+        return c.text('onError', 500);
+    };
+    const onNotFound = (c) => {
+        return c.text('onNotFound', 404);
+    };
+    const mHandler = async (c, next) => {
+        await next();
+    };
+    middleware.push(mHandler);
+    it('Should return 404 Response', async () => {
+        const composed = (0, compose_1.compose)(middleware, onError, onNotFound);
+        const context = await composed(c);
+        expect(context.res).not.toBeNull();
+        expect(context.res.status).toBe(404);
+        expect(await context.res.text()).toBe('onNotFound');
+    });
+});
+describe('compose with Context - 401 not authorized', () => {
+    const middleware = [];
+    const req = new Request('http://localhost/');
+    const c = new context_1.Context(req);
+    const onError = (error, c) => {
+        return c.text('onError', 500);
+    };
+    const handler = (c, next) => {
+        return c.text('Hello');
+    };
+    const mHandler = async (c, next) => {
+        await next();
+        c.res = new Response('Not authorized', { status: 401 });
+    };
+    middleware.push(handler);
+    middleware.push(mHandler);
+    it('Should return 401 Response', async () => {
+        const composed = (0, compose_1.compose)(middleware, onError);
+        const context = await composed(c);
+        expect(context.res).not.toBeNull();
+        expect(context.res.status).toBe(401);
+        expect(await context.res.text()).toBe('Not authorized');
+    });
+});
+describe('compose with Context - next() below', () => {
+    const middleware = [];
+    const req = new Request('http://localhost/');
+    const c = new context_1.Context(req);
+    const onError = (error, c) => {
+        return c.text('onError', 500);
+    };
+    const handler = (c) => {
+        const message = c.req.header('x-custom') || 'blank';
+        return c.text(message);
+    };
+    const mHandler = async (c, next) => {
+        c.req.headers.append('x-custom', 'foo');
+        await next();
+    };
+    middleware.push(mHandler);
+    middleware.push(handler);
+    it('Should return 200 Response', async () => {
+        const composed = (0, compose_1.compose)(middleware, onError);
+        const context = await composed(c);
+        expect(context.res).not.toBeNull();
+        expect(context.res.status).toBe(200);
+        expect(await context.res.text()).toBe('foo');
+    });
+});
+describe('compose with Context - 500 error', () => {
+    const middleware = [];
+    const req = new Request('http://localhost/');
+    const c = new context_1.Context(req);
+    const onError = (error, c) => {
+        return c.text('onError', 500);
+    };
+    it('Error on handler', async () => {
+        const handler = () => {
+            throw new Error();
+        };
+        const mHandler = async (c, next) => {
+            await next();
+        };
+        middleware.push(mHandler);
+        middleware.push(handler);
+        const composed = (0, compose_1.compose)(middleware, onError);
+        const context = await composed(c);
+        expect(context.res).not.toBeNull();
+        expect(context.res.status).toBe(500);
+        expect(await context.res.text()).toBe('onError');
+    });
+    it('Error on middleware', async () => {
+        const handler = (c) => {
+            return c.text('OK');
+        };
+        const mHandler = async () => {
+            throw new Error();
+        };
+        middleware.push(mHandler);
+        middleware.push(handler);
+        const composed = (0, compose_1.compose)(middleware, onError);
+        const context = await composed(c);
+        expect(c.res).not.toBeNull();
+        expect(c.res.status).toBe(500);
+        expect(await context.res.text()).toBe('onError');
+    });
+    it('Run all the middlewares', async () => {
+        const ctx = { req: {}, res: {} };
+        const stack = [];
+        const middlewares = [
+            async (ctx, next) => {
+                stack.push(0);
+                await next();
+            },
+            async (ctx, next) => {
+                stack.push(1);
+                await next();
+            },
+            async (ctx, next) => {
+                stack.push(2);
+                await next();
+            },
+        ];
+        const composed = await (0, compose_1.compose)(middlewares);
+        await composed(ctx);
+        expect(stack).toEqual([0, 1, 2]);
+    });
+});
+describe('Compose', function () {
+    function isPromise(x) {
+        return x && typeof x.then === 'function';
+    }
+    it('should get executed order one by one', async () => {
+        const arr = [];
+        const stack = [];
+        const called = [];
+        stack.push(async (context, next) => {
+            called.push(true);
+            arr.push(1);
+            await next();
+            arr.push(6);
+        });
+        stack.push(async (context, next) => {
+            called.push(true);
+            arr.push(2);
+            await next();
+            arr.push(5);
+        });
+        stack.push(async (context, next) => {
+            called.push(true);
+            arr.push(3);
+            await next();
+            arr.push(4);
+        });
+        await (0, compose_1.compose)(stack)({});
+        expect(called).toEqual([true, true, true]);
+        expect(arr).toEqual([1, 2, 3, 4, 5, 6]);
+    });
+    it('should not get executed if previous next() not triggered', async () => {
+        const arr = [];
+        const stack = [];
+        const called = [];
+        stack.push(async (context, next) => {
+            called.push(true);
+            arr.push(1);
+            await next();
+            arr.push(6);
+        });
+        stack.push(async (context, next) => {
+            called.push(true);
+            arr.push(2);
+        });
+        stack.push(async (context, next) => {
+            called.push(true);
+            arr.push(3);
+            await next();
+            arr.push(4);
+        });
+        await (0, compose_1.compose)(stack)({});
+        expect(called).toEqual([true, true]);
+        expect(arr).toEqual([1, 2, 6]);
+    });
+    it('should be able to be called twice', () => {
+        const stack = [];
+        stack.push(async (context, next) => {
+            context.arr.push(1);
+            await next();
+            context.arr.push(6);
+        });
+        stack.push(async (context, next) => {
+            context.arr.push(2);
+            await next();
+            context.arr.push(5);
+        });
+        stack.push(async (context, next) => {
+            context.arr.push(3);
+            await next();
+            context.arr.push(4);
+        });
+        const fn = (0, compose_1.compose)(stack);
+        const ctx1 = { arr: [] };
+        const ctx2 = { arr: [] };
+        const out = [1, 2, 3, 4, 5, 6];
+        return fn(ctx1)
+            .then(() => {
+            expect(out).toEqual(ctx1.arr);
+            return fn(ctx2);
+        })
+            .then(() => {
+            expect(out).toEqual(ctx2.arr);
+        });
+    });
+    it('should create next functions that return a Promise', function () {
+        const stack = [];
+        const arr = [];
+        for (let i = 0; i < 5; i++) {
+            stack.push((context, next) => {
+                arr.push(next());
+            });
+        }
+        (0, compose_1.compose)(stack)({});
+        for (const next of arr) {
+            expect(isPromise(next)).toBe(true);
+        }
+    });
+    it('should work with 0 middleware', function () {
+        return (0, compose_1.compose)([])({});
+    });
+    it('should work when yielding at the end of the stack', async () => {
+        const stack = [];
+        let called = false;
+        stack.push(async (ctx, next) => {
+            await next();
+            called = true;
+        });
+        await (0, compose_1.compose)(stack)({});
+        expect(called).toBe(true);
+    });
+    it('should reject on errors in middleware', () => {
+        const stack = [];
+        stack.push(() => {
+            throw new Error();
+        });
+        return (0, compose_1.compose)(stack)({}).then(() => {
+            throw new Error('promise was not rejected');
+        }, (e) => {
+            expect(e).toBeInstanceOf(Error);
+        });
+    });
+    it('should keep the context', () => {
+        const ctx = {};
+        const stack = [];
+        stack.push(async (ctx2, next) => {
+            await next();
+            expect(ctx2).toEqual(ctx);
+        });
+        stack.push(async (ctx2, next) => {
+            await next();
+            expect(ctx2).toEqual(ctx);
+        });
+        stack.push(async (ctx2, next) => {
+            await next();
+            expect(ctx2).toEqual(ctx);
+        });
+        return (0, compose_1.compose)(stack)(ctx);
+    });
+    it('should catch downstream errors', async () => {
+        const arr = [];
+        const stack = [];
+        stack.push(async (ctx, next) => {
+            arr.push(1);
+            try {
+                arr.push(6);
+                await next();
+                arr.push(7);
+            }
+            catch (err) {
+                arr.push(2);
+            }
+            arr.push(3);
+        });
+        stack.push(async (ctx, next) => {
+            arr.push(4);
+            throw new Error();
+        });
+        await (0, compose_1.compose)(stack)({});
+        expect(arr).toEqual([1, 6, 4, 2, 3]);
+    });
+    it('should compose w/ next', () => {
+        let called = false;
+        return (0, compose_1.compose)([])({}, async () => {
+            called = true;
+        }).then(function () {
+            expect(called).toBe(true);
+        });
+    });
+    it('should handle errors in wrapped non-async functions', () => {
+        const stack = [];
+        stack.push(function () {
+            throw new Error();
+        });
+        return (0, compose_1.compose)(stack)({}).then(() => {
+            throw new Error('promise was not rejected');
+        }, (e) => {
+            expect(e).toBeInstanceOf(Error);
+        });
+    });
+    // https://github.com/koajs/compose/pull/27#issuecomment-143109739
+    it('should compose w/ other compositions', () => {
+        const called = [];
+        return (0, compose_1.compose)([
+            (0, compose_1.compose)([
+                (ctx, next) => {
+                    called.push(1);
+                    return next();
+                },
+                (ctx, next) => {
+                    called.push(2);
+                    return next();
+                },
+            ]),
+            (ctx, next) => {
+                called.push(3);
+                return next();
+            },
+        ])({}).then(() => expect(called).toEqual([1, 2, 3]));
+    });
+    it('should throw if next() is called multiple times', () => {
+        return (0, compose_1.compose)([
+            async (ctx, next) => {
+                await next();
+                await next();
+            },
+        ])({}).then(() => {
+            throw new Error('boom');
+        }, (err) => {
+            expect(/multiple times/.test(err.message)).toBe(true);
+        });
+    });
+    it('should return a valid middleware', () => {
+        let val = 0;
+        return (0, compose_1.compose)([
+            (0, compose_1.compose)([
+                (ctx, next) => {
+                    val++;
+                    return next();
+                },
+                (ctx, next) => {
+                    val++;
+                    return next();
+                },
+            ]),
+            (ctx, next) => {
+                val++;
+                return next();
+            },
+        ])({}).then(function () {
+            expect(val).toEqual(3);
+        });
+    });
+    it('should return last return value', async () => {
+        const stack = [];
+        stack.push(async (ctx, next) => {
+            await next();
+            expect(ctx.val).toEqual(2);
+            ctx.val = 1;
+        });
+        stack.push(async (ctx, next) => {
+            ctx.val = 2;
+            await next();
+            expect(ctx.val).toEqual(2);
+        });
+        const res = await (0, compose_1.compose)(stack)({ val: 0 });
+        expect(res).toEqual({ val: 1 });
+    });
+    it('should not affect the original middleware array', () => {
+        const middleware = [];
+        const fn1 = (ctx, next) => {
+            return next();
+        };
+        middleware.push(fn1);
+        for (const fn of middleware) {
+            expect(fn).toEqual(fn1);
+        }
+        (0, compose_1.compose)(middleware);
+        for (const fn of middleware) {
+            expect(fn).toEqual(fn1);
+        }
+    });
+    it('should not get stuck on the passed in next', () => {
+        const middleware = [
+            (ctx, next) => {
+                ctx.middleware++;
+                return next();
+            },
+        ];
+        const ctx = {
+            middleware: 0,
+            next: 0,
+        };
+        return (0, compose_1.compose)(middleware)(ctx, (ctx, next) => {
+            ctx.next++;
+            return next();
+        }).then(() => {
+            expect(ctx).toEqual({ middleware: 1, next: 1 });
+        });
+    });
+});

package/dist/context.test.d.ts

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

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

@@ -10,7 +10,7 @@ declare global {
         header: (name: string) => string;
     }
 }
-export declare type Handler<RequestParamKeyType = string, E = Env> = (c: Context<RequestParamKeyType, E>, next?: Next) => Response | Promise<Response> | void | Promise<void>;
+export declare type Handler<RequestParamKeyType = 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>;

package/dist/hono.test.d.ts

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