add serverless.ts support

lib/classes/Utils.js

@@ -120,6 +120,8 @@ class Utils {
       servicePath = process.cwd();
     } else if (fileExistsSync(path.join(process.cwd(), 'serverless.js'))) {
       servicePath = process.cwd();
+    } else if (fileExistsSync(path.join(process.cwd(), 'serverless.ts'))) {
+      servicePath = process.cwd();
     }
 
     return servicePath;

lib/classes/Utils.test.js

@@ -313,6 +313,18 @@ describe('Utils', () => {
       expect(servicePath).to.not.equal(null);
     });
 
+    it('should detect if the CWD is a service directory when using Serverless .ts files', () => {
+      const tmpDirPath = getTmpDirPath();
+      const tmpFilePath = path.join(tmpDirPath, 'serverless.ts');
+
+      serverless.utils.writeFileSync(tmpFilePath, 'foo');
+      process.chdir(tmpDirPath);
+
+      const servicePath = serverless.utils.findServicePath();
+
+      expect(servicePath).to.not.equal(null);
+    });
+
     it('should detect if the CWD is not a service directory', () => {
       // just use the root of the tmpdir because findServicePath will
       // also check parent directories (and may find matching tmp dirs

lib/utils/getServerlessConfigFile.js

@@ -18,12 +18,14 @@ const getConfigFilePath = (servicePath, options = {}) => {
   const ymlPath = path.join(servicePath, 'serverless.yml');
   const yamlPath = path.join(servicePath, 'serverless.yaml');
   const jsPath = path.join(servicePath, 'serverless.js');
+  const tsPath = path.join(servicePath, 'serverless.ts');
 
   return BbPromise.props({
     json: fileExists(jsonPath),
     yml: fileExists(ymlPath),
     yaml: fileExists(yamlPath),
     js: fileExists(jsPath),
+    ts: fileExists(tsPath),
   }).then(exists => {
     if (exists.yaml) {
       return yamlPath;
@@ -33,6 +35,8 @@ const getConfigFilePath = (servicePath, options = {}) => {
       return jsonPath;
     } else if (exists.js) {
       return jsPath;
+    } else if (exists.ts) {
+      return tsPath;
     }
 
     return null;
@@ -46,28 +50,34 @@ const getServerlessConfigFilePath = serverless => {
   );
 };
 
-const handleJsConfigFile = jsConfigFile =>
+const handleJsOrTsConfigFile = (configFile, isTs) =>
   BbPromise.try(() => {
-    // use require to load serverless.js
+    if (isTs) {
+      // eslint-disable-next-line global-require
+      require('ts-node').register();
+    }
+    // use require to load serverless config file
     // eslint-disable-next-line global-require
-    const configExport = require(jsConfigFile);
+    const configExport = require(configFile);
     // In case of a promise result, first resolve it.
     return configExport;
   }).then(config => {
     if (_.isPlainObject(config)) {
       return config;
     }
-    throw new Error('serverless.js must export plain object');
+    throw new Error(`serverless.${isTs ? 'ts' : 'js'} must export plain object`);
   });
 
 const getServerlessConfigFile = _.memoize(
   serverless =>
     getServerlessConfigFilePath(serverless).then(configFilePath => {
       if (configFilePath !== null) {
-        const isJSConfigFile = _.last(_.split(configFilePath, '.')) === 'js';
+        const fileExtension = _.last(_.split(configFilePath, '.'));
+        const isJSConfigFile = fileExtension === 'js';
+        const isTSConfigFile = fileExtension === 'ts';
 
-        if (isJSConfigFile) {
-          return handleJsConfigFile(configFilePath);
+        if (isJSConfigFile || isTSConfigFile) {
+          return handleJsOrTsConfigFile(configFilePath, isTSConfigFile);
         }
 
         return readFile(configFilePath).then(result => result || {});

lib/utils/getServerlessConfigFile.test.js

@@ -146,6 +146,49 @@ describe('#getServerlessConfigFile()', () => {
     ).to.be.rejectedWith('serverless.js must export plain object');
   });
 
+  it('should return the file content if a serverless.ts file found', () => {
+    const serverlessFilePath = path.join(tmpDirPath, 'serverless.ts');
+    writeFileSync(serverlessFilePath, 'module.exports = {"service": "my-ts-service"};');
+
+    return expect(
+      getServerlessConfigFile({
+        processedInput: { options: {} },
+        config: { servicePath: tmpDirPath },
+      })
+    ).to.be.fulfilled.then(result => {
+      expect(result).to.deep.equal({ service: 'my-ts-service' });
+    });
+  });
+
+  it('should return the resolved value if a promise-using serverless.ts file found', () => {
+    const serverlessFilePath = path.join(tmpDirPath, 'serverless.ts');
+    writeFileSync(
+      serverlessFilePath,
+      'module.exports = new Promise(resolve => { resolve({"service": "my-ts-service"}); });'
+    );
+
+    return expect(
+      getServerlessConfigFile({
+        processedInput: { options: {} },
+        config: { servicePath: tmpDirPath },
+      })
+    ).to.be.fulfilled.then(result => {
+      expect(result).to.deep.equal({ service: 'my-ts-service' });
+    });
+  });
+
+  it('should throw an error, if serverless.ts export not a plain object', () => {
+    const serverlessFilePath = path.join(tmpDirPath, 'serverless.ts');
+    writeFileSync(serverlessFilePath, 'module.exports = function config() {};');
+
+    return expect(
+      getServerlessConfigFile({
+        processedInput: { options: {} },
+        config: { servicePath: tmpDirPath },
+      })
+    ).to.be.rejectedWith('serverless.ts must export plain object');
+  });
+
   it('should look in the current working directory if servicePath is undefined', () => {
     const serverlessFilePath = path.join(tmpDirPath, 'serverless.yml');
 

package.json

@@ -221,6 +221,7 @@
     "semver-regex": "^2.0.0",
     "stream-promise": "^3.2.0",
     "tabtab": "^3.0.2",
+    "ts-node": "^8.10.1",
     "untildify": "^3.0.3",
     "update-notifier": "^2.5.0",
     "uuid": "^8.0.0",