@venok/http 1.0.1-canary.0

package/test/helpers/flatten-routes.helper.spec.js

@@ -0,0 +1,131 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const core_1 = require("../../../core/index.ts");
+const helpers_1 = require("../../helpers");
+describe("flattenRoutePaths", () => {
+    it("should flatten all route paths", () => {
+        let ParentModule = class ParentModule {
+        };
+        ParentModule = __decorate([
+            (0, core_1.Module)({})
+        ], ParentModule);
+        let ChildModule = class ChildModule {
+        };
+        ChildModule = __decorate([
+            (0, core_1.Module)({})
+        ], ChildModule);
+        let ChildChildModule = class ChildChildModule {
+        };
+        ChildChildModule = __decorate([
+            (0, core_1.Module)({})
+        ], ChildChildModule);
+        let ChildModule2 = class ChildModule2 {
+        };
+        ChildModule2 = __decorate([
+            (0, core_1.Module)({})
+        ], ChildModule2);
+        let ParentChildModule = class ParentChildModule {
+        };
+        ParentChildModule = __decorate([
+            (0, core_1.Module)({})
+        ], ParentChildModule);
+        let ChildChildModule2 = class ChildChildModule2 {
+        };
+        ChildChildModule2 = __decorate([
+            (0, core_1.Module)({})
+        ], ChildChildModule2);
+        let AuthModule = class AuthModule {
+        };
+        AuthModule = __decorate([
+            (0, core_1.Module)({})
+        ], AuthModule);
+        let CatsModule = class CatsModule {
+        };
+        CatsModule = __decorate([
+            (0, core_1.Module)({})
+        ], CatsModule);
+        let DogsModule = class DogsModule {
+        };
+        DogsModule = __decorate([
+            (0, core_1.Module)({})
+        ], DogsModule);
+        let AuthModule2 = class AuthModule2 {
+        };
+        AuthModule2 = __decorate([
+            (0, core_1.Module)({})
+        ], AuthModule2);
+        let CatsModule2 = class CatsModule2 {
+        };
+        CatsModule2 = __decorate([
+            (0, core_1.Module)({})
+        ], CatsModule2);
+        let CatsModule3 = class CatsModule3 {
+        };
+        CatsModule3 = __decorate([
+            (0, core_1.Module)({})
+        ], CatsModule3);
+        let AuthModule3 = class AuthModule3 {
+        };
+        AuthModule3 = __decorate([
+            (0, core_1.Module)({})
+        ], AuthModule3);
+        const routes = [
+            {
+                path: "/parent",
+                module: ParentModule,
+                children: [
+                    {
+                        path: "/child",
+                        module: ChildModule,
+                        children: [
+                            { path: "/child2", module: ChildModule2 },
+                            {
+                                path: "/parentchild",
+                                module: ParentChildModule,
+                                children: [
+                                    {
+                                        path: "/childchild",
+                                        module: ChildChildModule,
+                                        children: [{ path: "/child2child", module: ChildChildModule2 }],
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            },
+            { path: "/v1", children: [AuthModule, CatsModule, DogsModule] },
+            { path: "/v2", children: [AuthModule2, CatsModule2] },
+            { path: "/v3", children: [AuthModule3, CatsModule3] },
+        ];
+        const expectedRoutes = [
+            { path: "/parent", module: ParentModule },
+            { path: "/parent/child", module: ChildModule },
+            { path: "/parent/child/child2", module: ChildModule2 },
+            { path: "/parent/child/parentchild", module: ParentChildModule },
+            {
+                path: "/parent/child/parentchild/childchild",
+                module: ChildChildModule,
+            },
+            {
+                path: "/parent/child/parentchild/childchild/child2child",
+                module: ChildChildModule2,
+            },
+            { path: "/v1", module: AuthModule },
+            { path: "/v1", module: CatsModule },
+            { path: "/v1", module: DogsModule },
+            { path: "/v2", module: AuthModule2 },
+            { path: "/v2", module: CatsModule2 },
+            { path: "/v3", module: AuthModule3 },
+            { path: "/v3", module: CatsModule3 },
+        ];
+        (0, chai_1.expect)((0, helpers_1.flattenRoutePaths)(routes)).to.be.eql(expectedRoutes);
+    });
+});

package/test/helpers/sse.helper.spec.d.ts

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

package/test/helpers/sse.helper.spec.js

@@ -0,0 +1,132 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+// @ts-ignore
+const eventsource_1 = __importDefault(require("eventsource"));
+const http_1 = require("http");
+const stream_1 = require("../../../../../../../stream");
+const sse_helper_1 = require("@venok/http/helpers/sse.helper");
+const noop = () => { };
+const written = (stream) => new Promise((resolve, reject) => stream.on("error", reject).on("finish", resolve));
+class Sink extends stream_1.Writable {
+    constructor(writeHead) {
+        super({ objectMode: true });
+        this.writeHead = writeHead;
+        this.chunks = [];
+    }
+    _write(chunk, encoding, callback) {
+        this.chunks.push(chunk);
+        callback();
+    }
+    get content() {
+        return this.chunks.join("");
+    }
+}
+describe("SseStream", () => {
+    it("writes multiple multiline messages", async () => {
+        const sse = new sse_helper_1.SseStream();
+        const sink = new Sink();
+        sse.pipe(sink);
+        sse.writeMessage({
+            data: "hello\nworld",
+        }, noop);
+        sse.writeMessage({
+            data: "bonjour\nmonde",
+        }, noop);
+        sse.end();
+        await written(sink);
+        (0, chai_1.expect)(sink.content).to.equal(`
+id: 1
+data: hello
+data: world
+
+id: 2
+data: bonjour
+data: monde
+
+`);
+    });
+    it("writes object messages as JSON", async () => {
+        const sse = new sse_helper_1.SseStream();
+        const sink = new Sink();
+        sse.pipe(sink);
+        sse.writeMessage({
+            data: { hello: "world" },
+        }, noop);
+        sse.end();
+        await written(sink);
+        (0, chai_1.expect)(sink.content).to.equal(`
+id: 1
+data: {"hello":"world"}
+
+`);
+    });
+    it("writes all message attributes", async () => {
+        const sse = new sse_helper_1.SseStream();
+        const sink = new Sink();
+        sse.pipe(sink);
+        sse.writeMessage({
+            type: "tea-time",
+            id: "the-id",
+            retry: 222,
+            data: "hello",
+        }, noop);
+        sse.end();
+        await written(sink);
+        (0, chai_1.expect)(sink.content).to.equal(`
+event: tea-time
+id: the-id
+retry: 222
+data: hello
+
+`);
+    });
+    it("sets headers on destination when it looks like a HTTP Response", (callback) => {
+        const sse = new sse_helper_1.SseStream();
+        const sink = new Sink((status, headers) => {
+            (0, chai_1.expect)(headers).to.deep.equal({
+                "Content-Type": "text/event-stream",
+                Connection: "keep-alive",
+                "Cache-Control": "private, no-cache, no-store, must-revalidate, max-age=0, no-transform",
+                Pragma: "no-cache",
+                Expire: "0",
+                "X-Accel-Buffering": "no",
+            });
+            callback();
+            return sink;
+        });
+        sse.pipe(sink);
+    });
+    it("sets additional headers when provided", (callback) => {
+        const sse = new sse_helper_1.SseStream();
+        const sink = new Sink((status, headers) => {
+            (0, chai_1.expect)(headers).to.contain.keys("access-control-headers");
+            (0, chai_1.expect)(headers["access-control-headers"]).to.equal("some-cors-value");
+            callback();
+            return sink;
+        });
+        sse.pipe(sink, {
+            additionalHeaders: { "access-control-headers": "some-cors-value" },
+        });
+    });
+    it("allows an eventsource to connect", (callback) => {
+        let sse;
+        const server = (0, http_1.createServer)((req, res) => {
+            sse = new sse_helper_1.SseStream(req);
+            sse.pipe(res);
+        });
+        server.listen(() => {
+            const es = new eventsource_1.default(`http://localhost:${server.address().port}`);
+            es.onmessage = (e) => {
+                (0, chai_1.expect)(e.data).to.equal("hello");
+                es.close();
+                server.close(callback);
+            };
+            es.onopen = () => sse.writeMessage({ data: "hello" }, noop);
+            es.onerror = (e) => callback(new Error(`Error from EventSource: ${JSON.stringify(e)}`));
+        });
+    });
+});

package/test/middleware/builder.spec.d.ts

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

package/test/middleware/builder.spec.js

@@ -0,0 +1,235 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const core_1 = require("../../../core/index.ts");
+const middleware_1 = require("../../middleware");
+const enums_1 = require("../../enums");
+const routes_mapper_1 = require("../../middleware/routes-mapper");
+const helpers_1 = require("../../helpers");
+const extractor_1 = require("../../middleware/extractor");
+const decorators_1 = require("../../decorators");
+const config_1 = require("../../application/config");
+describe("MiddlewareBuilder", () => {
+    let builder;
+    beforeEach(() => {
+        const container = new core_1.VenokContainer();
+        const httpConfig = new config_1.HttpConfig();
+        httpConfig.enableVersioning({ type: enums_1.VersioningType.URI });
+        builder = new middleware_1.MiddlewareBuilder(new routes_mapper_1.RoutesMapper(container, httpConfig), new helpers_1.NoopHttpAdapter({}), new extractor_1.RouteInfoPathExtractor(httpConfig));
+    });
+    describe("apply", () => {
+        it("should return configuration proxy", () => {
+            const configProxy = builder.apply([]);
+            const metatype = middleware_1.MiddlewareBuilder.ConfigProxy;
+            (0, chai_1.expect)(configProxy instanceof metatype).to.be.true;
+        });
+        describe("configuration proxy", () => {
+            describe('when "forRoutes()" called', () => {
+                let configProxy;
+                beforeEach(() => {
+                    configProxy = builder.apply([]);
+                });
+                let Test = class Test {
+                    getAll() { }
+                    getAllVersioned() { }
+                };
+                __decorate([
+                    (0, decorators_1.Get)("route"),
+                    __metadata("design:type", Function),
+                    __metadata("design:paramtypes", []),
+                    __metadata("design:returntype", void 0)
+                ], Test.prototype, "getAll", null);
+                __decorate([
+                    (0, decorators_1.Version)("1"),
+                    (0, decorators_1.Get)("versioned"),
+                    __metadata("design:type", Function),
+                    __metadata("design:paramtypes", []),
+                    __metadata("design:returntype", void 0)
+                ], Test.prototype, "getAllVersioned", null);
+                Test = __decorate([
+                    (0, decorators_1.Controller)("path")
+                ], Test);
+                const route = { path: "/test", method: enums_1.RequestMethod.GET };
+                it("should store configuration passed as argument", () => {
+                    configProxy.forRoutes(route, Test);
+                    (0, chai_1.expect)(builder.build()).to.deep.equal([
+                        {
+                            middleware: [],
+                            forRoutes: [
+                                {
+                                    method: enums_1.RequestMethod.GET,
+                                    path: route.path,
+                                },
+                                {
+                                    method: enums_1.RequestMethod.GET,
+                                    path: "/path/route",
+                                },
+                                {
+                                    method: enums_1.RequestMethod.GET,
+                                    path: "/path/versioned",
+                                    version: "1",
+                                },
+                            ],
+                        },
+                    ]);
+                });
+                let UsersController = class UsersController {
+                    hRsvp() { }
+                    oRsvp() { }
+                    gRsvp() { }
+                    pRsvp() { }
+                    puRsvp() { }
+                    ptRsvp() { }
+                    dRsvp() { }
+                    create() { }
+                    findAll() { }
+                    findOne() { }
+                    update() { }
+                    remove() { }
+                };
+                __decorate([
+                    (0, decorators_1.Head)("rsvp"),
+                    __metadata("design:type", Function),
+                    __metadata("design:paramtypes", []),
+                    __metadata("design:returntype", void 0)
+                ], UsersController.prototype, "hRsvp", null);
+                __decorate([
+                    (0, decorators_1.Options)("rsvp"),
+                    __metadata("design:type", Function),
+                    __metadata("design:paramtypes", []),
+                    __metadata("design:returntype", void 0)
+                ], UsersController.prototype, "oRsvp", null);
+                __decorate([
+                    (0, decorators_1.Get)("rsvp"),
+                    __metadata("design:type", Function),
+                    __metadata("design:paramtypes", []),
+                    __metadata("design:returntype", void 0)
+                ], UsersController.prototype, "gRsvp", null);
+                __decorate([
+                    (0, decorators_1.Post)("rsvp"),
+                    __metadata("design:type", Function),
+                    __metadata("design:paramtypes", []),
+                    __metadata("design:returntype", void 0)
+                ], UsersController.prototype, "pRsvp", null);
+                __decorate([
+                    (0, decorators_1.Put)("rsvp"),
+                    __metadata("design:type", Function),
+                    __metadata("design:paramtypes", []),
+                    __metadata("design:returntype", void 0)
+                ], UsersController.prototype, "puRsvp", null);
+                __decorate([
+                    (0, decorators_1.Patch)("rsvp"),
+                    __metadata("design:type", Function),
+                    __metadata("design:paramtypes", []),
+                    __metadata("design:returntype", void 0)
+                ], UsersController.prototype, "ptRsvp", null);
+                __decorate([
+                    (0, decorators_1.Delete)("rsvp"),
+                    __metadata("design:type", Function),
+                    __metadata("design:paramtypes", []),
+                    __metadata("design:returntype", void 0)
+                ], UsersController.prototype, "dRsvp", null);
+                __decorate([
+                    (0, decorators_1.Post)(),
+                    __metadata("design:type", Function),
+                    __metadata("design:paramtypes", []),
+                    __metadata("design:returntype", void 0)
+                ], UsersController.prototype, "create", null);
+                __decorate([
+                    (0, decorators_1.Get)(),
+                    __metadata("design:type", Function),
+                    __metadata("design:paramtypes", []),
+                    __metadata("design:returntype", void 0)
+                ], UsersController.prototype, "findAll", null);
+                __decorate([
+                    (0, decorators_1.Get)(":id"),
+                    __metadata("design:type", Function),
+                    __metadata("design:paramtypes", []),
+                    __metadata("design:returntype", void 0)
+                ], UsersController.prototype, "findOne", null);
+                __decorate([
+                    (0, decorators_1.Patch)(":id"),
+                    __metadata("design:type", Function),
+                    __metadata("design:paramtypes", []),
+                    __metadata("design:returntype", void 0)
+                ], UsersController.prototype, "update", null);
+                __decorate([
+                    (0, decorators_1.Delete)(":id"),
+                    __metadata("design:type", Function),
+                    __metadata("design:paramtypes", []),
+                    __metadata("design:returntype", void 0)
+                ], UsersController.prototype, "remove", null);
+                UsersController = __decorate([
+                    (0, decorators_1.Controller)("users")
+                ], UsersController);
+                it("should remove overlapping routes", () => {
+                    configProxy.forRoutes(UsersController);
+                    (0, chai_1.expect)(builder.build()).to.deep.equal([
+                        {
+                            middleware: [],
+                            forRoutes: [
+                                {
+                                    method: enums_1.RequestMethod.HEAD,
+                                    path: "/users/rsvp",
+                                },
+                                {
+                                    method: enums_1.RequestMethod.OPTIONS,
+                                    path: "/users/rsvp",
+                                },
+                                {
+                                    method: enums_1.RequestMethod.POST,
+                                    path: "/users/rsvp",
+                                },
+                                {
+                                    method: enums_1.RequestMethod.PUT,
+                                    path: "/users/rsvp",
+                                },
+                                {
+                                    method: enums_1.RequestMethod.POST,
+                                    path: "/users/",
+                                },
+                                {
+                                    method: enums_1.RequestMethod.GET,
+                                    path: "/users/",
+                                },
+                                {
+                                    method: enums_1.RequestMethod.GET,
+                                    path: "/users/:id",
+                                },
+                                {
+                                    method: enums_1.RequestMethod.PATCH,
+                                    path: "/users/:id",
+                                },
+                                {
+                                    method: enums_1.RequestMethod.DELETE,
+                                    path: "/users/:id",
+                                },
+                            ],
+                        },
+                    ]);
+                });
+            });
+        });
+    });
+    describe("exclude", () => {
+        it("should map string to RouteInfo", () => {
+            const path = "/test";
+            const proxy = builder.apply().exclude(path);
+            (0, chai_1.expect)(proxy.getExcludedRoutes()).to.be.eql([
+                {
+                    path,
+                    method: -1,
+                },
+            ]);
+        });
+    });
+});

package/test/middleware/container.spec.d.ts

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

package/test/middleware/container.spec.js

@@ -0,0 +1,81 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const decorators_1 = require("../../decorators");
+const enums_1 = require("../../enums");
+const core_1 = require("../../../core/index.ts");
+const container_1 = require("../../middleware/container");
+const module_1 = require("../../../core/injector/module/module");
+const wrapper_1 = require("../../../core/injector/instance/wrapper");
+describe("MiddlewareContainer", () => {
+    class ExampleModule {
+    }
+    let TestRoute = class TestRoute {
+        getTest() { }
+        getAnother() { }
+    };
+    __decorate([
+        (0, decorators_1.RequestMapping)({ path: "test" }),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], TestRoute.prototype, "getTest", null);
+    __decorate([
+        (0, decorators_1.RequestMapping)({ path: "another", method: enums_1.RequestMethod.DELETE }),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], TestRoute.prototype, "getAnother", null);
+    TestRoute = __decorate([
+        (0, decorators_1.Controller)("test")
+    ], TestRoute);
+    let TestMiddleware = class TestMiddleware {
+        use(req, res, next) { }
+    };
+    TestMiddleware = __decorate([
+        (0, core_1.Injectable)()
+    ], TestMiddleware);
+    let container;
+    beforeEach(() => {
+        const nestContainer = new core_1.VenokContainer();
+        const modules = nestContainer.getModules();
+        modules.set("Module", new module_1.Module(ExampleModule, nestContainer));
+        modules.set("Test", new module_1.Module(ExampleModule, nestContainer));
+        container = new container_1.MiddlewareContainer(nestContainer);
+    });
+    it("should store expected configurations for given module", () => {
+        const config = [
+            {
+                middleware: [TestMiddleware],
+                forRoutes: [TestRoute, "test"],
+            },
+        ];
+        container.insertConfig(config, "Module");
+        (0, chai_1.expect)([...container.getConfigurations().get("Module")]).to.deep.equal(config);
+    });
+    it("should store expected middleware for given module", () => {
+        const config = [
+            {
+                middleware: TestMiddleware,
+                forRoutes: [TestRoute],
+            },
+        ];
+        const key = "Test";
+        container.insertConfig(config, key);
+        const collection = container.getMiddlewareCollection(key);
+        const insertedMiddleware = collection.get(TestMiddleware);
+        (0, chai_1.expect)(collection.size).to.eql(config.length);
+        (0, chai_1.expect)(insertedMiddleware).to.be.instanceOf(wrapper_1.InstanceWrapper);
+        (0, chai_1.expect)(insertedMiddleware.scope).to.be.undefined;
+        (0, chai_1.expect)(insertedMiddleware.metatype).to.be.eql(TestMiddleware);
+    });
+});

package/test/middleware/module.spec.d.ts

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