feat(builders): introduce node build and execute builders

These builders handle building and executing node applications

Author: FrozenPandaz

Diff for: .gitignore

@@ -2,7 +2,7 @@ node_modules
 .idea
 .vscode
 dist
-build
+/build
 test
 .DS_Store
 tmp

Diff for: .prettierignore

@@ -1,5 +1,5 @@
 tmp
-build
+/build
 node_modules
 /package.json
-packages/schematics/src/collection/**/files/*.json
+packages/schematics/src/collection/**/files/*.json

Diff for: package.json

@@ -19,7 +19,9 @@
     "checkformat": "prettier \"./**/*.{ts,js,json,css,md}\" \"!./**/{__name__,__directory__}/**\" --list-different"
   },
   "devDependencies": {
+    "@angular-devkit/architect": "0.8.3",
     "@angular-devkit/build-angular": "0.8.3",
+    "@angular-devkit/build-webpack": "0.8.3",
     "@angular-devkit/core": "0.8.3",
     "@angular-devkit/schematics": "0.8.3",
     "@angular/cli": "6.2.3",
@@ -39,15 +41,19 @@
     "@schematics/angular": "0.8.3",
     "@types/jasmine": "~2.8.6",
     "@types/jasminewd2": "~2.0.3",
+    "@types/jest": "^23.3.2",
     "@types/node": "~8.9.4",
     "@types/prettier": "^1.10.0",
+    "@types/webpack": "^4.4.11",
     "@types/yargs": "^11.0.0",
     "angular": "1.6.6",
     "app-root-path": "^2.0.1",
+    "circular-dependency-plugin": "^5.0.2",
     "commitizen": "^2.10.1",
     "conventional-changelog-cli": "^1.3.21",
     "cosmiconfig": "^4.0.0",
     "cz-conventional-changelog": "^2.1.0",
+    "fork-ts-checker-webpack-plugin": "^0.4.9",
     "fs-extra": "5.0.0",
     "graphviz": "^0.0.8",
     "husky": "^1.0.0-rc.13",
@@ -60,6 +66,7 @@
     "karma-chrome-launcher": "~2.2.0",
     "karma-jasmine": "~1.1.1",
     "karma-webpack": "2.0.4",
+    "license-webpack-plugin": "^1.4.0",
     "lint-staged": "^7.2.2",
     "ng-packagr": "3.0.6",
     "npm-run-all": "4.1.2",
@@ -74,6 +81,8 @@
     "tslint": "5.11.0",
     "typescript": "~2.9.2",
     "viz.js": "^1.8.1",
+    "webpack": "4.9.2",
+    "webpack-node-externals": "^1.7.2",
     "yargs": "^11.0.0",
     "yargs-parser": "10.0.0",
     "zone.js": "^0.8.26"

Diff for: packages/builders/package.json

@@ -25,6 +25,12 @@
   "builders": "./src/builders.json",
   "dependencies": {
     "@angular-devkit/architect": "~0.8.0",
-    "rxjs": "6.2.2"
+    "@angular-devkit/build-webpack": "~0.8.0",
+    "fork-ts-checker-webpack-plugin": "0.4.9",
+    "license-webpack-plugin": "^1.4.0",
+    "rxjs": "6.2.2",
+    "ts-loader": "4.5.0",
+    "webpack": "4.9.2",
+    "webpack-node-externals": "1.7.2"
   }
 }

Diff for: packages/builders/src/builders.json

