| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| request-method.enum.ts | +100% | +6/6 | +100% | +2/2 | +100% | +1/1 | +100% | +6/6 | +
| 1 +2 +3 +4 +5 +6 +7 | 1x +1x +1x +1x +1x +1x + | export enum RequestMethod {
+ GET = 0,
+ POST,
+ PUT,
+ DELETE,
+ ALL
+} |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 | 1x +1x +1x +1x + +1x + + +1x + + + + + +1x +1x + +1x +1x + + + | import "reflect-metadata";
+import 'mocha';
+import { expect } from "chai";
+import { Component } from "../../utils/component.decorator";
+
+describe('@Injectable', () => {
+
+ @Component()
+ class TestComponent {
+ constructor(
+ param: number,
+ test: string) {}
+ }
+
+ it('should decorate type with "design:paramtypes" metadata', () => {
+ const constructorParams = Reflect.getMetadata('design:paramtypes', TestComponent);
+
+ expect(constructorParams[0]).to.be.eql(Number);
+ expect(constructorParams[1]).to.be.eql(String);
+ });
+
+}); |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 | 1x +1x +1x + +1x +1x + + + + +1x + + +1x + +1x +1x +1x + + +1x +1x +1x + + +1x +1x +1x + + + | import "reflect-metadata";
+import { expect } from "chai";
+import { Controller } from "../../utils/controller.decorator";
+
+describe('@Controller', () => {
+ const props = {
+ path: "test",
+ };
+
+ @Controller(props)
+ class Test {}
+
+ @Controller()
+ class AnotherTest {}
+
+ it('should decorate type with expected path metadata', () => {
+ const path = Reflect.getMetadata('path', Test);
+ expect(path).to.be.eql(props.path);
+ });
+
+ it('should set default path when no object passed as param', () => {
+ const path = Reflect.getMetadata('path', AnotherTest);
+ expect(path).to.be.eql("/");
+ });
+
+ it('should set default path when empty passed as param', () => {
+ const path = Reflect.getMetadata('path', AnotherTest);
+ expect(path).to.be.eql("/");
+ });
+
+}); |
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| component.decorator.spec.ts | +100% | +11/11 | +100% | +0/0 | +66.67% | +2/3 | +100% | +10/10 | +|
| controller.decorator.spec.ts | +100% | +18/18 | +100% | +0/0 | +100% | +4/4 | +100% | +16/16 | +|
| module.decorator.spec.ts | +100% | +20/20 | +100% | +0/0 | +100% | +3/3 | +100% | +19/19 | +|
| request-mapping.decorator.spec.ts | +100% | +19/19 | +100% | +0/0 | +66.67% | +4/6 | +100% | +19/19 | +
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 | 1x +1x +1x +1x + +1x +1x + + + + + + + +1x + +1x +1x +1x +1x +1x + +1x +1x +1x +1x + + +1x +1x + + + + +1x + + + | import "reflect-metadata";
+import { expect } from "chai";
+import { Module } from "../../utils/module.decorator";
+import { InvalidModuleConfigException } from "../../../errors/exceptions/invalid-module-config.exception";
+
+describe('@Module', () => {
+ const moduleProps = {
+ components: [ "Test" ],
+ modules: [ "Test" ],
+ exports: [ "Test" ],
+ controllers: [ "Test" ]
+ };
+
+ @Module(moduleProps)
+ class TestModule {}
+
+ it('should decorate type with expected module metadata', () => {
+ const modules = Reflect.getMetadata('modules', TestModule);
+ const components = Reflect.getMetadata('components', TestModule);
+ const exports = Reflect.getMetadata('exports', TestModule);
+ const controllers = Reflect.getMetadata('controllers', TestModule);
+
+ expect(modules).to.be.eql(moduleProps.modules);
+ expect(components).to.be.eql(moduleProps.components);
+ expect(controllers).to.be.eql(moduleProps.controllers);
+ expect(exports).to.be.eql(moduleProps.exports);
+ });
+
+ it('should throw exception when module properties are invalid', () => {
+ const invalidProps = {
+ ...moduleProps,
+ test: []
+ };
+
+ expect(Module.bind(null, invalidProps)).to.throw(InvalidModuleConfigException);
+ });
+
+}); |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 | 1x +1x +1x +1x +1x + +1x +1x + + + + +1x + + +1x + + +1x +1x + +1x +1x + + +1x + + +1x + + +1x +1x + + +1x +1x + + + | import "reflect-metadata";
+import { expect } from "chai";
+import { RequestMapping } from "../../utils/request-mapping.decorator";
+import { RequestMethod } from "../../enums/request-method.enum";
+import { InvalidPathVariableException } from "../../../errors/exceptions/invalid-path-variable.exception";
+
+describe('@RequestMapping', () => {
+ const requestProps = {
+ path: "test",
+ method: RequestMethod.ALL
+ };
+
+ it('should decorate type with expected request metadata', () => {
+ class Test {
+ @RequestMapping(requestProps)
+ static test() {}
+ }
+
+ const path = Reflect.getMetadata('path', Test.test);
+ const method = Reflect.getMetadata('method', Test.test);
+
+ expect(method).to.be.eql(requestProps.method);
+ expect(path).to.be.eql(requestProps.path);
+ });
+
+ it('should set request method on GET by default', () => {
+ class Test {
+ @RequestMapping({ path: "" })
+ static test() {}
+ }
+
+ const method = Reflect.getMetadata('method', Test.test);
+ expect(method).to.be.eql(RequestMethod.GET);
+ });
+
+ it('should throw exception when path variable is not set', () => {
+ expect(RequestMapping.bind(null, {})).throw(InvalidPathVariableException);
+ });
+
+}); |
| 1 +2 +3 | 1x +11x + | export const Component = (): ClassDecorator => {
+ return (target: Object) => {}
+}; |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 | 1x + + +1x + +1x +10x + + +10x +10x + + | import "reflect-metadata";
+import { ControllerMetadata } from "../interfaces/controller-metadata.interface";
+
+const defaultMetadata = { path: "/" };
+
+export const Controller = (metadata: ControllerMetadata = defaultMetadata): ClassDecorator => {
+ Iif (typeof metadata.path === "undefined") {
+ metadata.path = "/";
+ }
+ return (target: Object) => {
+ Reflect.defineMetadata("path", metadata.path, target);
+ }
+}; |
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| component.decorator.ts | +100% | +2/2 | +100% | +0/0 | +100% | +2/2 | +100% | +2/2 | +|
| controller.decorator.ts | +85.71% | +6/7 | +66.67% | +2/3 | +100% | +2/2 | +85.71% | +6/7 | +|
| module.decorator.ts | +100% | +13/13 | +75% | +3/4 | +100% | +4/4 | +100% | +12/12 | +|
| request-mapping.decorator.ts | +100% | +11/11 | +100% | +4/4 | +100% | +2/2 | +100% | +11/11 | +
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 | 1x + +1x + +1x +5x +5x + +5x +41x +1x + + +4x +4x +10x +10x + + + + | import "reflect-metadata";
+import { ModuleMetadata } from "../interfaces/module-metadata.interface";
+import { InvalidModuleConfigException } from "../../errors/exceptions/invalid-module-config.exception";
+
+export const Module = (props: ModuleMetadata): ClassDecorator => {
+ const propsKeys = Object.keys(props);
+ const acceptableParams = [ "modules", "exports", "components", "controllers" ];
+
+ propsKeys.map((prop) => {
+ if (acceptableParams.findIndex((param) => param === prop) < 0) {
+ throw new InvalidModuleConfigException(prop);
+ }
+ });
+ return (target: Object) => {
+ for (let property in props) {
+ Eif (props.hasOwnProperty(property)) {
+ Reflect.defineMetadata(property, props[property], target);
+ }
+ }
+ }
+}; |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 | 1x + +1x +1x + +1x +14x +1x + +13x + +13x +13x +13x + +13x + + | import "reflect-metadata";
+import { RequestMappingMetadata } from "../interfaces/request-mapping-metadata.interface";
+import { RequestMethod } from "../enums/request-method.enum";
+import { InvalidPathVariableException } from "../../errors/exceptions/invalid-path-variable.exception";
+
+export const RequestMapping = (metadata: RequestMappingMetadata): MethodDecorator => {
+ if (typeof metadata.path === "undefined") {
+ throw new InvalidPathVariableException("RequestMapping")
+ }
+ const requestMethod = metadata.method || RequestMethod.GET;
+
+ return function(target, key, descriptor: PropertyDescriptor) {
+ Reflect.defineMetadata("path", metadata.path, descriptor.value);
+ Reflect.defineMetadata("method", requestMethod, descriptor.value);
+
+ return descriptor;
+ }
+}; |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 | 1x + + +3x +3x + + +1x + + + +1x + + + | export class Exception {
+
+ constructor(
+ private readonly message: string,
+ private readonly status: number) {}
+
+ getMessage() {
+ return this.message;
+ }
+
+ getStatus() {
+ return this.status;
+ }
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 | 1x + +1x +6x + + +2x +1x +1x + + +1x + + + + + + | import { Exception } from "./exception";
+
+export class ExceptionsHandler {
+ private UNKOWN_EXCEPTION_MSG = "Unkown exception";
+
+ next(exception: Error | Exception, response) {
+ if (!(exception instanceof Exception)) {
+ response.status(500).json({ message: this.UNKOWN_EXCEPTION_MSG });
+ return;
+ }
+
+ response.status(exception.getStatus()).json({
+ message: exception.getMessage()
+ });
+ }
+
+}
+ |
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| exception.ts | +100% | +5/5 | +100% | +0/0 | +100% | +3/3 | +100% | +5/5 | +|
| exceptions-handler.ts | +100% | +7/7 | +100% | +2/2 | +100% | +2/2 | +100% | +7/7 | +
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| scanner.ts | +100% | +32/32 | +80% | +8/10 | +100% | +19/19 | +100% | +27/27 | +
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 | +1x + +1x +6x + + +8x +4x + + + + + + + + + + +4x + + + +3x +3x +3x + +3x + + + + +4x +4x +4x + + + + + + + +2x +2x +2x +1x + +1x + + + + + +4x +4x +4x + + + + + + + + + + + + + + + + + + + + | import { Controller, Injectable, NestModule } from "../../common/interfaces/";
+import { UnkownExportException } from "../../errors/exceptions/unkown-export.exception";
+
+export class NestContainer {
+ private readonly modules = new Map<NestModule, ModuleDependencies>();
+
+ addModule(moduleClass) {
+ if(!this.modules.has(moduleClass)) {
+ this.modules.set(moduleClass, {
+ instance: new moduleClass(),
+ relatedModules: new Set<ModuleDependencies>(),
+ components: new Map<Injectable, InstanceWrapper<Injectable>>(),
+ routes: new Map<Controller, InstanceWrapper<Controller>>(),
+ exports: new Set<Injectable>(),
+ });
+ }
+ }
+
+ getModules(): Map<NestModule, ModuleDependencies> {
+ return this.modules;
+ }
+
+ addRelatedModule(relatedModule: NestModule, module: NestModule) {
+ Eif(this.modules.has(module)) {
+ const storedModule = this.modules.get(module);
+ const related = this.modules.get(relatedModule);
+
+ storedModule.relatedModules.add(related);
+ }
+ }
+
+ addComponent(component: Injectable, module: NestModule) {
+ Eif(this.modules.has(module)) {
+ const storedModule = this.modules.get(module);
+ storedModule.components.set(component, {
+ instance: null,
+ isResolved: false,
+ });
+ }
+ }
+
+ addExportedComponent(exportedComponent: Injectable, module: NestModule) {
+ Eif(this.modules.has(module)) {
+ const storedModule = this.modules.get(module);
+ if (!storedModule.components.get(exportedComponent)) {
+ throw new UnkownExportException();
+ }
+ storedModule.exports.add(exportedComponent);
+ }
+
+ }
+
+ addRoute(route: Controller, module: NestModule) {
+ Eif(this.modules.has(module)) {
+ const storedModule = this.modules.get(module);
+ storedModule.routes.set(route, {
+ instance: null,
+ isResolved: false,
+ });
+ }
+ }
+
+}
+
+export interface ModuleDependencies {
+ instance: NestModule;
+ relatedModules?: Set<ModuleDependencies>;
+ components?: Map<Injectable, InstanceWrapper<Injectable>>;
+ routes?: Map<Controller, InstanceWrapper<Controller>>;
+ exports?: Set<Injectable>;
+}
+
+export interface InstanceWrapper<T> {
+ instance: T;
+ isResolved: boolean;
+} |
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| container.ts | +100% | +21/21 | +66.67% | +8/12 | +100% | +7/7 | +100% | +21/21 | +|
| injector.ts | +50.94% | +27/53 | +34.62% | +9/26 | +57.14% | +8/14 | +51.92% | +27/52 | +|
| instance-loader.ts | +100% | +21/21 | +100% | +0/0 | +100% | +14/14 | +100% | +21/21 | +
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 | 1x + + +1x +1x + +1x + +1x + + + + + + + + + + + + + + + + + + + + + +3x + +3x + + + + + + + + + + + +3x +3x +1x + +2x +2x +2x + + + +2x + + + + + +2x + +2x + + +2x +4x + +2x + + + +4x + + + +4x + + + +4x +4x + +4x + + +4x + + + +4x + + + + + + + +4x + + + + + + + + + + + + + + + + + + + + + + | import "reflect-metadata";
+import { ModuleDependencies, InstanceWrapper } from "./container";
+import { Middleware } from "../middlewares/interfaces/middleware.interface";
+import { CircularDependencyException } from "../../errors/exceptions/circular-dependency.exception";
+import { UnkownDependenciesException } from "../../errors/exceptions/unkown-dependencies.exception";
+import { MiddlewareProto } from "../middlewares/interfaces/middleware-proto.interface";
+import { RuntimeException } from "../../errors/exceptions/runtime.exception";
+
+export class Injector {
+
+ loadInstanceOfMiddleware(
+ middlewareType,
+ collection: Map<MiddlewareProto, Middleware>,
+ module: ModuleDependencies) {
+
+ const currentFetchedMiddleware = collection.get(middlewareType);
+
+ if(currentFetchedMiddleware === null) {
+ this.resolveConstructorParams(middlewareType, module, (argsInstances) => {
+ collection.set(middlewareType, new middlewareType(...argsInstances))
+ });
+ }
+ }
+
+ loadInstanceOfRoute(routeType, module: ModuleDependencies) {
+ const routes = module.routes;
+ this.loadInstance(routeType, routes, module);
+ }
+
+ loadPrototypeOfInstance<T>(type, collection: Map<T, InstanceWrapper<T>>) {
+ Iif (!collection) { return; }
+
+ collection.set(type, {
+ ...collection.get(type),
+ instance: Object.create(type.prototype),
+ });
+ }
+
+ loadInstanceOfComponent(componentType, module: ModuleDependencies) {
+ const components = module.components;
+ this.loadInstance(componentType, components, module);
+ }
+
+ loadInstance(type, collection, module: ModuleDependencies) {
+ const currentFetchedInstance = collection.get(type);
+ if (typeof currentFetchedInstance === 'undefined') {
+ throw new RuntimeException('');
+ }
+ Eif (!currentFetchedInstance.isResolved) {
+ this.resolveConstructorParams(type, module, (argsInstances) => {
+ currentFetchedInstance.instance = Object.assign(
+ currentFetchedInstance.instance,
+ new type(...argsInstances),
+ );
+ currentFetchedInstance.isResolved = true;
+ });
+ }
+ }
+
+ private resolveConstructorParams(type, module, callback) {
+ let constructorParams = Reflect.getMetadata('design:paramtypes', type) || [];
+
+ Iif ((<any>type).dependencies) {
+ constructorParams = (<any>type).dependencies;
+ }
+ const argsInstances = constructorParams.map((param) => (
+ this.resolveSingleParam(type, param, module)
+ ));
+ callback(argsInstances);
+ }
+
+ private resolveSingleParam(targetType, param, module: ModuleDependencies) {
+ Iif (typeof param === 'undefined') {
+ throw new CircularDependencyException(targetType);
+ }
+
+ return this.resolveComponentInstance(module, param, targetType);
+ }
+
+ private resolveComponentInstance(module: ModuleDependencies, param, componentType) {
+ const components = module.components;
+ const instanceWrapper = this.scanForComponent(components, param, module, componentType);
+
+ Iif (instanceWrapper.instance === null) {
+ this.loadInstanceOfComponent(param, module);
+ }
+ return instanceWrapper.instance;
+ }
+
+ private scanForComponent(components, param, module, componentType) {
+ Iif (!components.has(param)) {
+ const instanceWrapper = this.scanForComponentInRelatedModules(module, param);
+
+ if (instanceWrapper === null) {
+ throw new UnkownDependenciesException(componentType);
+ }
+ return instanceWrapper;
+ }
+ return components.get(param);
+ }
+
+ private scanForComponentInRelatedModules(module: ModuleDependencies, componentType) {
+ const relatedModules = module.relatedModules;
+ let component = null;
+
+ relatedModules.forEach((relatedModule) => {
+ const { components, exports } = relatedModule;
+
+ if (!exports.has(componentType) || !components.has(componentType)) {
+ return;
+ }
+
+ component = components.get(componentType);
+ if (!component.isResolved) {
+ this.loadInstanceOfComponent(componentType, relatedModule);
+ }
+ });
+ return component;
+ }
+
+} |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 | +1x + + + +1x +3x + +3x + + +3x + +3x +3x + + + +3x +3x +3x + + + + +3x +3x +3x + + + + +3x +2x + + + + +3x +2x + + + + +3x +2x + + + + +3x +2x + + + + | import { NestContainer, ModuleDependencies } from "./container";
+import { Injector } from "./injector";
+import { Injectable } from "../../common/interfaces/injectable.interface";
+import { Controller } from "../../common/interfaces/controller.interface";
+
+export class InstanceLoader {
+ private injector = new Injector();
+
+ constructor(private container: NestContainer) {}
+
+ createInstancesOfDependencies() {
+ const modules = this.container.getModules();
+
+ this.createPrototypes(modules);
+ this.createInstances(modules);
+ }
+
+ private createPrototypes(modules) {
+ modules.forEach((module) => {
+ this.createPrototypesOfComponents(module);
+ this.createPrototypesOfRoutes(module);
+ });
+ }
+
+ private createInstances(modules) {
+ modules.forEach((module) => {
+ this.createInstancesOfComponents(module);
+ this.createInstancesOfRoutes(module);
+ })
+ }
+
+ private createPrototypesOfComponents(module: ModuleDependencies) {
+ module.components.forEach((wrapper, componentType) => {
+ this.injector.loadPrototypeOfInstance<Injectable>(componentType, module.components);
+ });
+ }
+
+ private createInstancesOfComponents(module: ModuleDependencies) {
+ module.components.forEach((wrapper, componentType) => {
+ this.injector.loadInstanceOfComponent(componentType, module);
+ });
+ }
+
+ private createPrototypesOfRoutes(module: ModuleDependencies) {
+ module.routes.forEach((wrapper, routeType) => {
+ this.injector.loadPrototypeOfInstance<Controller>(routeType, module.routes);
+ });
+ }
+
+ private createInstancesOfRoutes(module: ModuleDependencies) {
+ module.routes.forEach((wrapper, routeType) => {
+ this.injector.loadInstanceOfRoute(routeType, module);
+ });
+ }
+
+} |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 | +1x + +1x +5x + + +4x + + +1x + + +3x +3x + + + +3x + + + | import { MiddlewareConfiguration } from "./interfaces/middleware-configuration.interface";
+import { InvalidMiddlewareConfigurationException } from "../../errors/exceptions/invalid-middleware-configuration.exception";
+
+export class MiddlewareBuilder {
+ private storedConfiguration = new Set<MiddlewareConfiguration>();
+
+ use(configuration: MiddlewareConfiguration) {
+ if (typeof configuration.middlewares === "undefined" ||
+ typeof configuration.forRoutes === "undefined") {
+
+ throw new InvalidMiddlewareConfigurationException();
+ }
+
+ this.storedConfiguration.add(configuration);
+ return this;
+ }
+
+ build() {
+ return [ ...this.storedConfiguration ];
+ }
+
+} |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 | + + + + + +1x +4x +4x + +4x + + +7x + + + +1x + + + +5x +5x + +5x +4x + +4x + + + +4x +4x + + + + +4x +7x +3x + + + +5x +3x + +5x + + + +5x +3x + +5x + + + | import { MiddlewareConfiguration } from "./interfaces/middleware-configuration.interface";
+import { Middleware } from "./interfaces/middleware.interface";
+import { MiddlewareProto } from "./interfaces/middleware-proto.interface";
+import { RoutesMapper } from "./routes-mapper";
+import { NestModule } from "../../common/interfaces/nest-module.interface";
+
+export class MiddlewaresContainer {
+ private readonly middlewares = new Map<NestModule, Map<MiddlewareProto, Middleware>>();
+ private readonly configs = new Map<NestModule, Set<MiddlewareConfiguration>>();
+
+ constructor(private routesMapper: RoutesMapper) {}
+
+ getMiddlewares(module: NestModule): Map<MiddlewareProto, Middleware> {
+ return this.middlewares.get(module) || new Map();
+ }
+
+ getConfigs(): Map<NestModule, Set<MiddlewareConfiguration>> {
+ return this.configs;
+ }
+
+ addConfig(configList: MiddlewareConfiguration[], module: NestModule) {
+ const currentMiddlewares = this.getCurrentMiddlewares(module);
+ const currentConfig = this.getCurrentConfig(module);
+
+ (configList || []).map((config) => {
+ [].concat(config.middlewares).map(
+ (middleware) => {
+ currentMiddlewares.set(middleware, null);
+ }
+ );
+
+ config.forRoutes = this.mapRoutesToFlatList(config.forRoutes);
+ currentConfig.add(config);
+ });
+ }
+
+ private mapRoutesToFlatList(forRoutes) {
+ return forRoutes.map((route) => (
+ this.routesMapper.mapRouteToRouteProps(route)
+ )).reduce((a, b) => a.concat(b));
+ }
+
+ private getCurrentMiddlewares(module: NestModule) {
+ if (!this.middlewares.has(module)) {
+ this.middlewares.set(module, new Map<MiddlewareProto, Middleware>());
+ }
+ return this.middlewares.get(module);
+ }
+
+ private getCurrentConfig(module: NestModule) {
+ if (!this.configs.has(module)) {
+ this.configs.set(module, new Set<MiddlewareConfiguration>());
+ }
+ return this.configs.get(module);
+ }
+}
+ |
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| builder.ts | +100% | +8/8 | +100% | +4/4 | +100% | +3/3 | +100% | +8/8 | +|
| container.ts | +100% | +22/22 | +75% | +6/8 | +100% | +11/11 | +100% | +22/22 | +|
| middlewares-module.ts | +62.22% | +28/45 | +53.85% | +7/13 | +41.67% | +5/12 | +62.22% | +28/45 | +|
| resolver.ts | +100% | +7/7 | +100% | +0/0 | +100% | +3/3 | +100% | +7/7 | +|
| routes-mapper.ts | +100% | +16/16 | +100% | +8/8 | +100% | +5/5 | +100% | +15/15 | +
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 | + +1x +1x +1x + + + +1x +1x +1x +1x + +1x +1x + + + +2x + + + + + + + + + + + + + + + + + + + +1x + + + +1x +1x + +1x +1x +1x + + + + + + + + + + + + + + + + + + + + + + +3x + +3x +3x +3x + +3x +1x + +2x +1x + +1x +1x + + + + +1x + + + + + +1x + + + + | import { Application } from "express";
+import { NestContainer, ModuleDependencies } from "../injector/container";
+import { MiddlewareBuilder } from "./builder";
+import { MiddlewaresContainer } from "./container";
+import { MiddlewaresResolver } from "./resolver";
+import { ControllerMetadata } from "../../common/interfaces/controller-metadata.interface";
+import { NestModule } from "../../common/interfaces/nest-module.interface";
+import { MiddlewareConfiguration } from "./interfaces/middleware-configuration.interface";
+import { UnkownMiddlewareException } from "../../errors/exceptions/unkown-middleware.exception";
+import { InvalidMiddlewareException } from "../../errors/exceptions/invalid-middleware.exception";
+import { RequestMethod } from "../../common/enums/request-method.enum";
+import { RoutesMapper } from "./routes-mapper";
+
+export class MiddlewaresModule {
+ private static container = new MiddlewaresContainer(new RoutesMapper());
+ private static resolver: MiddlewaresResolver;
+
+ static getContainer(): MiddlewaresContainer {
+ return this.container;
+ }
+
+ static setup(container: NestContainer) {
+ this.resolver = new MiddlewaresResolver(this.container);
+
+ const modules = container.getModules();
+ this.resolveMiddlewares(modules);
+ }
+
+ static resolveMiddlewares(modules: Map<NestModule, ModuleDependencies>) {
+ modules.forEach((module, moduleProto) => {
+ const instance = module.instance;
+
+ this.loadConfiguration(instance, moduleProto);
+ this.resolver.resolveInstances(module, moduleProto);
+ });
+ }
+
+ static loadConfiguration(instance, module: NestModule) {
+ Iif (!instance.configure) {
+ return;
+ }
+
+ const middlewaresBuilder = new MiddlewareBuilder();
+ instance.configure(middlewaresBuilder);
+
+ Eif (middlewaresBuilder instanceof MiddlewareBuilder) {
+ const config = middlewaresBuilder.build();
+ this.container.addConfig(config, module);
+ }
+ }
+
+ static setupMiddlewares(app: Application) {
+ const configs = this.container.getConfigs();
+
+ configs.forEach((moduleConfigs, module) => {
+ [ ...moduleConfigs ].map((config: MiddlewareConfiguration) => {
+
+ config.forRoutes.map((route: ControllerMetadata & { method: RequestMethod }) => {
+ this.setupRouteMiddleware(route, config, module, app);
+ });
+ });
+ });
+ }
+
+ static setupRouteMiddleware(
+ route: ControllerMetadata & { method: RequestMethod },
+ config: MiddlewareConfiguration,
+ module: NestModule,
+ app: Application) {
+
+ const { path, method } = route;
+
+ [].concat(config.middlewares).map((middlewareType) => {
+ const middlewaresCollection = this.container.getMiddlewares(module);
+ const middleware = middlewaresCollection.get(middlewareType);
+
+ if (typeof middleware === "undefined") {
+ throw new UnkownMiddlewareException();
+ }
+ if (typeof middleware.resolve === "undefined") {
+ throw new InvalidMiddlewareException();
+ }
+ const router = this.findRouterMethod(app, method).bind(app);
+ router(path, middleware.resolve());
+ });
+ }
+
+ private static findRouterMethod(app, requestMethod: RequestMethod) {
+ switch(requestMethod) {
+ case RequestMethod.POST: { return app.post; }
+ case RequestMethod.ALL: { return app.all; }
+ case RequestMethod.DELETE: { return app.delete; }
+ case RequestMethod.PUT: { return app.put; }
+ default: {
+ return app.get;
+ }
+ }
+ }
+} |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 | + +1x + + +1x +1x + +1x + + +1x + +1x +1x + + + + + + + + + | import { ModuleDependencies } from "../injector/container";
+import { MiddlewaresContainer } from "./container";
+import { Injector } from "../injector/injector";
+import { NestModule } from "../../common/interfaces/nest-module.interface";
+
+export class MiddlewaresResolver {
+ private instanceLoader = new Injector();
+
+ constructor(private middlewaresContainer: MiddlewaresContainer) {}
+
+ resolveInstances(module: ModuleDependencies, moduleProto: NestModule) {
+ const middlewares = this.middlewaresContainer.getMiddlewares(moduleProto);
+
+ middlewares.forEach((val, middlewareType) => {
+ this.instanceLoader.loadInstanceOfMiddleware(
+ middlewareType,
+ middlewares,
+ module
+ );
+ });
+ }
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 | 1x +1x +1x +1x + +1x +6x + + +10x + +10x +4x + + +6x + + + + +10x + + + + + + +4x +1x + + +3x + + + + + + +23x + + + + | import "reflect-metadata";
+import { RouterBuilder } from "../router/router-builder";
+import { UnkownRequestMappingException } from "../../errors/exceptions/unkown-request-mapping.exception";
+import { RequestMethod } from "../../common/enums/request-method.enum";
+
+export class RoutesMapper {
+ private readonly routerBuilder = new RouterBuilder();
+
+ mapRouteToRouteProps(routeProto) {
+ const routePath: string = Reflect.getMetadata("path", routeProto);
+
+ if (typeof routePath === "undefined") {
+ return [ this.mapObjectToRouteProps(routeProto) ];
+ }
+
+ const paths = this.routerBuilder.scanForPathsFromPrototype(
+ Object.create(routeProto),
+ routeProto.prototype
+ );
+
+ return paths.map((singlePath) => ({
+ path: this.validateRoutePath(routePath) + this.validateRoutePath(singlePath.path),
+ method: singlePath.requestMethod
+ }));
+ }
+
+ private mapObjectToRouteProps(route) {
+ if (typeof route.path === "undefined") {
+ throw new UnkownRequestMappingException();
+ }
+
+ return {
+ path: this.validateRoutePath(route.path),
+ method: (typeof route.method === "undefined") ? RequestMethod.ALL : route.method
+ };
+ }
+
+ private validateRoutePath(routePath: string): string {
+ return (routePath.charAt(0) !== '/') ? '/' + routePath : routePath;
+ }
+
+}
+ |
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| router-builder.ts | +90% | +36/40 | +53.85% | +7/13 | +100% | +14/14 | +90% | +36/40 | +|
| router-proxy.ts | +100% | +7/7 | +100% | +0/0 | +100% | +4/4 | +100% | +7/7 | +|
| routes-resolver.ts | +76.92% | +10/13 | +100% | +0/0 | +60% | +3/5 | +83.33% | +10/12 | +
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 | 1x + +1x + +1x + + +1x + + +10x +10x + + +1x +1x +1x + +1x + +1x + + + +1x +1x + + + +8x +24x +16x +16x + + + +17x + +17x +17x +1x + + +16x +16x + + + + + + + +2x +4x + + + + +2x + +2x +2x + +2x + + + +2x +1x + + + + +1x + + + + + +1x +1x + + + +17x + + +17x + + + + + + + + + | import "reflect-metadata";
+import { Controller } from "../../common/interfaces/controller.interface";
+import { RequestMethod } from "../../common/enums/request-method.enum";
+import { RouterProxy, RouterProxyCallback } from "./router-proxy";
+import { UnkownRequestMappingException } from "../../errors/exceptions/unkown-request-mapping.exception";
+import { ExpressAdapter } from "../adapters/express-adapter";
+
+export class RouterBuilder {
+
+ constructor(
+ private routerProxy?: RouterProxy,
+ private expressAdapter?: ExpressAdapter) {}
+
+ public build(instance: Controller, routePrototype: Function) {
+ const router = (<any>this.expressAdapter).createRouter();
+ const path = this.fetchRouterPath(routePrototype);
+ const routerPaths = this.scanForPaths(instance);
+
+ this.applyPathsToRouterProxy(router, routerPaths);
+
+ return { path, router };
+ }
+
+ scanForPaths(instance: Controller): RoutePathProperties[] {
+ const instancePrototype = Object.getPrototypeOf(instance);
+ return this.scanForPathsFromPrototype(instance, instancePrototype);
+ }
+
+ scanForPathsFromPrototype(instance: Controller, instancePrototype) {
+ return Object.getOwnPropertyNames(instancePrototype)
+ .filter((method) => method !== "constructor")
+ .map((methodName) => this.exploreMethodMetadata(instance, instancePrototype, methodName))
+ .filter((path) => path !== null);
+ }
+
+ exploreMethodMetadata(instance, instancePrototype, methodName: string): RoutePathProperties {
+ const callbackMethod = instancePrototype[methodName];
+
+ const routePath = Reflect.getMetadata("path", callbackMethod);
+ if(typeof routePath === "undefined") {
+ return null;
+ }
+
+ const requestMethod: RequestMethod = Reflect.getMetadata("method", callbackMethod);
+ return {
+ targetCallback: (<Function>callbackMethod).bind(instance),
+ path: this.validateRoutePath(routePath),
+ requestMethod,
+ };
+ }
+
+ applyPathsToRouterProxy(router, routePaths: RoutePathProperties[]) {
+ (routePaths || []).map((pathProperties) => {
+ this.bindMethodToRouterProxy(router, pathProperties);
+ });
+ }
+
+ private bindMethodToRouterProxy(router, pathProperties: RoutePathProperties) {
+ const { path, requestMethod, targetCallback } = pathProperties;
+
+ const routerMethod = this.findRouterMethod(router, requestMethod).bind(router);
+ const proxy = this.routerProxy.createProxy(targetCallback);
+
+ routerMethod(path, proxy);
+ }
+
+ private findRouterMethod(router, requestMethod: RequestMethod) {
+ switch(requestMethod) {
+ case RequestMethod.POST: { return router.post; }
+ case RequestMethod.ALL: { return router.all; }
+ case RequestMethod.DELETE: { return router.delete; }
+ case RequestMethod.PUT: { return router.put; }
+ default: {
+ return router.get;
+ }
+ }
+ }
+
+ private fetchRouterPath(routePrototype: Function) {
+ const path = Reflect.getMetadata("path", routePrototype);
+ return this.validateRoutePath(path);
+ }
+
+ private validateRoutePath(routePath: string): string {
+ Iif(typeof routePath === "undefined") {
+ throw new UnkownRequestMappingException();
+ }
+ return (routePath.charAt(0) !== '/') ? '/' + routePath : routePath;
+ }
+
+}
+
+export interface RoutePathProperties {
+ path: string,
+ requestMethod: RequestMethod,
+ targetCallback: RouterProxyCallback,
+} |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 | + +1x + +4x + + +5x +2x +2x +1x + + + +1x + + + + + + + + + + | import { ExceptionsHandler } from "../exceptions/exceptions-handler";
+
+export class RouterProxy {
+
+ constructor(private exceptionsHandler: ExceptionsHandler) {}
+
+ createProxy(targetCallback: RouterProxyCallback) {
+ return (req, res, next) => {
+ try {
+ Promise.resolve(targetCallback(req, res, next)).catch((e) => {
+ this.exceptionsHandler.next(e, res);
+ });
+ }
+ catch(e) {
+ this.exceptionsHandler.next(e, res);
+ }
+ }
+ }
+
+}
+
+export interface RouterProxyCallback {
+ (req?, res?, next?): void;
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 | + +1x +1x +1x + + +1x +1x + + +1x +1x + + + + + + + + + + + +1x +1x + +1x + + + | import { Application } from "express";
+import { NestContainer, InstanceWrapper } from "../injector/container";
+import { RouterBuilder } from "./router-builder";
+import { RouterProxy } from "./router-proxy";
+import { ExceptionsHandler } from "../exceptions/exceptions-handler";
+import { Controller } from "../../common/interfaces/controller.interface";
+
+export class RoutesResolver {
+ private readonly routerProxy = new RouterProxy(new ExceptionsHandler());
+ private routerBuilder: RouterBuilder;
+
+ constructor(private container: NestContainer, expressAdapter) {
+ this.routerBuilder = new RouterBuilder(this.routerProxy, expressAdapter);
+ }
+
+ resolve(expressInstance: Application) {
+ const modules = this.container.getModules();
+ modules.forEach(({ routes }) => this.setupRouters(routes, expressInstance));
+ }
+
+ setupRouters(
+ routes: Map<Controller, InstanceWrapper<Controller>>,
+ expressInstance: Application) {
+
+ routes.forEach(({ instance }, routePrototype: Function) => {
+ const { path, router } = this.routerBuilder.build(instance, routePrototype);
+
+ expressInstance.use(path, router);
+ });
+ }
+} |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 | 1x + + + + + +1x + +4x + + +4x +4x + + + +8x + +8x +8x + + + +8x + + + +4x + +4x +6x +6x +6x +6x + + + + + +6x +6x + + + +6x +6x + + + +6x +6x + + + +6x +6x + + + +3x + + + +6x + + + +2x + + + +6x + + + | import "reflect-metadata";
+import { NestContainer } from "./injector/container";
+import { NestModule } from "../common/interfaces/nest-module.interface";
+import { Controller } from "../common/interfaces/controller.interface";
+import { Injectable } from "../common/interfaces/injectable.interface";
+
+export class DependenciesScanner {
+
+ constructor(private container: NestContainer) {}
+
+ scan(module: NestModule) {
+ this.scanForModules(module);
+ this.scanModulesForDependencies();
+ }
+
+ private scanForModules(module: NestModule) {
+ this.storeModule(module);
+
+ const innerModules = Reflect.getMetadata('modules', module) || [];
+ innerModules.map((module) => this.scanForModules(module));
+ }
+
+ private storeModule(module: NestModule) {
+ this.container.addModule(module);
+ }
+
+ private scanModulesForDependencies() {
+ const modules = this.container.getModules();
+
+ modules.forEach((deps, module) => {
+ this.reflectRelatedModules(module);
+ this.reflectComponents(module);
+ this.reflectRoutes(module);
+ this.reflectExports(module);
+ });
+ }
+
+
+ private reflectRelatedModules(module: NestModule) {
+ const modules = Reflect.getMetadata('modules', module) || [];
+ modules.map((related) => this.storeRelatedModule(related, module));
+ }
+
+ private reflectComponents(module: NestModule) {
+ const components = Reflect.getMetadata('components', module) || [];
+ components.map((component) => this.storeComponent(component, module));
+ }
+
+ private reflectRoutes(module: NestModule) {
+ const routes = Reflect.getMetadata('controllers', module) || [];
+ routes.map((route) => this.storeRoute(route, module));
+ }
+
+ private reflectExports(module: NestModule) {
+ const exports = Reflect.getMetadata('exports', module) || [];
+ exports.map((exportedComponent) => this.storeExportedComponent(exportedComponent, module));
+ }
+
+ private storeRelatedModule(related: NestModule, module: NestModule) {
+ this.container.addRelatedModule(related, module);
+ }
+
+ private storeComponent(component: Injectable, module: NestModule) {
+ this.container.addComponent(component, module);
+ }
+
+ private storeExportedComponent(exportedComponent: Injectable, module: NestModule) {
+ this.container.addExportedComponent(exportedComponent, module);
+ }
+
+ private storeRoute(route: Controller, module: NestModule) {
+ this.container.addRoute(route, module);
+ }
+
+} |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 | 1x +1x +1x +1x + +1x + + + + + +1x +2x +2x +2x + +2x + + + +2x +2x + + +1x + +1x +1x + +1x +1x + + +1x +1x +1x + +1x + +1x +1x + + + + + | import * as sinon from "sinon";
+import { expect } from "chai";
+import { ExceptionsHandler } from "../../exceptions/exceptions-handler";
+import { Exception } from "../../exceptions/exception";
+
+describe('ExceptionsHandler', () => {
+ let handler: ExceptionsHandler;
+ let statusStub: sinon.SinonStub;
+ let jsonStub: sinon.SinonStub;
+ let response;
+
+ beforeEach(() => {
+ handler = new ExceptionsHandler();
+ statusStub = sinon.stub();
+ jsonStub = sinon.stub();
+
+ response = {
+ status: statusStub,
+ json: jsonStub
+ };
+ response.status.returns(response);
+ response.json.returns(response);
+ });
+
+ describe('next', () => {
+
+ it('should method send expected response status code and message when exception is unknown', () => {
+ handler.next(new Error(), response);
+
+ expect(statusStub.calledWith(500)).to.be.true;
+ expect(jsonStub.calledWith({ message: "Unkown exception" })).to.be.true;
+ });
+
+ it('should method send expected response status code and message when exception is instance of Exception', () => {
+ const status = 401;
+ const message = "Unauthorized";
+
+ handler.next(new Exception(message, status), response);
+
+ expect(statusStub.calledWith(status)).to.be.true;
+ expect(jsonStub.calledWith({ message })).to.be.true;
+ });
+
+ });
+
+}); |
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| exceptions-handler.spec.ts | +100% | +23/23 | +100% | +0/0 | +100% | +5/5 | +100% | +23/23 | +
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| scanner.spec.ts | +100% | +40/40 | +100% | +0/0 | +100% | +8/8 | +100% | +36/36 | +
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 | 1x +1x +1x + + +1x + +1x + + + +1x + +1x +2x + + +1x +1x + +1x + + + + + + + + + +1x +1x + +1x + + + + + | import { expect } from "chai";
+import { NestContainer, ModuleDependencies, InstanceWrapper } from "../../injector/container";
+import { Module } from "../../../common/utils/module.decorator";
+import { Injectable } from "../../../common/interfaces/injectable.interface";
+import { Controller } from "../../../common/interfaces/controller.interface";
+import { UnkownExportException } from "../../../errors/exceptions/unkown-export.exception";
+
+describe('NestContainer', () => {
+ let container: NestContainer;
+
+ @Module({})
+ class TestModule {}
+
+ beforeEach(() => {
+ container = new NestContainer();
+ });
+
+ it('should create module instance and collections for dependencies', () => {
+ container.addModule(TestModule);
+
+ expect(container["modules"].get(TestModule)).to.be.deep.equal({
+ instance: new TestModule(),
+ relatedModules: new Set<ModuleDependencies>(),
+ components: new Map<Injectable, InstanceWrapper<any>>(),
+ routes: new Map<Controller, InstanceWrapper<Controller>>(),
+ exports: new Set<Injectable>(),
+ })
+ });
+
+
+ it('should throw "UnkownExportException" when given exported component is not a part of components array', () => {
+ container.addModule(TestModule);
+
+ expect(
+ container.addExportedComponent.bind(container, <any>"Test", TestModule)
+ ).throws(UnkownExportException);
+ });
+
+}); |
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| container.spec.ts | +100% | +15/15 | +100% | +0/0 | +100% | +4/4 | +100% | +14/14 | +|
| injector.spec.ts | +100% | +43/43 | +100% | +0/0 | +100% | +11/11 | +100% | +39/39 | +|
| instance-loader.spec.ts | +100% | +55/55 | +100% | +0/0 | +100% | +5/5 | +100% | +53/53 | +
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 | 1x + +1x +1x +1x + +1x + + +1x +4x + + +1x + + +1x + + +1x + + +1x + +2x +2x + + + + +1x +3x + + + +3x + + + +3x + + + +3x + + + + + +1x +1x +1x + +1x +1x +1x + + +1x +1x +1x +1x + + +1x +1x + + + + + + +1x + + +1x + + + +1x +1x + + + +1x + + + + + +1x +1x + + + +1x +1x + + + + | import { expect } from "chai";
+import { ModuleDependencies, InstanceWrapper } from "../../injector/container";
+import { Injector } from "../../injector/injector";
+import { Component } from "../../../common/utils/component.decorator";
+import { RuntimeException } from "../../../errors/exceptions/runtime.exception";
+
+describe('Injector', () => {
+ let injector: Injector;
+
+ beforeEach(() => {
+ injector = new Injector();
+ });
+
+ describe('loadInstance', () => {
+
+ @Component()
+ class DependencyOne {}
+
+ @Component()
+ class DependencyTwo {}
+
+ @Component()
+ class MainTest {
+ constructor(
+ public depOne: DependencyOne,
+ public depTwo: DependencyTwo) {}
+ }
+
+ let moduleDeps: ModuleDependencies;
+
+ beforeEach(() => {
+ moduleDeps = {
+ instance: null,
+ components: new Map<any, InstanceWrapper<any>>(),
+ };
+ moduleDeps.components.set(MainTest, {
+ instance: Object.create(MainTest.prototype),
+ isResolved: false
+ });
+ moduleDeps.components.set(DependencyOne, {
+ instance: Object.create(DependencyOne.prototype),
+ isResolved: false
+ });
+ moduleDeps.components.set(DependencyTwo, {
+ instance: Object.create(DependencyOne.prototype),
+ isResolved: false
+ });
+ });
+
+ it('should create an instance of component with proper dependencies', () => {
+ injector.loadInstance(MainTest, moduleDeps.components, moduleDeps);
+ const { instance } = <InstanceWrapper<MainTest>>(moduleDeps.components.get(MainTest));
+
+ expect(instance.depOne instanceof DependencyOne).to.be.true;
+ expect(instance.depTwo instanceof DependencyOne).to.be.true;
+ expect(instance instanceof MainTest).to.be.true;
+ });
+
+ it('should set "isResolved" property to true after instance initialization', () => {
+ injector.loadInstance(MainTest, moduleDeps.components, moduleDeps);
+ const { isResolved } = <InstanceWrapper<MainTest>>(moduleDeps.components.get(MainTest));
+ expect(isResolved).to.be.true;
+ });
+
+ it('should throw RuntimeException when type is not stored in collection', () => {
+ expect(
+ injector.loadInstance.bind(injector, "Test", moduleDeps.components, moduleDeps)
+ ).to.throw(RuntimeException);
+ });
+
+ });
+
+ describe('loadPrototypeOfInstance', () => {
+
+ @Component()
+ class Test {}
+
+ let moduleDeps: ModuleDependencies;
+
+ beforeEach(() => {
+ moduleDeps = {
+ instance: null,
+ components: new Map<any, InstanceWrapper<any>>(),
+ };
+ moduleDeps.components.set(Test, {
+ instance: Object.create(Test.prototype),
+ isResolved: false
+ });
+ });
+
+ it('should create prototype of instance', () => {
+ const expectedResult = {
+ instance: Object.create(Test.prototype),
+ isResolved: false
+ };
+ injector.loadPrototypeOfInstance(Test, moduleDeps.components);
+ expect(moduleDeps.components.get(Test)).to.deep.equal(expectedResult);
+ });
+ });
+
+}); |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 | 1x +1x +1x +1x +1x +1x +1x + +1x + + + + + +1x + + +1x + +1x +3x +3x +3x + + +1x +1x +1x + +1x + + + +1x +1x + +1x +1x +1x + +1x + +1x +1x + +1x +1x +1x + + +1x +1x +1x + +1x + + + +1x + +1x +1x +1x + +1x +1x + +1x +1x + + +1x +1x +1x + +1x + + + +1x + +1x +1x +1x + +1x +1x + +1x +1x + + + | import * as sinon from "sinon";
+import { expect } from "chai";
+import { InstanceLoader } from "../../injector/instance-loader";
+import { NestContainer } from "../../injector/container";
+import { Injector } from "../../injector/injector";
+import { Controller } from "../../../common/utils/controller.decorator";
+import { Component } from "../../../common/utils/component.decorator";
+
+describe('NestContainer', () => {
+ let loader: InstanceLoader;
+ let container: NestContainer;
+ let mockContainer: sinon.SinonMock;
+
+ @Controller({ path: "" })
+ class TestRoute {}
+
+ @Component()
+ class TestComponent {}
+
+ beforeEach(() => {
+ container = new NestContainer();
+ loader = new InstanceLoader(container);
+ mockContainer = sinon.mock(container);
+ });
+
+ it('should call "loadPrototypeOfInstance" for each component and route in each module', () => {
+ const injector = new Injector();
+ loader["injector"] = injector;
+
+ const module = {
+ components: new Map(),
+ routes: new Map(),
+ };
+ module.components.set(TestComponent, { instance: null });
+ module.routes.set(TestRoute, { instance: null });
+
+ const modules = new Map();
+ modules.set("Test", module);
+ mockContainer.expects("getModules").returns(modules);
+
+ const loadComponentPrototypeStub = sinon.stub(injector, "loadPrototypeOfInstance");
+
+ sinon.stub(injector, "loadInstanceOfRoute");
+ sinon.stub(injector, "loadInstanceOfComponent");
+
+ loader.createInstancesOfDependencies();
+ expect(loadComponentPrototypeStub.calledWith(TestComponent, module.components)).to.be.true;
+ expect(loadComponentPrototypeStub.calledWith(TestRoute, module.components)).to.be.true;
+ });
+
+ it('should call "loadInstanceOfComponent" for each component in each module', () => {
+ const injector = new Injector();
+ loader["injector"] = injector;
+
+ const module = {
+ components: new Map(),
+ routes: new Map(),
+ };
+ module.components.set(TestComponent, { instance: null });
+
+ const modules = new Map();
+ modules.set("Test", module);
+ mockContainer.expects("getModules").returns(modules);
+
+ const loadComponentStub = sinon.stub(injector, "loadInstanceOfComponent");
+ sinon.stub(injector, "loadInstanceOfRoute");
+
+ loader.createInstancesOfDependencies();
+ expect(loadComponentStub.calledWith(TestComponent, module)).to.be.true;
+ });
+
+ it('should call "loadInstanceOfRoute" for each route in each module', () => {
+ const injector = new Injector();
+ loader["injector"] = injector;
+
+ const module = {
+ components: new Map(),
+ routes: new Map(),
+ };
+ module.routes.set(TestRoute, { instance: null });
+
+ const modules = new Map();
+ modules.set("Test", module);
+ mockContainer.expects("getModules").returns(modules);
+
+ sinon.stub(injector, "loadInstanceOfComponent");
+ const loadRoutesStub = sinon.stub(injector, "loadInstanceOfRoute");
+
+ loader.createInstancesOfDependencies();
+ expect(loadRoutesStub.calledWith(TestRoute, module)).to.be.true;
+ });
+
+}); |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 | 1x +1x +1x + +1x + + +1x +3x + + +1x +1x + + + + +1x + + + + + +1x +1x + + + + + + +1x + + + + + + + + +1x +1x + + + | import { expect } from "chai";
+import { MiddlewareBuilder } from "../../middlewares/builder";
+import { InvalidMiddlewareConfigurationException } from "../../../errors/exceptions/invalid-middleware-configuration.exception";
+
+describe('MiddlewareBuilder', () => {
+ let builder: MiddlewareBuilder;
+
+ beforeEach(() => {
+ builder = new MiddlewareBuilder();
+ });
+
+ it('should store configuration passed as argument', () => {
+ builder.use(<any>{
+ middlewares: "Test",
+ forRoutes: "Test"
+ });
+
+ expect(builder.build()).to.deep.equal([{
+ middlewares: "Test",
+ forRoutes: "Test"
+ }]);
+ });
+
+ it('should be possible to chain "use" calls', () => {
+ builder.use(<any>{
+ middlewares: "Test",
+ forRoutes: "Test"
+ }).use(<any>{
+ middlewares: "Test",
+ forRoutes: "Test"
+ });
+ expect(builder.build()).to.deep.equal([<any>{
+ middlewares: "Test",
+ forRoutes: "Test"
+ }, <any>{
+ middlewares: "Test",
+ forRoutes: "Test"
+ }]);
+ });
+
+ it('should throw exception when middleware configuration object is invalid', () => {
+ expect(builder.use.bind(builder, "test")).throws(InvalidMiddlewareConfigurationException);
+ });
+
+}); |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 | 1x +1x + + +1x +1x +1x +1x +1x + +1x + +1x + + +1x + + +1x + + + +1x + + + + + + + +1x +2x + + +1x +1x + + + + + + + +1x +1x + + +1x +1x + + + + + +1x +1x +1x +1x + + + | import { expect } from "chai";
+import { MiddlewaresContainer } from "../../middlewares/container";
+import { MiddlewareConfiguration } from "../../middlewares/interfaces/middleware-configuration.interface";
+import { Middleware } from "../../middlewares/interfaces/middleware.interface";
+import { Component } from "../../../common/utils/component.decorator";
+import { RoutesMapper } from "../../middlewares/routes-mapper";
+import { Controller } from "../../../common/utils/controller.decorator";
+import { RequestMapping } from "../../../common/utils/request-mapping.decorator";
+import { RequestMethod } from "../../../common/enums/request-method.enum";
+
+describe('MiddlewaresContainer', () => {
+ @Controller({ path: "test" })
+ class TestRoute {
+
+ @RequestMapping({ path: "test" })
+ getTest() {}
+
+ @RequestMapping({ path: "another", method: RequestMethod.DELETE })
+ getAnother() {}
+ }
+
+ @Component()
+ class TestMiddleware implements Middleware {
+ resolve() {
+ return (req, res, next) => {}
+ }
+ }
+
+ let container: MiddlewaresContainer;
+
+ beforeEach(() => {
+ container = new MiddlewaresContainer(new RoutesMapper());
+ });
+
+ it('should store expected configurations for given module', () => {
+ const config: MiddlewareConfiguration[] = [{
+ middlewares: [ TestMiddleware ],
+ forRoutes: [
+ TestRoute,
+ { path: "test" }
+ ]
+ }
+ ];
+ container.addConfig(config, <any>"Module");
+ expect([ ...container.getConfigs().get("Module") ]).to.deep.equal(config);
+ });
+
+ it('should store expected middlewares for given module', () => {
+ const config: MiddlewareConfiguration[] = [{
+ middlewares: TestMiddleware,
+ forRoutes: [ TestRoute ]
+ }
+ ];
+
+ const key = <any>"Test";
+ container.addConfig(config, key);
+ expect(container.getMiddlewares(key).size).to.eql(config.length);
+ expect(container.getMiddlewares(key).get(TestMiddleware)).to.eql(null);
+ });
+
+}); |
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| builder.spec.ts | +100% | +14/14 | +100% | +0/0 | +100% | +5/5 | +100% | +14/14 | +|
| container.spec.ts | +96.3% | +26/27 | +100% | +0/0 | +50% | +4/8 | +96% | +24/25 | +|
| middlewares-module.spec.ts | +100% | +59/59 | +100% | +0/0 | +72.73% | +8/11 | +100% | +55/55 | +|
| resolver.spec.ts | +95.65% | +22/23 | +100% | +0/0 | +60% | +3/5 | +95.45% | +21/22 | +|
| routes-mapper.spec.ts | +100% | +20/20 | +100% | +0/0 | +66.67% | +4/6 | +100% | +19/19 | +
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 | 1x +1x + +1x +1x +1x +1x +1x +1x +1x +1x + +1x + +1x + + +1x + + +1x + + +1x + + + +1x + +1x + + + +1x + +1x +1x +1x + + + +1x + +1x +1x + + + +1x + +1x +1x +1x + + + + +1x +1x + +1x + + + + +1x + +1x + +1x +1x + + + + +1x +1x + +1x +1x +1x + +1x +1x + +1x + + + + +1x +1x +1x + + + + +1x +1x + + + +1x +1x +1x + +1x +1x + +1x +1x + + + + + | import { expect } from "chai";
+import * as sinon from "sinon";
+import { Middleware } from "../../middlewares/interfaces/middleware.interface";
+import { Component } from "../../../common/utils/component.decorator";
+import { MiddlewareBuilder } from "../../middlewares/builder";
+import { MiddlewaresModule } from "../../middlewares/middlewares-module";
+import { UnkownMiddlewareException } from "../../../errors/exceptions/unkown-middleware.exception";
+import { InvalidMiddlewareException } from "../../../errors/exceptions/invalid-middleware.exception";
+import { RequestMethod } from "../../../common/enums/request-method.enum";
+import { Controller } from "../../../common/utils/controller.decorator";
+import { RequestMapping } from "../../../common/utils/request-mapping.decorator";
+
+describe('MiddlewaresModule', () => {
+ @Controller({ path: "test" })
+ class AnotherRoute { }
+
+ @Controller({ path: "test" })
+ class TestRoute {
+
+ @RequestMapping({ path: "test" })
+ getTest() {}
+
+ @RequestMapping({ path: "another", method: RequestMethod.DELETE })
+ getAnother() {}
+ }
+
+ @Component()
+ class TestMiddleware implements Middleware {
+ resolve() {
+ return (req, res, next) => {}
+ }
+ }
+
+ describe('loadConfiguration', () => {
+
+ it('should call "configure" method if method is implemented', () => {
+ const configureSpy = sinon.spy();
+ const mockModule = {
+ configure: configureSpy
+ };
+
+ MiddlewaresModule.loadConfiguration(<any>mockModule, <any>"Test");
+
+ expect(configureSpy.calledOnce).to.be.true;
+ expect(configureSpy.calledWith(new MiddlewareBuilder())).to.be.true;
+ });
+ });
+
+ describe('setupRouteMiddleware', () => {
+
+ it('should throw "UnkownMiddlewareException" exception when middlewares is not stored in container', () => {
+ const route = { path: "Test" };
+ const configuration = {
+ middlewares: [ TestMiddleware ],
+ forRoutes: [ TestRoute ]
+ };
+
+ const useSpy = sinon.spy();
+ const app = { use: useSpy };
+
+ expect(MiddlewaresModule.setupRouteMiddleware.bind(
+ MiddlewaresModule, route, configuration, <any>"Test", <any>app
+ )).throws(UnkownMiddlewareException);
+ });
+
+ it('should throw "InvalidMiddlewareException" exception when middlewares does not have "resolve" method', () => {
+ @Component()
+ class InvalidMiddleware {}
+
+ const route = { path: "Test" };
+ const configuration = {
+ middlewares: [ InvalidMiddleware ],
+ forRoutes: [ TestRoute ]
+ };
+
+ const useSpy = sinon.spy();
+ const app = { use: useSpy };
+
+ const container = MiddlewaresModule.getContainer();
+ const moduleKey = <any>"Test";
+ container.addConfig([ <any>configuration ], moduleKey);
+
+ const instance = new InvalidMiddleware();
+ container.getMiddlewares(moduleKey).set(<any>InvalidMiddleware, <any>instance);
+
+ expect(MiddlewaresModule.setupRouteMiddleware.bind(
+ MiddlewaresModule, route, configuration, moduleKey, <any>app
+ )).throws(InvalidMiddlewareException);
+ });
+
+ it('should store middlewares when middleware is stored in container', () => {
+ const route = { path: "Test", method: RequestMethod.GET };
+ const configuration = {
+ middlewares: [ TestMiddleware ],
+ forRoutes: [ { path: "test" }, AnotherRoute, TestRoute ]
+ };
+
+ const useSpy = sinon.spy();
+ const app = {
+ get: useSpy
+ };
+
+ const container = MiddlewaresModule.getContainer();
+ const moduleKey = <any>"Test";
+ container.addConfig([ configuration ], moduleKey);
+
+ const instance = new TestMiddleware();
+ container.getMiddlewares(moduleKey).set(TestMiddleware, instance);
+
+ MiddlewaresModule.setupRouteMiddleware(route, configuration, moduleKey, <any>app);
+ expect(useSpy.calledOnce).to.be.true;
+ });
+
+ });
+
+}); |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 | 1x +1x +1x +1x +1x + +1x + +1x + +1x + + + + + + + + + +1x +1x +1x +1x + + +1x +1x +1x +1x + +1x +1x + +1x +1x + + + + + +1x + + | import * as sinon from "sinon";
+import { expect } from "chai";
+import { MiddlewaresResolver } from "../../middlewares/resolver";
+import { MiddlewaresContainer } from "../../middlewares/container";
+import { Component } from "../../../common/utils/component.decorator";
+import { Middleware } from "../../middlewares/interfaces/middleware.interface";
+import { RoutesMapper } from "../../middlewares/routes-mapper";
+
+describe('MiddlewaresResolver', () => {
+ @Component()
+ class TestMiddleware implements Middleware {
+ resolve() {
+ return (req, res, next) => {}
+ }
+ }
+
+ let resolver: MiddlewaresResolver;
+ let container: MiddlewaresContainer;
+ let mockContainer: sinon.SinonMock;
+
+ beforeEach(() => {
+ container = new MiddlewaresContainer(new RoutesMapper());
+ resolver = new MiddlewaresResolver(container);
+ mockContainer = sinon.mock(container);
+ });
+
+ it('should resolve middleware instances from container', () => {
+ const loadInstanceOfMiddleware = sinon.stub(resolver["instanceLoader"], "loadInstanceOfMiddleware");
+ const middlewares = new Map();
+ middlewares.set(TestMiddleware, null);
+
+ mockContainer.expects("getMiddlewares").returns(middlewares);
+ resolver.resolveInstances(null, null);
+
+ expect(loadInstanceOfMiddleware.callCount).to.be.equal(middlewares.size);
+ expect(loadInstanceOfMiddleware.calledWith(
+ TestMiddleware,
+ middlewares,
+ null
+ )).to.be.true;
+
+ loadInstanceOfMiddleware.restore();
+ });
+}); |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 | +1x +1x +1x +1x +1x +1x + +1x + +1x + + +1x + + +1x + + + + +1x +2x + + +1x +1x + + + + + + + +1x + + + +1x + + + + + +1x +1x + + + + + + +1x + + + + + | import * as sinon from "sinon";
+import { expect } from "chai";
+import { RoutesMapper } from "../../middlewares/routes-mapper";
+import { Controller } from "../../../common/utils/controller.decorator";
+import { RequestMapping } from "../../../common/utils/request-mapping.decorator";
+import { RequestMethod } from "../../../common/enums/request-method.enum";
+import { UnkownRequestMappingException } from "../../../errors/exceptions/unkown-request-mapping.exception";
+
+describe('RoutesMapper', () => {
+ @Controller({ path: "test" })
+ class TestRoute {
+
+ @RequestMapping({ path: "test" })
+ getTest() {}
+
+ @RequestMapping({ path: "another", method: RequestMethod.DELETE })
+ getAnother() {}
+ }
+
+ let mapper: RoutesMapper;
+
+ beforeEach(() => {
+ mapper = new RoutesMapper();
+ });
+
+ it('should map @Controller() to "ControllerMetadata" in forRoutes', () => {
+ const config = {
+ middlewares: "Test",
+ forRoutes: [
+ { path: "test", method: RequestMethod.GET },
+ TestRoute
+ ]
+ };
+
+ expect(mapper.mapRouteToRouteProps(config.forRoutes[0])).to.deep.equal([{
+ path: "/test", method: RequestMethod.GET
+ }]);
+
+ expect(mapper.mapRouteToRouteProps(config.forRoutes[1])).to.deep.equal([
+ { path: "/test/test", method: RequestMethod.GET },
+ { path: "/test/another", method: RequestMethod.DELETE },
+ ]);
+ });
+
+ it('should throw exception when invalid object was passed as route', () => {
+ const config = {
+ middlewares: "Test",
+ forRoutes: [
+ { method: RequestMethod.GET }
+ ]
+ };
+
+ expect(
+ mapper.mapRouteToRouteProps.bind(mapper, config.forRoutes[0])
+ ).throws(UnkownRequestMappingException);
+ });
+
+}); |
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| router-builder.spec.ts | +100% | +38/38 | +100% | +0/0 | +66.67% | +8/12 | +100% | +37/37 | +|
| router-proxy.spec.ts | +100% | +29/29 | +100% | +0/0 | +90.91% | +10/11 | +100% | +28/28 | +|
| routes-resolver.spec.ts | +100% | +25/25 | +100% | +0/0 | +75% | +6/8 | +100% | +24/24 | +
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 | 1x +1x +1x +1x +1x +1x + +1x + +1x + +1x + + +1x + + +1x + + + + + +1x +3x + + +1x + +1x +1x + +1x + +1x +1x +1x + +1x +1x +1x + + + + +1x + +1x +1x +1x + +1x + +1x +1x + + + + +1x + +1x +1x +1x + +1x + +1x +1x + + + + + | import * as sinon from "sinon";
+import { expect } from "chai";
+import { RouterBuilder } from "../../router/router-builder";
+import { Controller } from "../../../common/utils/controller.decorator";
+import { RequestMapping } from "../../../common/utils/request-mapping.decorator";
+import { RequestMethod } from "../../../common/enums/request-method.enum";
+
+describe('RouterBuilder', () => {
+ @Controller({ path: "global" })
+ class TestRoute {
+ @RequestMapping({ path: "test" })
+ getTest() {}
+
+ @RequestMapping({ path: "test", method: RequestMethod.POST })
+ postTest() {}
+
+ @RequestMapping({ path: "another-test", method: RequestMethod.ALL })
+ anotherTest() {}
+
+ private simplePlainMethod() {}
+ }
+
+ let routerBuilder: RouterBuilder;
+ beforeEach(() => {
+ routerBuilder = new RouterBuilder(null, null);
+ });
+
+ describe('scanForPathsFromPrototype', () => {
+
+ it('should method return expected list of route paths', () => {
+ const paths = routerBuilder.scanForPathsFromPrototype(new TestRoute(), TestRoute.prototype);
+
+ expect(paths).to.have.length(3);
+
+ expect(paths[0].path).to.eql("/test");
+ expect(paths[1].path).to.eql("/test");
+ expect(paths[2].path).to.eql("/another-test");
+
+ expect(paths[0].requestMethod).to.eql(RequestMethod.GET);
+ expect(paths[1].requestMethod).to.eql(RequestMethod.POST);
+ expect(paths[2].requestMethod).to.eql(RequestMethod.ALL);
+ });
+
+ });
+
+ describe('exploreMethodMetadata', () => {
+
+ it('should method return expected object which represent single route', () => {
+ const instance = new TestRoute();
+ const instanceProto = Object.getPrototypeOf(instance);
+
+ const route = routerBuilder.exploreMethodMetadata(new TestRoute(), instanceProto, "getTest");
+
+ expect(route.path).to.eql("/test");
+ expect(route.requestMethod).to.eql(RequestMethod.GET);
+ });
+
+ });
+
+ describe('applyPathsToRouterProxy', () => {
+
+ it('should method return expected object which represent single route', () => {
+ const bindStub = sinon.stub(routerBuilder, "bindMethodToRouterProxy");
+ const paths = [ null, null ];
+
+ routerBuilder.applyPathsToRouterProxy(null, paths);
+
+ expect(bindStub.calledWith(null, null)).to.be.true;
+ expect(bindStub.callCount).to.be.eql(paths.length);
+ });
+
+ });
+
+}); |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 | 1x +1x +1x +1x +1x + +1x + + + +1x +3x +3x +3x + + +1x + +1x +1x +1x + + +1x +1x +1x +1x + +1x +1x + + +1x +1x +1x +1x + +1x + +1x +1x +1x + + + + + | import * as sinon from "sinon";
+import { expect } from "chai";
+import { RouterProxy } from "../../router/router-proxy";
+import { ExceptionsHandler } from "../../exceptions/exceptions-handler";
+import { Exception } from "../../exceptions/exception";
+
+describe('RouterProxy', () => {
+ let routerProxy: RouterProxy;
+ let handlerMock: sinon.SinonMock;
+
+ beforeEach(() => {
+ const handler = new ExceptionsHandler();
+ handlerMock = sinon.mock(handler);
+ routerProxy = new RouterProxy(handler);
+ });
+
+ describe('createProxy', () => {
+
+ it('should method return thunk', () => {
+ const proxy = routerProxy.createProxy(() => {});
+ expect(typeof proxy === "function").to.be.true;
+ });
+
+ it('should method encapsulate callback passed as argument', () => {
+ const expectation = handlerMock.expects("next").once();
+ const proxy = routerProxy.createProxy((req, res, next) => {
+ throw new Exception("test", 500);
+ });
+ proxy(null, null, null);
+ expectation.verify();
+ });
+
+ it('should method encapsulate async callback passed as argument', (done) => {
+ const expectation = handlerMock.expects("next").once();
+ const proxy = routerProxy.createProxy(async (req, res, next) => {
+ throw new Exception("test", 500);
+ });
+ proxy(null, null, null);
+
+ setTimeout(() => {
+ expectation.verify();
+ done();
+ }, 0);
+ });
+
+ });
+}); |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 | 1x +1x +1x +1x +1x +1x + +1x + +1x + +1x + + +1x + + + + + +1x +1x + + + + + +1x +1x +1x + + + +1x + +1x +1x +1x + +1x +1x + +1x +1x +1x + + + + | import * as sinon from "sinon";
+import { expect } from "chai";
+import { RoutesResolver } from "../../router/routes-resolver";
+import { Controller } from "../../../common/utils/controller.decorator";
+import { RequestMapping } from "../../../common/utils/request-mapping.decorator";
+import { RequestMethod } from "../../../common/enums/request-method.enum";
+
+describe('RoutesResolver', () => {
+ @Controller({ path: "global" })
+ class TestRoute {
+ @RequestMapping({ path: "test" })
+ getTest() {}
+
+ @RequestMapping({ path: "another-test", method: RequestMethod.POST })
+ anotherTest() {}
+ }
+
+ let router;
+ let routesResolver: RoutesResolver;
+
+ before(() => {
+ router = {
+ get() {},
+ post() {}
+ };
+ });
+
+ beforeEach(() => {
+ routesResolver = new RoutesResolver(null, {
+ createRouter: () => router,
+ });
+ });
+
+ describe('setupRouters', () => {
+
+ it('should method setup controllers to express application instance', () => {
+ const routes = new Map();
+ routes.set(TestRoute, { instance: new TestRoute() });
+
+ const use = sinon.spy();
+ const applicationMock = { use };
+
+ routesResolver.setupRouters(routes, <any>applicationMock);
+ expect(use.calledOnce).to.be.true;
+ expect(use.calledWith('/global', router)).to.be.true;
+ });
+
+ });
+}); |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 | 1x +1x +1x +1x + +1x +1x + +1x + +1x +1x + + + + + + +1x + + + + + + +1x + + + + + +1x +1x +1x + + +1x +4x + + +1x +4x + + +1x +1x +1x +1x + + +1x +1x +1x + +1x +1x +1x + + +1x +1x +1x +1x + + +1x +1x +1x +1x + + + | import * as sinon from "sinon";
+import { DependenciesScanner } from "./../scanner";
+import { NestContainer } from "./../injector/container";
+import { Module } from "../../common/utils/module.decorator";
+import { NestModule } from "../../common/interfaces/nest-module.interface";
+import { Component } from "../../common/utils/component.decorator";
+import { Controller } from "../../common/utils/controller.decorator";
+
+describe('DependenciesScanner', () => {
+
+ @Component() class TestComponent {}
+ @Controller({ path: "" }) class TestRoute {}
+
+ @Module({
+ components: [ TestComponent ],
+ controllers: [ TestRoute ],
+ exports: [ TestComponent ]
+ })
+ class AnotherTestModule implements NestModule {}
+
+ @Module({
+ modules: [ AnotherTestModule ],
+ components: [ TestComponent ],
+ controllers: [ TestRoute ],
+ })
+ class TestModule implements NestModule {}
+
+ let scanner: DependenciesScanner;
+ let mockContainer: sinon.SinonMock;
+ let container: NestContainer;
+
+ before(() => {
+ container = new NestContainer();
+ mockContainer = sinon.mock(container);
+ });
+
+ beforeEach(() => {
+ scanner = new DependenciesScanner(container);
+ });
+
+ afterEach(() => {
+ mockContainer.restore();
+ });
+
+ it('should "storeModule" call twice (2 modules) container method "addModule"', () => {
+ const expectation = mockContainer.expects("addModule").twice();
+ scanner.scan(TestModule);
+ expectation.verify();
+ });
+
+ it('should "storeComponent" call twice (2 components) container method "addComponent"', () => {
+ const expectation = mockContainer.expects("addComponent").twice();
+ const stub = sinon.stub(scanner, "storeExportedComponent");
+
+ scanner.scan(TestModule);
+ expectation.verify();
+ stub.restore();
+ });
+
+ it('should "storeRoute" call twice (2 components) container method "addRoute"', () => {
+ const expectation = mockContainer.expects("addRoute").twice();
+ scanner.scan(TestModule);
+ expectation.verify();
+ });
+
+ it('should "storeExportedComponent" call once (1 component) container method "addExportedComponent"', () => {
+ const expectation = mockContainer.expects("addExportedComponent").once();
+ scanner.scan(TestModule);
+ expectation.verify();
+ });
+
+}); |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 | 1x + +1x + + + + + + + | import { RuntimeException } from "./runtime.exception";
+
+export class CircularDependencyException extends RuntimeException {
+
+ constructor(type) {
+ super(`Can't create instance of ${type}. It is possible `
+ + `that you are trying to do circular-dependency A->B, B->A.`);
+ }
+
+} |
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| circular-dependency.exception.ts | +66.67% | +2/3 | +100% | +0/0 | +0% | +0/1 | +66.67% | +2/3 | +|
| invalid-middleware-configuration.exception.ts | +100% | +3/3 | +100% | +0/0 | +100% | +1/1 | +100% | +3/3 | +|
| invalid-middleware.exception.ts | +100% | +3/3 | +100% | +0/0 | +100% | +1/1 | +100% | +3/3 | +|
| invalid-module-config.exception.ts | +100% | +3/3 | +100% | +0/0 | +100% | +1/1 | +100% | +3/3 | +|
| invalid-path-variable.exception.ts | +100% | +3/3 | +100% | +0/0 | +100% | +1/1 | +100% | +3/3 | +|
| runtime.exception.ts | +75% | +3/4 | +100% | +0/0 | +50% | +1/2 | +75% | +3/4 | +|
| unkown-dependencies.exception.ts | +66.67% | +2/3 | +100% | +0/0 | +0% | +0/1 | +66.67% | +2/3 | +|
| unkown-export.exception.ts | +100% | +3/3 | +100% | +0/0 | +100% | +1/1 | +100% | +3/3 | +|
| unkown-middleware.exception.ts | +100% | +3/3 | +100% | +0/0 | +100% | +1/1 | +100% | +3/3 | +|
| unkown-request-mapping.exception.ts | +100% | +3/3 | +100% | +0/0 | +100% | +1/1 | +100% | +3/3 | +
| 1 +2 +3 +4 +5 +6 +7 +8 +9 | 1x + +1x + + +1x + + + | import { RuntimeException } from "./runtime.exception";
+
+export class InvalidMiddlewareConfigurationException extends RuntimeException {
+
+ constructor() {
+ super(`Invalid middleware configuration passed in module "configure()" method.`);
+ }
+
+} |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 | 1x + +1x + + +1x + + + | import { RuntimeException } from "./runtime.exception";
+
+export class InvalidMiddlewareException extends RuntimeException {
+
+ constructor() {
+ super(`You are trying to setup middleware without "resolve" method.`);
+ }
+
+} |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 | 1x + +1x + + +1x + + + | import { RuntimeException } from "./runtime.exception";
+
+export class InvalidModuleConfigException extends RuntimeException {
+
+ constructor(property: string) {
+ super(`Invalid property [${property}] in @Module({}) annotation.`);
+ }
+
+} |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 | 1x + +1x + + +1x + + + | import { RuntimeException } from "./runtime.exception";
+
+export class InvalidPathVariableException extends RuntimeException {
+
+ constructor(annotationName: string) {
+ super(`Invalid path in @${annotationName}!`);
+ }
+
+} |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 | 1x +8x +8x + + + + + + | export class RuntimeException extends Error {
+ constructor(private msg: string) {
+ super();
+ }
+
+ what() {
+ return this.msg;
+ }
+} |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 | 1x + +1x + + + + + + | import { RuntimeException } from "./runtime.exception";
+
+export class UnkownDependenciesException extends RuntimeException {
+
+ constructor(type) {
+ super(`Can't recognize dependencies of ${type}.`);
+ }
+
+} |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 | 1x + +1x + + +1x + + + + | import { RuntimeException } from "./runtime.exception";
+
+export class UnkownExportException extends RuntimeException {
+
+ constructor() {
+ super(`You are trying to export unkown component. Maybe ` +
+ `you forgot to place this one to components list also.`);
+ }
+
+} |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 | 1x + +1x + + +1x + + + | import { RuntimeException } from "./runtime.exception";
+
+export class UnkownMiddlewareException extends RuntimeException {
+
+ constructor() {
+ super(`Not recognized middleware - runtime error!`);
+ }
+
+} |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 | 1x + +1x + + +1x + + + | import { RuntimeException } from "./runtime.exception";
+
+export class UnkownRequestMappingException extends RuntimeException {
+
+ constructor() {
+ super(`RequestMapping not defined in @RequestMapping() annotation!`);
+ }
+
+} |
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| common/enums | +100% | +6/6 | +100% | +2/2 | +100% | +1/1 | +100% | +6/6 | +|
| common/test/utils | +100% | +68/68 | +100% | +0/0 | +81.25% | +13/16 | +100% | +64/64 | +|
| common/utils | +96.97% | +32/33 | +81.82% | +9/11 | +100% | +10/10 | +96.88% | +31/32 | +|
| core | +100% | +32/32 | +80% | +8/10 | +100% | +19/19 | +100% | +27/27 | +|
| core/exceptions | +100% | +12/12 | +100% | +2/2 | +100% | +5/5 | +100% | +12/12 | +|
| core/injector | +72.63% | +69/95 | +44.74% | +17/38 | +82.86% | +29/35 | +73.4% | +69/94 | +|
| core/middlewares | +82.65% | +81/98 | +75.76% | +25/33 | +79.41% | +27/34 | +82.47% | +80/97 | +|
| core/router | +88.33% | +53/60 | +53.85% | +7/13 | +91.3% | +21/23 | +89.83% | +53/59 | +|
| core/test | +100% | +40/40 | +100% | +0/0 | +100% | +8/8 | +100% | +36/36 | +|
| core/test/exceptions | +100% | +23/23 | +100% | +0/0 | +100% | +5/5 | +100% | +23/23 | +|
| core/test/injector | +100% | +113/113 | +100% | +0/0 | +100% | +20/20 | +100% | +106/106 | +|
| core/test/middlewares | +98.6% | +141/143 | +100% | +0/0 | +68.57% | +24/35 | +98.52% | +133/135 | +|
| core/test/router | +100% | +92/92 | +100% | +0/0 | +77.42% | +24/31 | +100% | +89/89 | +|
| errors/exceptions | +90.32% | +28/31 | +100% | +0/0 | +72.73% | +8/11 | +90.32% | +28/31 | +|
| socket/test/utils | +100% | +23/23 | +100% | +0/0 | +80% | +4/5 | +100% | +22/22 | +|
| socket/utils | +100% | +14/14 | +33.33% | +1/3 | +100% | +4/4 | +100% | +14/14 | +
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| socket-gateway.decorator.spec.ts | +100% | +13/13 | +100% | +0/0 | +100% | +2/2 | +100% | +12/12 | +|
| subscribe-message.decorator.spec.ts | +100% | +10/10 | +100% | +0/0 | +66.67% | +2/3 | +100% | +10/10 | +
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 | 1x +1x +1x + +1x + + +1x + +1x +1x +1x +1x + +1x +1x +1x + + + | import "reflect-metadata";
+import { expect } from "chai";
+import { SocketGateway } from "../../utils/socket-gateway.decorator";
+
+describe('@SocketGateway', () => {
+
+ @SocketGateway({ port: 80, namespace: "/" })
+ class TestGateway {}
+
+ it('should decorate type with expected metadata', () => {
+ const isGateway = Reflect.getMetadata('__isGateway', TestGateway);
+ const port = Reflect.getMetadata('port', TestGateway);
+ const namespace = Reflect.getMetadata('namespace', TestGateway);
+
+ expect(isGateway).to.be.eql(true);
+ expect(port).to.be.eql(80);
+ expect(namespace).to.be.eql("/");
+ });
+
+}); |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 | 1x +1x +1x + +1x + + + +1x + + +1x +1x +1x + +1x +1x + + + | import "reflect-metadata";
+import { expect } from "chai";
+import { SubscribeMessage } from "../../utils/subscribe-message.decorator";
+
+describe('@SubscribeMessage', () => {
+
+ class TestGateway {
+ @SubscribeMessage({ value: "filter" })
+ static fn() {}
+ }
+
+ it('should decorate type with expected metadata', () => {
+ const isMessageMapping = Reflect.getMetadata('__isMessageMapping', TestGateway.fn);
+ const message = Reflect.getMetadata('message', TestGateway.fn);
+
+ expect(isMessageMapping).to.be.true;
+ expect(message).to.be.eql("filter");
+ });
+
+}); |
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| socket-gateway.decorator.ts | +100% | +7/7 | +50% | +1/2 | +100% | +2/2 | +100% | +7/7 | +|
| subscribe-message.decorator.ts | +100% | +7/7 | +0% | +0/1 | +100% | +2/2 | +100% | +7/7 | +
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 | 1x + + +1x +1x +1x +1x +1x +1x + + | import "reflect-metadata";
+import { GatewayMetadata } from "../interfaces";
+
+export const SocketGateway = (metadata?: GatewayMetadata): ClassDecorator => {
+ metadata = metadata || {};
+ return (target: Object) => {
+ Reflect.defineMetadata("__isGateway", true, target);
+ Reflect.defineMetadata("namespace", metadata.namespace, target);
+ Reflect.defineMetadata("port", metadata.port, target);
+ }
+}; |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 | 1x + +1x +1x +1x +1x +1x + +1x + + | import "reflect-metadata";
+
+const defaultMetadata = { value: "" };
+export const SubscribeMessage = (metadata: { value: string } = defaultMetadata): MethodDecorator => {
+ return (target, key, descriptor: PropertyDescriptor) => {
+ Reflect.defineMetadata("__isMessageMapping", true, descriptor.value);
+ Reflect.defineMetadata("message", metadata.value, descriptor.value);
+
+ return descriptor;
+ }
+}; |