Inline TypeScript compiler for rendering from source files

Implement inline TypeScript compiler that we can use to extract module
definitions from Angular CLI projects that cannot define additional
webpack targets. The next step is to integrate the offline compiler to
generate NgFactory files and use those to instantiate the renderer.

Author: clbond

source/application/compiler/bundle.ts

@@ -1,54 +1,110 @@
 import {
+  NgModuleFactory,
+  NgModule
+} from '@angular/core';
+
+import {
+  CompilerOptions,
   Diagnostic,
-  FormatDiagnosticsHost,
+  ModuleKind,
+  ModuleResolutionKind,
   Program,
-  SourceFile,
   WriteFileCallback,
   createCompilerHost,
   createProgram,
-  formatDiagnostics,
   getPreEmitDiagnostics,
 } from 'typescript';
 
-import {EOL} from 'os';
-import {cwd} from 'process';
-import {relative} from 'path';
+import {dirname} from 'path';
 
-import {ApplicationBundle} from './bundle';
-import {CompilerOptions, loadProjectOptions} from './options';
+import {CompileOptions, loadProjectOptions} from './options';
 import {CompilerException} from 'exception';
 import {Project} from '../project';
-
+import {Reflector} from 'platform';
+import {VirtualMachine} from './vm';
+import {diagnosticsToException} from './diagnostics';
 import {flatten} from 'transformation';
 
 export class Compiler {
-  private options: CompilerOptions;
+  private options: CompileOptions;
 
-  constructor(project: Project) {
+  constructor(private project: Project) {
     this.options = loadProjectOptions(project);
+
+    if (project.ngModule == null ||
+        project.ngModule.length < 2) {
+      throw new CompilerException('Compiler requires a module ID and an export name in ngModule');
+    }
+  }
+
+  compile(): NgModuleFactory<any> {
+    const vm = new VirtualMachine();
+    try {
+      this.compileToVm(vm);
+
+      const [moduleId, exported] = this.project.ngModule;
+
+      const requiredModule = vm.require(moduleId);
+      if (requiredModule == null) {
+        throw new CompilerException(`Attempted to require ${moduleId} but received a null or undefined object`);
+      }
+
+      const rootModule =
+        !exported
+          ? requiredModule
+          : requiredModule[exported];
+
+      if (Reflector.decorated(rootModule, NgModule) === false) {
+        throw new CompilerException(`Root module type ${rootModule.name} is not decorated with @NgModule`);
+      }
+
+      return rootModule;
+    }
+    finally {
+      vm.dispose();
+    }
   }
 
-  async compile(): Promise<ApplicationBundle> {
+  private compileToVm(vm: VirtualMachine) {
     const program = this.createProgram(null);
 
-    return new Promise(resolve => {
-      const writer: WriteFileCallback =
-        (fileName: string, data: string, writeByteOrderMark: boolean, onError?: (message: string) => void, sourceFiles?: SourceFile[]) => {
-          throw new CompilerException('Not implemented');
-        };
+    const compilerOptions = program.getCompilerOptions();
 
-      program.emit(undefined, writer, null, false);
-    });
+    const writer: WriteFileCallback =
+      (fileName, data, writeByteOrderMark, onError?, sourceFiles?) => {
+        try {
+          const moduleId = this.moduleIdFromFilename(fileName, compilerOptions);
+
+          vm.define(fileName, moduleId, data);
+        }
+        catch (exception) {
+          if (onError == null) {
+            throw exception;
+          }
+          onError(exception.stack);
+        }
+      };
+
+    program.emit(undefined, writer, null, false);
   }
 
   private createProgram(previousProgram?: Program): Program {
     const {typescriptOptions} = this.options;
 
-    const compilerHost = createCompilerHost(typescriptOptions.options, true);
+    const options = Object.assign({}, typescriptOptions.options, {
+      declaration: false,
+      sourceMap: false,
+      sourceRoot: null,
+      inlineSourceMap: false,
+      module: ModuleKind.CommonJS,
+      moduleResolution: ModuleResolutionKind.NodeJs,
+    });
+
+    const compilerHost = createCompilerHost(options, true);
 
     const program = createProgram(
       typescriptOptions.fileNames,
-      typescriptOptions.options,
+      options,
       compilerHost,
       previousProgram);
 
@@ -64,18 +120,37 @@ export class Compiler {
   }
 
   private conditionalException(diagnostics: Array<Diagnostic>) {
-    if (diagnostics == null || diagnostics.length === 0) {
+    if (diagnostics == null ||
+        diagnostics.length === 0) {
       return;
     }
+    throw new CompilerException(diagnosticsToException(diagnostics));
+  }
 
-    const host: FormatDiagnosticsHost = {
-       getCurrentDirectory: (): string => cwd(),
-       getCanonicalFileName: (filename: string): string => relative(cwd(), filename),
-       getNewLine: (): string => EOL,
-    };
-
-    const formatted = formatDiagnostics(diagnostics, host);
+  private moduleIdFromFilename(filename: string, compilerOptions: CompilerOptions): string {
+    const projectPath = (path: string): string =>
+      path.toLowerCase().endsWith('.json')
+        ? dirname(path)
+        : path;
+
+    const candidates = [
+      compilerOptions.baseUrl,
+      compilerOptions.outDir,
+      compilerOptions.rootDir,
+      compilerOptions.project
+        ? projectPath(compilerOptions.project)
+        : null,
+    ].concat(compilerOptions.rootDirs || []).filter(v => v);
+
+    const lowerfile = filename.toLowerCase();
+
+    const matches = candidates.map(v => v.toLowerCase()).filter(p => lowerfile.startsWith(p));
+    if (matches.length > 0) {
+      return filename.substring(matches[0].length)
+        .replace(/\.js$/, String())
+        .replace(/^\//, String());
+    }
 
-    throw new CompilerException(formatted);
+    throw new CompilerException(`Cannot determine module ID of file ${filename}`);
   }
 }

source/application/compiler/compiler.ts

@@ -0,0 +1,18 @@
+import {EOL} from 'os';
+import {cwd} from 'process';
+
+import {
+  Diagnostic,
+  FormatDiagnosticsHost,
+  formatDiagnostics
+} from 'typescript';
+
+export const diagnosticsToException = (diagnostics: Array<Diagnostic>): string => {
+  const host: FormatDiagnosticsHost = {
+      getCurrentDirectory: (): string => cwd(),
+      getCanonicalFileName: (filename: string): string => filename,
+      getNewLine: (): string => EOL,
+  };
+
+  return formatDiagnostics(diagnostics, host);
+};

source/application/compiler/diagnostics.ts

@@ -1,3 +1,3 @@
-export * from './bundle';
+export * from './vm';
 export * from './compiler';
 export * from './options';

source/application/compiler/index.ts

@@ -5,15 +5,15 @@ import {ParsedCommandLine} from 'typescript';
 
 import {Project} from '../project';
 
-export interface CompilerOptions {
+export interface CompileOptions {
   // TypeScript compiler options
   typescriptOptions: ParsedCommandLine;
 
   // Angular compiler options
   angularOptions: AngularCompilerOptions;
 }
 
-export const loadProjectOptions = (project: Project): CompilerOptions => {
+export const loadProjectOptions = (project: Project): CompileOptions => {
   const tsc = new Tsc();
 
   const {parsed, ngOptions} = tsc.readConfiguration(project.tsconfig, project.basePath);

source/application/compiler/options.ts

@@ -10,14 +10,15 @@ describe('Compiler', () => {
 
     return new Compiler({
       basePath: dirname(tsconfig),
-      ngModule: ['test-fixtures/application-basic-inline.ts', 'BasicInlineApplication'],
+      ngModule: ['test-fixtures/application-basic-inline', 'BasicInlineApplication'],
       tsconfig,
     });
   };
 
-  xit('should be able to build a TypeScript application and produce in-memory artifacts', async () => {
+  it('should be able to build a TypeScript application and produce in-memory artifacts', async () => {
     const compiler = createCompiler();
-    const bundle = await compiler.compile();
-    expect(bundle).not.toBeNull();
+    const module = await compiler.compile();
+    expect(module).not.toBeNull();
+    expect(typeof module).toBe('function');
   });
 });

source/application/compiler/tests/compiler.ts

@@ -0,0 +1 @@
+export * from './virtual-machine';

source/application/compiler/vm/index.ts

@@ -0,0 +1,16 @@
+import {VirtualMachine} from '../virtual-machine';
+
+describe('VirtualMachine', () => {
+  it('can define multiple sandboxed scripts and execute them', () => {
+    const vm = new VirtualMachine();
+
+    vm.define('/foo/m1.js', 'm1', 'module.exports = {foo: function() { return 1; }};');
+    vm.define('/foo/m2.js', 'm2', `return require('./m1')`);
+
+    const result = vm.require('./m1');
+    expect(result).not.toBeNull();
+    expect(result.foo).not.toBeNull();
+    expect(typeof result.foo).toBe('function');
+    expect(result.foo()).toBe(1);
+  });
+});

source/application/compiler/vm/tests/vm.ts

@@ -0,0 +1,71 @@
+import {Script, createContext} from 'vm';
+
+import {dirname, join, normalize} from 'path';
+
+import {Disposable} from 'disposable';
+
+import {VirtualMachineException} from 'exception';
+
+export class VirtualMachine implements Disposable {
+  private scripts = new Map<string, Script>();
+  private modules = new Map<string, any>();
+
+  define(filename: string, moduleId: string, code: string) {
+    if (moduleId.startsWith('/') ||
+        moduleId.startsWith('.')) {
+      throw new VirtualMachineException(`Invalid module ID: ${moduleId}`);
+    }
+
+    if (this.scripts.has(moduleId)) {
+      throw new VirtualMachineException(`Cannot overwrite existing module ${moduleId}`);
+    }
+
+    const wrappedCode = `(function() {
+      const module = {id: '${moduleId}', exports: {}, filename: '${filename}'};
+      const exports = module.exports;
+      ${code};
+      return exports;
+    })()`;
+
+    const script = new Script(wrappedCode, {filename, displayErrors: true});
+
+    this.scripts.set(moduleId, script);
+  }
+
+  require(moduleId: string, relativeTo?: string) {
+    const absolutePath = this.resolvePath(moduleId, relativeTo);
+
+    if (this.modules.has(absolutePath) === false) {
+      const script = this.scripts.get(absolutePath);
+      if (script == null) {
+        return require(moduleId); // probably a third-party module
+      }
+
+      const context = createContext({require: mid => this.require(mid, moduleId)});
+
+      try {
+        this.modules.set(moduleId, script.runInContext(context));
+      }
+      catch (exception) {
+        throw new VirtualMachineException(`Failure to execute ${moduleId} in VM: ${exception.stack}`, exception);
+      }
+    }
+
+    return this.modules.get(moduleId);
+  }
+
+  dispose() {
+    this.scripts.clear();
+    this.modules.clear();
+  }
+
+  private resolvePath(to: string, from: string) {
+    if (to.startsWith('/')) {
+      throw new VirtualMachineException(`Cannot resolve a path that starts with /: ${to} (from ${from})`);
+    }
+    if (from) {
+      return normalize(join(dirname(from), to));
+    }
+    return normalize(to);
+  }
+}

source/application/compiler/vm/virtual-machine.ts

@@ -1,7 +1,16 @@
 export class Exception extends Error {
-  constructor(msg: string, private innerException?: Error) {
-    super(msg);
-  }
+  private innerException: Error;
+
+  constructor(msg: string, innerException?: Error) {
+    if (innerException) {
+      super(`${msg} -> ${innerException.stack}`);
+    }
+    else {
+      super(msg);
+    }
+
+    this.innerException = innerException;
+ }
 
   public get stack(): string {
     if (this.innerException) {
@@ -20,4 +29,6 @@ export class PlatformException extends Exception {}
 export class RendererException extends Exception {}
 export class ResourceException extends Exception {}
 export class RouteException extends Exception {}
-export class SnapshotException extends Exception {}
+export class SnapshotException extends Exception {}
+export class MemoryFilesystemException extends Exception {}
+export class VirtualMachineException extends Exception {}