Add a TwilioAPI client based on the Twilio OpenAPI spec

package.json

@@ -24,6 +24,7 @@
     "@oclif/test": "^1.2.4",
     "@twilio/cli-test": "^0.0.1",
     "chai": "^4.2.0",
+    "chai-as-promised": "^7.1.1",
     "eslint": "^4.19.1",
     "eslint-config-oclif": "^1.5.1",
     "eslint-plugin-mocha": "^5.3.0",

src/base-commands/twilio-client-command.js

@@ -2,14 +2,16 @@ const chalk = require('chalk');
 const { flags } = require('@oclif/command');
 const BaseCommand = require('./base-command');
 const CliRequestClient = require('../services/cli-http-client');
+const { TwilioApiClient } = require('../services/twilio-api');
 const { TwilioCliError } = require('../services/error');
 const { HELP_ENVIRONMENT_VARIABLES, UNEXPECTED_ERROR } = require('../services/messaging/help-messages');
 
 class TwilioClientCommand extends BaseCommand {
   constructor(argv, config, secureStorage) {
     super(argv, config, secureStorage);
     this.httpClient = undefined;
-    this.twilioClient = undefined;
+    this.twilio = undefined;
+    this.twilioApi = undefined;
 
     // Ensure the 'runCommand' function is defined in the child class.
     if (!this.runCommand || typeof this.runCommand !== 'function') {
@@ -46,11 +48,6 @@ class TwilioClientCommand extends BaseCommand {
       }
 
       this.httpClient = new CliRequestClient(this.id, this.logger);
-      this.twilioClient = require('twilio')(this.currentProject.apiKey, this.currentProject.apiSecret, {
-        accountSid: this.currentProject.accountSid,
-        region: this.currentProject.region,
-        httpClient: this.httpClient
-      });
 
       // Run the 'abstract' command executor.
       return await this.runCommand();
@@ -113,6 +110,28 @@ class TwilioClientCommand extends BaseCommand {
 
     return results;
   }
+
+  get twilioClient() {
+    if (!this.twilio) {
+      this.twilio = this.buildClient(require('twilio'));
+    }
+    return this.twilio;
+  }
+
+  get twilioApiClient() {
+    if (!this.twilioApi) {
+      this.twilioApi = this.buildClient(TwilioApiClient);
+    }
+    return this.twilioApi;
+  }
+
+  buildClient(ClientClass) {
+    return new ClientClass(this.currentProject.apiKey, this.currentProject.apiSecret, {
+      accountSid: this.currentProject.accountSid,
+      region: this.currentProject.region,
+      httpClient: this.httpClient
+    });
+  }
 }
 
 TwilioClientCommand.flags = Object.assign(

src/services/api-schema/json-converter.js

@@ -0,0 +1,102 @@
+const { logger } = require('../messaging/logging');
+
+const SCHEMA_TYPE_TO_CONVERT_FUNC_MAP = {
+  array: 'convertArray',
+  boolean: 'convertBoolean',
+  integer: 'convertInteger',
+  number: 'convertNumber',
+  object: 'convertObject',
+  string: 'convertString'
+};
+
+/**
+ * A JSON Schema conversion orchestrator. It accepts a JSON schema and value
+ * and converts any fields that require ... conversion.
+ */
+class JsonSchemaConverter {
+  constructor() {
+    this.logger = logger;
+  }
+
+  convertSchema(schema, value) {
+    if (schema) {
+      const convertFunc = SCHEMA_TYPE_TO_CONVERT_FUNC_MAP[schema.type];
+
+      if (convertFunc) {
+        value = this[convertFunc](schema, value);
+      } else {
+        this.logger.debug(`No conversion function for "${schema.type}" schema type`);
+      }
+    }
+
+    return value;
+  }
+
+  convertArray(schema, value) {
+    if (!value) {
+      if (!schema.nullable) {
+        this.logger.debug('Null array found when nullable not allowed by schema: ' + JSON.stringify(schema));
+      }
+
+      return value;
+    }
+
+    // Recurse into the value using the schema's items schema.
+    return value.map(item => this.convertSchema(schema.items, item));
+  }
+
+  convertObject(schema, value) {
+    const converted = {};
+
+    let properties = schema.properties;
+
+    // If the schema has no properties, it is a free-form object with arbitrary
+    // property/value pairs. We'll map the object's keys to null-schemas so
+    // they'll be processed as-is (i.e., no type so just use the value).
+    if (!properties) {
+      const nameList = Object
+        .keys(value)
+        .map(name => ({ [name]: null }));
+
+      properties = Object.assign({}, ...nameList);
+    }
+
+    // Convert each object property and store it in the converted object, if a
+    // value was provided.
+    Object.entries(properties).forEach(([name, propSchema]) => {
+      const { propName, propValue } = this.convertObjectProperty(propSchema, name, value[name]);
+
+      if (propValue !== undefined) {
+        converted[propName] = propValue;
+      }
+    });
+
+    return converted;
+  }
+
+  convertObjectProperty(propSchema, propName, propValue) {
+    if (propValue !== undefined) {
+      propValue = this.convertSchema(propSchema, propValue);
+    }
+
+    return { propName, propValue };
+  }
+
+  convertBoolean(schema, value) {
+    return value;
+  }
+
+  convertInteger(schema, value) {
+    return value;
+  }
+
+  convertNumber(schema, value) {
+    return value;
+  }
+
+  convertString(schema, value) {
+    return value;
+  }
+}
+
+module.exports = JsonSchemaConverter;

src/services/api-schema/twilio-converter.js

@@ -0,0 +1,56 @@
+const JsonSchemaConverter = require('./json-converter');
+const { camelCase } = require('../naming-conventions');
+
+const STRING_FORMAT_TO_CONVERT_FUNC_MAP = {
+  'date-time': 'convertDateTime',
+  'date-time-rfc-2822': 'convertDateTime',
+  uri: 'convertUri'
+};
+
+/**
+ * A Twilio extension of the JSON Schema converter. We do additional date-time
+ * conversion and also camelCase object property names (keys).
+ */
+class TwilioSchemaConverter extends JsonSchemaConverter {
+  convertObjectProperty(propSchema, propName, propValue) {
+    // Convert the property *and* camelCase the key to make it more JSON-ic.
+    if (propValue !== undefined) {
+      propValue = this.convertSchema(propSchema, propValue);
+    }
+
+    return { propName: camelCase(propName), propValue };
+  }
+
+  convertString(schema, value) {
+    if (schema.format) {
+      const validateFunc = STRING_FORMAT_TO_CONVERT_FUNC_MAP[schema.format];
+
+      if (validateFunc) {
+        value = this[validateFunc](schema, value);
+      } else {
+        this.logger.debug(`No conversion function for "${schema.format}" schema format`);
+      }
+    }
+
+    return value;
+  }
+
+  convertDateTime(schema, value) {
+    // The date constructor accepts both ISO 8601 and RFC 2822 date-time formats.
+    const dateValue = new Date(value);
+
+    if (isNaN(dateValue)) {
+      this.logger.debug(`Date-Time value "${value}" is not properly formatted for "${schema.format}" schema format`);
+      return value;
+    }
+
+    return dateValue;
+  }
+
+  convertUri(schema, value) {
+    // We don't currently do any URI conversion. This just keeps from logging non-helpful debug.
+    return value;
+  }
+}
+
+module.exports = TwilioSchemaConverter;

src/services/cli-http-client.js

@@ -83,6 +83,8 @@ class CliRequestClient {
     this.logger.debug('User-Agent: ' + options.headers['User-Agent']);
     this.logger.debug('-- END Twilio API Request --');
 
+    this.lastRequest = options;
+
     return this.http(options);
   }
 }

src/services/naming-conventions.js

@@ -32,9 +32,12 @@ const capitalize = input => {
   return input.trim().replace(/^[a-z]/, g => g[0].toUpperCase()); // upper the first character
 };
 
+const pascalCase = input => capitalize(camelCase(input));
+
 module.exports = {
   kebabCase,
   camelCase,
   snakeCase,
-  capitalize
+  capitalize,
+  pascalCase
 };