Name typo fix

Author: kamil.mysliwiec

src/core/constants.ts

@@ -1,5 +1,5 @@
 export const messages = {
     APPLICATION_START: `Starting Nest application...`,
     APPLICATION_READY: `Nest application is ready!`,
-    UNKOWN_EXCEPTION_MESSAGE: 'Unkown exception',
+    UNKNOWN_EXCEPTION_MESSAGE: 'Unkown exception',
 };

src/core/exceptions/exceptions-handler.ts

@@ -13,7 +13,7 @@ export class ExceptionsHandler {
         if (this.invokeCustomFilters(exception, response)) return;
 
         if (!(exception instanceof HttpException)) {
-            response.status(500).json({ message: messages.UNKOWN_EXCEPTION_MESSAGE });
+            response.status(500).json({ message: messages.UNKNOWN_EXCEPTION_MESSAGE });
 
             this.logger.error(exception.message, exception.stack);
             return;

src/core/injector/container.ts

@@ -1,6 +1,6 @@
 import { Controller, Injectable } from '../../common/interfaces/';
 import { Module } from './module';
-import { UnkownModuleException } from '../../errors/exceptions/unkown-module.exception';
+import { UnknownModuleException } from '../../errors/exceptions/unknown-module.exception';
 import { NestModuleMetatype } from '../../common/interfaces/module-metatype.interface';
 import { Metatype } from '../../common/interfaces/metatype.interface';
 
@@ -28,23 +28,23 @@ export class NestContainer {
 
     public addComponent(component: Metatype<Injectable>, metatype: NestModuleMetatype) {
         if (!this.modules.has(metatype.name)) {
-            throw new UnkownModuleException();
+            throw new UnknownModuleException();
         }
         const module = this.modules.get(metatype.name);
         module.addComponent(component);
     }
 
     public addExportedComponent(exportedComponent: Metatype<Injectable>, metatype: NestModuleMetatype) {
         if (!this.modules.has(metatype.name)) {
-            throw new UnkownModuleException();
+            throw new UnknownModuleException();
         }
         const module = this.modules.get(metatype.name);
         module.addExportedComponent(exportedComponent);
     }
 
     public addController(controller: Metatype<Controller>, metatype: NestModuleMetatype) {
         if (!this.modules.has(metatype.name)) {
-            throw new UnkownModuleException();
+            throw new UnknownModuleException();
         }
         const module = this.modules.get(metatype.name);
         module.addRoute(controller);

src/core/router/router-exception-filters.ts

@@ -6,7 +6,7 @@ import { isEmpty, isFunction } from '../../common/utils/shared.utils';
 import { Metatype } from '../../common/interfaces/index';
 import { ExceptionFilterMetadata } from '../../common/interfaces/exception-filter-metadata.interface';
 import { NestContainer } from '../injector/container';
-import { UnkownModuleException } from '../../errors/exceptions/unkown-module.exception';
+import { UnknownModuleException } from '../../errors/exceptions/unknown-module.exception';
 import { ExceptionFilter } from '../../common/interfaces/exception-filter.interface';
 
 export class RouterExceptionFilters {
@@ -45,7 +45,7 @@ export class RouterExceptionFilters {
     public findExceptionsFilterInstance(metatype: Metatype<any>, moduleName: string): ExceptionFilter {
         const modules = this.container.getModules();
         if (!modules.has(moduleName)) {
-            throw new UnkownModuleException();
+            throw new UnknownModuleException();
         }
         const { components } = modules.get(moduleName);
         const { instance } =  components.get(metatype.name);

src/core/scanner.ts

@@ -19,7 +19,7 @@ export class DependenciesScanner {
         this.storeModule(module);
 
         const importedModules = this.reflectMetadata(module, metadata.MODULES);
-        importedModules.map((imported) => this.scanForModules(imported));
+        importedModules.map((innerModule) => this.scanForModules(innerModule));
     }
 
     private storeModule(module: NestModuleMetatype) {

src/core/test/injector/container.spec.ts

@@ -2,7 +2,7 @@ import { expect } from 'chai';
 import * as sinon from 'sinon';
 import { NestContainer } from '../../injector/container';
 import { Module } from '../../../common/utils/decorators/module.decorator';
-import { UnkownModuleException } from '../../../errors/exceptions/unkown-module.exception';
+import { UnknownModuleException } from '../../../errors/exceptions/unknown-module.exception';
 
 describe('NestContainer', () => {
     let container: NestContainer;
@@ -25,16 +25,16 @@ describe('NestContainer', () => {
         expect(setSpy.calledOnce).to.be.true;
     });
 
-    it('should "addComponent" throw "UnkownModuleException" when module is not stored in collection', () => {
-        expect(() => container.addComponent(null, TestModule)).throw(UnkownModuleException);
+    it('should "addComponent" throw "UnknownModuleException" when module is not stored in collection', () => {
+        expect(() => container.addComponent(null, TestModule)).throw(UnknownModuleException);
     });
 
-    it('should "addController" throw "UnkownModuleException" when module is not stored in collection', () => {
-        expect(() => container.addController(null, TestModule)).throw(UnkownModuleException);
+    it('should "addController" throw "UnknownModuleException" when module is not stored in collection', () => {
+        expect(() => container.addController(null, TestModule)).throw(UnknownModuleException);
     });
 
-    it('should "addExportedComponent" throw "UnkownModuleException" when module is not stored in collection', () => {
-        expect(() => container.addExportedComponent(null, TestModule)).throw(UnkownModuleException);
+    it('should "addExportedComponent" throw "UnknownModuleException" when module is not stored in collection', () => {
+        expect(() => container.addExportedComponent(null, TestModule)).throw(UnknownModuleException);
     });
 
 });

…rs/exceptions/unkown-module.exception.ts …s/exceptions/unknown-module.exception.tssrc/errors/exceptions/unkown-module.exception.ts renamed to src/errors/exceptions/unknown-module.exception.ts src/errors/exceptions/unkown-module.exception.ts renamed to src/errors/exceptions/unknown-module.exception.ts

@@ -1,6 +1,6 @@
 import { RuntimeException } from './runtime.exception';
 
-export class UnkownModuleException extends RuntimeException {
+export class UnknownModuleException extends RuntimeException {
     constructor() {
         super();
     }

src/nest-application.ts

@@ -27,6 +27,7 @@ export class NestApplication implements INestApplication {
     }
 
     public listen(port: number, callback?: () => void) {
+        console.log(this.container.getModules());
         this.setupMiddlewares(this.express);
         this.setupRoutes(this.express);
 

src/websockets/middlewares-injector.ts

@@ -2,7 +2,7 @@ import 'reflect-metadata';
 import { NestContainer, InstanceWrapper } from '../core/injector/container';
 import { NestGateway } from './index';
 import { GATEWAY_MIDDLEWARES } from './constants';
-import { UnkownModuleException } from '../errors/exceptions/unkown-module.exception';
+import { UnknownModuleException } from '../errors/exceptions/unknown-module.exception';
 import { Injectable } from '../common/interfaces/injectable.interface';
 import { RuntimeException } from '../errors/exceptions/runtime.exception';
 import { GatewayMiddleware } from './interfaces/gateway-middleware.interface';
@@ -15,7 +15,7 @@ export class MiddlewaresInjector {
         const opaqueTokens = this.reflectMiddlewaresTokens(instance);
         const modules = this.container.getModules();
         if (!modules.has(module)) {
-            throw new UnkownModuleException();
+            throw new UnknownModuleException();
         }
         const { components } = modules.get(module);
         this.applyMiddlewares(server, components, opaqueTokens);

src/websockets/test/middlewares-injector.spec.ts

@@ -1,7 +1,7 @@
 import * as sinon from 'sinon';
 import { expect } from 'chai';
 import { MiddlewaresInjector } from '../middlewares-injector';
-import { UnkownModuleException } from '../../errors/exceptions/unkown-module.exception';
+import { UnknownModuleException } from '../../errors/exceptions/unknown-module.exception';
 import { WebSocketGateway } from '../index';
 import { RuntimeException } from '../../errors/exceptions/runtime.exception';
 
@@ -23,11 +23,11 @@ describe('MiddlewaresInjector', () => {
         beforeEach(() => {
             sinon.stub(injector, 'reflectMiddlewaresTokens').returns(tokens);
         });
-        it('should throws "UnkownModuleException" when module is not known', () => {
+        it('should throws "UnknownModuleException" when module is not known', () => {
             sinon.stub(modules, 'has').returns(false);
             expect(
                 () => injector.inject(null, null, ''),
-            ).to.throws(UnkownModuleException);
+            ).to.throws(UnknownModuleException);
         });
         it('should call "applyMiddlewares" with expected arguments', () => {
             const components = {};