nest.js - npm Package Compare versions

Comparing version 1.0.0-alpha-2 to 1.0.0-alpha-20

common/enums/index.d.ts

@@ -1,1 +0,2 @@
-export * from "./request-method.enum";
+export * from './request-method.enum';
+export * from './transport.enum';

common/enums/index.js

@@ -5,2 +5,4 @@ "use strict";
 }
+Object.defineProperty(exports, "__esModule", { value: true });
 __export(require("./request-method.enum"));
+__export(require("./transport.enum"));

common/enums/request-method.enum.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 var RequestMethod;
@@ -3,0 +4,0 @@ (function (RequestMethod) {

common/index.d.ts

 export * from './utils';
 export * from './enums';
-export { NestModule, NestApplication } from './interfaces';
+export { NestModule } from './interfaces';

common/index.js

@@ -5,3 +5,4 @@ "use strict";
 }
+Object.defineProperty(exports, "__esModule", { value: true });
 __export(require("./utils"));
 __export(require("./enums"));

common/interfaces/controller-metadata.interface.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

common/interfaces/controller.interface.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

common/interfaces/index.d.ts

@@ -1,8 +0,8 @@
-export * from "./request-mapping-metadata.interface";
-export * from "./nest-module.interface";
-export * from "./module-metadata.interface";
-export * from "./nest-application.interface";
-export * from "./controller.interface";
-export * from "./injectable.interface";
-export * from "./controller-metadata.interface";
-export * from "./nest-application-factory.interface";
+export * from './request-mapping-metadata.interface';
+export * from './nest-module.interface';
+export * from './module-metadata.interface';
+export * from './controller.interface';
+export * from './injectable.interface';
+export * from './controller-metadata.interface';
+export * from './module-metadata.interface';
+export * from './metatype.interface';

common/interfaces/index.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

common/interfaces/injectable.interface.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

common/interfaces/module-metadata.interface.d.ts

@@ -1,8 +0,8 @@
-import { NestModule } from "./nest-module.interface";
-import { Controller } from "./controller.interface";
+import { NestModule } from './nest-module.interface';
+import { Controller } from './controller.interface';
 export interface ModuleMetadata {
     modules?: NestModule[];
     components?: any[];
-    controllers?: Controller[];
+    controllers?: Controller[] | any[];
     exports?: any[];
 }

common/interfaces/module-metadata.interface.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

common/interfaces/nest-module.interface.d.ts

@@ -1,4 +0,4 @@
-import { MiddlewareBuilder } from "../../core/middlewares/builder";
+import { MiddlewareBuilder } from '../../core/middlewares/builder';
 export interface NestModule {
     configure?: (router: MiddlewareBuilder) => MiddlewareBuilder;
 }

common/interfaces/nest-module.interface.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

common/interfaces/request-mapping-metadata.interface.d.ts

@@ -1,5 +0,5 @@
-import { RequestMethod } from "../enums/request-method.enum";
+import { RequestMethod } from '../enums/request-method.enum';
 export interface RequestMappingMetadata {
-    path: string;
+    path?: string;
     method?: RequestMethod;
 }

common/interfaces/request-mapping-metadata.interface.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

common/utils/component.decorator.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.Component = () => {
     return (target) => { };
 };

common/utils/controller.decorator.d.ts

@@ -1,3 +0,3 @@
-import "reflect-metadata";
-import { ControllerMetadata } from "../interfaces/controller-metadata.interface";
+import 'reflect-metadata';
+import { ControllerMetadata } from '../interfaces/controller-metadata.interface';
 export declare const Controller: (metadata?: ControllerMetadata) => ClassDecorator;

common/utils/controller.decorator.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 require("reflect-metadata");
-const defaultMetadata = { path: "/" };
+const shared_utils_1 = require("./shared.utils");
+const constants_1 = require("../constants");
+const defaultMetadata = { [constants_1.PATH_METADATA]: '/' };
 exports.Controller = (metadata = defaultMetadata) => {
-    if (typeof metadata.path === "undefined") {
-        metadata.path = "/";
+    if (shared_utils_1.isUndefined(metadata[constants_1.PATH_METADATA])) {
+        metadata[constants_1.PATH_METADATA] = '/';
     }
     return (target) => {
-        Reflect.defineMetadata("path", metadata.path, target);
+        Reflect.defineMetadata(constants_1.PATH_METADATA, metadata[constants_1.PATH_METADATA], target);
     };
 };

common/utils/index.d.ts

@@ -1,4 +0,5 @@
-export * from "./request-mapping.decorator";
-export * from "./controller.decorator";
-export * from "./component.decorator";
-export * from "./module.decorator";
+export * from './request-mapping.decorator';
+export * from './controller.decorator';
+export * from './component.decorator';
+export * from './module.decorator';
+export { Component as Middleware } from './component.decorator';

common/utils/index.js

@@ -5,2 +5,3 @@ "use strict";
 }
+Object.defineProperty(exports, "__esModule", { value: true });
 __export(require("./request-mapping.decorator"));
@@ -10,1 +11,3 @@ __export(require("./controller.decorator"));
 __export(require("./module.decorator"));
+var component_decorator_1 = require("./component.decorator");
+exports.Middleware = component_decorator_1.Component;

common/utils/module.decorator.d.ts

@@ -1,3 +0,3 @@
-import "reflect-metadata";
-import { ModuleMetadata } from "../interfaces/module-metadata.interface";
+import 'reflect-metadata';
+import { ModuleMetadata } from '../interfaces/module-metadata.interface';
 export declare const Module: (props: ModuleMetadata) => ClassDecorator;

common/utils/module.decorator.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 require("reflect-metadata");
 const invalid_module_config_exception_1 = require("../../errors/exceptions/invalid-module-config.exception");
+const constants_1 = require("../constants");
 exports.Module = (props) => {
     const propsKeys = Object.keys(props);
-    const acceptableParams = ["modules", "exports", "components", "controllers"];
-    propsKeys.map((prop) => {
+    const acceptableParams = [constants_1.metadata.MODULES, constants_1.metadata.EXPORTS, constants_1.metadata.COMPONENTS, constants_1.metadata.CONTROLLERS];
+    propsKeys.forEach((prop) => {
         if (acceptableParams.findIndex((param) => param === prop) < 0) {
@@ -9,0 +11,0 @@ throw new invalid_module_config_exception_1.InvalidModuleConfigException(prop);

common/utils/request-mapping.decorator.d.ts

@@ -1,3 +0,3 @@
-import "reflect-metadata";
-import { RequestMappingMetadata } from "../interfaces/request-mapping-metadata.interface";
-export declare const RequestMapping: (metadata: RequestMappingMetadata) => MethodDecorator;
+import 'reflect-metadata';
+import { RequestMappingMetadata } from '../interfaces/request-mapping-metadata.interface';
+export declare const RequestMapping: (metadata?: RequestMappingMetadata) => MethodDecorator;

common/utils/request-mapping.decorator.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 require("reflect-metadata");
 const request_method_enum_1 = require("../enums/request-method.enum");
-const invalid_path_variable_exception_1 = require("../../errors/exceptions/invalid-path-variable.exception");
-exports.RequestMapping = (metadata) => {
-    if (typeof metadata.path === "undefined") {
-        throw new invalid_path_variable_exception_1.InvalidPathVariableException("RequestMapping");
-    }
-    const requestMethod = metadata.method || request_method_enum_1.RequestMethod.GET;
-    return function (target, key, descriptor) {
-        Reflect.defineMetadata("path", metadata.path, descriptor.value);
-        Reflect.defineMetadata("method", requestMethod, descriptor.value);
+const constants_1 = require("../constants");
+const defaultMetadata = { [constants_1.PATH_METADATA]: '/', [constants_1.METHOD_METADATA]: request_method_enum_1.RequestMethod.GET };
+exports.RequestMapping = (metadata = defaultMetadata) => {
+    const path = metadata[constants_1.PATH_METADATA] || '/';
+    const requestMethod = metadata[constants_1.METHOD_METADATA] || request_method_enum_1.RequestMethod.GET;
+    return (target, key, descriptor) => {
+        Reflect.defineMetadata(constants_1.PATH_METADATA, path, descriptor.value);
+        Reflect.defineMetadata(constants_1.METHOD_METADATA, requestMethod, descriptor.value);
         return descriptor;
     };
 };

core/adapters/express-adapter.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 const express = require("express");
@@ -3,0 +4,0 @@ class ExpressAdapter {

core/exceptions/exceptions-handler.d.ts

@@ -1,5 +0,5 @@
-import { Exception } from "./exception";
+import { HttpException } from './http-exception';
 export declare class ExceptionsHandler {
-    private UNKOWN_EXCEPTION_MSG;
-    next(exception: Error | Exception, response: any): void;
+    private readonly logger;
+    next(exception: Error | HttpException, response: any): void;
 }

core/exceptions/exceptions-handler.js

 "use strict";
-const exception_1 = require("./exception");
+Object.defineProperty(exports, "__esModule", { value: true });
+const http_exception_1 = require("./http-exception");
+const constants_1 = require("../constants");
+const logger_service_1 = require("../../common/services/logger.service");
 class ExceptionsHandler {
     constructor() {
-        this.UNKOWN_EXCEPTION_MSG = "Unkown exception";
+        this.logger = new logger_service_1.Logger(ExceptionsHandler.name);
     }
     next(exception, response) {
-        if (!(exception instanceof exception_1.Exception)) {
-            response.status(500).json({ message: this.UNKOWN_EXCEPTION_MSG });
+        if (!(exception instanceof http_exception_1.HttpException)) {
+            response.status(500).json({ message: constants_1.messages.UNKOWN_EXCEPTION_MESSAGE });
+            this.logger.error(exception.message, exception.stack);
             return;
@@ -11,0 +15,0 @@ }

core/index.d.ts

@@ -1,3 +0,3 @@
-export { Exception } from './exceptions/exception';
-export { Middleware, MiddlewareConfiguration } from './middlewares/interfaces';
+export { HttpException } from './exceptions/http-exception';
+export { NestMiddleware, MiddlewareConfiguration } from './middlewares/interfaces';
 export { MiddlewareBuilder } from './middlewares/builder';

core/index.js

 "use strict";
-var exception_1 = require("./exceptions/exception");
-exports.Exception = exception_1.Exception;
+Object.defineProperty(exports, "__esModule", { value: true });
+var http_exception_1 = require("./exceptions/http-exception");
+exports.HttpException = http_exception_1.HttpException;
 var builder_1 = require("./middlewares/builder");
 exports.MiddlewareBuilder = builder_1.MiddlewareBuilder;

core/injector/container.d.ts

@@ -1,21 +0,19 @@
-import { Controller, Injectable, NestModule } from "../../common/interfaces/";
+import { Controller, Injectable } from '../../common/interfaces/';
+import { Module } from './module';
+import { NestModuleMetatype } from '../../common/interfaces/module-metatype.interface';
+import { Metatype } from '../../common/interfaces/metatype.interface';
 export declare class NestContainer {
     private readonly modules;
-    addModule(moduleClass: any): void;
-    getModules(): Map<NestModule, ModuleDependencies>;
-    addRelatedModule(relatedModule: NestModule, module: NestModule): void;
-    addComponent(component: Injectable, module: NestModule): void;
-    addExportedComponent(exportedComponent: Injectable, module: NestModule): void;
-    addRoute(route: Controller, module: NestModule): void;
+    addModule(metatype: NestModuleMetatype): void;
+    getModules(): Map<string, Module>;
+    addRelatedModule(relatedModule: NestModuleMetatype, target: NestModuleMetatype): void;
+    addComponent(component: Metatype<Injectable>, metatype: NestModuleMetatype): void;
+    addExportedComponent(exportedComponent: Metatype<Injectable>, metatype: NestModuleMetatype): void;
+    addRoute(controller: Metatype<Controller>, metatype: NestModuleMetatype): void;
+    clear(): void;
 }
-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> {
+    metatype: Metatype<T>;
     instance: T;
     isResolved: boolean;
 }

core/injector/container.js

 "use strict";
-const unkown_export_exception_1 = require("../../errors/exceptions/unkown-export.exception");
+Object.defineProperty(exports, "__esModule", { value: true });
+const module_1 = require("./module");
+const unkown_module_exception_1 = require("../../errors/exceptions/unkown-module.exception");
 class NestContainer {
@@ -7,12 +9,7 @@ constructor() {
     }
-    addModule(moduleClass) {
-        if (!this.modules.has(moduleClass)) {
-            this.modules.set(moduleClass, {
-                instance: new moduleClass(),
-                relatedModules: new Set(),
-                components: new Map(),
-                routes: new Map(),
-                exports: new Set(),
-            });
+    addModule(metatype) {
+        if (this.modules.has(metatype.name)) {
+            return;
         }
+        this.modules.set(metatype.name, new module_1.Module(metatype));
     }
@@ -22,37 +19,35 @@ getModules() {
     }
-    addRelatedModule(relatedModule, module) {
-        if (this.modules.has(module)) {
-            const storedModule = this.modules.get(module);
-            const related = this.modules.get(relatedModule);
-            storedModule.relatedModules.add(related);
+    addRelatedModule(relatedModule, target) {
+        if (!this.modules.has(target.name)) {
+            return;
         }
+        const storedModule = this.modules.get(target.name);
+        const related = this.modules.get(relatedModule.name);
+        storedModule.addRelatedModule(related);
     }
-    addComponent(component, module) {
-        if (this.modules.has(module)) {
-            const storedModule = this.modules.get(module);
-            storedModule.components.set(component, {
-                instance: null,
-                isResolved: false,
-            });
+    addComponent(component, metatype) {
+        if (!this.modules.has(metatype.name)) {
+            throw new unkown_module_exception_1.UnkownModuleException();
         }
+        const storedModule = this.modules.get(metatype.name);
+        storedModule.addComponent(component);
     }
-    addExportedComponent(exportedComponent, module) {
-        if (this.modules.has(module)) {
-            const storedModule = this.modules.get(module);
-            if (!storedModule.components.get(exportedComponent)) {
-                throw new unkown_export_exception_1.UnkownExportException();
-            }
-            storedModule.exports.add(exportedComponent);
+    addExportedComponent(exportedComponent, metatype) {
+        if (!this.modules.has(metatype.name)) {
+            throw new unkown_module_exception_1.UnkownModuleException();
         }
+        const storedModule = this.modules.get(metatype.name);
+        storedModule.addExportedComponent(exportedComponent);
     }
-    addRoute(route, module) {
-        if (this.modules.has(module)) {
-            const storedModule = this.modules.get(module);
-            storedModule.routes.set(route, {
-                instance: null,
-                isResolved: false,
-            });
+    addRoute(controller, metatype) {
+        if (!this.modules.has(metatype.name)) {
+            throw new unkown_module_exception_1.UnkownModuleException();
         }
+        const storedModule = this.modules.get(metatype.name);
+        storedModule.addRoute(controller);
     }
+    clear() {
+        this.modules.clear();
+    }
 }
 exports.NestContainer = NestContainer;

core/injector/injector.d.ts

@@ -1,16 +0,20 @@
-import "reflect-metadata";
-import { ModuleDependencies, InstanceWrapper } from "./container";
-import { Middleware } from "../middlewares/interfaces/middleware.interface";
-import { MiddlewareProto } from "../middlewares/interfaces/middleware-proto.interface";
+import 'reflect-metadata';
+import { InstanceWrapper } from './container';
+import { MiddlewareMetatype } from '../middlewares/interfaces/middleware-metatype.interface';
+import { Module } from './module';
+import { Metatype } from '../../common/interfaces/metatype.interface';
+import { Controller } from '../../common/interfaces/controller.interface';
+import { Injectable } from '../../common/interfaces/injectable.interface';
+import { MiddlewareWrapper } from '../middlewares/container';
 export declare class Injector {
-    loadInstanceOfMiddleware(middlewareType: any, collection: Map<MiddlewareProto, Middleware>, module: ModuleDependencies): void;
-    loadInstanceOfRoute(routeType: any, module: ModuleDependencies): void;
-    loadPrototypeOfInstance<T>(type: any, collection: Map<T, InstanceWrapper<T>>): void;
-    loadInstanceOfComponent(componentType: any, module: ModuleDependencies): void;
-    loadInstance(type: any, collection: any, module: ModuleDependencies): void;
-    private resolveConstructorParams(type, module, callback);
-    private resolveSingleParam(targetType, param, module);
-    private resolveComponentInstance(module, param, componentType);
-    private scanForComponent(components, param, module, componentType);
-    private scanForComponentInRelatedModules(module, componentType);
+    loadInstanceOfMiddleware(metatype: MiddlewareMetatype, collection: Map<string, MiddlewareWrapper>, module: Module): void;
+    loadInstanceOfRoute(metatype: Metatype<Controller>, module: Module): void;
+    loadPrototypeOfInstance<T>(metatype: Metatype<T>, collection: Map<string, InstanceWrapper<T>>): void;
+    loadInstanceOfComponent(metatype: Metatype<Injectable>, module: Module): void;
+    loadInstance<T>(type: Metatype<T>, collection: any, module: Module): void;
+    resolveConstructorParams<T>(type: Metatype<T>, module: Module, callback: Function): void;
+    resolveSingleParam<T>(type: Metatype<T>, param: Metatype<any>, module: Module): any;
+    resolveComponentInstance<T>(module: Module, param: Metatype<any>, metatype: Metatype<T>): any;
+    scanForComponent<T>(components: Map<string, any>, param: Metatype<any>, module: Module, metatype: Metatype<T>): any;
+    scanForComponentInRelatedModules(module: Module, metatype: Metatype<any>): any;
 }

core/injector/injector.js

 "use strict";
-var __assign = (this && this.__assign) || Object.assign || function(t) {
-    for (var s, i = 1, n = arguments.length; i < n; i++) {
-        s = arguments[i];
-        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-            t[p] = s[p];
-    }
-    return t;
-};
+Object.defineProperty(exports, "__esModule", { value: true });
 require("reflect-metadata");
-const circular_dependency_exception_1 = require("../../errors/exceptions/circular-dependency.exception");
 const unkown_dependencies_exception_1 = require("../../errors/exceptions/unkown-dependencies.exception");
 const runtime_exception_1 = require("../../errors/exceptions/runtime.exception");
+const shared_utils_1 = require("../../common/utils/shared.utils");
+const constants_1 = require("../../common/constants");
 class Injector {
-    loadInstanceOfMiddleware(middlewareType, collection, module) {
-        const currentFetchedMiddleware = collection.get(middlewareType);
-        if (currentFetchedMiddleware === null) {
-            this.resolveConstructorParams(middlewareType, module, (argsInstances) => {
-                collection.set(middlewareType, new middlewareType(...argsInstances));
+    loadInstanceOfMiddleware(metatype, collection, module) {
+        const currentFetchedMiddleware = collection.get(metatype.name);
+        if (currentFetchedMiddleware.instance !== null)
+            return;
+        this.resolveConstructorParams(metatype, module, (argsInstances) => {
+            collection.set(metatype.name, {
+                instance: new metatype(...argsInstances),
+                metatype
             });
-        }
+        });
     }
-    loadInstanceOfRoute(routeType, module) {
+    loadInstanceOfRoute(metatype, module) {
         const routes = module.routes;
-        this.loadInstance(routeType, routes, module);
+        this.loadInstance(metatype, routes, module);
     }
-    loadPrototypeOfInstance(type, collection) {
-        if (!collection) {
+    loadPrototypeOfInstance(metatype, collection) {
+        if (!collection || collection.get(metatype.name).isResolved) {
             return;
         }
-        collection.set(type, __assign({}, collection.get(type), { instance: Object.create(type.prototype) }));
+        collection.set(metatype.name, Object.assign({}, collection.get(metatype.name), { instance: Object.create(metatype.prototype) }));
     }
-    loadInstanceOfComponent(componentType, module) {
+    loadInstanceOfComponent(metatype, module) {
         const components = module.components;
-        this.loadInstance(componentType, components, module);
+        this.loadInstance(metatype, components, module);
     }
     loadInstance(type, collection, module) {
-        const currentFetchedInstance = collection.get(type);
-        if (typeof currentFetchedInstance === 'undefined') {
-            throw new runtime_exception_1.RuntimeException("");
+        const currentFetchedInstance = collection.get(type.name);
+        if (shared_utils_1.isUndefined(currentFetchedInstance)) {
+            throw new runtime_exception_1.RuntimeException('');
         }
-        if (!currentFetchedInstance.isResolved) {
-            this.resolveConstructorParams(type, module, (argsInstances) => {
-                currentFetchedInstance.instance = Object.assign(currentFetchedInstance.instance, new type(...argsInstances));
-                currentFetchedInstance.isResolved = true;
-            });
-        }
+        if (currentFetchedInstance.isResolved)
+            return;
+        this.resolveConstructorParams(type, module, (argsInstances) => {
+            currentFetchedInstance.instance = Object.assign(currentFetchedInstance.instance, new type(...argsInstances));
+            currentFetchedInstance.isResolved = true;
+        });
     }
     resolveConstructorParams(type, module, callback) {
-        let constructorParams = Reflect.getMetadata('design:paramtypes', type) || [];
-        if (type.dependencies) {
-            constructorParams = type.dependencies;
-        }
-        const argsInstances = constructorParams.map((param) => (this.resolveSingleParam(type, param, module)));
+        const constructorParams = Reflect.getMetadata(constants_1.PARAMTYPES_METADATA, type) || [];
+        const argsInstances = constructorParams.map(param => this.resolveSingleParam(type, param, module));
         callback(argsInstances);
     }
-    resolveSingleParam(targetType, param, module) {
-        if (typeof param === "undefined") {
-            throw new circular_dependency_exception_1.CircularDependencyException(targetType);
+    resolveSingleParam(type, param, module) {
+        if (shared_utils_1.isUndefined(param)) {
+            throw new runtime_exception_1.RuntimeException('');
         }
-        return this.resolveComponentInstance(module, param, targetType);
+        return this.resolveComponentInstance(module, param, type);
     }
-    resolveComponentInstance(module, param, componentType) {
+    resolveComponentInstance(module, param, metatype) {
         const components = module.components;
-        const instanceWrapper = this.scanForComponent(components, param, module, componentType);
+        const instanceWrapper = this.scanForComponent(components, param, module, metatype);
         if (instanceWrapper.instance === null) {
@@ -71,23 +65,23 @@ this.loadInstanceOfComponent(param, module);
     }
-    scanForComponent(components, param, module, componentType) {
-        if (!components.has(param)) {
-            const instanceWrapper = this.scanForComponentInRelatedModules(module, param);
-            if (instanceWrapper === null) {
-                throw new unkown_dependencies_exception_1.UnkownDependenciesException(componentType);
-            }
-            return instanceWrapper;
+    scanForComponent(components, param, module, metatype) {
+        if (components.has(param.name)) {
+            return components.get(param.name);
         }
-        return components.get(param);
+        const instanceWrapper = this.scanForComponentInRelatedModules(module, param);
+        if (instanceWrapper === null) {
+            throw new unkown_dependencies_exception_1.UnkownDependenciesException(metatype.name);
+        }
+        return instanceWrapper;
     }
-    scanForComponentInRelatedModules(module, componentType) {
-        const relatedModules = module.relatedModules;
+    scanForComponentInRelatedModules(module, metatype) {
+        const relatedModules = module.relatedModules || [];
         let component = null;
         relatedModules.forEach((relatedModule) => {
             const { components, exports } = relatedModule;
-            if (!exports.has(componentType) || !components.has(componentType)) {
+            if (!exports.has(metatype.name) || !components.has(metatype.name)) {
                 return;
             }
-            component = components.get(componentType);
+            component = components.get(metatype.name);
             if (!component.isResolved) {
-                this.loadInstanceOfComponent(componentType, relatedModule);
+                this.loadInstanceOfComponent(metatype, relatedModule);
             }
@@ -94,0 +88,0 @@ });

core/injector/instance-loader.d.ts

@@ -1,5 +0,6 @@
-import { NestContainer } from "./container";
+import { NestContainer } from './container';
 export declare class InstanceLoader {
     private container;
     private injector;
+    private readonly logger;
     constructor(container: NestContainer);
@@ -6,0 +7,0 @@ createInstancesOfDependencies(): void;

core/injector/instance-loader.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 const injector_1 = require("./injector");
+const logger_service_1 = require("../../common/services/logger.service");
+const messages_1 = require("../helpers/messages");
 class InstanceLoader {
@@ -7,2 +10,3 @@ constructor(container) {
         this.injector = new injector_1.Injector();
+        this.logger = new logger_service_1.Logger(InstanceLoader.name);
     }
@@ -21,25 +25,26 @@ createInstancesOfDependencies() {
     createInstances(modules) {
-        modules.forEach((module) => {
+        modules.forEach((module, name) => {
             this.createInstancesOfComponents(module);
             this.createInstancesOfRoutes(module);
+            this.logger.log(messages_1.getModuleInitMessage(name));
         });
     }
     createPrototypesOfComponents(module) {
-        module.components.forEach((wrapper, componentType) => {
-            this.injector.loadPrototypeOfInstance(componentType, module.components);
+        module.components.forEach((wrapper) => {
+            this.injector.loadPrototypeOfInstance(wrapper.metatype, module.components);
         });
     }
     createInstancesOfComponents(module) {
-        module.components.forEach((wrapper, componentType) => {
-            this.injector.loadInstanceOfComponent(componentType, module);
+        module.components.forEach((wrapper) => {
+            this.injector.loadInstanceOfComponent(wrapper.metatype, module);
         });
     }
     createPrototypesOfRoutes(module) {
-        module.routes.forEach((wrapper, routeType) => {
-            this.injector.loadPrototypeOfInstance(routeType, module.routes);
+        module.routes.forEach((wrapper) => {
+            this.injector.loadPrototypeOfInstance(wrapper.metatype, module.routes);
         });
     }
     createInstancesOfRoutes(module) {
-        module.routes.forEach((wrapper, routeType) => {
-            this.injector.loadInstanceOfRoute(routeType, module);
+        module.routes.forEach((wrapper) => {
+            this.injector.loadInstanceOfRoute(wrapper.metatype, module);
         });
@@ -46,0 +51,0 @@ }

core/middlewares/builder.d.ts

@@ -1,2 +0,2 @@
-import { MiddlewareConfiguration } from "./interfaces/middleware-configuration.interface";
+import { MiddlewareConfiguration } from './interfaces/middleware-configuration.interface';
 export declare class MiddlewareBuilder {
@@ -3,0 +3,0 @@ private storedConfiguration;

core/middlewares/builder.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 const invalid_middleware_configuration_exception_1 = require("../../errors/exceptions/invalid-middleware-configuration.exception");
+const shared_utils_1 = require("../../common/utils/shared.utils");
 class MiddlewareBuilder {
@@ -8,4 +10,4 @@ constructor() {
     use(configuration) {
-        if (typeof configuration.middlewares === "undefined" ||
-            typeof configuration.forRoutes === "undefined") {
+        const { middlewares, forRoutes } = configuration;
+        if (shared_utils_1.isUndefined(middlewares) || shared_utils_1.isUndefined(forRoutes)) {
             throw new invalid_middleware_configuration_exception_1.InvalidMiddlewareConfigurationException();
@@ -12,0 +14,0 @@ }

core/middlewares/container.d.ts

@@ -1,6 +0,5 @@
-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";
+import { MiddlewareConfiguration } from './interfaces/middleware-configuration.interface';
+import { NestMiddleware } from './interfaces/nest-middleware.interface';
+import { RoutesMapper } from './routes-mapper';
+import { Metatype } from '../../common/interfaces/metatype.interface';
 export declare class MiddlewaresContainer {
@@ -11,5 +10,5 @@ private routesMapper;
     constructor(routesMapper: RoutesMapper);
-    getMiddlewares(module: NestModule): Map<MiddlewareProto, Middleware>;
-    getConfigs(): Map<NestModule, Set<MiddlewareConfiguration>>;
-    addConfig(configList: MiddlewareConfiguration[], module: NestModule): void;
+    getMiddlewares(module: string): Map<string, MiddlewareWrapper>;
+    getConfigs(): Map<string, Set<MiddlewareConfiguration>>;
+    addConfig(configList: MiddlewareConfiguration[], module: string): void;
     private mapRoutesToFlatList(forRoutes);
@@ -19,1 +18,5 @@ private getCurrentMiddlewares(module);
 }
+export interface MiddlewareWrapper {
+    instance: NestMiddleware;
+    metatype: Metatype<NestMiddleware>;
+}

core/middlewares/container.js

 "use strict";
-const unkown_module_exception_1 = require("../../errors/exceptions/unkown-module.exception");
+Object.defineProperty(exports, "__esModule", { value: true });
 class MiddlewaresContainer {
@@ -10,6 +10,3 @@ constructor(routesMapper) {
     getMiddlewares(module) {
-        if (!this.middlewares.has(module)) {
-            throw new unkown_module_exception_1.UnkownModuleException();
-        }
-        return this.middlewares.get(module);
+        return this.middlewares.get(module) || new Map();
     }
@@ -23,4 +20,7 @@ getConfigs() {
         (configList || []).map((config) => {
-            [].concat(config.middlewares).map((middleware) => {
-                currentMiddlewares.set(middleware, null);
+            [].concat(config.middlewares).map((metatype) => {
+                currentMiddlewares.set(metatype.name, {
+                    instance: null,
+                    metatype
+                });
             });
@@ -27,0 +27,0 @@ config.forRoutes = this.mapRoutesToFlatList(config.forRoutes);

core/middlewares/interfaces/index.d.ts

@@ -1,2 +0,2 @@
-export * from "./middleware-configuration.interface";
-export * from "./middleware.interface";
+export * from './middleware-configuration.interface';
+export * from './nest-middleware.interface';

core/middlewares/interfaces/index.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

core/middlewares/interfaces/middleware-configuration.interface.d.ts

@@ -1,7 +0,6 @@
-import { ControllerMetadata } from "../../../common/interfaces/controller-metadata.interface";
-import { Controller } from "../../../common/interfaces/controller.interface";
-import { MiddlewareProto } from "./middleware-proto.interface";
-import { RequestMethod } from "../../../common/enums/request-method.enum";
+import { ControllerMetadata } from '../../../common/interfaces/controller-metadata.interface';
+import { Controller } from '../../../common/interfaces/controller.interface';
+import { RequestMethod } from '../../../common/enums/request-method.enum';
 export interface MiddlewareConfiguration {
-    middlewares: MiddlewareProto | MiddlewareProto[];
+    middlewares: any;
     forRoutes: (Controller | ControllerMetadata & {
@@ -8,0 +7,0 @@ method?: RequestMethod;

core/middlewares/interfaces/middleware-configuration.interface.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

core/middlewares/middlewares-module.d.ts

 /// <reference types="express" />
-import { Application } from "express";
-import { NestContainer, ModuleDependencies } from "../injector/container";
-import { MiddlewaresContainer } from "./container";
-import { ControllerMetadata } from "../../common/interfaces/controller-metadata.interface";
-import { NestModule } from "../../common/interfaces/nest-module.interface";
-import { MiddlewareConfiguration } from "./interfaces/middleware-configuration.interface";
-import { RequestMethod } from "../../common/enums/request-method.enum";
+import { Application } from 'express';
+import { NestContainer } from '../injector/container';
+import { MiddlewaresContainer } from './container';
+import { ControllerMetadata } from '../../common/interfaces/controller-metadata.interface';
+import { NestModule } from '../../common/interfaces/nest-module.interface';
+import { MiddlewareConfiguration } from './interfaces/middleware-configuration.interface';
+import { RequestMethod } from '../../common/enums/request-method.enum';
+import { Module } from '../injector/module';
 export declare class MiddlewaresModule {
     private static container;
     private static resolver;
+    private static routerProxy;
+    private static routerMethodFactory;
     static getContainer(): MiddlewaresContainer;
     static setup(container: NestContainer): void;
-    static resolveMiddlewares(modules: Map<NestModule, ModuleDependencies>): void;
-    static loadConfiguration(instance: any, module: NestModule): void;
+    static resolveMiddlewares(modules: Map<string, Module>): void;
+    static loadConfiguration(instance: NestModule, module: string): void;
     static setupMiddlewares(app: Application): void;
     static setupRouteMiddleware(route: ControllerMetadata & {
         method: RequestMethod;
-    }, config: MiddlewareConfiguration, module: NestModule, app: Application): void;
-    private static findRouterMethod(app, requestMethod);
+    }, config: MiddlewareConfiguration, module: string, app: Application): void;
+    private static setupHandler(instance, metatype, app, method, path);
 }

core/middlewares/middlewares-module.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 const builder_1 = require("./builder");
 const container_1 = require("./container");
 const resolver_1 = require("./resolver");
-const unkown_middleware_exception_1 = require("../../errors/exceptions/unkown-middleware.exception");
 const invalid_middleware_exception_1 = require("../../errors/exceptions/invalid-middleware.exception");
-const request_method_enum_1 = require("../../common/enums/request-method.enum");
 const routes_mapper_1 = require("./routes-mapper");
+const router_proxy_1 = require("../router/router-proxy");
+const exceptions_handler_1 = require("../exceptions/exceptions-handler");
+const util_1 = require("util");
+const router_method_factory_1 = require("../helpers/router-method-factory");
+const runtime_exception_1 = require("../../errors/exceptions/runtime.exception");
 class MiddlewaresModule {
@@ -19,6 +23,6 @@ static getContainer() {
     static resolveMiddlewares(modules) {
-        modules.forEach((module, moduleProto) => {
+        modules.forEach((module, name) => {
             const instance = module.instance;
-            this.loadConfiguration(instance, moduleProto);
-            this.resolver.resolveInstances(module, moduleProto);
+            this.loadConfiguration(instance, name);
+            this.resolver.resolveInstances(module, name);
         });
@@ -49,36 +53,24 @@ }
         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 unkown_middleware_exception_1.UnkownMiddlewareException();
+        [].concat(config.middlewares).map((middlewareMetatype) => {
+            const collection = this.container.getMiddlewares(module);
+            const middleware = collection.get(middlewareMetatype.name);
+            if (util_1.isUndefined(middleware)) {
+                throw new runtime_exception_1.RuntimeException();
             }
-            if (typeof middleware.resolve === "undefined") {
-                throw new invalid_middleware_exception_1.InvalidMiddlewareException();
-            }
-            const router = this.findRouterMethod(app, method).bind(app);
-            router(path, middleware.resolve());
+            const instance = middleware.instance;
+            this.setupHandler(instance, middlewareMetatype, app, method, path);
         });
     }
-    static findRouterMethod(app, requestMethod) {
-        switch (requestMethod) {
-            case request_method_enum_1.RequestMethod.POST: {
-                return app.post;
-            }
-            case request_method_enum_1.RequestMethod.ALL: {
-                return app.all;
-            }
-            case request_method_enum_1.RequestMethod.DELETE: {
-                return app.delete;
-            }
-            case request_method_enum_1.RequestMethod.PUT: {
-                return app.put;
-            }
-            default: {
-                return app.get;
-            }
+    static setupHandler(instance, metatype, app, method, path) {
+        if (util_1.isUndefined(instance.resolve)) {
+            throw new invalid_middleware_exception_1.InvalidMiddlewareException(metatype.name);
         }
+        const router = this.routerMethodFactory.get(app, method).bind(app);
+        const proxy = this.routerProxy.createProxy(instance.resolve());
+        router(path, proxy);
     }
 }
 MiddlewaresModule.container = new container_1.MiddlewaresContainer(new routes_mapper_1.RoutesMapper());
+MiddlewaresModule.routerProxy = new router_proxy_1.RouterProxy(new exceptions_handler_1.ExceptionsHandler());
+MiddlewaresModule.routerMethodFactory = new router_method_factory_1.RouterMethodFactory();
 exports.MiddlewaresModule = MiddlewaresModule;

core/middlewares/resolver.d.ts

@@ -1,9 +0,10 @@
-import { ModuleDependencies } from "../injector/container";
-import { MiddlewaresContainer } from "./container";
-import { NestModule } from "../../common/interfaces/nest-module.interface";
+import { MiddlewaresContainer } from './container';
+import { Module } from '../injector/module';
 export declare class MiddlewaresResolver {
     private middlewaresContainer;
-    private instanceLoader;
+    private readonly logger;
+    private readonly instanceLoader;
     constructor(middlewaresContainer: MiddlewaresContainer);
-    resolveInstances(module: ModuleDependencies, moduleProto: NestModule): void;
+    resolveInstances(module: Module, moduleName: string): void;
+    private resolveMiddlewareInstance(metatype, middlewares, module);
 }

core/middlewares/resolver.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 const injector_1 = require("../injector/injector");
+const logger_service_1 = require("../../common/services/logger.service");
+const messages_1 = require("../helpers/messages");
 class MiddlewaresResolver {
     constructor(middlewaresContainer) {
         this.middlewaresContainer = middlewaresContainer;
+        this.logger = new logger_service_1.Logger(MiddlewaresResolver.name);
         this.instanceLoader = new injector_1.Injector();
     }
-    resolveInstances(module, moduleProto) {
-        const middlewares = this.middlewaresContainer.getMiddlewares(moduleProto);
-        middlewares.forEach((val, middlewareType) => {
-            this.instanceLoader.loadInstanceOfMiddleware(middlewareType, middlewares, module);
+    resolveInstances(module, moduleName) {
+        const middlewares = this.middlewaresContainer.getMiddlewares(moduleName);
+        middlewares.forEach(({ metatype }) => {
+            this.resolveMiddlewareInstance(metatype, middlewares, module);
+            this.logger.log(messages_1.getMiddlewareInitMessage(metatype.name, module.metatype.name));
         });
     }
+    resolveMiddlewareInstance(metatype, middlewares, module) {
+        this.instanceLoader.loadInstanceOfMiddleware(metatype, middlewares, module);
+    }
 }
 exports.MiddlewaresResolver = MiddlewaresResolver;

core/middlewares/routes-mapper.d.ts

@@ -1,5 +0,5 @@
-import "reflect-metadata";
+import 'reflect-metadata';
 export declare class RoutesMapper {
     private readonly routerBuilder;
-    mapRouteToRouteProps(routeProto: any): {
+    mapRouteToRouteProps(routeMetatype: any): {
         path: string;
@@ -9,3 +9,3 @@ method: any;
     private mapObjectToRouteProps(route);
-    private validateRoutePath(routePath);
+    private validateRoutePath(path);
 }

core/middlewares/routes-mapper.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 require("reflect-metadata");
@@ -6,2 +7,4 @@ const router_builder_1 = require("../router/router-builder");
 const request_method_enum_1 = require("../../common/enums/request-method.enum");
+const shared_utils_1 = require("../../common/utils/shared.utils");
+const constants_1 = require("../../common/constants");
 class RoutesMapper {
@@ -11,8 +14,8 @@ constructor() {
     }
-    mapRouteToRouteProps(routeProto) {
-        const routePath = Reflect.getMetadata("path", routeProto);
-        if (typeof routePath === "undefined") {
-            return [this.mapObjectToRouteProps(routeProto)];
+    mapRouteToRouteProps(routeMetatype) {
+        const routePath = Reflect.getMetadata(constants_1.PATH_METADATA, routeMetatype);
+        if (shared_utils_1.isUndefined(routePath)) {
+            return [this.mapObjectToRouteProps(routeMetatype)];
         }
-        const paths = this.routerBuilder.scanForPathsFromPrototype(Object.create(routeProto), routeProto.prototype);
+        const paths = this.routerBuilder.scanForPathsFromPrototype(Object.create(routeMetatype), routeMetatype.prototype);
         return paths.map((singlePath) => ({
@@ -24,14 +27,15 @@ path: this.validateRoutePath(routePath) + this.validateRoutePath(singlePath.path),
     mapObjectToRouteProps(route) {
-        if (typeof route.path === "undefined") {
+        const { path, method } = route;
+        if (shared_utils_1.isUndefined(path)) {
             throw new unkown_request_mapping_exception_1.UnkownRequestMappingException();
         }
         return {
-            path: this.validateRoutePath(route.path),
-            method: (typeof route.method === "undefined") ? request_method_enum_1.RequestMethod.ALL : route.method
+            path: this.validateRoutePath(path),
+            method: (shared_utils_1.isUndefined(method)) ? request_method_enum_1.RequestMethod.ALL : method
         };
     }
-    validateRoutePath(routePath) {
-        return (routePath.charAt(0) !== '/') ? '/' + routePath : routePath;
+    validateRoutePath(path) {
+        return shared_utils_1.validatePath(path);
     }
 }
 exports.RoutesMapper = RoutesMapper;

core/router/router-builder.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 require("reflect-metadata");
-const request_method_enum_1 = require("../../common/enums/request-method.enum");
 const unkown_request_mapping_exception_1 = require("../../errors/exceptions/unkown-request-mapping.exception");
+const shared_utils_1 = require("../../common/utils/shared.utils");
+const router_method_factory_1 = require("../helpers/router-method-factory");
+const constants_1 = require("../../common/constants");
+const logger_service_1 = require("../../common/services/logger.service");
+const messages_1 = require("../helpers/messages");
 class RouterBuilder {
@@ -9,6 +14,8 @@ constructor(routerProxy, expressAdapter) {
         this.expressAdapter = expressAdapter;
+        this.routerMethodFactory = new router_method_factory_1.RouterMethodFactory();
+        this.logger = new logger_service_1.Logger(RouterBuilder.name);
     }
-    build(instance, routePrototype) {
+    build(instance, metatype) {
         const router = this.expressAdapter.createRouter();
-        const path = this.fetchRouterPath(routePrototype);
+        const path = this.fetchRouterPath(metatype);
         const routerPaths = this.scanForPaths(instance);
@@ -24,3 +31,9 @@ this.applyPathsToRouterProxy(router, routerPaths);
         return Object.getOwnPropertyNames(instancePrototype)
-            .filter((method) => method !== "constructor")
+            .filter((method) => {
+            const descriptor = Object.getOwnPropertyDescriptor(instancePrototype, method);
+            if (descriptor.set || descriptor.get) {
+                return false;
+            }
+            return !shared_utils_1.isConstructor(method) && shared_utils_1.isFunction(instancePrototype[method]);
+        })
             .map((methodName) => this.exploreMethodMetadata(instance, instancePrototype, methodName))
@@ -31,7 +44,7 @@ .filter((path) => path !== null);
         const callbackMethod = instancePrototype[methodName];
-        const routePath = Reflect.getMetadata("path", callbackMethod);
-        if (typeof routePath === "undefined") {
+        const routePath = Reflect.getMetadata(constants_1.PATH_METADATA, callbackMethod);
+        if (shared_utils_1.isUndefined(routePath)) {
             return null;
         }
-        const requestMethod = Reflect.getMetadata("method", callbackMethod);
+        const requestMethod = Reflect.getMetadata(constants_1.METHOD_METADATA, callbackMethod);
         return {
@@ -50,36 +63,18 @@ targetCallback: callbackMethod.bind(instance),
         const { path, requestMethod, targetCallback } = pathProperties;
-        const routerMethod = this.findRouterMethod(router, requestMethod).bind(router);
+        const routerMethod = this.routerMethodFactory.get(router, requestMethod).bind(router);
         const proxy = this.routerProxy.createProxy(targetCallback);
         routerMethod(path, proxy);
+        this.logger.log(messages_1.getRouteMappedMessage(path, requestMethod));
     }
-    findRouterMethod(router, requestMethod) {
-        switch (requestMethod) {
-            case request_method_enum_1.RequestMethod.POST: {
-                return router.post;
-            }
-            case request_method_enum_1.RequestMethod.ALL: {
-                return router.all;
-            }
-            case request_method_enum_1.RequestMethod.DELETE: {
-                return router.delete;
-            }
-            case request_method_enum_1.RequestMethod.PUT: {
-                return router.put;
-            }
-            default: {
-                return router.get;
-            }
-        }
-    }
-    fetchRouterPath(routePrototype) {
-        const path = Reflect.getMetadata("path", routePrototype);
+    fetchRouterPath(metatype) {
+        const path = Reflect.getMetadata(constants_1.PATH_METADATA, metatype);
         return this.validateRoutePath(path);
     }
-    validateRoutePath(routePath) {
-        if (typeof routePath === "undefined") {
+    validateRoutePath(path) {
+        if (shared_utils_1.isUndefined(path)) {
             throw new unkown_request_mapping_exception_1.UnkownRequestMappingException();
         }
-        return (routePath.charAt(0) !== '/') ? '/' + routePath : routePath;
+        return shared_utils_1.validatePath(path);
     }
 }
 exports.RouterBuilder = RouterBuilder;

core/router/router-proxy.d.ts

@@ -1,2 +0,2 @@
-import { ExceptionsHandler } from "../exceptions/exceptions-handler";
+import { ExceptionsHandler } from '../exceptions/exceptions-handler';
 export declare class RouterProxy {
@@ -3,0 +3,0 @@ private exceptionsHandler;

core/router/router-proxy.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 class RouterProxy {
@@ -9,3 +10,5 @@ constructor(exceptionsHandler) {
             try {
-                Promise.resolve(targetCallback(req, res, next)).catch((e) => {
+                Promise
+                    .resolve(targetCallback(req, res, next))
+                    .catch((e) => {
                     this.exceptionsHandler.next(e, res);
@@ -12,0 +15,0 @@ });

core/router/routes-resolver.d.ts

 /// <reference types="express" />
-import { Application } from "express";
-import { NestContainer, InstanceWrapper } from "../injector/container";
-import { Controller } from "../../common/interfaces/controller.interface";
+import { Application } from 'express';
+import { NestContainer, InstanceWrapper } from '../injector/container';
+import { Controller } from '../../common/interfaces/controller.interface';
 export declare class RoutesResolver {
     private container;
+    private readonly logger;
     private readonly routerProxy;
@@ -11,3 +12,3 @@ private routerBuilder;
     resolve(expressInstance: Application): void;
-    setupRouters(routes: Map<Controller, InstanceWrapper<Controller>>, expressInstance: Application): void;
+    setupRouters(routes: Map<string, InstanceWrapper<Controller>>, expressInstance: Application): void;
 }

core/router/routes-resolver.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 const router_builder_1 = require("./router-builder");
 const router_proxy_1 = require("./router-proxy");
 const exceptions_handler_1 = require("../exceptions/exceptions-handler");
+const logger_service_1 = require("../../common/services/logger.service");
+const messages_1 = require("../helpers/messages");
 class RoutesResolver {
     constructor(container, expressAdapter) {
         this.container = container;
+        this.logger = new logger_service_1.Logger(RoutesResolver.name);
         this.routerProxy = new router_proxy_1.RouterProxy(new exceptions_handler_1.ExceptionsHandler());
@@ -16,4 +20,5 @@ this.routerBuilder = new router_builder_1.RouterBuilder(this.routerProxy, expressAdapter);
     setupRouters(routes, expressInstance) {
-        routes.forEach(({ instance }, routePrototype) => {
-            const { path, router } = this.routerBuilder.build(instance, routePrototype);
+        routes.forEach(({ instance, metatype }) => {
+            this.logger.log(messages_1.getControllerMappingMessage(metatype.name));
+            const { path, router } = this.routerBuilder.build(instance, metatype);
             expressInstance.use(path, router);
@@ -20,0 +25,0 @@ });

core/scanner.d.ts

@@ -1,8 +0,8 @@
-import "reflect-metadata";
-import { NestContainer } from "./injector/container";
-import { NestModule } from "../common/interfaces/nest-module.interface";
+import 'reflect-metadata';
+import { NestContainer } from './injector/container';
+import { NestModuleMetatype } from '../common/interfaces/module-metatype.interface';
 export declare class DependenciesScanner {
     private container;
     constructor(container: NestContainer);
-    scan(module: NestModule): void;
+    scan(module: NestModuleMetatype): void;
     private scanForModules(module);
@@ -13,3 +13,3 @@ private storeModule(module);
     private reflectComponents(module);
-    private reflectRoutes(module);
+    private reflectControllers(module);
     private reflectExports(module);
@@ -20,2 +20,3 @@ private storeRelatedModule(related, module);
     private storeRoute(route, module);
+    private reflectMetadata(module, metadata);
 }

core/scanner.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 require("reflect-metadata");
+const constants_1 = require("../common/constants");
 class DependenciesScanner {
@@ -13,3 +15,3 @@ constructor(container) {
         this.storeModule(module);
-        const innerModules = Reflect.getMetadata('modules', module) || [];
+        const innerModules = this.reflectMetadata(module, constants_1.metadata.MODULES);
         innerModules.map((module) => this.scanForModules(module));
@@ -22,23 +24,23 @@ }
         const modules = this.container.getModules();
-        modules.forEach((deps, module) => {
-            this.reflectRelatedModules(module);
-            this.reflectComponents(module);
-            this.reflectRoutes(module);
-            this.reflectExports(module);
+        modules.forEach(({ metatype }) => {
+            this.reflectRelatedModules(metatype);
+            this.reflectComponents(metatype);
+            this.reflectControllers(metatype);
+            this.reflectExports(metatype);
         });
     }
     reflectRelatedModules(module) {
-        const modules = Reflect.getMetadata('modules', module) || [];
+        const modules = this.reflectMetadata(module, constants_1.metadata.MODULES);
         modules.map((related) => this.storeRelatedModule(related, module));
     }
     reflectComponents(module) {
-        const components = Reflect.getMetadata('components', module) || [];
+        const components = this.reflectMetadata(module, constants_1.metadata.COMPONENTS);
         components.map((component) => this.storeComponent(component, module));
     }
-    reflectRoutes(module) {
-        const routes = Reflect.getMetadata('controllers', module) || [];
+    reflectControllers(module) {
+        const routes = this.reflectMetadata(module, constants_1.metadata.CONTROLLERS);
         routes.map((route) => this.storeRoute(route, module));
     }
     reflectExports(module) {
-        const exports = Reflect.getMetadata('exports', module) || [];
+        const exports = this.reflectMetadata(module, constants_1.metadata.EXPORTS);
         exports.map((exportedComponent) => this.storeExportedComponent(exportedComponent, module));
@@ -58,3 +60,6 @@ }
     }
+    reflectMetadata(module, metadata) {
+        return Reflect.getMetadata(metadata, module) || [];
+    }
 }
 exports.DependenciesScanner = DependenciesScanner;

errors/exception-handler.d.ts

 import { RuntimeException } from "./exceptions/runtime.exception";
 export declare class ExceptionHandler {
-    handle(e: RuntimeException | Error): void;
+    private readonly logger;
+    handle(exception: RuntimeException | Error): void;
 }

errors/exception-handler.js

 "use strict";
-const clc = require("cli-color");
+Object.defineProperty(exports, "__esModule", { value: true });
 const runtime_exception_1 = require("./exceptions/runtime.exception");
+const logger_service_1 = require("../common/services/logger.service");
 class ExceptionHandler {
-    handle(e) {
-        var error = clc.red.bold;
-        var warn = clc.xterm(214);
-        if (e instanceof runtime_exception_1.RuntimeException) {
-            console.log(error("[Nest] Runtime error!"));
-            console.log(warn(e.what()));
+    constructor() {
+        this.logger = new logger_service_1.Logger(ExceptionHandler.name);
+    }
+    handle(exception) {
+        if (!(exception instanceof runtime_exception_1.RuntimeException)) {
+            this.logger.error(exception.message, exception.stack);
+            return;
         }
-        console.log(error("Stack trace:"));
-        console.log(e.stack);
+        this.logger.error(exception.what(), exception.stack);
     }
 }
 exports.ExceptionHandler = ExceptionHandler;

errors/exceptions-zone.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 const exception_handler_1 = require("./exception-handler");
@@ -3,0 +4,0 @@ class ExceptionsZone {

errors/exceptions/invalid-middleware-configuration.exception.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 const runtime_exception_1 = require("./runtime.exception");
+const messages_1 = require("../messages");
 class InvalidMiddlewareConfigurationException extends runtime_exception_1.RuntimeException {
     constructor() {
-        super(`Invalid middleware configuration passed in module "configure()" method.`);
+        super(messages_1.INVALID_MIDDLEWARE_CONFIGURATION);
     }
 }
 exports.InvalidMiddlewareConfigurationException = InvalidMiddlewareConfigurationException;

errors/exceptions/invalid-middleware.exception.d.ts

 import { RuntimeException } from "./runtime.exception";
 export declare class InvalidMiddlewareException extends RuntimeException {
-    constructor();
+    constructor(name: string);
 }

errors/exceptions/invalid-middleware.exception.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 const runtime_exception_1 = require("./runtime.exception");
+const messages_1 = require("../messages");
 class InvalidMiddlewareException extends runtime_exception_1.RuntimeException {
-    constructor() {
-        super(`You are trying to setup middleware without "resolve" method.`);
+    constructor(name) {
+        super(messages_1.getInvalidMiddlewareMessage(name));
     }
 }
 exports.InvalidMiddlewareException = InvalidMiddlewareException;

errors/exceptions/invalid-module-config.exception.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 const runtime_exception_1 = require("./runtime.exception");
+const messages_1 = require("../messages");
 class InvalidModuleConfigException extends runtime_exception_1.RuntimeException {
     constructor(property) {
-        super(`Invalid property [${property}] in @Module({}) annotation.`);
+        super(messages_1.getInvalidModuleConfigMessage(property));
     }
 }
 exports.InvalidModuleConfigException = InvalidModuleConfigException;

errors/exceptions/runtime.exception.d.ts

@@ -0,5 +1,11 @@
+export declare class Error {
+    name: string;
+    message: string;
+    stack: string;
+    constructor(message?: string);
+}
 export declare class RuntimeException extends Error {
     private msg;
-    constructor(msg: string);
+    constructor(msg?: string);
     what(): string;
 }

errors/exceptions/runtime.exception.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 class RuntimeException extends Error {
-    constructor(msg) {
-        super();
+    constructor(msg = ``) {
+        super(msg);
         this.msg = msg;
@@ -6,0 +7,0 @@ }

errors/exceptions/unkown-dependencies.exception.d.ts

 import { RuntimeException } from "./runtime.exception";
 export declare class UnkownDependenciesException extends RuntimeException {
-    constructor(type: any);
+    constructor(type: string);
 }

errors/exceptions/unkown-dependencies.exception.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 const runtime_exception_1 = require("./runtime.exception");
+const messages_1 = require("../messages");
 class UnkownDependenciesException extends runtime_exception_1.RuntimeException {
     constructor(type) {
-        super(`Can't recognize dependencies of ${type}.`);
+        super(messages_1.getUnkownDependenciesMessage(type));
     }
 }
 exports.UnkownDependenciesException = UnkownDependenciesException;

errors/exceptions/unkown-export.exception.d.ts

 import { RuntimeException } from "./runtime.exception";
 export declare class UnkownExportException extends RuntimeException {
-    constructor();
+    constructor(name: string);
 }

errors/exceptions/unkown-export.exception.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 const runtime_exception_1 = require("./runtime.exception");
+const messages_1 = require("../messages");
 class UnkownExportException extends runtime_exception_1.RuntimeException {
-    constructor() {
-        super(`You are trying to export unkown component. Maybe ` +
-            `you forgot to place this one to components list also.`);
+    constructor(name) {
+        super(messages_1.getUnkownExportMessage(name));
     }
 }
 exports.UnkownExportException = UnkownExportException;

errors/exceptions/unkown-module.exception.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 const runtime_exception_1 = require("./runtime.exception");
 class UnkownModuleException extends runtime_exception_1.RuntimeException {
     constructor() {
-        super(`Not recognized module - runtime error!`);
+        super();
     }
 }
 exports.UnkownModuleException = UnkownModuleException;

errors/exceptions/unkown-request-mapping.exception.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 const runtime_exception_1 = require("./runtime.exception");
+const messages_1 = require("../messages");
 class UnkownRequestMappingException extends runtime_exception_1.RuntimeException {
     constructor() {
-        super(`RequestMapping not defined in @RequestMapping() annotation!`);
+        super(messages_1.UNKOWN_REQUEST_MAPPING);
     }
 }
 exports.UnkownRequestMappingException = UnkownRequestMappingException;

index.d.ts

 export * from './common';
-export * from './runner';
+export * from './nest-factory';
 export * from './core';

index.js

@@ -11,4 +11,5 @@ /*
 }
+Object.defineProperty(exports, "__esModule", { value: true });
 __export(require("./common"));
-__export(require("./runner"));
+__export(require("./nest-factory"));
 __export(require("./core"));

package.json

 {
   "name": "nest.js",
-  "version": "1.0.0-alpha-2",
-  "description": "Modern, fast, powerful web framework",
-  "main": "index.js",
-  "keywords": [
-    "nest",
-    "modern",
-    "web",
-    "rest",
-    "scalable",
-    "framework"
-  ],
-  "author": {
-    "name": "Kamil Mysliwiec",
-    "email": "[e-mail]"
-  },
-  "license": "MIT",
+  "version": "1.0.0-alpha-20",
+  "description": "Modern, fast, powerful node.js web framework",
+  "author": "Kamil Mysliwiec",
+  "license": "ISC",
   "dependencies": {
@@ -24,4 +12,6 @@ "cli-color": "^1.1.0",
     "rxjs": "^5.0.3",
-    "socket.io": "^1.7.2"
+    "socket.io": "^1.7.2",
+    "json-socket": "^0.2.1",
+    "redis": "^2.6.5"
   }
 }

Readme.md

 [![Nest Logo](http://kamilmysliwiec.com/public/nest-logo.png)](http://kamilmysliwiec.com/)
 
-  Modern, fast, powerful web framework for [node](http://nodejs.org).
+  Modern, powerful web application framework for [Node.js](http://nodejs.org).
 
   [![NPM Version][npm-image]][npm-url]
   [![NPM Downloads][downloads-image]][downloads-url]
-  [![Linux Build][travis-image]][travis-url]
-  [![Windows Build][appveyor-image]][appveyor-url]
+  [![Travis][travis-image]][travis-url]
+  [![Linux][linux-image]][linux-url]
+  [![Coverage Status](https://coveralls.io/repos/github/kamilmysliwiec/nest/badge.svg?branch=master)](https://coveralls.io/github/kamilmysliwiec/nest?branch=master)
 
+## Description
+
+Nest is a powerful web framework for [Node.js](http://nodejs.org), which allows you to easily build efficient, scalable applications.
+It uses modern JavaScript, is built with [TypeScript](http://www.typescriptlang.org) and bring best concepts to JavaScript back-end world such as Dependency Injection (with IoC Container) and Separation of Concerns.
+
+It is not just another framework. You do not have to wait on large community, because Nest is built with awesome, popular well-known libraries - [Express](https://github.com/expressjs/express) and [socket.io](https://github.com/socketio/socket.io)! It means, that you could quickly start using framework with no worries about a third party plugins.
+
+Nest is inspired by [Spring](https://spring.io) and [Angular](https://angular.io/) and is very much still a work in progress.
+
+## Installation
+
+```bash
+$ npm install nest.js
+```
+
+## Philosophy
+
+JavaScript is awesome. This language is no longer just a trash to create simple animations in the browser. Right now, the front end world is rich in variety of tools. We have a lot of amazing frameworks / libraries such as [Angular](https://angular.io/), [React](https://github.com/facebook/react) or [Vue](https://github.com/vuejs/vue), which improves our development process and makes our applications fast and flexible. 
+
+[Node.js](http://nodejs.org) gave us a possibility to use this language also on the server side. There are a lot of superb libraries, helpers and tools for node, but non of them do not solve the main problem - the architecture. 
+
+We want to create scalable, modern and easy to maintain applications. Nest helps us with it.
+
+## Features
+
+- Compatible with both TypeScript and ES6 (I recommend to use [TypeScript](http://www.typescriptlang.org))
+- Based on well-known libraries ([Express](https://github.com/expressjs/express) / [socket.io](https://github.com/socketio/socket.io)) so you could share your experience 
+- Easy to learn - syntax is similar to [Angular](https://angular.io/) / [Spring](https://spring.io) (Java)
+- Dependency Injection, Inversion of Control Container
+- Exceptions handler layer (helps to focus on logic)
+- Own modularity system
+- Sockets module (based on [socket.io](https://github.com/socketio/socket.io))
+
+## Documentation & Quick Start
+
+[Documentation & Tutorial](https://kamilmysliwiec.gitbooks.io/nest/content/)
+
+## Starter repos
+
+- [TypeScript](https://github.com/kamilmysliwiec/nest-typescript-starter)
+- [Babel](https://github.com/kamilmysliwiec/nest-babel-starter/)
+
+## Future
+
+Nest is very much still a work in progress. There is still some things to finish:
+
+- Better test utilities
+- Exception filters
+- Starter repos
+- Validation helpers
+- Increase test coverage
+- Gateways middleware
+- and more...
+
+## People
+
+Author - [Kamil Myśliwiec](http://kamilmysliwiec.com)
+
 ## License
@@ -18,11 +77,5 @@
 [downloads-url]: https://npmjs.org/package/nest.js
-[travis-image]: https://img.shields.io/travis/nest.jsjs/nest.js/master.svg?label=linux
-[travis-url]: https://travis-ci.org/nest.jsjs/nest.js
-[appveyor-image]: https://img.shields.io/appveyor/ci/dougwilson/nest.js/master.svg?label=windows
-[appveyor-url]: https://ci.appveyor.com/project/dougwilson/nest.js
-[coveralls-image]: https://img.shields.io/coveralls/nest.jsjs/nest.js/master.svg
-[coveralls-url]: https://coveralls.io/r/nest.jsjs/nest.js?branch=master
-[gratipay-image-visionmedia]: https://img.shields.io/gratipay/visionmedia.svg
-[gratipay-url-visionmedia]: https://gratipay.com/visionmedia/
-[gratipay-image-dougwilson]: https://img.shields.io/gratipay/dougwilson.svg
-[gratipay-url-dougwilson]: https://gratipay.com/dougwilson/
+[travis-image]: https://api.travis-ci.org/kamilmysliwiec/nest.svg?branch=master
+[travis-url]: https://travis-ci.org/kamilmysliwiec/nest
+[linux-image]: https://img.shields.io/travis/kamilmysliwiec/nest/master.svg?label=linux
+[linux-url]: https://travis-ci.org/kamilmysliwiec/nest

socket/adapters/io-adapter.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 const io = require("socket.io");
@@ -3,0 +4,0 @@ class IoAdapter {

socket/container.d.ts

@@ -1,6 +0,6 @@
-import { ObservableSocketServer } from "./interfaces";
+import { ObservableSocketServer } from './interfaces';
 export declare class SocketsContainer {
     private readonly socketSubjects;
     getSocketSubjects(namespace: string, port: number): ObservableSocketServer;
-    storeSocketSubjects(namespace: string, port: number, observableServer: ObservableSocketServer): void;
+    storeSocketSubjects(namespace: string, port: number, server: ObservableSocketServer): void;
 }

socket/container.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 class SocketsContainer {
@@ -7,8 +8,14 @@ constructor() {
     getSocketSubjects(namespace, port) {
-        return this.socketSubjects.get({ namespace, port });
+        return this.socketSubjects.get({
+            namespace,
+            port
+        });
     }
-    storeSocketSubjects(namespace, port, observableServer) {
-        this.socketSubjects.set({ namespace, port }, observableServer);
+    storeSocketSubjects(namespace, port, server) {
+        this.socketSubjects.set({
+            namespace,
+            port
+        }, server);
     }
 }
 exports.SocketsContainer = SocketsContainer;

socket/exceptions/invalid-socket-port.exception.d.ts

@@ -1,4 +0,4 @@
-import { RuntimeException } from "../../errors/exceptions/runtime.exception";
+import { RuntimeException } from '../../errors/exceptions/runtime.exception';
 export declare class InvalidSocketPortException extends RuntimeException {
     constructor(port: any, type: any);
 }

socket/exceptions/invalid-socket-port.exception.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 const runtime_exception_1 = require("../../errors/exceptions/runtime.exception");
@@ -3,0 +4,0 @@ class InvalidSocketPortException extends runtime_exception_1.RuntimeException {

socket/gateway-metadata-explorer.d.ts

@@ -1,7 +0,7 @@
-import { Gateway } from "./interfaces/gateway.interface";
+import { NestGateway } from './interfaces/nest-gateway.interface';
 export declare class GatewayMetadataExplorer {
-    static explore(instance: Gateway): MessageMappingProperties[];
-    static scanForHandlersFromPrototype(instance: Gateway, instancePrototype: any): MessageMappingProperties[];
-    static exploreMethodMetadata(instance: any, instancePrototype: any, methodName: string): MessageMappingProperties;
-    static scanForServerHooks(instance: Gateway): IterableIterator<string>;
+    explore(instance: NestGateway): MessageMappingProperties[];
+    scanForHandlersFromPrototype(instance: NestGateway, instancePrototype: any): MessageMappingProperties[];
+    exploreMethodMetadata(instance: any, instancePrototype: any, methodName: string): MessageMappingProperties;
+    scanForServerHooks(instance: NestGateway): IterableIterator<string>;
 }
@@ -8,0 +8,0 @@ export interface MessageMappingProperties {

socket/gateway-metadata-explorer.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const shared_utils_1 = require("../common/utils/shared.utils");
+const constants_1 = require("./constants");
 class GatewayMetadataExplorer {
-    static explore(instance) {
+    explore(instance) {
         const instancePrototype = Object.getPrototypeOf(instance);
         return this.scanForHandlersFromPrototype(instance, instancePrototype);
     }
-    static scanForHandlersFromPrototype(instance, instancePrototype) {
+    scanForHandlersFromPrototype(instance, instancePrototype) {
         return Object.getOwnPropertyNames(instancePrototype)
-            .filter((method) => method !== "constructor" && typeof instancePrototype[method] === "function")
+            .filter((method) => {
+            const descriptor = Object.getOwnPropertyDescriptor(instancePrototype, method);
+            if (descriptor.set || descriptor.get) {
+                return false;
+            }
+            return !shared_utils_1.isConstructor(method) && shared_utils_1.isFunction(instancePrototype[method]);
+        })
             .map((methodName) => this.exploreMethodMetadata(instance, instancePrototype, methodName))
             .filter((mapper) => mapper !== null);
     }
-    static exploreMethodMetadata(instance, instancePrototype, methodName) {
+    exploreMethodMetadata(instance, instancePrototype, methodName) {
         const callbackMethod = instancePrototype[methodName];
-        const isMessageMapping = Reflect.getMetadata("__isMessageMapping", callbackMethod);
-        if (typeof isMessageMapping === "undefined") {
+        const isMessageMapping = Reflect.getMetadata(constants_1.MESSAGE_MAPPING_METADATA, callbackMethod);
+        if (shared_utils_1.isUndefined(isMessageMapping)) {
             return null;
         }
-        const message = Reflect.getMetadata("message", callbackMethod);
+        const message = Reflect.getMetadata(constants_1.MESSAGE_METADATA, callbackMethod);
         return {
@@ -25,11 +34,11 @@ targetCallback: callbackMethod.bind(instance),
     }
-    static *scanForServerHooks(instance) {
+    *scanForServerHooks(instance) {
         for (const propertyKey in instance) {
-            if (typeof propertyKey === "function") {
+            if (shared_utils_1.isFunction(propertyKey))
                 continue;
+            const property = String(propertyKey);
+            const isServer = Reflect.getMetadata(constants_1.GATEWAY_SERVER_METADATA, instance, property);
+            if (!shared_utils_1.isUndefined(isServer)) {
+                yield property;
             }
-            const isServer = Reflect.getMetadata("__isSocketServer", instance, String(propertyKey));
-            if (typeof isServer !== "undefined") {
-                yield String(propertyKey);
-            }
         }
@@ -36,0 +45,0 @@ }

socket/interfaces/gateway-metadata.interface.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

socket/interfaces/index.d.ts

@@ -1,4 +0,4 @@
-export * from "./gateway-metadata.interface";
-export * from "./gateway.interface";
-export * from "./observable-socket-server.interface";
-export * from "./socket-server.interface";
+export * from './gateway-metadata.interface';
+export * from './nest-gateway.interface';
+export * from './observable-socket-server.interface';
+export * from './socket-server.interface';

socket/interfaces/index.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

socket/interfaces/observable-socket-server.interface.d.ts

@@ -1,2 +0,3 @@
-import { Subject, ReplaySubject } from "rxjs";
+import { ReplaySubject } from 'rxjs/ReplaySubject';
+import { Subject } from 'rxjs/Subject';
 export interface ObservableSocketServer {
@@ -3,0 +4,0 @@ server: any;

socket/interfaces/observable-socket-server.interface.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

socket/interfaces/socket-server.interface.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

socket/observable-socket.d.ts

@@ -1,4 +0,4 @@
-import { ObservableSocketServer } from "./interfaces/observable-socket-server.interface";
+import { ObservableSocketServer } from './interfaces/observable-socket-server.interface';
 export declare class ObservableSocket {
     static create(server: any): ObservableSocketServer;
 }

socket/observable-socket.js

 "use strict";
-const rxjs_1 = require("rxjs");
+Object.defineProperty(exports, "__esModule", { value: true });
+const Subject_1 = require("rxjs/Subject");
+const ReplaySubject_1 = require("rxjs/ReplaySubject");
 class ObservableSocket {
     static create(server) {
         return {
-            init: new rxjs_1.ReplaySubject(),
-            connection: new rxjs_1.Subject(),
-            disconnect: new rxjs_1.Subject(),
+            init: new ReplaySubject_1.ReplaySubject(),
+            connection: new Subject_1.Subject(),
+            disconnect: new Subject_1.Subject(),
             server,
@@ -10,0 +12,0 @@ };

socket/socket-module.d.ts

@@ -1,4 +0,4 @@
-import "reflect-metadata";
-import { NestContainer, InstanceWrapper } from "../core/injector/container";
-import { Injectable } from "../common/interfaces/injectable.interface";
+import 'reflect-metadata';
+import { NestContainer, InstanceWrapper } from '../core/injector/container';
+import { Injectable } from '../common/interfaces/injectable.interface';
 export declare class SocketModule {
@@ -8,3 +8,3 @@ private static socketsContainer;
     static setup(container: NestContainer): void;
-    static hookGatewaysIntoServers(components: Map<Injectable, InstanceWrapper<Injectable>>): void;
+    static hookGatewaysIntoServers(components: Map<string, InstanceWrapper<Injectable>>): void;
 }

socket/socket-module.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 require("reflect-metadata");
@@ -6,2 +7,3 @@ const container_1 = require("./container");
 const socket_server_provider_1 = require("./socket-server-provider");
+const constants_1 = require("./constants");
 class SocketModule {
@@ -14,8 +16,8 @@ static setup(container) {
     static hookGatewaysIntoServers(components) {
-        components.forEach(({ instance }, componentType) => {
-            const metadataKeys = Reflect.getMetadataKeys(componentType);
-            if (metadataKeys.indexOf("__isGateway") < 0) {
+        components.forEach(({ instance, metatype }) => {
+            const metadataKeys = Reflect.getMetadataKeys(metatype);
+            if (metadataKeys.indexOf(constants_1.GATEWAY_METADATA) < 0) {
                 return;
             }
-            this.subjectsController.hookGatewayIntoServer(instance, componentType);
+            this.subjectsController.hookGatewayIntoServer(instance, metatype);
         });
@@ -22,0 +24,0 @@ }

socket/socket-server-provider.d.ts

@@ -1,6 +0,6 @@
-import "reflect-metadata";
-import { SocketsContainer } from "./container";
-import { ObservableSocketServer } from "./interfaces/observable-socket-server.interface";
+import 'reflect-metadata';
+import { SocketsContainer } from './container';
+import { ObservableSocketServer } from './interfaces/observable-socket-server.interface';
 export declare class SocketServerProvider {
-    private socketsContainer;
+    private readonly socketsContainer;
     constructor(socketsContainer: SocketsContainer);
@@ -7,0 +7,0 @@ scanForSocketServer(namespace: string, port: number): ObservableSocketServer;

socket/socket-server-provider.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 require("reflect-metadata");
 const observable_socket_1 = require("./observable-socket");
 const io_adapter_1 = require("./adapters/io-adapter");
+const shared_utils_1 = require("../common/utils/shared.utils");
 class SocketServerProvider {
@@ -10,7 +12,4 @@ constructor(socketsContainer) {
     scanForSocketServer(namespace, port) {
-        let observableServer = this.socketsContainer.getSocketSubjects(namespace, port);
-        if (!observableServer) {
-            observableServer = this.createSocketServer(namespace, port);
-        }
-        return observableServer;
+        const observableServer = this.socketsContainer.getSocketSubjects(namespace, port);
+        return observableServer ? observableServer : this.createSocketServer(namespace, port);
     }
@@ -30,8 +29,5 @@ createSocketServer(namespace, port) {
     validateNamespace(namespace) {
-        if (namespace.charAt(0) !== '/') {
-            return '/' + namespace;
-        }
-        return namespace;
+        return shared_utils_1.validatePath(namespace);
     }
 }
 exports.SocketServerProvider = SocketServerProvider;

socket/subjects-controller.d.ts

@@ -1,9 +0,13 @@
-import "reflect-metadata";
-import { Gateway } from "./interfaces/gateway.interface";
-import { Injectable } from "../common/interfaces/injectable.interface";
-import { SocketServerProvider } from "./socket-server-provider";
+import 'reflect-metadata';
+import { NestGateway } from './interfaces/nest-gateway.interface';
+import { Injectable } from '../common/interfaces/injectable.interface';
+import { SocketServerProvider } from './socket-server-provider';
+import { Metatype } from '../common/interfaces/metatype.interface';
 export declare class SubjectsController {
     private socketServerProvider;
+    private readonly metadataExplorer;
+    private readonly CONNECTION_EVENT;
+    private readonly DISCONNECT_EVENT;
     constructor(socketServerProvider: SocketServerProvider);
-    hookGatewayIntoServer(instance: Gateway, componentType: Injectable): void;
+    hookGatewayIntoServer(instance: NestGateway, metatype: Metatype<Injectable>): void;
     private subscribeObservableServer(instance, namespace, port);
@@ -10,0 +14,0 @@ private hookServerToProperties(instance, server);

socket/subjects-controller.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 require("reflect-metadata");
 const invalid_socket_port_exception_1 = require("./exceptions/invalid-socket-port.exception");
 const gateway_metadata_explorer_1 = require("./gateway-metadata-explorer");
+const constants_1 = require("./constants");
 class SubjectsController {
     constructor(socketServerProvider) {
         this.socketServerProvider = socketServerProvider;
+        this.metadataExplorer = new gateway_metadata_explorer_1.GatewayMetadataExplorer();
+        this.CONNECTION_EVENT = 'connection';
+        this.DISCONNECT_EVENT = 'disconnect';
     }
-    hookGatewayIntoServer(instance, componentType) {
-        const namespace = Reflect.getMetadata("namespace", componentType) || "";
-        const port = Reflect.getMetadata("port", componentType) || 80;
+    hookGatewayIntoServer(instance, metatype) {
+        const namespace = Reflect.getMetadata(constants_1.NAMESPACE_METADATA, metatype) || '';
+        const port = Reflect.getMetadata(constants_1.PORT_METADATA, metatype) || 80;
         if (!Number.isInteger(port)) {
-            throw new invalid_socket_port_exception_1.InvalidSocketPortException(port, componentType);
+            throw new invalid_socket_port_exception_1.InvalidSocketPortException(port, metatype);
         }
@@ -18,3 +23,3 @@ this.subscribeObservableServer(instance, namespace, port);
     subscribeObservableServer(instance, namespace, port) {
-        const messageHandlers = gateway_metadata_explorer_1.GatewayMetadataExplorer.explore(instance);
+        const messageHandlers = this.metadataExplorer.explore(instance);
         const observableServer = this.socketServerProvider.scanForSocketServer(namespace, port);
@@ -25,3 +30,3 @@ this.hookServerToProperties(instance, observableServer.server);
     hookServerToProperties(instance, server) {
-        for (const propertyKey of gateway_metadata_explorer_1.GatewayMetadataExplorer.scanForServerHooks(instance)) {
+        for (const propertyKey of this.metadataExplorer.scanForServerHooks(instance)) {
             Reflect.set(instance, propertyKey, server);
@@ -34,3 +39,3 @@ }
         init.next(server);
-        server.on("connection", (client) => {
+        server.on(this.CONNECTION_EVENT, (client) => {
             this.subscribeConnectionEvent(instance, connection);
@@ -40,3 +45,3 @@ connection.next(client);
             this.subscribeDisconnectEvent(instance, disconnect);
-            client.on("disconnect", (client) => disconnect.next(client));
+            client.on(this.DISCONNECT_EVENT, (client) => disconnect.next(client));
         });
@@ -43,0 +48,0 @@ }

socket/utils/index.d.ts

@@ -1,3 +0,3 @@
-export * from "./socket-gateway.decorator";
-export * from "./subscribe-message.decorator";
-export * from "./socket-server.decorator";
+export * from './socket-gateway.decorator';
+export * from './subscribe-message.decorator';
+export * from './gateway-server.decorator';

socket/utils/index.js

@@ -5,4 +5,5 @@ "use strict";
 }
+Object.defineProperty(exports, "__esModule", { value: true });
 __export(require("./socket-gateway.decorator"));
 __export(require("./subscribe-message.decorator"));
-__export(require("./socket-server.decorator"));
+__export(require("./gateway-server.decorator"));

socket/utils/socket-gateway.decorator.d.ts

@@ -1,3 +0,3 @@
-import "reflect-metadata";
-import { GatewayMetadata } from "../interfaces";
-export declare const SocketGateway: (metadata?: GatewayMetadata) => ClassDecorator;
+import 'reflect-metadata';
+import { GatewayMetadata } from '../interfaces';
+export declare const WebSocketGateway: (metadata?: GatewayMetadata) => ClassDecorator;

socket/utils/socket-gateway.decorator.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 require("reflect-metadata");
-exports.SocketGateway = (metadata) => {
+const constants_1 = require("../constants");
+exports.WebSocketGateway = (metadata) => {
     metadata = metadata || {};
     return (target) => {
-        Reflect.defineMetadata("__isGateway", true, target);
-        Reflect.defineMetadata("namespace", metadata.namespace, target);
-        Reflect.defineMetadata("port", metadata.port, target);
+        Reflect.defineMetadata(constants_1.GATEWAY_METADATA, true, target);
+        Reflect.defineMetadata(constants_1.NAMESPACE_METADATA, metadata.namespace, target);
+        Reflect.defineMetadata(constants_1.PORT_METADATA, metadata.port, target);
     };
 };

socket/utils/subscribe-message.decorator.d.ts

@@ -1,4 +0,4 @@
-import "reflect-metadata";
+import 'reflect-metadata';
 export declare const SubscribeMessage: (metadata?: {
     value: string;
 }) => MethodDecorator;

socket/utils/subscribe-message.decorator.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 require("reflect-metadata");
-const defaultMetadata = { value: "" };
+const constants_1 = require("../constants");
+const defaultMetadata = { value: '' };
 exports.SubscribeMessage = (metadata = defaultMetadata) => {
     return (target, key, descriptor) => {
-        Reflect.defineMetadata("__isMessageMapping", true, descriptor.value);
-        Reflect.defineMetadata("message", metadata.value, descriptor.value);
+        Reflect.defineMetadata(constants_1.MESSAGE_MAPPING_METADATA, true, descriptor.value);
+        Reflect.defineMetadata(constants_1.MESSAGE_METADATA, metadata.value, descriptor.value);
         return descriptor;
     };
 };

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Network access

Supply chain risk

This module accesses the network.

Found 1 instance in 1 package

Mixed license

License

(Experimental) Package contains multiple licenses.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

116359

increased by76.86%

Number of package files

200

increased by43.88%

Lines of code

2626

increased by68.33%

Number of lines in readme file

81

increased by189.29%

Worsened metrics

Dependency count

7

increased by40%

Number of low license alerts

1

increased byInfinity%

Number of medium supply chain risk alerts

2

increased byInfinity%

Dependency changes

• + Addedjson-socket@^0.2.1

• + Addedredis@^2.6.5

• + Addeddouble-ended-queue@2.1.0-0(transitive)

• + Addedjson-socket@0.2.1(transitive)

• + Addedredis@2.8.0(transitive)

• + Addedredis-commands@1.7.0(transitive)

• + Addedredis-parser@2.6.0(transitive)