Major refactoring + support watch mode

Author: RomanHotsiy

src/index.ts

@@ -1,19 +1,22 @@
 import * as path from 'path'
 import * as fs from 'fs-p'
+
 import * as _ from 'lodash'
 import * as globby from 'globby'
 
 import { ServerlessOptions, ServerlessInstance, ServerlessFunction } from './types'
 import * as typescript from './typescript'
 
+import { watchFiles } from './watchFiles'
+
 // Folders
 const serverlessFolder = '.serverless'
 const buildFolder = '.build'
 
-class ServerlessPlugin {
+export class ServerlessPlugin {
 
   private originalServicePath: string
-  private originalFunctions: { [key: string]: ServerlessFunction } | {}
+  private isWatching: boolean
 
   serverless: ServerlessInstance
   options: ServerlessOptions
@@ -25,67 +28,110 @@ class ServerlessPlugin {
     this.options = options
 
     this.hooks = {
-      'before:offline:start:init': this.beforeCreateDeploymentArtifacts.bind(this),
-      'before:package:createDeploymentArtifacts': this.beforeCreateDeploymentArtifacts.bind(this, 'service'),
-      'after:package:createDeploymentArtifacts': this.afterCreateDeploymentArtifacts.bind(this, 'service'),
-      'before:deploy:function:packageFunction': this.beforeCreateDeploymentArtifacts.bind(this, 'function'),
-      'after:deploy:function:packageFunction': this.afterCreateDeploymentArtifacts.bind(this, 'function'),
-      'before:invoke:local:invoke': this.beforeCreateDeploymentArtifacts.bind(this),
-      'after:invoke:local:invoke': this.cleanup.bind(this),
-    }
-    this.commands = {
-      ts: {
-        commands: {
-          invoke: {
-            usage: 'Run a function locally from the tsc output bundle',
-            lifecycleEvents: [
-              'invoke',
-            ],
-            options: {
-              function: {
-                usage: 'Name of the function',
-                shortcut: 'f',
-                required: true,
-              },
-              path: {
-                usage: 'Path to JSON file holding input data',
-                shortcut: 'p',
-              },
-            },
-          },
-        },
+      'before:offline:start': async () => {
+        await this.compileTs()
+        this.watchAll()
       },
+      'before:offline:start:init': async () => {
+        await this.compileTs()
+        this.watchAll()
+      },
+      'before:package:createDeploymentArtifacts': this.compileTs.bind(this),
+      'after:package:createDeploymentArtifacts': this.cleanup.bind(this),
+      'before:deploy:function:packageFunction': this.compileTs.bind(this),
+      'after:deploy:function:packageFunction': this.cleanup.bind(this),
+      'before:invoke:local:invoke': async () => {
+        const emitedFiles = await this.compileTs()
+        if (this.isWatching) {
+          emitedFiles.forEach(filename => {
+            const module = require.resolve(path.resolve(this.originalServicePath, filename))
+            delete require.cache[module]
+          })
+        }
+      },
+      'after:invoke:local:invoke': () => {
+        if (this.options.watch) {
+          this.watchFunction()
+          this.serverless.cli.log('Waiting for changes ...')
+        }
+      }
     }
   }
 
-  async beforeCreateDeploymentArtifacts(type: string): Promise<void> {
-    this.serverless.cli.log('Compiling with Typescript...')
-
-    // Save original service path and functions
-    this.originalServicePath = this.serverless.config.servicePath
-    this.originalFunctions = type === 'function'
-      ? _.pick(this.serverless.service.functions, [this.options.function])
+  get functions() {
+    return this.options.function
+      ? { [this.options.function] : this.serverless.service.functions[this.options.function] }
       : this.serverless.service.functions
+  }
 
-    // Fake service path so that serverless will know what to zip
-    this.serverless.config.servicePath = path.join(this.originalServicePath, buildFolder)
-
-    const tsFileNames = typescript.extractFileNames(this.originalFunctions)
-    const tsconfig = typescript.getTypescriptConfig(this.originalServicePath)
+  get rootFileNames() {
+    return typescript.extractFileNames(this.functions)
+  }
 
-    for (const fnName in this.originalFunctions) {
-      const fn = this.originalFunctions[fnName]
+  prepare() {
+    // exclude serverless-plugin-typescript
+    const functions = this.functions
+    for (const fnName in functions) {
+      const fn = functions[fnName]
       fn.package = fn.package || {
         exclude: [],
         include: [],
       }
       fn.package.exclude = _.uniq([...fn.package.exclude, 'node_modules/serverless-plugin-typescript'])
     }
+  }
+
+  async watchFunction(): Promise<void> {
+    if (this.isWatching) {
+      return
+    }
+
+    this.serverless.cli.log(`Watch function ${this.options.function}...`)
+
+    this.isWatching = true
+    watchFiles(this.rootFileNames, this.originalServicePath, () => {
+      this.serverless.pluginManager.spawn('invoke:local')
+    })
+  }
+
+  async watchAll(): Promise<void> {
+    if (this.isWatching) {
+      return
+    }
+
+    this.serverless.cli.log(`Watching typescript files...`)
+
+    this.isWatching = true
+    watchFiles(this.rootFileNames, this.originalServicePath, () => {
+      this.compileTs()
+    })
+  }
+
+  async compileTs(): Promise<string[]> {
+    this.prepare()
+    this.serverless.cli.log('Compiling with Typescript...')
+
+    if (!this.originalServicePath) {
+      // Save original service path and functions
+      this.originalServicePath = this.serverless.config.servicePath
+      // Fake service path so that serverless will know what to zip
+      this.serverless.config.servicePath = path.join(this.originalServicePath, buildFolder)
+    }
+
+    const tsFileNames = typescript.extractFileNames(this.functions)
+    const tsconfig = typescript.getTypescriptConfig(
+      this.originalServicePath,
+      this.isWatching ? null : this.serverless.cli
+    )
 
     tsconfig.outDir = buildFolder
 
-    await typescript.run(tsFileNames, tsconfig)
+    const emitedFiles = await typescript.run(tsFileNames, tsconfig)
+    await this.copyExtras()
+    return emitedFiles
+  }
 
+  async copyExtras() {
     // include node_modules into build
     if (!fs.existsSync(path.resolve(path.join(buildFolder, 'node_modules')))) {
       fs.symlinkSync(path.resolve('node_modules'), path.resolve(path.join(buildFolder, 'node_modules')))
@@ -115,23 +161,21 @@ class ServerlessPlugin {
     }
   }
 
-  async afterCreateDeploymentArtifacts(type: string): Promise<void> {
-    // Copy .build to .serverless
+  async cleanup(): Promise<void> {
     await fs.copy(
       path.join(this.originalServicePath, buildFolder, serverlessFolder),
       path.join(this.originalServicePath, serverlessFolder)
     )
 
-    const basename = type === 'function'
-      ? path.basename(this.originalFunctions[this.options.function].artifact)
-      : path.basename(this.serverless.service.package.artifact)
-    this.serverless.service.package.artifact = path.join(this.originalServicePath, serverlessFolder, basename)
-
-    // Cleanup after everything is copied
-    await this.cleanup()
-  }
+    if (this.options.function) {
+      const fn = this.serverless.service.functions[this.options.function]
+      const basename = path.basename(fn.package.artifact)
+      fn.package.artifact =  path.join(this.originalServicePath, serverlessFolder, basename)
+    } else {
+      const basename = path.basename(this.serverless.service.package.artifact)
+      this.serverless.service.package.artifact = path.join(this.originalServicePath, serverlessFolder, basename)
+    }
 
-  async cleanup(): Promise<void> {
     // Restore service path
     this.serverless.config.servicePath = this.originalServicePath
     // Remove temp build folder

src/types.ts

@@ -10,10 +10,12 @@ export interface ServerlessInstance {
     package: ServerlessPackage
     getFunction: (name: string) => any
   }
+  pluginManager: PluginManager
 }
 
 export interface ServerlessOptions {
   function?: string
+  watch?: boolean
   extraServicePath?: string
 }
 
@@ -26,4 +28,9 @@ export interface ServerlessPackage {
   include: string[]
   exclude: string[]
   artifact?: string
+  individually?: boolean
+}
+
+export interface PluginManager {
+  spawn(command: string): Promise<void>
 }

src/typescript.ts

@@ -30,6 +30,7 @@ export function extractFileNames(functions: { [key: string]: ServerlessFunction
 }
 
 export async function run(fileNames: string[], options: ts.CompilerOptions): Promise<string[]> {
+  options.listEmittedFiles = true
   const program = ts.createProgram(fileNames, options)
 
   const emitResult = program.emit()
@@ -49,10 +50,29 @@ export async function run(fileNames: string[], options: ts.CompilerOptions): Pro
     throw new Error('Typescript compilation failed')
   }
 
-  return fileNames.map(f => f.replace(/\.ts$/, '.js'))
+  return emitResult.emittedFiles.filter(filename => filename.endsWith('.js'))
 }
 
-export function getTypescriptConfig(cwd: string): ts.CompilerOptions {
+/*
+ * based on rootFileNames returns list of all related (e.g. imported) source files
+ */
+export function getSourceFiles(
+  rootFileNames: string[],
+  options: ts.CompilerOptions
+): string[] {
+  const program = ts.createProgram(rootFileNames, options)
+  const programmFiles = program.getSourceFiles()
+    .map(file => file.fileName)
+    .filter(file => {
+      return file.split(path.sep).indexOf('node_modules') < 0
+    })
+  return programmFiles
+}
+
+export function getTypescriptConfig(
+  cwd: string,
+  logger?: { log: (str: string) => void }
+): ts.CompilerOptions {
   const configFilePath = path.join(cwd, 'tsconfig.json')
 
   if (fs.existsSync(configFilePath)) {
@@ -68,7 +88,12 @@ export function getTypescriptConfig(cwd: string): ts.CompilerOptions {
       throw new Error(JSON.stringify(configParseResult.errors))
     }
 
-    console.log(`Using local tsconfig.json`)
+    if (logger) {
+      logger.log(`Using local tsconfig.json`)
+    }
+
+    // disallow overrriding rootDir
+    configParseResult.options.rootDir = './'
 
     return configParseResult.options
   }

src/watchFiles.ts

@@ -0,0 +1,42 @@
+import * as typescript from './typescript'
+import * as ts from 'typescript'
+import { watchFile, unwatchFile, Stats} from 'fs'
+import { ServerlessOptions, ServerlessInstance, ServerlessFunction } from './types'
+
+export function watchFiles(
+  rootFileNames: string[],
+  originalServicePath: string,
+  cb: () => void
+) {
+  const tsConfig = typescript.getTypescriptConfig(originalServicePath)
+  let watchFiles = typescript.getSourceFiles(rootFileNames, tsConfig)
+
+  watchFiles.forEach(fileName => {
+    watchFile(fileName, { persistent: true, interval: 250 }, watchCallback)
+  })
+
+  function watchCallback(curr: Stats, prev: Stats) {
+    // Check timestamp
+    if (+curr.mtime <= +prev.mtime) {
+        return
+    }
+
+    cb()
+
+    // use can reference not watched yet file or remove reference to already watched
+    const newWatchFiles =  typescript.getSourceFiles(rootFileNames, tsConfig)
+    watchFiles.forEach(fileName => {
+      if (newWatchFiles.indexOf(fileName) < 0) {
+        unwatchFile(fileName, watchCallback)
+      }
+    })
+
+    newWatchFiles.forEach(fileName => {
+      if (watchFiles.indexOf(fileName) < 0) {
+        watchFile(fileName, { persistent: true, interval: 250 }, watchCallback)
+      }
+    })
+
+    watchFiles = newWatchFiles
+  }
+}