twilio 4.6.0 → 4.7.0

package/lib/base/serialize.d.ts

@@ -0,0 +1,53 @@
+import TwiML from "../twiml/TwiML";
+/**
+ * @namespace serialize
+ */
+/**
+ * Turns a Date object into a string if parameter is a Date otherwise returns the parameter
+ *
+ * @param d - date object to format
+ * @returns date formatted in YYYY-MM-DD form, otherwise the
+ * provided parameter.
+ */
+export declare function iso8601Date<T>(date: T | Date): T | string;
+/**
+ * Turns a Date object into a string if parameter is a Date otherwise returns the parameter
+ *
+ * @param  d - date object to format
+ * @returns date formatted in YYYY-MM-DD[T]HH:mm:ss[Z] form, otherwise the
+ * provided parameter.
+ */
+export declare function iso8601DateTime<T>(date: T | Date): T | string;
+/**
+ * Turns a map of params int oa flattened map separated by dots if the parameter is an object, otherwise returns an empty map
+ *
+ * @param m - map to transform
+ * @param prefix - to append to each flattened value
+ * @returns flattened map
+ */
+export declare function prefixedCollapsibleMap<T extends {}>(m: T, prefix?: string): T;
+/**
+ * Turns an object into a JSON string if the parameter is an object, otherwise returns the passed in object
+ *
+ * @param o - json object or array
+ * @returns stringified object
+ */
+export declare function object<T>(o: T): T;
+/**
+ * Coerces a boolean literal into a string
+ *
+ * @param input - boolean or string to be coerced
+ * @returns a string 'true' or 'false' if passed a boolean, else the value
+ */
+export declare function bool(input: string | boolean): string | "true" | "false";
+export declare function twiml(input: TwiML | string): string;
+type MapFunction<TInput, TOutput> = (input: TInput) => TOutput;
+/**
+ * Maps transform over each element in input if input is an array
+ *
+ * @param input - array to map transform over, if not an array then it is
+ * returned as is.
+ * @returns new array with transform applied to each element.
+ */
+export declare function map<TInput, TOutput>(input: Array<TInput>, transform: MapFunction<TInput, TOutput>): Array<TOutput>;
+export {};

package/lib/base/serialize.js

@@ -1,122 +1,122 @@
-'use strict';
-
-var _ = require('lodash');
-var moment = require('moment');
-
-module.exports = {};
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.map = exports.twiml = exports.bool = exports.object = exports.prefixedCollapsibleMap = exports.iso8601DateTime = exports.iso8601Date = void 0;
+const dayjs_1 = __importDefault(require("dayjs"));
+const utc_1 = __importDefault(require("dayjs/plugin/utc"));
+dayjs_1.default.extend(utc_1.default);
 /**
  * @namespace serialize
  */
-
-/**
- * @function iso8601Date
- * @memberOf serialize
- * @description turns a Date object into a string if parameter is a Date
- * otherwise returns the parameter
- *
- * @param  {Date} d date object to format
- * @return {string|object} date formatted in YYYY-MM-DD form
- */
-module.exports.iso8601Date = function(d) {
-  if (_.isUndefined(d) || _.isString(d) || !((d instanceof Date))) {
-    return d;
-  } else {
-    return moment.utc(d).format('YYYY-MM-DD');
-  }
-};
-
 /**
- * @function iso8601DateTime
- * @memberOf serialize
- * @description turns a Date object into a string if parameter is a Date
- * otherwise returns the parameter
+ * Turns a Date object into a string if parameter is a Date otherwise returns the parameter
  *
- * @param  {Date} d date object to format
- * @return {string|object} date formatted in YYYY-MM-DD[T]HH:mm:ss[Z] form
+ * @param d - date object to format
+ * @returns date formatted in YYYY-MM-DD form, otherwise the
+ * provided parameter.
  */
