Add more commands and cleanup

Author: stefanjudis

.gitignore

@@ -1 +1,2 @@
 node_modules
+.vscode

.prettierrc

@@ -0,0 +1 @@
+{"singleQuote": true}

Readme.md

@@ -0,0 +1,45 @@
+# Twilio Runtime Serverless Plugin
+
+This plugin enables Twilio Functions and Assets support within the Serverless Framework.
+
+## Getting started
+
+### Pre-requisites
+
+- Node.js v8.10.0 (this is the runtime version supported by Azure Functions)
+- Serverless CLI v1.48.0+. You can run npm i -g serverless if you don't already have it.
+- A Twilio account. If you don't have one you can [sign up quickly](https://www.twilio.com/try-twilio).
+
+### Create a new Twilio service
+
+- Create a new service using the standard Node.js template, specifying a unique name for your app: `serverless create -t azure-nodejs -p <appName>`
+- `cd` into the generated app directory: `cd <appName>`
+- Install the app's NPM dependencies, which includes this plugin: `npm install`
+
+### Deploy, test, and diagnose your Twilio runtime
+
+1. Now that you have the service on your local machine you can deploy your service using the credentials you find in [the Twilio Console](https://www.twilio.com/console/).
+
+### Supported commands
+
+#### `serverless deploy`
+
+Deploy all functions and assets defined in your `serverless.yml`
+
+```
+serverless deploy
+```
+
+Deploying of a single function is also supported using the `--function` or `-f` parameter.
+
+```
+serverless deploy --function hello-world
+```
+
+#### `serverless deploy`
+
+Get information about the currently deployed runtime
+
+```
+serverless info
+```

deploy/twilio-deploy-function.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const { logDeployedResources } = require('../util/log');
+const { getTwilioClient, getTwilioDeployConfig } = require('../util/util');
+const { validateIfFunctionExists } = require('../util/validate');
+
+class TwilioDeploy {
+  constructor(serverless, options) {
+    this.serverless = serverless;
+    this.options = options;
+
+    this.hooks = {
+      'deploy:function:deploy': this.deployFunction.bind(this)
+    };
+  }
+
+  async deployFunction() {
+    const serverless = this.serverless;
+    const functionName = this.options.f || this.options.function;
+    const twilioServerlessClient = getTwilioClient(serverless);
+
+    validateIfFunctionExists(serverless, functionName);
+
+    const config = await getTwilioDeployConfig(serverless, {
+      deploySingleFunction: functionName
+    });
+    const result = await twilioServerlessClient.deployProject(config);
+
+    logDeployedResources(serverless, result);
+  }
+}
+
+module.exports = TwilioDeploy;

deploy/twilio-deploy.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const { logDeployedResources } = require('../util/log');
+const { getTwilioClient, getTwilioDeployConfig } = require('../util/util');
+
+class TwilioDeploy {
+  constructor(serverless, options) {
+    this.serverless = serverless;
+
+    this.hooks = {
+      'deploy:deploy': this.deploy.bind(this)
+    };
+  }
+
+  async deploy() {
+    const serverless = this.serverless;
+    const twilioServerlessClient = getTwilioClient(serverless);
+    const config = await getTwilioDeployConfig(serverless, { deployAll: true });
+    const result = await twilioServerlessClient.deployProject(config);
+
+    logDeployedResources(serverless, result);
+  }
+}
+
+module.exports = TwilioDeploy;

index.js

@@ -1,114 +1,20 @@
 'use strict';
 
 const TwilioProvider = require('./provider/twilioProvider');
-const path = require('path');
-const {
-  TwilioServerlessApiClient,
-  utils
-} = require('@twilio-labs/serverless-api');
-const { readFile } = utils;
+const TwilioDeploy = require('./deploy/twilio-deploy');
+const TwilioDeployFunction = require('./deploy/twilio-deploy-function');
+const TwilioInfo = require('./info/twilio-info');
+const TwilioInvoke = require('./invoke/twilio-invoke');
 
 class ServerlessPlugin {
-  constructor(serverless, options) {
+  constructor(serverless) {
     this.serverless = serverless;
-    this.options = options;
     this.provider = this.serverless.setProvider('twilio', TwilioProvider);
 
-    this.commands = {
-      deploy: {
-        usage: 'Deploy Twilio functions and assets',
-        lifecycleEvents: [],
-        options: {
-          sid: {
-            usage:
-              'Specify the environment you want to deploy ' +
-              '(e.g. "--sid \'AC....\'" or "-s \'AC....\'")',
-            required: true,
-            shortcut: 's'
-          },
-          token: {
-            usage:
-              'Specify your Twilio auth token to deploy' +
-              '(e.g. "--token \'a86....\'" or "-t \'a86....\'")',
-            required: true,
-            shortcut: 'auth'
-          },
-          env: {
-            usage:
-              'Specify the environment you want to deploy ' +
-              '(e.g. "--env \'staging\'")'
-          }
-        }
-      }
-    };
-
-    this.hooks = {
-      'deploy:deploy': this.deploy.bind(this)
-    };
-  }
-
-  async deploy() {
-    const serverless = this.serverless;
-    const { sid: accountSid, token: authToken } = serverless.variables.options;
-    const twilioServerlessClient = new TwilioServerlessApiClient({
-      accountSid,
-      authToken
-    });
-
-    const config = {
-      env: serverless.service.provider.environmentVars,
-      pkgJson: {
-        dependencies: serverless.service.provider.dependencies
-      },
-      serviceName: serverless.service.service,
-      functionsEnv: serverless.service.provider.environment || 'dev',
-      assets: [],
-      functions: [],
-      overrideExistingService: true
-    };
-
-    config.functions = await Promise.all(
-      Object.entries(serverless.service.functions).map(
-        async ([name, fnConfig]) => {
-          let { access = 'public', path: fnPath, handler } = fnConfig;
-          let content = await readFile(
-            path.join(serverless.config.servicePath, `${handler}.js`)
-          );
-
-          return { access, content, name, path: fnPath };
-        }
-      )
-    );
-
-    config.assets = await Promise.all(
-      Object.entries(serverless.service.resources.assets).map(
-        async ([name, assetConfig]) => {
-          let { access = 'public', path: assetPath } = assetConfig;
-          let content = await readFile(
-            path.join(serverless.config.servicePath, assetPath)
-          );
-
-          return { access, content, name, path: assetPath };
-        }
-      )
-    );
-
-    twilioServerlessClient.on('status-update', evt => {
-      this.serverless.cli.log(evt.message);
-    });
-
-    const result = await twilioServerlessClient.deployProject(config);
-
-    result.functionResources.forEach(fn =>
-      this.serverless.cli.log(
-        `Function available at: ${result.domain}${fn.path}`
-      )
-    );
-    result.assetResources.forEach(asset =>
-      this.serverless.cli.log(
-        `Asset available at: ${result.domain}${asset.path}`
-      )
-    );
+    this.serverless.pluginManager.addPlugin(TwilioDeploy);
+    this.serverless.pluginManager.addPlugin(TwilioDeployFunction);
+    this.serverless.pluginManager.addPlugin(TwilioInfo);
+    this.serverless.pluginManager.addPlugin(TwilioInvoke);
   }
 }
 

info/twilio-info.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const { logMessage } = require('../util/log');
+
+class TwilioInfo {
+  constructor(serverless, options) {
+    this.serverless = serverless;
+    this.options = options;
+
+    this.hooks = {
+      'info:info': this.logInfo.bind(this)
+    };
+  }
+
+  async logInfo() {
+    logMessage(this.serverless, `'serverless info' is not yet implemented...`);
+  }
+}
+
+module.exports = TwilioInfo;

util/log.js

@@ -0,0 +1,30 @@
+'use strict';
+
+function logDeployedResources(serverless, result) {
+  if (result.functionResources.length) {
+    result.functionResources.forEach(fn =>
+      logMessage(
+        serverless,
+        `Function available at: ${result.domain}${fn.path}`
+      )
+    );
+  }
+
+  if (result.assetResources.length) {
+    result.assetResources.forEach(asset =>
+      logMessage(
+        serverless,
+        `Asset available at: ${result.domain}/${asset.path}`
+      )
+    );
+  }
+}
+
+function logMessage(serverless, message) {
+  serverless.cli.log(`twilio-runtime: ${message}`);
+}
+
+module.exports = {
+  logDeployedResources,
+  logMessage
+};

util/util.js

@@ -0,0 +1,106 @@
+'use strict';
+
+const {
+  TwilioServerlessApiClient,
+  utils
+} = require('@twilio-labs/serverless-api');
+const path = require('path');
+const { readFile } = utils;
+const { logMessage } = require('./log');
+
+/**
+ *
+ * @param {*} serverless
+ */
+function getTwilioClient(serverless) {
+  const { accountSid, authToken } = serverless.service.provider.config;
+
+  const client = new TwilioServerlessApiClient({
+    accountSid,
+    authToken
+  });
+
+  client.on('status-update', evt => {
+    logMessage(serverless, evt.message);
+  });
+
+  return client;
+}
+
+/**
+ *
+ * @param {*} serverless
+ * @param {*} options
+ */
+async function getTwilioDeployConfig(serverless, options = {}) {
+  const config = {
+    env: serverless.service.provider.environmentVars,
+    pkgJson: {
+      dependencies: serverless.service.provider.dependencies
+    },
+    serviceName: serverless.service.service,
+    functionsEnv: serverless.service.provider.environment || 'dev',
+    assets: [],
+    functions: [],
+    overrideExistingService: true
+  };
+
+  if (options.deployAll) {
+    config.functions = await Promise.all(
+      Object.entries(serverless.service.functions).map(
+        async ([name, config]) =>
+          await getFunctionResource(serverless, { name, config })
+      )
+    );
+
+    config.assets = await Promise.all(
+      Object.entries(serverless.service.resources.assets).map(
+        async ([name, config]) =>
+          await getAssetResource(serverless, { name, config })
+      )
+    );
+  } else if (options.deploySingleFunction) {
+    config.functions = [
+      await getFunctionResource(serverless, {
+        name: options.deploySingleFunction,
+        config: serverless.service.functions[options.deploySingleFunction]
+      })
+    ];
+  }
+
+  return config;
+}
+
+/**
+ *
+ * @param {*} serverless
+ * @param {*} param1
+ */
+async function getFunctionResource(serverless, { name, config }) {
+  let { access = 'public', path: fnPath, handler } = config;
+  let content = await readFile(
+    path.join(serverless.config.servicePath, `${handler}.js`)
+  );
+
+  return { access, content, name, path: fnPath };
+}
+
+/**
+ *
+ * @param {*} serverless
+ * @param {*} param1
+ */
+async function getAssetResource(serverless, { name, config }) {
+  let { access = 'public', path: assetPath } = config;
+  let content = await readFile(
+    path.join(serverless.config.servicePath, assetPath)
+  );
+
+  return { access, content, name, path: assetPath };
+}
+
+module.exports = {
+  getTwilioClient,
+  getTwilioDeployConfig,
+  readFile
+};