refactor: generate type declarations

Author: KingDarBoja

src/Serverless.d.ts

@@ -3,8 +3,9 @@ import * as fs from 'fs-extra'
 import * as _ from 'lodash'
 import * as globby from 'globby'
 
-import * as typescript from './typescript'
-import watchFiles from './watchFiles'
+import { ServerlessTSInstance, ServerlessTSOptions, ServerlessTSFunction } from './serverlessTypes'
+import { extractFileNames, getTypescriptConfig, run } from './typescript'
+import { watchFiles } from './watchFiles'
 
 const SERVERLESS_FOLDER = '.serverless'
 const BUILD_FOLDER = '.build'
@@ -13,11 +14,11 @@ export class TypeScriptPlugin {
   private originalServicePath: string
   private isWatching: boolean
 
-  serverless: Serverless.Instance
-  options: Serverless.Options
+  serverless: ServerlessTSInstance
+  options: ServerlessTSOptions
   hooks: { [key: string]: Function }
 
-  constructor(serverless: Serverless.Instance, options: Serverless.Options) {
+  constructor(serverless: ServerlessTSInstance, options: ServerlessTSOptions) {
     this.serverless = serverless
     this.options = options
 
@@ -75,7 +76,7 @@ export class TypeScriptPlugin {
     }
   }
 
-  get functions(): { [key: string]: Serverless.Function } {
+  get functions(): { [key: string]: ServerlessTSFunction } {
     const { options } = this
     const { service } = this.serverless
 
@@ -89,7 +90,7 @@ export class TypeScriptPlugin {
   }
 
   get rootFileNames(): string[] {
-    return typescript.extractFileNames(
+    return extractFileNames(
       this.originalServicePath,
       this.serverless.service.provider.name,
       this.functions
@@ -145,15 +146,15 @@ export class TypeScriptPlugin {
       this.serverless.config.servicePath = path.join(this.originalServicePath, BUILD_FOLDER)
     }
 
-    const tsconfig = typescript.getTypescriptConfig(
+    const tsconfig = getTypescriptConfig(
       this.originalServicePath,
       this.serverless,
       this.isWatching ? null : this.serverless.cli
     )
 
     tsconfig.outDir = BUILD_FOLDER
 
-    const emitedFiles = typescript.run(this.rootFileNames, tsconfig)
+    const emitedFiles = run(this.rootFileNames, tsconfig)
     this.serverless.cli.log('Typescript compiled.')
     return emitedFiles
   }
@@ -277,5 +278,3 @@ export class TypeScriptPlugin {
       })
   }
 }
-
-module.exports = TypeScriptPlugin

src/index.ts

@@ -0,0 +1,48 @@
+export interface ServerlessTSInstance {
+  cli: {
+    log(str: string): void
+  }
+  config: {
+    servicePath: string
+  }
+  service: Partial<ServerlessTSService>
+  pluginManager: ServerlessTSPluginManager
+}
+
+export interface ServerlessTSService {
+  provider: {
+    name: string
+  }
+  custom: {
+    typeScript: {
+      tsconfigFilePath: string | undefined
+    }
+  }
+  functions: {
+    [key: string]: ServerlessTSFunction
+  }
+  package: ServerlessTSPackage
+  getAllFunctions(): string[]
+}
+
+export interface ServerlessTSOptions {
+  function?: string
+  watch?: boolean
+  extraServicePath?: string
+}
+
+export interface ServerlessTSFunction {
+  handler: string
+  package: ServerlessTSPackage
+}
+
+export interface ServerlessTSPackage {
+  include: string[]
+  exclude: string[]
+  artifact?: string
+  individually?: boolean
+}
+
+export interface ServerlessTSPluginManager {
+  spawn(command: string): Promise<void>
+}

src/serverlessTypes.ts

@@ -1,8 +1,10 @@
 import * as ts from 'typescript'
-import * as fs from 'fs-extra'
+import * as fse from 'fs-extra'
 import * as _ from 'lodash'
 import * as path from 'path'
 
+import { ServerlessTSFunction, ServerlessTSInstance } from './serverlessTypes'
+
 export const makeDefaultTypescriptConfig = (): ts.CompilerOptions => {
   const defaultTypescriptConfig: ts.CompilerOptions = {
     preserveConstEnums: true,
@@ -18,7 +20,7 @@ export const makeDefaultTypescriptConfig = (): ts.CompilerOptions => {
   return defaultTypescriptConfig
 }
 
-export const extractFileNames = (cwd: string, provider: string, functions?: { [key: string]: Serverless.Function }): string[] => {
+export const extractFileNames = (cwd: string, provider: string, functions?: { [key: string]: ServerlessTSFunction }): string[] => {
   // The Google provider will use the entrypoint not from the definition of the
   // handler function, but instead from the package.json:main field, or via a
   // index.js file. This check reads the current package.json in the same way
@@ -27,17 +29,17 @@ export const extractFileNames = (cwd: string, provider: string, functions?: { [k
   // it instead selects the index.js file.
   if (provider === 'google') {
     const packageFilePath = path.join(cwd, 'package.json')
-    if (fs.existsSync(packageFilePath)) {
+    if (fse.existsSync(packageFilePath)) {
 
       // Load in the package.json file.
-      const packageFile = JSON.parse(fs.readFileSync(packageFilePath).toString())
+      const packageFile = JSON.parse(fse.readFileSync(packageFilePath).toString())
 
       // Either grab the package.json:main field, or use the index.ts file.
       // (This will be transpiled to index.js).
       const main = packageFile.main ? packageFile.main.replace(/\.js$/, '.ts') : 'index.ts'
 
       // Check that the file indeed exists.
-      if (!fs.existsSync(path.join(cwd, main))) {
+      if (!fse.existsSync(path.join(cwd, main))) {
         console.log(`Cannot locate entrypoint, ${main} not found`)
         throw new Error('Typescript compilation failed')
       }
@@ -55,12 +57,12 @@ export const extractFileNames = (cwd: string, provider: string, functions?: { [k
       const fileName = h.substring(0, fnNameLastAppearanceIndex)
 
       // Check if the .ts files exists. If so return that to watch
-      if (fs.existsSync(path.join(cwd, fileName + 'ts'))) {
+      if (fse.existsSync(path.join(cwd, fileName + 'ts'))) {
         return fileName + 'ts'
       }
 
       // Check if the .js files exists. If so return that to watch
-      if (fs.existsSync(path.join(cwd, fileName + 'js'))) {
+      if (fse.existsSync(path.join(cwd, fileName + 'js'))) {
         return fileName + 'js'
       }
 
@@ -112,21 +114,21 @@ export const getSourceFiles = (
 
 export const getTypescriptConfig = (
   cwd: string,
-  serverless?: Partial<Serverless.Instance>,
+  serverless?: Partial<ServerlessTSInstance>,
   logger?: { log: (str: string) => void }
 ): ts.CompilerOptions => {
   let configFilePath = path.join(cwd, 'tsconfig.json')
 
   if (serverless && serverless.service.custom && serverless.service.custom.typeScript && serverless.service.custom.typeScript.tsconfigFilePath) {
     configFilePath = path.join(cwd, serverless.service.custom.typeScript.tsconfigFilePath)
-    if (!fs.existsSync(configFilePath)) {
+    if (!fse.existsSync(configFilePath)) {
       throw new Error(`Custom Typescript Config File not found at "${configFilePath}"`)
     }
   }
 
-  if (fs.existsSync(configFilePath)) {
+  if (fse.existsSync(configFilePath)) {
 
-    const configFileText = fs.readFileSync(configFilePath).toString()
+    const configFileText = fse.readFileSync(configFilePath).toString()
     const result = ts.parseConfigFileTextToJson(configFilePath, configFileText)
     if (result.error) {
       throw new Error(JSON.stringify(result.error))

src/typescript.ts

@@ -1,14 +1,16 @@
-import * as typescript from './typescript'
 import { watchFile, unwatchFile, Stats } from 'fs'
 
-const watchFiles = (
+import { ServerlessTSInstance } from './serverlessTypes'
+import { getSourceFiles, getTypescriptConfig } from './typescript'
+
+export const watchFiles = (
   rootFileNames: string[],
   originalServicePath: string,
-  serverless: Serverless.Instance,
+  serverless: ServerlessTSInstance,
   cb: () => Promise<void>
 ): void => {
-  const tsConfig = typescript.getTypescriptConfig(originalServicePath, serverless)
-  let watchedFiles = typescript.getSourceFiles(rootFileNames, tsConfig)
+  const tsConfig = getTypescriptConfig(originalServicePath, serverless)
+  let watchedFiles = getSourceFiles(rootFileNames, tsConfig)
 
   watchedFiles.forEach(fileName => {
     watchFile(fileName, { persistent: true, interval: 250 }, watchCallback)
@@ -23,7 +25,7 @@ const watchFiles = (
     cb()
 
     // use can reference not watched yet file or remove reference to already watched
-    const newWatchFiles = typescript.getSourceFiles(rootFileNames, tsConfig)
+    const newWatchFiles = getSourceFiles(rootFileNames, tsConfig)
     watchedFiles.forEach(fileName => {
       if (!newWatchFiles.includes(fileName)) {
         unwatchFile(fileName, watchCallback)
@@ -39,5 +41,3 @@ const watchFiles = (
     watchedFiles = newWatchFiles
   }
 }
-
-export default watchFiles

src/watchFiles.ts

@@ -1,7 +1,9 @@
-import {extractFileNames} from '../src/typescript'
 import * as path from 'path'
 
-const functions: { [key: string]: Serverless.Function } = {
+import { extractFileNames } from '../src/typescript'
+import { ServerlessTSFunction } from '../src/serverlessTypes'
+
+const functions: { [key: string]: ServerlessTSFunction } = {
     hello: {
         handler: 'tests/assets/hello.handler',
         package: {

tests/typescript.extractFileName.test.ts

@@ -1,4 +1,4 @@
-import {getTypescriptConfig, makeDefaultTypescriptConfig} from '../src/typescript'
+import { getTypescriptConfig, makeDefaultTypescriptConfig } from '../src/typescript'
 
 describe('getTypescriptConfig', () => {
     it('returns default typescript configuration if the one provided does not exist', () => {
@@ -18,7 +18,7 @@ describe('getTypescriptConfig', () => {
                             tsconfigFilePath: './some-path'
                         }
                     }}
-                } as any),
+                }),
         ).toThrowError('Custom Typescript Config File not found')
     })
 

tests/typescript.getTypescriptConfig.test.ts

@@ -1,11 +1,12 @@
 {
   "compilerOptions": {
     "module": "commonjs",
-    "rootDir": ".",
     "target": "es6",
+    "declaration": true,
     "sourceMap": true,
     "outDir": "dist"
   },
+  "include": ["src/**/*.ts"],
   "exclude": [
     "node_modules"
   ]