@@ -1,6 +1,16 @@
 {
-  "$schema": "../architect/src/builders-schema.json",
+  "$schema": "@angular-devkit/architect/src/builders-schema.json",
   "builders": {
+    "node-build": {
+      "class": "./node/build/node-build.builder",
+      "schema": "./node/build/schema.json",
+      "description": "Build a Node application"
+    },
+    "node-execute": {
+      "class": "./node/execute/node-execute.builder",
+      "schema": "./node/execute/schema.json",
+      "description": "Build a Node application"
+    },
     "jest": {
       "class": "./jest/jest.builder",
       "schema": "./jest/schema.json",

Diff for: packages/builders/src/jest/jest.builder.spec.ts

@@ -1,23 +1,24 @@
 import JestBuilder from './jest.builder';
 import { normalize } from '@angular-devkit/core';
-import * as jestCLI from 'jest';
+jest.mock('jest');
+const { runCLI } = require('jest');
 import * as path from 'path';
 
 describe('Jest Builder', () => {
   let builder: JestBuilder;
 
   beforeEach(() => {
     builder = new JestBuilder();
-  });
-
-  it('should send appropriate options to jestCLI', () => {
-    const runCLI = spyOn(jestCLI, 'runCLI').and.returnValue(
+    runCLI.mockReturnValue(
       Promise.resolve({
         results: {
           success: true
         }
       })
     );
+  });
+
+  it('should send appropriate options to jestCLI', () => {
     const root = normalize('/root');
     builder
       .run({
@@ -46,13 +47,6 @@ describe('Jest Builder', () => {
   });
 
   it('should send other options to jestCLI', () => {
-    const runCLI = spyOn(jestCLI, 'runCLI').and.returnValue(
-      Promise.resolve({
-        results: {
-          success: true
-        }
-      })
-    );
     const root = normalize('/root');
     builder
       .run({
@@ -98,19 +92,12 @@ describe('Jest Builder', () => {
     );
   });
 
-  it('should send the main to jestCLI', () => {
-    const runCLI = spyOn(jestCLI, 'runCLI').and.returnValue(
-      Promise.resolve({
-        results: {
-          success: true
-        }
-      })
-    );
+  it('should send the main to runCLI', () => {
     const root = normalize('/root');
     builder
       .run({
         root,
-        builder: '',
+        builder: '@nrwl/builders:jest',
         projectType: 'application',
         options: {
           jestConfig: './jest.config.js',
@@ -139,13 +126,6 @@ describe('Jest Builder', () => {
   });
 
   it('should return the proper result', async done => {
-    spyOn(jestCLI, 'runCLI').and.returnValue(
-      Promise.resolve({
-        results: {
-          success: true
-        }
-      })
-    );
     const root = normalize('/root');
     const result = await builder
       .run({

Diff for: packages/builders/src/jest/jest.builder.ts

@@ -9,7 +9,7 @@ import { map } from 'rxjs/operators';
 
 import * as path from 'path';
 
-import { runCLI as runJest } from 'jest';
+const { runCLI } = require('jest');
 
 export interface JestBuilderOptions {
   jestConfig: string;
@@ -61,7 +61,7 @@ export default class JestBuilder implements Builder<JestBuilderOptions> {
       );
     }
 
-    return from(runJest(config, [options.jestConfig])).pipe(
+    return from(runCLI(config, [options.jestConfig])).pipe(
       map((results: any) => {
         return {
           success: results.results.success

Diff for: packages/builders/src/node/build/node-build.builder.spec.ts

@@ -0,0 +1,162 @@
+import { normalize } from '@angular-devkit/core';
+import { TestLogger } from '@angular-devkit/architect/testing';
+import BuildNodeBuilder from './node-build.builder';
+import { BuildNodeBuilderOptions } from './node-build.builder';
+import { of } from 'rxjs';
+import * as fs from 'fs';
+
+describe('NodeBuildBuilder', () => {
+  let builder: BuildNodeBuilder;
+  let testOptions: BuildNodeBuilderOptions;
+
+  beforeEach(() => {
+    builder = new BuildNodeBuilder({
+      host: <any>{},
+      logger: new TestLogger('test'),
+      workspace: <any>{
+        root: '/root'
+      },
+      architect: <any>{}
+    });
+    testOptions = {
+      main: 'apps/nodeapp/src/main.ts',
+      tsConfig: 'apps/nodeapp/tsconfig.app.json',
+      outputPath: 'dist/apps/nodeapp',
+      externalDependencies: 'all',
+      fileReplacements: [
+        {
+          replace: 'apps/environment/environment.ts',
+          with: 'apps/environment/environment.prod.ts'
+        },
+        {
+          replace: 'module1.ts',
+          with: 'module2.ts'
+        }
+      ]
+    };
+  });
+
+  describe('run', () => {
+    it('should call runWebpack', () => {
+      const runWebpack = spyOn(
+        builder.webpackBuilder,
+        'runWebpack'
+      ).and.returnValue(
+        of({
+          success: true
+        })
+      );
+
+      builder.run({
+        root: normalize('/root'),
+        projectType: 'application',
+        builder: '@nrwl/builders:node-build',
+        options: testOptions
+      });
+
+      expect(runWebpack).toHaveBeenCalled();
+    });
+
+    it('should emit the outfile along with success', async () => {
+      const runWebpack = spyOn(
+        builder.webpackBuilder,
+        'runWebpack'
+      ).and.returnValue(
+        of({
+          success: true
+        })
+      );
+
+      const buildEvent = await builder
+        .run({
+          root: normalize('/root'),
+          projectType: 'application',
+          builder: '@nrwl/builders:node-build',
+          options: testOptions
+        })
+        .toPromise();
+
+      expect(buildEvent.success).toEqual(true);
+      expect(buildEvent.outfile).toEqual('/root/dist/apps/nodeapp/main.js');
+    });
+
+    describe('when stats json option is passed', () => {
+      beforeEach(() => {
+        const stats = {
+          stats: 'stats'
+        };
+        spyOn(builder.webpackBuilder, 'runWebpack').and.callFake((opts, cb) => {
+          cb({
+            toJson: () => stats,
+            toString: () => JSON.stringify(stats)
+          });
+          return of({
+            success: true
+          });
+        });
+        spyOn(fs, 'writeFileSync');
+      });
+
+      it('should generate a stats json', async () => {
+        await builder
+          .run({
+            root: normalize('/root'),
+            projectType: 'application',
+            builder: '@nrwl/builders:node-build',
+            options: {
+              ...testOptions,
+              statsJson: true
+            }
+          })
+          .toPromise();
+
+        expect(fs.writeFileSync).toHaveBeenCalledWith(
+          '/root/dist/apps/nodeapp/stats.json',
+          JSON.stringify(
+            {
+              stats: 'stats'
+            },
+            null,
+            2
+          )
+        );
+      });
+    });
+  });
+
+  describe('options normalization', () => {
+    it('should add the root', () => {
+      const result = (<any>builder).normalizeOptions(testOptions);
+      expect(result.root).toEqual('/root');
+    });
+
+    it('should resolve main from root', () => {
+      const result = (<any>builder).normalizeOptions(testOptions);
+      expect(result.main).toEqual('/root/apps/nodeapp/src/main.ts');
+    });
+
+    it('should resolve the output path', () => {
+      const result = (<any>builder).normalizeOptions(testOptions);
+      expect(result.outputPath).toEqual('/root/dist/apps/nodeapp');
+    });
+
+    it('should resolve the tsConfig path', () => {
+      const result = (<any>builder).normalizeOptions(testOptions);
+      expect(result.tsConfig).toEqual('/root/apps/nodeapp/tsconfig.app.json');
+    });
+
+    it('should resolve the file replacement paths', () => {
+      const result = (<any>builder).normalizeOptions(testOptions);
+      expect(result.fileReplacements).toEqual([
+        {
+          replace: '/root/apps/environment/environment.ts',
+          with: '/root/apps/environment/environment.prod.ts'
+        },
+        {
+          replace: '/root/module1.ts',
+          with: '/root/module2.ts'
+        }
+      ]);
+    });
+  });
+});

Diff for: packages/builders/src/node/build/node-build.builder.ts

@@ -0,0 +1,100 @@
+import {
+  Builder,
+  BuildEvent,
+  BuilderConfiguration,
+  BuilderContext
+} from '@angular-devkit/architect';
+import { virtualFs, Path } from '@angular-devkit/core';
+import { WebpackBuilder } from '@angular-devkit/build-webpack';
+
+import { Observable } from 'rxjs';
+import { Stats, writeFileSync } from 'fs';
+import { getWebpackConfig, OUT_FILENAME } from './webpack/config';
+import { resolve } from 'path';
+import { map } from 'rxjs/operators';
+
+export interface BuildNodeBuilderOptions {
+  main: string;
+  outputPath: string;
+  tsConfig: string;
+  watch?: boolean;
+  optimization?: boolean;
+  externalDependencies: 'all' | 'none' | string[];
+  showCircularDependencies?: boolean;
+  maxWorkers?: number;
+
+  fileReplacements: FileReplacement[];
+
+  progress?: boolean;
+  statsJson?: boolean;
+  extractLicenses?: boolean;
+
+  root?: Path;
+}
+
+export interface FileReplacement {
+  replace: string;
+  with: string;
+}
+
+export interface NodeBuildEvent extends BuildEvent {
+  outfile: string;
+}
+
+export default class BuildNodeBuilder
+  implements Builder<BuildNodeBuilderOptions> {
+  webpackBuilder: WebpackBuilder;
+
+  private get root() {
+    return this.context.workspace.root;
+  }
+
+  constructor(private context: BuilderContext) {
+    this.webpackBuilder = new WebpackBuilder(this.context);
+  }
+
+  run(
+    builderConfig: BuilderConfiguration<BuildNodeBuilderOptions>
+  ): Observable<NodeBuildEvent> {
+    const options = this.normalizeOptions(builderConfig.options);
+
+    let config = getWebpackConfig(options);
+    return this.webpackBuilder
+      .runWebpack(config, stats => {
+        if (options.statsJson) {
+          writeFileSync(
+            resolve(this.root, options.outputPath, 'stats.json'),
+            JSON.stringify(stats.toJson(), null, 2)
+          );
+        }
+
+        this.context.logger.info(stats.toString());
+      })
+      .pipe(
+        map(buildEvent => ({
+          ...buildEvent,
+          outfile: resolve(this.root, options.outputPath, OUT_FILENAME)
+        }))
+      );
+  }
+
+  private normalizeOptions(options: BuildNodeBuilderOptions) {
+    return {
+      ...options,
+      root: this.root,
+      main: resolve(this.root, options.main),
+      outputPath: resolve(this.root, options.outputPath),
+      tsConfig: resolve(this.root, options.tsConfig),
+      fileReplacements: this.normalizeFileReplacements(options.fileReplacements)
+    };
+  }
+
+  private normalizeFileReplacements(
+    fileReplacements: FileReplacement[]
+  ): FileReplacement[] {
+    return fileReplacements.map(fileReplacement => ({
+      replace: resolve(this.root, fileReplacement.replace),
+      with: resolve(this.root, fileReplacement.with)
+    }));
+  }
+}

Diff for: packages/builders/src/node/build/schema.json

@@ -0,0 +1,88 @@
+{
+  "title": "Node Application Build Target",
+  "description": "Node application build target options for Build Facade",
+  "type": "object",
+  "properties": {
+    "main": {
+      "type": "string",
+      "description": "The name of the main entry-point file."
+    },
+    "tsConfig": {
+      "type": "string",
+      "description": "The name of the Typescript configuration file."
+    },
+    "watch": {
+      "type": "boolean",
+      "description": "Run build when files change.",
+      "default": false
+    },
+    "progress": {
+      "type": "boolean",
+      "description": "Log progress to the console while building.",
+      "default": false
+    },
+    "externalDependencies": {
+      "oneOf": [
+        {
+          "type": "string",
+          "enum": ["none", "all"]
+        },
+        {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        }
+      ],
+      "description":
+        "Dependencies to keep external to the bundle. (\"all\" (default), \"none\", or an array of module names)",
+      "default": "all"
+    },
+    "statsJson": {
+      "type": "boolean",
+      "description":
+        "Generates a 'stats.json' file which can be analyzed using tools such as: #webpack-bundle-analyzer' or https: //webpack.github.io/analyse.",
+      "default": false
+    },
+    "extractLicenses": {
+      "type": "boolean",
+      "description":
+        "Extract all licenses in a separate file, in the case of production builds only.",
+      "default": false
+    },
+    "optimization": {
+      "type": "boolean",
+      "description": "Defines the optimization level of the build.",
+      "default": false
+    },
+    "showCircularDependencies": {
+      "type": "boolean",
+      "description": "Show circular dependency warnings on builds.",
+      "default": true
+    },
+    "maxWorkers": {
+      "type": "number",
+      "description":
+        "Number of workers to use for type checking. (defaults to # of CPUS - 2)"
+    },
+    "fileReplacements": {
+      "description": "Replace files with other files in the build.",
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "replace": {
+            "type": "string"
+          },
+          "with": {
+            "type": "string"
+          }
+        },
+        "additionalProperties": false,
+        "required": ["replace", "with"]
+      },
+      "default": []
+    }
+  },
+  "required": ["tsConfig", "main"]
+}

Diff for: packages/builders/src/node/build/webpack/config.spec.ts

@@ -0,0 +1,310 @@
+import { getWebpackConfig } from './config';
+import { BuildNodeBuilderOptions } from '../node-build.builder';
+import { normalize } from '@angular-devkit/core';
+
+import * as ts from 'typescript';
+import { LicenseWebpackPlugin } from 'license-webpack-plugin';
+import CircularDependencyPlugin = require('circular-dependency-plugin');
+import ForkTsCheckerWebpackPlugin = require('fork-ts-checker-webpack-plugin');
+import { ProgressPlugin } from 'webpack';
+
+describe('getWebpackConfig', () => {
+  let input: BuildNodeBuilderOptions;
+  beforeEach(() => {
+    input = {
+      main: 'main.ts',
+      outputPath: 'dist',
+      tsConfig: 'tsconfig.json',
+      externalDependencies: 'all',
+      fileReplacements: [],
+      root: normalize('/root')
+    };
+  });
+
+  describe('unconditional options', () => {
+    it('should have output options', () => {
+      const result = getWebpackConfig(input);
+
+      expect(result.output.filename).toEqual('main.js');
+      expect(result.output.libraryTarget).toEqual('commonjs');
+    });
+
+    it('should have a rule for typescript', () => {
+      const result = getWebpackConfig(input);
+
+      const typescriptRule = result.module.rules.find(rule =>
+        (rule.test as RegExp).test('app/main.ts')
+      );
+      expect(typescriptRule).toBeTruthy();
+
+      expect(typescriptRule.loader).toEqual('ts-loader');
+    });
+
+    it('should split typescript type checking into a separate workers', () => {
+      const result = getWebpackConfig(input);
+
+      const typeCheckerPlugin = result.plugins.find(
+        plugin => plugin instanceof ForkTsCheckerWebpackPlugin
+      ) as ForkTsCheckerWebpackPlugin;
+      expect(typeCheckerPlugin).toBeTruthy();
+    });
+
+    it('should target node', () => {
+      const result = getWebpackConfig(input);
+
+      expect(result.target).toEqual('node');
+    });
+
+    it('should disable performance hints', () => {
+      const result = getWebpackConfig(input);
+
+      expect(result.performance).toEqual({
+        hints: false
+      });
+    });
+
+    it('should resolve typescript and javascript', () => {
+      const result = getWebpackConfig(input);
+
+      expect(result.resolve.extensions).toEqual(['.ts', '.js']);
+    });
+
+    it('should not polyfill node apis', () => {
+      const result = getWebpackConfig(input);
+
+      expect(result.node).toEqual(false);
+    });
+  });
+
+  describe('the main option', () => {
+    it('should set the correct entry options', () => {
+      const result = getWebpackConfig(input);
+
+      expect(result.entry).toEqual(['main.ts']);
+    });
+  });
+
+  describe('the output option', () => {
+    it('should set the correct output options', () => {
+      const result = getWebpackConfig(input);
+
+      expect(result.output.path).toEqual('dist');
+    });
+  });
+
+  describe('the tsConfig option', () => {
+    it('should set the correct typescript rule', () => {
+      const result = getWebpackConfig(input);
+
+      expect(
+        result.module.rules.find(rule => rule.loader === 'ts-loader').options
+      ).toEqual({
+        configFile: 'tsconfig.json',
+        transpileOnly: true,
+        experimentalWatchApi: true
+      });
+    });
+
+    it('should set the correct options for the type checker plugin', () => {
+      const result = getWebpackConfig(input);
+
+      const typeCheckerPlugin = result.plugins.find(
+        plugin => plugin instanceof ForkTsCheckerWebpackPlugin
+      ) as ForkTsCheckerWebpackPlugin;
+      expect(typeCheckerPlugin.options.tsconfig).toBe('tsconfig.json');
+    });
+
+    it('should set aliases for compilerOptionPaths', () => {
+      spyOn(ts, 'parseJsonConfigFileContent').and.returnValue({
+        options: {
+          paths: {
+            '@npmScope/libraryName': ['libs/libraryName/src/index.ts']
+          }
+        }
+      });
+
+      const result = getWebpackConfig(input);
+      expect(result.resolve.alias).toEqual({
+        '@npmScope/libraryName': '/root/libs/libraryName/src/index.ts'
+      });
+    });
+  });
+
+  describe('the file replacements option', () => {
+    it('should set aliases', () => {
+      spyOn(ts, 'parseJsonConfigFileContent').and.returnValue({
+        options: {}
+      });
+
+      const result = getWebpackConfig({
+        ...input,
+        fileReplacements: [
+          {
+            replace: 'environments/environment.ts',
+            with: 'environments/environment.prod.ts'
+          }
+        ]
+      });
+
+      expect(result.resolve.alias).toEqual({
+        'environments/environment.ts': 'environments/environment.prod.ts'
+      });
+    });
+  });
+
+  describe('the externalDependencies option', () => {
+    it('should change all node_modules to commonjs imports', () => {
+      const result = getWebpackConfig(input);
+      const callback = jest.fn();
+      result.externals[0](null, '@angular/core', callback);
+      expect(callback).toHaveBeenCalledWith(null, 'commonjs @angular/core');
+    });
+
+    it('should change given module names to commonjs imports but not others', () => {
+      const result = getWebpackConfig({
+        ...input,
+        externalDependencies: ['module1']
+      });
+      const callback = jest.fn();
+      result.externals[0](null, 'module1', callback);
+      expect(callback).toHaveBeenCalledWith(null, 'commonjs module1');
+      result.externals[0](null, '@angular/core', callback);
+      expect(callback).toHaveBeenCalledWith();
+    });
+
+    it('should not change any modules to commonjs imports', () => {
+      const result = getWebpackConfig({
+        ...input,
+        externalDependencies: 'none'
+      });
+
+      expect(result.externals).not.toBeDefined();
+    });
+  });
+
+  describe('the watch option', () => {
+    it('should enable file watching', () => {
+      const result = getWebpackConfig({
+        ...input,
+        watch: true
+      });
+
+      expect(result.watch).toEqual(true);
+    });
+  });
+
+  describe('the optimization option', () => {
+    describe('by default', () => {
+      it('should set the mode to development', () => {
+        const result = getWebpackConfig(input);
+
+        expect(result.mode).toEqual('development');
+      });
+    });
+
+    describe('when true', () => {
+      it('should set the mode to production', () => {
+        const result = getWebpackConfig({
+          ...input,
+          optimization: true
+        });
+
+        expect(result.mode).toEqual('production');
+      });
+
+      it('should not minify', () => {
+        const result = getWebpackConfig({
+          ...input,
+          optimization: true
+        });
+
+        expect(result.optimization.minimize).toEqual(false);
+      });
+
+      it('should not concatenate modules', () => {
+        const result = getWebpackConfig({
+          ...input,
+          optimization: true
+        });
+
+        expect(result.optimization.concatenateModules).toEqual(false);
+      });
+    });
+  });
+
+  describe('the max workers option', () => {
+    it('should set the maximum workers for the type checker', () => {
+      const result = getWebpackConfig({
+        ...input,
+        maxWorkers: 1
+      });
+
+      const typeCheckerPlugin = result.plugins.find(
+        plugin => plugin instanceof ForkTsCheckerWebpackPlugin
+      ) as ForkTsCheckerWebpackPlugin;
+      expect(typeCheckerPlugin.options.workers).toEqual(1);
+    });
+  });
+
+  describe('the circular dependencies option', () => {
+    it('should show warnings for circular dependencies', () => {
+      const result = getWebpackConfig({
+        ...input,
+        showCircularDependencies: true
+      });
+
+      expect(
+        result.plugins.find(
+          plugin => plugin instanceof CircularDependencyPlugin
+        )
+      ).toBeTruthy();
+    });
+
+    it('should exclude node modules', () => {
+      const result = getWebpackConfig({
+        ...input,
+        showCircularDependencies: true
+      });
+
+      const circularDependencyPlugin: CircularDependencyPlugin = result.plugins.find(
+        plugin => plugin instanceof CircularDependencyPlugin
+      );
+      expect(circularDependencyPlugin.options.exclude).toEqual(
+        /[\\\/]node_modules[\\\/]/
+      );
+    });
+  });
+
+  describe('the extract licenses option', () => {
+    it('should extract licenses to a separate file', () => {
+      const result = getWebpackConfig({
+        ...input,
+        extractLicenses: true
+      });
+
+      const licensePlugin = result.plugins.find(
+        plugin => plugin instanceof LicenseWebpackPlugin
+      ) as LicenseWebpackPlugin;
+      const options = (<any>licensePlugin).options;
+
+      expect(licensePlugin).toBeTruthy();
+      expect(options.pattern).toEqual(/.*/);
+      expect(options.suppressErrors).toEqual(true);
+      expect(options.perChunkOutput).toEqual(false);
+      expect(options.outputFilename).toEqual('3rdpartylicenses.txt');
+    });
+  });
+
+  describe('the progress option', () => {
+    it('should show build progress', () => {
+      const result = getWebpackConfig({
+        ...input,
+        progress: true
+      });
+
+      expect(
+        result.plugins.find(plugin => plugin instanceof ProgressPlugin)
+      ).toBeTruthy();
+    });
+  });
+});

Diff for: packages/builders/src/node/build/webpack/config.ts

@@ -0,0 +1,137 @@
+import * as webpack from 'webpack';
+import { Configuration, ProgressPlugin } from 'webpack';
+
+import * as ts from 'typescript';
+import { dirname, resolve } from 'path';
+
+import { LicenseWebpackPlugin } from 'license-webpack-plugin';
+import CircularDependencyPlugin = require('circular-dependency-plugin');
+import ForkTsCheckerWebpackPlugin = require('fork-ts-checker-webpack-plugin');
+
+import { BuildNodeBuilderOptions } from '../node-build.builder';
+import * as nodeExternals from 'webpack-node-externals';
+
+export const OUT_FILENAME = 'main.js';
+
+export function getWebpackConfig(
+  options: BuildNodeBuilderOptions
+): Configuration {
+  const webpackConfig: Configuration = {
+    entry: [options.main],
+    mode: options.optimization ? 'production' : 'development',
+    output: {
+      path: options.outputPath,
+      filename: OUT_FILENAME,
+      libraryTarget: 'commonjs'
+    },
+    module: {
+      rules: [
+        {
+          test: /\.ts$/,
+          loader: `ts-loader`,
+          options: {
+            configFile: options.tsConfig,
+            transpileOnly: true,
+            // https://github.com/TypeStrong/ts-loader/pull/685
+            experimentalWatchApi: true
+          }
+        }
+      ]
+    },
+    resolve: {
+      extensions: ['.ts', '.js'],
+      alias: getAliases(options)
+    },
+    target: 'node',
+    node: false,
+    performance: {
+      hints: false
+    },
+    plugins: [
+      new ForkTsCheckerWebpackPlugin({
+        tsconfig: options.tsConfig,
+        workers: options.maxWorkers || ForkTsCheckerWebpackPlugin.TWO_CPUS_FREE
+      })
+    ],
+    watch: options.watch
+  };
+
+  const extraPlugins: webpack.Plugin[] = [];
+
+  if (options.progress) {
+    extraPlugins.push(new ProgressPlugin());
+  }
+
+  if (options.optimization) {
+    webpackConfig.optimization = {
+      minimize: false,
+      concatenateModules: false
+    };
+  }
+
+  if (options.extractLicenses) {
+    extraPlugins.push(
+      new LicenseWebpackPlugin({
+        pattern: /.*/,
+        suppressErrors: true,
+        perChunkOutput: false,
+        outputFilename: `3rdpartylicenses.txt`
+      })
+    );
+  }
+
+  if (options.externalDependencies === 'all') {
+    webpackConfig.externals = [nodeExternals()];
+  } else if (Array.isArray(options.externalDependencies)) {
+    webpackConfig.externals = [
+      function(context, request, callback: Function) {
+        if (options.externalDependencies.includes(request)) {
+          // not bundled
+          return callback(null, 'commonjs ' + request);
+        }
+        // bundled
+        callback();
+      }
+    ];
+  }
+
+  if (options.showCircularDependencies) {
+    extraPlugins.push(
+      new CircularDependencyPlugin({
+        exclude: /[\\\/]node_modules[\\\/]/
+      })
+    );
+  }
+
+  webpackConfig.plugins = [...webpackConfig.plugins, ...extraPlugins];
+
+  return webpackConfig;
+}
+
+function getAliases(
+  options: BuildNodeBuilderOptions
+): { [key: string]: string } {
+  const readResult = ts.readConfigFile(options.tsConfig, ts.sys.readFile);
+  const tsConfig = ts.parseJsonConfigFileContent(
+    readResult.config,
+    ts.sys,
+    dirname(options.tsConfig)
+  );
+  const compilerOptions = tsConfig.options;
+  const replacements = [
+    ...options.fileReplacements,
+    ...(compilerOptions.paths
+      ? Object.entries(compilerOptions.paths).map(([importPath, values]) => ({
+          replace: importPath,
+          with: resolve(options.root, values[0])
+        }))
+      : [])
+  ];
+  return replacements.reduce(
+    (aliases, replacement) => ({
+      ...aliases,
+      [replacement.replace]: replacement.with
+    }),
+    {}
+  );
+}

Diff for: packages/builders/src/node/execute/node-execute.builder.spec.ts

@@ -0,0 +1,175 @@
+import {
+  NodeExecuteBuilder,
+  NodeExecuteBuilderOptions
+} from './node-execute.builder';
+import { TestLogger } from '@angular-devkit/architect/testing';
+import { normalize } from '@angular-devkit/core';
+import { of } from 'rxjs';
+import { cold } from 'jasmine-marbles';
+jest.mock('child_process');
+let { fork } = require('child_process');
+jest.mock('tree-kill');
+let treeKill = require('tree-kill');
+
+class MockArchitect {
+  getBuilderConfiguration() {
+    return {
+      config: 'testConfig'
+    };
+  }
+  run() {
+    return cold('--a--b--a', {
+      a: {
+        success: true,
+        outfile: 'outfile.js'
+      },
+      b: {
+        success: false,
+        outfile: 'outfile.js'
+      }
+    });
+  }
+  getBuilderDescription() {
+    return of({
+      description: 'testDescription'
+    });
+  }
+  validateBuilderOptions() {
+    return of({
+      options: {}
+    });
+  }
+}
+
+describe('NodeExecuteBuilder', () => {
+  let builder: NodeExecuteBuilder;
+  let architect: MockArchitect;
+  let logger: TestLogger;
+  let testOptions: NodeExecuteBuilderOptions;
+
+  beforeEach(() => {
+    fork.mockReturnValue({
+      pid: 123
+    });
+    treeKill.mockImplementation((pid, signal, callback) => {
+      callback();
+    });
+    logger = new TestLogger('test');
+    architect = new MockArchitect();
+    builder = new NodeExecuteBuilder({
+      workspace: <any>{
+        root: '/root'
+      },
+      logger,
+      host: <any>{},
+      architect: <any>architect
+    });
+    testOptions = {
+      inspect: true,
+      args: [],
+      buildTarget: 'nodeapp:build'
+    };
+  });
+
+  it('should build the application and start the built file', () => {
+    const getBuilderConfiguration = spyOn(
+      architect,
+      'getBuilderConfiguration'
+    ).and.callThrough();
+    expect(
+      builder.run({
+        root: normalize('/root'),
+        projectType: 'application',
+        builder: '@nrwl/builders:node-execute',
+        options: testOptions
+      })
+    ).toBeObservable(
+      cold('--a--b--a', {
+        a: {
+          success: true,
+          outfile: 'outfile.js'
+        },
+        b: {
+          success: false,
+          outfile: 'outfile.js'
+        }
+      })
+    );
+    expect(getBuilderConfiguration).toHaveBeenCalledWith({
+      project: 'nodeapp',
+      target: 'build',
+      overrides: {
+        watch: true
+      }
+    });
+    expect(fork).toHaveBeenCalledWith('outfile.js', [], {
+      execArgv: ['--inspect']
+    });
+    expect(treeKill).toHaveBeenCalledTimes(1);
+    expect(fork).toHaveBeenCalledTimes(2);
+  });
+
+  it('should build the application and start the built file with options', () => {
+    expect(
+      builder.run({
+        root: normalize('/root'),
+        projectType: 'application',
+        builder: '@nrwl/builders:node-execute',
+        options: {
+          ...testOptions,
+          inspect: false,
+          args: ['arg1', 'arg2']
+        }
+      })
+    ).toBeObservable(
+      cold('--a--b--a', {
+        a: {
+          success: true,
+          outfile: 'outfile.js'
+        },
+        b: {
+          success: false,
+          outfile: 'outfile.js'
+        }
+      })
+    );
+    expect(fork).toHaveBeenCalledWith('outfile.js', ['arg1', 'arg2'], {
+      execArgv: []
+    });
+  });
+
+  it('should warn users who try to use it in production', () => {
+    spyOn(architect, 'validateBuilderOptions').and.returnValue(
+      of({
+        options: {
+          optimization: true
+        }
+      })
+    );
+    spyOn(logger, 'warn');
+    expect(
+      builder.run({
+        root: normalize('/root'),
+        projectType: 'application',
+        builder: '@nrwl/builders:node-execute',
+        options: {
+          ...testOptions,
+          inspect: false,
+          args: ['arg1', 'arg2']
+        }
+      })
+    ).toBeObservable(
+      cold('--a--b--a', {
+        a: {
+          success: true,
+          outfile: 'outfile.js'
+        },
+        b: {
+          success: false,
+          outfile: 'outfile.js'
+        }
+      })
+    );
+    expect(logger.warn).toHaveBeenCalled();
+  });
+});

Diff for: packages/builders/src/node/execute/node-execute.builder.ts

@@ -0,0 +1,133 @@
+import {
+  BuildEvent,
+  Builder,
+  BuilderConfiguration,
+  BuilderContext
+} from '@angular-devkit/architect';
+import { ChildProcess, fork } from 'child_process';
+import * as treeKill from 'tree-kill';
+
+import { Observable, bindCallback, of } from 'rxjs';
+import { concatMap, tap, mapTo } from 'rxjs/operators';
+
+import {
+  BuildNodeBuilderOptions,
+  NodeBuildEvent
+} from '../build/node-build.builder';
+import { stripIndents } from '@angular-devkit/core/src/utils/literals';
+
+export interface NodeExecuteBuilderOptions {
+  inspect: boolean;
+  args: string[];
+  buildTarget: string;
+}
+
+export class NodeExecuteBuilder implements Builder<NodeExecuteBuilderOptions> {
+  private subProcess: ChildProcess;
+
+  constructor(private context: BuilderContext) {}
+
+  run(
+    target: BuilderConfiguration<NodeExecuteBuilderOptions>
+  ): Observable<BuildEvent> {
+    const options = target.options;
+
+    return this.startBuild(options).pipe(
+      concatMap((event: NodeBuildEvent) => {
+        if (event.success) {
+          return this.restartProcess(event.outfile, options).pipe(mapTo(event));
+        } else {
+          this.context.logger.error(
+            'There was an error with the build. See above.'
+          );
+          this.context.logger.info(`${event.outfile} was not restarted.`);
+          return of(event);
+        }
+      })
+    );
+  }
+
+  private runProcess(file: string, options: NodeExecuteBuilderOptions) {
+    if (this.subProcess) {
+      throw new Error('Already running');
+    }
+    this.subProcess = fork(file, options.args, {
+      execArgv: options.inspect ? ['--inspect'] : []
+    });
+  }
+
+  private restartProcess(file: string, options: NodeExecuteBuilderOptions) {
+    return this.killProcess().pipe(
+      tap(() => {
+        this.runProcess(file, options);
+      })
+    );
+  }
+
+  private killProcess(): Observable<void | Error> {
+    if (!this.subProcess) {
+      return of(undefined);
+    }
+
+    const observableTreeKill = bindCallback(treeKill);
+    return observableTreeKill(this.subProcess.pid, 'SIGTERM').pipe(
+      tap(err => {
+        if (err) {
+          throw err;
+        } else {
+          this.subProcess = null;
+        }
+      })
+    );
+  }
+
+  private startBuild(
+    options: NodeExecuteBuilderOptions
+  ): Observable<NodeBuildEvent> {
+    const builderConfig = this._getBuildBuilderConfig(options);
+
+    return this.context.architect.getBuilderDescription(builderConfig).pipe(
+      concatMap(buildDescription =>
+        this.context.architect.validateBuilderOptions(
+          builderConfig,
+          buildDescription
+        )
+      ),
+      tap(builderConfig => {
+        if (builderConfig.options.optimization) {
+          this.context.logger.warn(stripIndents`
+            ************************************************
+            This is a simple process manager for use in
+            testing or debugging Node applications locally.
+            DO NOT USE IT FOR PRODUCTION!
+            You should look into proper means of deploying
+            your node application to production.
+            ************************************************`);
+        }
+      }),
+      concatMap(
+        builderConfig =>
+          this.context.architect.run(builderConfig, this.context) as Observable<
+            NodeBuildEvent
+          >
+      )
+    );
+  }
+
+  private _getBuildBuilderConfig(options: NodeExecuteBuilderOptions) {
+    const [project, target, configuration] = options.buildTarget.split(':');
+
+    return this.context.architect.getBuilderConfiguration<
+      BuildNodeBuilderOptions
+    >({
+      project,
+      target,
+      configuration,
+      overrides: {
+        watch: true
+      }
+    });
+  }
+}
+
+export default NodeExecuteBuilder;

Diff for: packages/builders/src/node/execute/schema.json

@@ -0,0 +1,26 @@
+{
+  "title": "Schema for Executing NodeJS apps",
+  "description": "NodeJS execution options",
+  "type": "object",
+  "properties": {
+    "buildTarget": {
+      "type": "string",
+      "description": "The target to run to build you the app"
+    },
+    "inspect": {
+      "type": "boolean",
+      "description": "Ensures the app is starting with debugging",
+      "default": true
+    },
+    "args": {
+      "type": "array",
+      "description": "Extra args when starting the app",
+      "default": [],
+      "items": {
+        "type": "string"
+      }
+    }
+  },
+  "additionalProperties": false,
+  "required": ["buildTarget"]
+}