Refactoring of CLI application

Author: Christopher Bond

package.json

@@ -52,6 +52,7 @@
     "reflect-metadata": "^0.1.9",
     "rimraf": "^2.5.4",
     "rxjs": "^5.1.0",
+    "scoped-logger": "0.0.15",
     "source-map-support": "^0.4.11",
     "typescript": "^2.2.0"
   },

source/application/compiler/compiler-vm.ts

@@ -52,12 +52,12 @@ export class CompilerVmHost extends DelegatingHost {
       const traversal = pathFromString(targetPath);
 
       const files = new Set([
-        ...Array.from(traversal.files()).map(f => f.path()),
+        ...Array.from(traversal.files()).map(f => f.toString()),
         ...Array.from(this.vm.filenames(targetPath))
       ]);
 
       const directories = new Set<string>([
-        ...Array.from(traversal.directories()).map(d => d.string()),
+        ...Array.from(traversal.directories()).map(d => d.toString()),
         ...Array.from(this.vm.directories(targetPath))
       ]);
 

source/application/compiler/compiler.ts

@@ -21,12 +21,6 @@ export class Compiler {
 
   constructor(private project: Project) {
     this.options = loadProjectOptions(project);
-
-    if (project.rootModule == null ||
-        !project.rootModule.source ||
-        !project.rootModule.symbol) {
-      throw new CompilerException('Compilation requires a source and symbol');
-    }
   }
 
   async compile(): Promise<NgModuleFactory<any>> {
@@ -68,7 +62,7 @@ export class Compiler {
       assertDiagnostics(emitResult.diagnostics);
     }
 
-    return emit.rootModule(compilerVmHost, this.options.angular.basePath, vmoptions.options);
+    return emit.rootModule(program, compilerVmHost, vmoptions.options);
   }
 
   private createProgram(files: Array<string>, compilerHost: CompilerHost, previousProgram?: Program): Program {

source/application/compiler/emit.ts

@@ -1,5 +1,7 @@
 import {
+  CompilerHost,
   CompilerOptions,
+  Program,
   SourceFile,
   resolveModuleName
 } from 'typescript';
@@ -10,10 +12,10 @@ import {
   resolve
 } from 'path';
 
-import {CompilerVmHost} from './compiler-vm';
 import {CompilerException} from '../../exception';
-import {Project} from '../../application';
+import {ApplicationModuleDescriptor, Project} from '../../application';
 import {Publisher} from '../../publisher';
+import {StaticAnalyzer} from '../static';
 
 export type CompiledSource = {filename: string, source: string};
 
@@ -47,20 +49,38 @@ export class CompilationEmit {
     }
   }
 
-  rootModule(compilerHost: CompilerVmHost, basePath: string, options: CompilerOptions): [string, string] {
-    const containingFile = join(basePath, 'index.ts');
+  applicationModule(program: Program): ApplicationModuleDescriptor {
+    const parser = new StaticAnalyzer(program.getSourceFiles());
 
-    const rootModule = sourceToNgFactory(this.project.rootModule.source);
+    return parser.getBootstrapModule();
+  }
+
+  rootModule(program: Program, compilerHost: CompilerHost, options: CompilerOptions): [string, string] {
+    const containingFile = join(this.project.basePath, 'index.ts');
+
+    const applicationModule =
+      this.project.applicationModule
+        ? this.project.applicationModule
+        : this.applicationModule(program);
+
+    if (applicationModule == null ||
+        applicationModule.source == null ||
+        applicationModule.symbol == null) {
+      throw new CompilerException(`Cannot find application root @NgModule, please provide in Project structure`);
+    }
+
+    const rootModule = sourceToNgFactory(applicationModule.source);
 
     const resolved = resolveModuleName(rootModule, containingFile, options, compilerHost);
 
-    if (resolved == null || resolved.resolvedModule == null) {
+    if (resolved == null ||
+        resolved.resolvedModule == null) {
       throw new CompilerException(`Cannot resolve root module: ${rootModule}`);
     }
 
     const moduleFile = this.getModuleFromSourceFile(resolved.resolvedModule.resolvedFileName);
 
-    const symbol = symbolToNgFactory(this.project.rootModule.symbol);
+    const symbol = symbolToNgFactory(applicationModule.symbol);
 
     return [moduleFile, symbol];
   }
@@ -94,7 +114,7 @@ const executable = (filename: string) => /\.js$/.test(filename);
 
 const sourceToNgFactory = (source: string): string => {
   if (/\.ngfactory(\.(ts|js))?$/.test(source) === false) {
-    return `${source}.ngfactory`;
+    return `${source.replace(/\.(js|ts)$/, String())}.ngfactory`;
   }
   return source;
 };

source/application/compiler/options.ts

@@ -26,19 +26,24 @@ export const loadProjectOptions = (project: Project): CompileOptions => {
   ngOptions.basePath = project.basePath;
   ngOptions.generateCodeForLibraries = true;
 
+  // Test files cannot be included but ng new projects do not exclude them from the
+  // build in tsconfig.json files, so we must manually snip them from the root file
+  // list. This is really super nasty and it would be great if it weren't necessary.
+  const rootSources = parsed.fileNames.filter(file => testHeuristic(file) === false);
+
   return {
     angular: ngOptions,
-    rootSources: parsed.fileNames,
+    rootSources,
     ts: adjustOptions(parsed.options),
   };
 };
 
 export const adjustOptions = (baseOptions?: CompilerOptions): CompilerOptions => {
   return Object.assign({}, baseOptions, {
     declaration: false,
-    sourceMap: false,
-    inlineSourceMap: false,
     module: ModuleKind.CommonJS,
     moduleResolution: ModuleResolutionKind.NodeJs,
   });
 };
+
+const testHeuristic = (filename: string) => /(e2e|\.?(spec|tests?)\.)/.test(filename);

source/application/index.ts

@@ -1,5 +1,6 @@
 export * from './builder';
 export * from './compiler';
+export * from './static';
 export * from './fork';
 export * from './project';
 export * from './render';

source/application/project.ts

@@ -1,13 +1,16 @@
+export interface ApplicationModuleDescriptor {
+  source: string;
+  symbol: string;
+}
+
 export interface Project {
-  // project root path
   basePath: string;
 
   // path to the tsconfig.json file for this project
   tsconfig: string;
 
-  // path to the application root NgModule file, and the name of that module
-  rootModule: {
-    source: string;
-    symbol: string;
-  }
+  // path to the application root NgModule file, and the name of that module.
+  // we will automatically determine this using static analysis if it is not
+  // provided, but this will add a bit more time to the compilation process
+  applicationModule?: ApplicationModuleDescriptor;
 }

source/application/static/analyzer.ts

@@ -0,0 +1,45 @@
+import {
+  CallExpression,
+  PropertyAccessExpression,
+  SourceFile,
+  SyntaxKind,
+} from 'typescript';
+
+import {findExpression} from './expression';
+
+import {ApplicationModuleDescriptor} from '../project';
+
+export class StaticAnalyzer {
+  constructor(private sources: Array<SourceFile>) {}
+
+  getBootstrapModule(): ApplicationModuleDescriptor {
+    for (const file of this.sources) {
+      const expression = findExpression<CallExpression>(file, SyntaxKind.CallExpression, isBootstrapCall);
+      if (expression) {
+        return {source: file.fileName, symbol: expression.arguments[0].getText()}
+      }
+    }
+    return null;
+  }
+}
+
+const isBootstrapCall = (expr: CallExpression): boolean => {
+  if (expr.expression.kind !== SyntaxKind.PropertyAccessExpression) {
+    return false;
+  }
+
+  const accessor = <PropertyAccessExpression> expr.expression;
+  if (accessor.name.kind !== SyntaxKind.Identifier ||
+      accessor.expression == null ||
+      accessor.expression.kind !== SyntaxKind.CallExpression) {
+    return false;
+  }
+
+  switch (accessor.name.text) {
+    case 'bootstrapModule':
+    case 'bootstrapModuleFactory':
+      return true;
+    default:
+      return false;
+  }
+};

source/application/static/expression.ts

@@ -0,0 +1,22 @@
+import {Node, SyntaxKind} from 'typescript';
+
+export const findExpression = <N extends Node>(root: Node, kind: SyntaxKind, predicate: (node: N) => boolean): N => {
+  const match = (n: Node) => n.kind === kind && predicate(n as N);
+
+  if (match(root)) {
+    return root as N;
+  }
+
+  for (const child of root.getChildren()) {
+    if (match(child)) {
+      return child as N;
+    }
+
+    const result = findExpression(child, kind, predicate);
+    if (result) {
+      return result;
+    }
+  }
+
+  return null;
+};

source/application/static/index.ts

@@ -0,0 +1,2 @@
+export * from './analyzer';
+export * from './expression';