-module.exports.iso8601DateTime = function(d) {
-  if (_.isUndefined(d) || _.isString(d) || !(d instanceof Date)) {
-    return d;
-  } else {
-    return moment.utc(d).format('YYYY-MM-DD[T]HH:mm:ss[Z]');
-  }
-};
-
+function iso8601Date(date) {
+    if (!date || !(date instanceof Date)) {
+        return date;
+    }
+    else {
+        return dayjs_1.default.utc(date).format("YYYY-MM-DD");
+    }
+}
+exports.iso8601Date = iso8601Date;
 /**
- * @function prefixedCollapsibleMap
- * @memberOf serialize
- * @description turns a map of params int oa flattened map separated by dots
- * if the parameter is an object, otherwise returns an empty map
+ * Turns a Date object into a string if parameter is a Date otherwise returns the parameter
  *
- * @param {object} m map to transform
- * @param {string|undefined} prefix to append to each flattened value
- * @return {object} flattened map
+ * @param  d - date object to format
+ * @returns date formatted in YYYY-MM-DD[T]HH:mm:ss[Z] form, otherwise the
+ * provided parameter.
  */
-module.exports.prefixedCollapsibleMap = function(m, prefix) {
-  if (_.isUndefined(m) || !_.isPlainObject(m)) {
-    return {};
-  }
-
-  function flatten(m, result, previous) {
-    result = result || {};
-    previous = previous || [];
-
-    _.each(_.keys(m), function(key) {
-      if (_.isPlainObject(m[key])) {
-        flatten(m[key], result, _.union(previous, [key]));
-      } else {
-        result[_.join(_.union(previous, [key]), '.')] = m[key];
-      }
-    });
-
+function iso8601DateTime(date) {
+    if (!date || !(date instanceof Date)) {
+        return date;
+    }
+    else {
+        return dayjs_1.default.utc(date).format("YYYY-MM-DD[T]HH:mm:ss[Z]");
+    }
+}
+exports.iso8601DateTime = iso8601DateTime;
+function prefixedCollapsibleMap(m, prefix) {
+    if (!m ||
+        typeof m !== "object" ||
+        Object.prototype.toString.call(m) !== "[object Object]") {
+        return {};
+    }
+    function flatten(m, result, previous) {
+        result = result || {};
+        previous = previous || [];
+        Object.keys(m).forEach((key) => {
+            const unionKeys = [...previous];
+            if (!unionKeys.includes(key)) {
+                unionKeys.push(key);
+            }
+            if (typeof m[key] === "object" &&
+                Object.prototype.toString.call(m[key]) === "[object Object]") {
+                flatten(m[key], result, unionKeys);
+            }
+            else {
+                result[unionKeys.join(".")] = m[key];
+            }
+        });
+        return result;
+    }
+    var flattened = flatten(m);
+    var result = flattened;
+    if (prefix) {
+        result = {};
+        Object.keys(flattened).forEach((key) => {
+            result[prefix + "." + key] = flattened[key];
+        });
+    }
     return result;
-  }
-
-  var flattened = flatten(m);
-  var result = flattened;
-  if (prefix) {
-    result = {};
-    _.each(_.keys(flattened), function(key) {
-      result[prefix + '.' + key] = flattened[key];
-    });
-  }
-
-  return result;
-};
-
+}
+exports.prefixedCollapsibleMap = prefixedCollapsibleMap;
+function object(o) {
+    if (typeof o === "object") {
+        return JSON.stringify(o);
+    }
+    return o;
+}
+exports.object = object;
 /**
- * @function object
- * @memberOf serialize
- * @description turns an object into a JSON string if the parameter
- * is an object, otherwise returns the passed in object
+ * Coerces a boolean literal into a string
  *
- * @param {object|array} o json object or array
- * @returns {string|object} stringified object
+ * @param input - boolean or string to be coerced
+ * @returns a string 'true' or 'false' if passed a boolean, else the value
  */
