hono 1.1.1 → 1.2.2

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.d.ts

@@ -4,11 +4,16 @@ declare type Headers = Record<string, string>;
 declare type Data = string | ArrayBuffer | ReadableStream;
 export declare type Env = Record<string, any>;
 export declare class Context<RequestParamKeyType = string, E = Env> {
-    #private;
     req: Request<RequestParamKeyType>;
     res: Response;
     env: E;
     event: FetchEvent;
+    private _headers;
+    private _status;
+    private _statusText;
+    private _pretty;
+    private _prettySpace;
+    private _map;
     render: (template: string, params?: object, options?: object) => Promise<Response>;
     notFound: () => Response | Promise<Response>;
     constructor(req: Request<RequestParamKeyType>, opts?: {
@@ -19,6 +24,8 @@ export declare class Context<RequestParamKeyType = string, E = Env> {
     private initRequest;
     header(name: string, value: string): void;
     status(status: StatusCode): void;
+    set(key: string, value: any): void;
+    get(key: string): any;
     pretty(prettyJSON: boolean, space?: number): void;
     newResponse(data: Data, init?: ResponseInit): Response;
     body(data: Data, status?: StatusCode, headers?: Headers): Response;

package/dist/context.js

@@ -1,30 +1,19 @@
 "use strict";
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    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 _Context_headers, _Context_status, _Context_statusText, _Context_pretty, _Context_prettySpace;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Context = void 0;
 const http_status_1 = require("./utils/http-status");
 const url_1 = require("./utils/url");
 class Context {
     constructor(req, opts) {
-        _Context_headers.set(this, void 0);
-        _Context_status.set(this, void 0);
-        _Context_statusText.set(this, void 0);
-        _Context_pretty.set(this, void 0);
-        _Context_prettySpace.set(this, 2);
+        this.res = undefined;
+        this._headers = {};
+        this._status = 200;
+        this._statusText = '';
+        this._pretty = false;
+        this._prettySpace = 2;
         this.req = this.initRequest(req);
+        this._map = {};
         Object.assign(this, opts);
-        __classPrivateFieldSet(this, _Context_headers, {}, "f");
     }
     initRequest(req) {
         req.header = (name) => {
@@ -40,51 +29,53 @@ class Context {
         if (this.res) {
             this.res.headers.set(name, value);
         }
-        __classPrivateFieldGet(this, _Context_headers, "f")[name] = value;
+        this._headers[name] = value;
     }
     status(status) {
-        if (this.res) {
-            console.warn('c.res.status is already set.');
-            return;
-        }
-        __classPrivateFieldSet(this, _Context_status, status, "f");
-        __classPrivateFieldSet(this, _Context_statusText, (0, http_status_1.getStatusText)(status), "f");
+        this._status = status;
+        this._statusText = (0, http_status_1.getStatusText)(status);
+    }
+    set(key, value) {
+        this._map[key] = value;
+    }
+    get(key) {
+        return this._map[key];
     }
     pretty(prettyJSON, space = 2) {
-        __classPrivateFieldSet(this, _Context_pretty, prettyJSON, "f");
-        __classPrivateFieldSet(this, _Context_prettySpace, space, "f");
+        this._pretty = prettyJSON;
+        this._prettySpace = space;
     }
     newResponse(data, init = {}) {
-        init.status = init.status || __classPrivateFieldGet(this, _Context_status, "f") || 200;
+        init.status = init.status || this._status || 200;
         init.statusText =
-            init.statusText || __classPrivateFieldGet(this, _Context_statusText, "f") || (0, http_status_1.getStatusText)(init.status);
-        init.headers = Object.assign(Object.assign({}, __classPrivateFieldGet(this, _Context_headers, "f")), init.headers);
+            init.statusText || this._statusText || (0, http_status_1.getStatusText)(init.status);
+        init.headers = Object.assign(Object.assign({}, this._headers), init.headers);
         return new Response(data, init);
     }
-    body(data, status = __classPrivateFieldGet(this, _Context_status, "f"), headers = __classPrivateFieldGet(this, _Context_headers, "f")) {
+    body(data, status = this._status, headers = this._headers) {
         return this.newResponse(data, {
             status: status,
             headers: headers,
         });
     }
-    text(text, status = __classPrivateFieldGet(this, _Context_status, "f"), headers = {}) {
+    text(text, status = this._status, headers = {}) {
         if (typeof text !== 'string') {
             throw new TypeError('text method arg must be a string!');
         }
         headers['Content-Type'] || (headers['Content-Type'] = 'text/plain; charset=UTF-8');
         return this.body(text, status, headers);
     }
-    json(object, status = __classPrivateFieldGet(this, _Context_status, "f"), headers = {}) {
+    json(object, status = this._status, headers = {}) {
         if (typeof object !== 'object') {
             throw new TypeError('json method arg must be an object!');
         }
-        const body = __classPrivateFieldGet(this, _Context_pretty, "f")
-            ? JSON.stringify(object, null, __classPrivateFieldGet(this, _Context_prettySpace, "f"))
+        const body = this._pretty
+            ? JSON.stringify(object, null, this._prettySpace)
             : JSON.stringify(object);
         headers['Content-Type'] || (headers['Content-Type'] = 'application/json; charset=UTF-8');
         return this.body(body, status, headers);
     }
-    html(html, status = __classPrivateFieldGet(this, _Context_status, "f"), headers = {}) {
+    html(html, status = this._status, headers = {}) {
         if (typeof html !== 'string') {
             throw new TypeError('html method arg must be a string!');
         }
@@ -109,4 +100,3 @@ class Context {
     }
 }
 exports.Context = Context;
-_Context_headers = new WeakMap(), _Context_status = new WeakMap(), _Context_statusText = new WeakMap(), _Context_pretty = new WeakMap(), _Context_prettySpace = new WeakMap();

package/dist/context.test.d.ts

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