Merge branch 'master' of github.com:nestjs/nest into refactor_clean_as_any

Author: jbpionnier

CONTRIBUTING.md

@@ -8,6 +8,7 @@ today! As a contributor, here are the guidelines we would like you to follow:
  - [Issues and Bugs](#issue)
  - [Feature Requests](#feature)
  - [Submission Guidelines](#submit)
+ - [Development Setup](#development)
  - [Coding Rules](#rules)
  - [Commit Message Guidelines](#commit)
  <!-- - [Signing the CLA](#cla) -->
@@ -143,6 +144,41 @@ from the main (upstream) repository:
     ```shell
     git pull --ff upstream master
     ```
+    
+## <a name="development"></a> Development Setup
+
+You will need Node.js version 8.9.0+.
+
+1. After cloning the repo, run:
+```bash
+$ npm i # (or yarn install)
+```
+
+2. In order to prepare your environment run `prepare.sh` shell script:
+```bash
+$ sh scripts/prepare.sh
+```
+
+That will compile fresh packages and afterward, move them to all `sample` directories as well as integration tests.
+
+### Commonly used NPM scripts
+
+```bash
+# build all packages and move to "sample" and "integration" directories
+# if cross-packages breaking changes were performed you may face irrelevant errors
+# in order to verify the build, you can run this command again then
+$ npm run build
+
+# run the full unit tests suite
+$ npm run test
+
+# run integration tests
+# docker is required(!)
+$ sh scripts/run-integration.sh
+
+# run linter
+$ npm run lint
+```
 
 ## <a name="rules"></a> Coding Rules
 To ensure consistency throughout the source code, keep these rules in mind as you are working:
@@ -184,11 +220,7 @@ Samples: (even more [samples](https://github.com/nestjs/nest/commits/master))
 
 ```
 docs(changelog) update change log to beta.5
-```
-```
 bugfix(core) need to depend on latest rxjs and zone.js
-
-The version in our package.json gets copied to the one we publish, and users need the latest of these.
 ```
 
 ### Revert

bundle/common/cache/cache.module.js

@@ -45,7 +45,7 @@ let CacheModule = CacheModule_1 = class CacheModule {
         }
         return {
             provide: cache_constants_1.CACHE_MODULE_OPTIONS,
-            useFactory: async (optionsFactory) => await optionsFactory.createCacheOptions(),
+            useFactory: async (optionsFactory) => optionsFactory.createCacheOptions(),
             inject: [options.useExisting || options.useClass],
         };
     }

bundle/common/files/multer.module.js

@@ -46,7 +46,7 @@ let MulterModule = MulterModule_1 = class MulterModule {
         }
         return {
             provide: files_constants_1.MULTER_MODULE_OPTIONS,
-            useFactory: async (optionsFactory) => await optionsFactory.createMulterOptions(),
+            useFactory: async (optionsFactory) => optionsFactory.createMulterOptions(),
             inject: [options.useExisting || options.useClass],
         };
     }

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "nestjs",
-  "version": "5.3.8",
+  "version": "5.3.10",
   "description": "Modern, fast, powerful node.js web framework",
   "scripts": {
     "coverage": "nyc report --reporter=text-lcov | coveralls",
@@ -13,7 +13,7 @@
     "build:lib": "gulp build --dist bundle",
     "postinstall": "opencollective",
     "copy-docs": "gulp copy-docs",
-    "prepare": "npm run build:lib && npm run copy-docs",
+    "prepare:npm": "npm run build:lib && npm run copy-docs",
     "prepare:rc": "npm run build:lib && npm run copy-docs",
     "prepare:next": "npm run build:lib && npm run copy-docs",
     "prepare:beta": "npm run build:lib && npm run copy-docs",

package.json

@@ -52,8 +52,9 @@ export class Injector {
   ) {
     const { metatype } = wrapper;
     const currentMetatype = collection.get(metatype.name);
-    if (currentMetatype.instance !== null) return;
-
+    if (currentMetatype.instance !== null) {
+      return;
+    }
     await this.resolveConstructorParams(
       wrapper as any,
       module,
@@ -87,12 +88,13 @@ export class Injector {
     { metatype, name }: InstanceWrapper<T>,
     collection: Map<string, InstanceWrapper<T>>,
   ) {
-    if (!collection) return null;
-
+    if (!collection) {
+      return null;
+    }
     const target = collection.get(name);
-    if (target.isResolved || !isNil(target.inject) || !metatype.prototype)
+    if (target.isResolved || !isNil(target.inject) || !metatype.prototype) {
       return null;
-
+    }
     collection.set(name, {
       ...collection.get(name),
       instance: Object.create(metatype.prototype),
@@ -125,32 +127,21 @@ export class Injector {
       return wrapper.done$;
     }
     const done = this.applyDoneHook(wrapper);
-    const { metatype, name, inject } = wrapper;
-    const currentMetatype = collection.get(name);
-    if (isUndefined(currentMetatype)) {
+    const { name, inject } = wrapper;
+
+    const targetMetatype = collection.get(name);
+    if (isUndefined(targetMetatype)) {
       throw new RuntimeException();
     }
-    if (currentMetatype.isResolved) {
+    if (targetMetatype.isResolved) {
       return void 0;
     }
-
     await this.resolveConstructorParams<T>(
       wrapper,
       module,
       inject,
-      async instances => {
-        if (isNil(inject)) {
-          currentMetatype.instance = Object.assign(
-            currentMetatype.instance,
-            new metatype(...instances),
-          );
-        } else {
-          const factoryResult = currentMetatype.metatype(...instances);
-          currentMetatype.instance = await factoryResult;
-        }
-        currentMetatype.isResolved = true;
-        done();
-      },
+      async instances =>
+        this.instantiateClass(instances, wrapper, targetMetatype, done),
     );
   }
 
@@ -269,17 +260,11 @@ export class Injector {
   ) {
     const { name } = dependencyContext;
     const scanInExports = () =>
-      this.lookupComponentInExports(
-        components,
-        dependencyContext,
-        module,
-        wrapper,
-      );
+      this.lookupComponentInExports(dependencyContext, module, wrapper);
     return components.has(name) ? components.get(name) : scanInExports();
   }
 
   public async lookupComponentInExports<T = any>(
-    components: Map<string, any>,
     dependencyContext: InjectorDependencyContext,
     module: Module,
     wrapper: InstanceWrapper<T>,
@@ -328,4 +313,26 @@ export class Injector {
     }
     return componentRef;
   }
+
+  public async instantiateClass(
+    instances: any[],
+    wrapper: InstanceWrapper<any>,
+    targetMetatype: InstanceWrapper<any>,
+    done: Function,
+  ) {
+    const { metatype, inject } = wrapper;
+    if (isNil(inject)) {
+      targetMetatype.instance = Object.assign(
+        targetMetatype.instance,
+        new metatype(...instances),
+      );
+    } else {
+      const factoryResult = ((targetMetatype.metatype as any) as Function)(
+        ...instances,
+      );
+      targetMetatype.instance = await factoryResult;
+    }
+    targetMetatype.isResolved = true;
+    done();
+  }
 }

packages/core/injector/injector.ts

@@ -0,0 +1,8 @@
+# 1. Install all dependencies
+for D in integration/*; do [ -d "${D}" ] && npm i; done
+
+# 2. Build fresh packages and move them to sample and integration directories
+npm run build &>/dev/null
+
+# 3. Start docker containers to perform integration tests
+cd integration && docker-compose up -d

scripts/prepare.sh

@@ -0,0 +1,8 @@
+# 1. Build fresh packages and move them integration dit
+npm run build &>/dev/null
+
+# 2. Start docker containers to perform integration tests
+cd integration && docker-compose up -d
+
+# 3. Run integration tests
+npm run integration-test

scripts/run-integration.sh

@@ -0,0 +1,3 @@
+# Run both unit and integration tests
+npm run test
+npm run integration-test