-module.exports.object = function(o) {
-  if (_.isObject(o) || _.isArray(o)) {
-    return JSON.stringify(o);
-  }
-
-  return o;
-};
-
+function bool(input) {
+    if (typeof input === "string") {
+        return input;
+    }
+    if (typeof input === "boolean" ||
+        (typeof input === "object" &&
+            Object.prototype.toString.call(input) === "[object Boolean]")) {
+        return input.toString();
+    }
+    return input;
+}
+exports.bool = bool;
+function twiml(input) {
+    return input.toString();
+}
+exports.twiml = twiml;
 /**
- * @function bool
- * @memberOf serialize
- * @description coerces a boolean literal into a string
+ * Maps transform over each element in input if input is an array
  *
- * @param {boolean|string} input boolean or string to be coerced
- * @returns {string} a string "true" or "false"
+ * @param input - array to map transform over, if not an array then it is
+ * returned as is.
+ * @returns new array with transform applied to each element.
  */
-module.exports.bool = function(input) {
-  if (_.isString(input)) {
+function map(input, transform) {
+    if (typeof input === "object" && Array.isArray(input)) {
+        return input.map((element) => transform(element));
+    }
     return input;
-  }
-  if(_.isBoolean(input)) {
-    return input.toString();
-  }
-
-  return input;
-};
+}
+exports.map = map;

package/lib/base/utility.d.ts

@@ -0,0 +1,2 @@
+export declare const trim: (str: string, c?: string) => string;
+export declare function isValidPathParam(param: any): boolean;

package/lib/base/utility.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidPathParam = exports.trim = void 0;
+const INVALID_PATH_PARAM_CHARS = ["/", "?"];
+const trim = (str, c = "\\s") => str.replace(new RegExp(`^([${c}]*)(.*?)([${c}]*)$`), "$2");
+exports.trim = trim;
+function isValidPathParam(param) {
+    if (param === null || param === undefined)
+        return false;
+    const paramString = param.toString();
+    return INVALID_PATH_PARAM_CHARS.every((invalidChar) => !paramString.includes(invalidChar));
+}
+exports.isValidPathParam = isValidPathParam;

package/lib/base/values.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @namespace values
+ */
+/**
+ * Removes all undefined values of an object
+ *
+ * @param obj - object to filter
+ * @returns object with no undefined values
+ */
+export declare function of(obj: Object): Object;

package/lib/base/values.js

@@ -1,22 +1,16 @@
-'use strict';
-var _ = require('lodash');
-
+"use strict";
 /**
  * @namespace values
  */
-
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.of = void 0;
 /**
- * @function of
- * @memberOf values
- * @description removes all undefined values of an object
+ * Removes all undefined values of an object
  *
- * @param  {object} obj object to filter
- * @return {object} object with no undefined values
+ * @param obj - object to filter
+ * @returns object with no undefined values
  */
 function of(obj) {
-  return _.omitBy(obj, _.isUndefined);
+    return Object.fromEntries(Object.entries(obj).filter((entry) => entry[1] !== undefined));
 }
-
-module.exports = {
-  of: of,
-};
+exports.of = of;

package/lib/http/request.d.ts

@@ -0,0 +1,25 @@
+import { HttpMethod } from "../interfaces";
+export interface RequestOptions<TData> {
+    method?: HttpMethod | "*";
+    url?: string;
+    auth?: string;
+    params?: object | "*";
+    data?: TData | "*";
+    headers?: Headers;
+}
+export interface Headers {
+    [header: string]: string;
+}
+export default class Request<TData> {
+    method: HttpMethod | "*";
+    url: string;
+    auth: string;
+    params: object | "*";
+    data: TData | "*";
+    headers: Headers | "*";
+    constructor(opts?: RequestOptions<TData>);
+    get ANY(): "*";
+    attributeEqual(lhs: any, rhs: any): boolean;
+    isEqual(other: Request<any>): boolean;
+    toString(): string;
+}

package/lib/http/request.js

@@ -1,74 +1,85 @@
-'use strict';
-
-var _ = require('lodash');
-
-var Request = function(opts) {
-  opts = opts || {};
-
-  this.method = opts.method || this.ANY;
-  this.url = opts.url || this.ANY;
-  this.auth = opts.auth || this.ANY;
-  this.params = opts.params || this.ANY;
-  this.data = opts.data || this.ANY;
-  this.headers = opts.headers || this.ANY;
-};
-
-Request.prototype.ANY = '*';
-
-Request.prototype.attributeEqual = function(lhs, rhs) {
-  if (lhs === this.ANY || rhs === this.ANY) {
-    return true;
-  }
-
-  lhs = lhs || undefined;
-  rhs = rhs || undefined;
-
-  return _.isEqual(lhs, rhs);
-};
-
-Request.prototype.isEqual = function(other) {
-  return (this.attributeEqual(this.method, other.method) &&
-      this.attributeEqual(this.url, other.url) &&
-      this.attributeEqual(this.auth, other.auth) &&
-      this.attributeEqual(this.params, other.params) &&
-      this.attributeEqual(this.data, other.data) &&
-      this.attributeEqual(this.headers, other.headers));
-};
-
-Request.prototype.toString = function() {
-  var auth = '';
-  if (this.auth && this.auth !== this.ANY) {
-    auth = this.auth + ' ';
-  }
-
-  var params = '';
-  if (this.params && this.params !== this.ANY) {
-    params = '?' + _.join(_.chain(_.keys(this.params))
-        .map(function(key) { return key + '=' + this.params[key]; }.bind(this))
-        .value(), '&');
-  }
-
-  var data = '';
-  if (this.data && this.data !== this.ANY) {
-    if (this.method === 'GET') {
-      data = '\n -G';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Request {
+    constructor(opts) {
+        opts = opts || {};
+        this.method = opts.method || this.ANY;
+        this.url = opts.url || this.ANY;
+        this.auth = opts.auth || this.ANY;
+        this.params = opts.params || this.ANY;
+        this.data = opts.data || this.ANY;
+        this.headers = opts.headers || this.ANY;
     }
-
-    data = data + '\n' + _.join(
-      _.map(this.data, function(value, key) {
-        return ' -d ' + key + '='  + value;
-      }), '\n');
-  }
-
-  var headers = '';
-  if (this.headers && this.headers !== this.ANY) {
-    headers = '\n' + _.join(
-      _.map(this.headers, function(value, key) {
-        return ' -H ' + key + '='  + value;
-      }), '\n');
-  }
-
-  return auth + this.method + ' ' + this.url + params + data + headers;
-};
-
-module.exports = Request;
+    get ANY() {
+        return "*";
+    }
+    attributeEqual(lhs, rhs) {
+        if (lhs === this.ANY || rhs === this.ANY) {
+            return true;
+        }
+        lhs = lhs || undefined;
+        rhs = rhs || undefined;
+        if (typeof lhs !== typeof rhs) {
+            return false;
+        }
+        if (typeof lhs !== "object") {
+            return lhs === rhs;
+        }
+        return (Object.entries(lhs)
+            .sort((a, b) => a[0].localeCompare(b[0]))
+            .toString() ===
+            Object.entries(rhs)
+                .sort((a, b) => a[0].localeCompare(b[0]))
+                .toString());
+    }
+    isEqual(other) {
+        return (this.attributeEqual(this.method, other.method) &&
+            this.attributeEqual(this.url, other.url) &&
+            this.attributeEqual(this.auth, other.auth) &&
+            this.attributeEqual(this.params, other.params) &&
+            this.attributeEqual(this.data, other.data) &&
+            this.attributeEqual(this.headers, other.headers));
+    }
+    toString() {
+        var auth = "";
+        if (this.auth && this.auth !== this.ANY) {
+            auth = this.auth + " ";
+        }
+        var params = "";
+        if (this.params && this.params !== this.ANY) {
+            params =
+                "?" +
+                    Object.keys(this.params)
+                        .map((key) => function () {
+                        return key + "=" + this.params[key];
+                    }.bind(this)())
+                        .join("&");
+        }
+        var data = "";
+        if (this.data && this.data !== this.ANY) {
+            if (this.method === "get") {
+                data = "\n -G";
+            }
+            data =
+                data +
+                    "\n" +
+                    Object.entries(this.data)
+                        .map((d) => {
+                        return " -d " + d[0] + "=" + d[1];
+                    })
+                        .join("\n");
+        }
+        var headers = "";
+        if (this.headers && this.headers !== this.ANY) {
+            headers =
+                "\n" +
+                    Object.entries(this.headers)
+                        .map((header) => {
+                        return " -H " + header[0] + "=" + header[1];
+                    })
+                        .join("\n");
+        }
+        return auth + this.method + " " + this.url + params + data + headers;
+    }
+}
+exports.default = Request;

package/lib/http/response.d.ts

@@ -0,0 +1,7 @@
+export default class Response<TPayload> {
+    statusCode: number;
+    body: TPayload;
+    headers: any;
+    constructor(statusCode: number, body: TPayload, headers: any);
+    toString(): string;
+}

package/lib/http/response.js

@@ -1,12 +1,13 @@
-'use strict';
-
-var Response = function(statusCode, body) {
-  this.statusCode = statusCode;
-  this.body = body;
-};
-
-Response.prototype.toString = function() {
-  return 'HTTP ' + this.statusCode + ' ' + this.body;
-};
-
-module.exports = Response;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Response {
+    constructor(statusCode, body, headers) {
+        this.statusCode = statusCode;
+        this.body = body;
+        this.headers = headers;
+    }
+    toString() {
+        return "HTTP " + this.statusCode + " " + this.body;
+    }
+}
+exports.default = Response;

package/lib/index.d.ts

@@ -0,0 +1,39 @@
+import Twilio from "./rest/Twilio";
+import * as webhooks from "./webhooks/webhooks";
+import RequestClient from "./base/RequestClient";
+import { ClientOpts } from "./base/BaseTwilio";
+import AccessToken from "./jwt/AccessToken";
+import ClientCapability from "./jwt/ClientCapability";
+import TaskRouterCapability from "./jwt/taskrouter/TaskRouterCapability";
+import * as taskRouterUtil from "./jwt/taskrouter/util";
+import VoiceResponse from "./twiml/VoiceResponse";
+import MessagingResponse from "./twiml/MessagingResponse";
+import FaxResponse from "./twiml/FaxResponse";
+interface TwilioSDK extends Function {
+    (accountSid?: string, authToken?: string, opts?: ClientOpts): Twilio;
+    Twilio: typeof Twilio;
+    jwt: {
+        AccessToken: typeof AccessToken;
+        ClientCapability: typeof ClientCapability;
+        taskrouter: {
+            TaskRouterCapability: typeof TaskRouterCapability;
+            util: typeof taskRouterUtil;
+        };
+    };
+    twiml: {
+        VoiceResponse: typeof VoiceResponse;
+        MessagingResponse: typeof MessagingResponse;
+        FaxResponse: typeof FaxResponse;
+    };
+    RequestClient: typeof RequestClient;
+    validateBody: typeof webhooks.validateBody;
+    validateRequest: typeof webhooks.validateRequest;
+    validateRequestWithBody: typeof webhooks.validateRequestWithBody;
+    validateExpressRequest: typeof webhooks.validateExpressRequest;
+    validateIncomingRequest: typeof webhooks.validateIncomingRequest;
+    getExpectedBodyHash: typeof webhooks.getExpectedBodyHash;
+    getExpectedTwilioSignature: typeof webhooks.getExpectedTwilioSignature;
+    webhook: typeof webhooks.webhook;
+}
+declare var initializer: TwilioSDK;
+export = initializer;