twilio 4.6.0 → 4.7.0

package/lib/base/Version.js

@@ -1,177 +1,335 @@
-'use strict';
-var _ = require('lodash');
-var RestException = require('./RestException');
-
-/**
- * @constructor
- *
- * @description Base version object
- *
- * @param {Domain} domain twilio domain
- * @param {Version} version api version
- */
-function Version(domain, version) {
-  this._domain = domain;
-  this._version = version;
-}
-
-/**
- * Generate absolute url from a uri
- *
- * @param  {string} uri uri to transform
- * @return {string} transformed url
- */
-Version.prototype.absoluteUrl = function(uri) {
-  return this._domain.absoluteUrl(this.relativeUrl(uri));
-};
-
-/**
- * Generate relative url from a uri
- *
- * @param  {string} uri uri to transform
- * @return {string} transformed url
- */
-Version.prototype.relativeUrl = function(uri) {
-  return _.trim(this._version, '/') + '/' + _.trim(uri, '/');
-};
-
-/**
- * Make a request against the domain
- *
- * @param  {object} opts request options
- * @return {Promise} promise that resolves to request response
- */
-Version.prototype.request = function(opts) {
-  return this._domain.request(_.assign({}, opts, {
-    uri: this.relativeUrl(opts.uri),
-  }));
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-
-/**
- * Fetch a instance of a record
- * @throws {Error} If response returns non 2xx status code
- *
- * @param  {object} opts request options
- * @return {Promise} promise that resolves to fetched result
- */
-Version.prototype.fetch = function(opts) {
-  var qResponse = this.request(opts);
-
-  qResponse = qResponse.then(
-    function success(response) {
-      if (response.statusCode < 200 || response.statusCode >= 300) {
-        throw new RestException(response);
-      }
-
-      return JSON.parse(response.body);
+Object.defineProperty(exports, "__esModule", { value: true });
+const RestException_1 = __importDefault(require("./RestException"));
+const utility_1 = require("./utility");
+class Version {
+    /**
+     *
+     * Base version object
+     *
+     * @param domain - twilio domain
+     * @param version - api version
+     */
+    constructor(domain, version) {
+        this._domain = domain;
+        this._version = version;
     }
-  );
-
-  return qResponse;
-};
-
-/**
- * Update a record
- * @throws {Error} If response returns non 2xx status code
- *
- * @param  {object} opts request options
- * @return {Promise} promise that resolves to updated result
- */
-Version.prototype.update = function(opts) {
-  var qResponse = this.request(opts);
-  qResponse = qResponse.then(
-    function success(response) {
-      if (response.statusCode < 200 || response.statusCode >= 300) {
-        throw new RestException(response);
-      }
-
-      return JSON.parse(response.body);
+    get domain() {
+        return this._domain;
     }
-  );
-
-  return qResponse;
-};
-
-/**
- * Delete a record
- * @throws {Error} If response returns a 5xx status
- *
- * @param  {object} opts request options
- * @return {Promise} promise that resolves to true if record was deleted
- */
-Version.prototype.remove = function(opts) {
-  var qResponse = this.request(opts);
-  qResponse = qResponse.then(
-    function success(response) {
-      if (response.statusCode < 200 || response.statusCode >= 300) {
-        throw new RestException(response);
-      }
-
-      return response.statusCode === 204;
+    /**
+     * Generate absolute url from a uri
+     *
+     * @param uri - uri to transform
+     * @returns transformed url
+     */
+    absoluteUrl(uri) {
+        return this._domain.absoluteUrl(this.relativeUrl(uri));
     }
-  );
-
-  return qResponse;
-};
-
-/**
- * Create a new record
- * @throws {Error} If response returns non 2xx or 201 status code
- *
- * @param  {object} opts request options
- * @return {Promise} promise that resolves to created record
- */
-Version.prototype.create = function(opts) {
-  var qResponse = this.request(opts);
-  qResponse = qResponse.then(
-    function success(response) {
-      if (response.statusCode < 200 || response.statusCode >= 300) {
-        throw new RestException(response);
-      }
-
-      return JSON.parse(response.body);
+    /**
+     * Generate relative url from a uri
+     *
+     * @param uri - uri to transform
+     * @returns transformed url
+     */
+    relativeUrl(uri) {
+        var result = "";
+        if (typeof this._version === "string") {
+            const version = (0, utility_1.trim)(this._version, "/");
+            result += version;
+            result += "/";
+        }
+        if (typeof uri === "string") {
+            uri = (0, utility_1.trim)(uri, "/");
+            if (result === "") {
+                result += "/";
+            }
+            result += uri;
+        }
+        return result;
     }
-  );
-
-  return qResponse;
-};
-
-/**
- * Fetch a page of records
- *
- * @param  {object} opts request options
- * @return {Promise} promise that resolves to page of records
- */
-Version.prototype.page = function(opts) {
-  return this.request(opts);
-};
-
-/**
- * Process limits for list requests
- *
- * @param {object} [opts] ...
- * @param {number} [opts.limit] The maximum number of items to fetch
- * @param {number} [opts.pageSize] The maximum number of items to return
- *                                  with every request
- */
-Version.prototype.readLimits = function(opts) {
-  var limit = opts.limit;
-  var pageLimit;
-  var pageSize = opts.pageSize;
-
-  if (limit) {
-    if (!pageSize) {
-      pageSize = limit;
+    /**
+     * Make a request against the domain
+     *
+     * @param opts - request options
+     * @returns promise that resolves to request response
+     */
+    request(opts) {
+        return this._domain.request({
+            ...opts,
+            uri: this.relativeUrl(opts.uri || ""),
+        });
     }
-
-    pageLimit = parseInt(Math.ceil(limit / parseFloat(pageSize)), 10);
-  }
-
-  return {
-    limit: limit,
-    pageSize: pageSize,
-    pageLimit: pageLimit,
-  };
-};
-
-module.exports = Version;
+    /**
+     * Create a new record
+     *
+     * @param opts - request options
+     *
+     * @throws Error If response returns non 2xx or 201 status code
+     *
+     * @returns promise that resolves to created record
+     */
+    create(opts) {
+        var qResponse = this.request(opts);
+        qResponse = qResponse.then(function success(response) {
+            if (response.statusCode < 200 || response.statusCode >= 300) {
+                throw new RestException_1.default(response);
+            }
+            if (typeof response.body === "string") {
+                return JSON.parse(response.body);
+            }
+            return response.body;
+        });
+        return qResponse;
+    }
+    /**
+     * Fetch an instance of a record
+     *
+     * @param opts - request options
+     *
+     * @throws Error If response returns non 2xx or 3xx status code
+     *
+     * @returns promise that resolves to fetched result
+     */
+    fetch(opts) {
+        var qResponse = this.request(opts);
+        qResponse = qResponse.then(function success(response) {
+            if (response.statusCode < 200 || response.statusCode >= 400) {
+                throw new RestException_1.default(response);
+            }
+            if (typeof response.body === "string") {
+                return JSON.parse(response.body);
+            }
+            return response.body;
+        });
+        return qResponse;
+    }
+    /**
+     * Fetch a page of records
+     *
+     * @param opts - request options
+     * @returns promise that resolves to page of records
+     */
+    page(opts) {
+        return this.request(opts);
+    }
+    /**
+     * Update a record
+     *
+     * @param opts - request options
+     *
+     * @throws Error If response returns non 2xx status code
+     *
+     * @returns promise that resolves to updated result
+     */
+    update(opts) {
+        var qResponse = this.request(opts);
+        qResponse = qResponse.then(function success(response) {
+            if (response.statusCode < 200 || response.statusCode >= 300) {
+                throw new RestException_1.default(response);
+            }
+            if (typeof response.body === "string") {
+                return JSON.parse(response.body);
+            }
+            return response.body;
+        });
+        return qResponse;
+    }
+    /**
+     * Delete a record
+     *
+     * @param opts - request options
+     *
+     * @throws Error If response returns a 5xx status
+     *
+     * @returns promise that resolves to true if record was deleted
+     */
+    remove(opts) {
+        var qResponse = this.request(opts);
+        qResponse = qResponse.then(function success(response) {
+            if (response.statusCode < 200 || response.statusCode >= 300) {
+                throw new RestException_1.default(response);
+            }
+            return response.statusCode === 204;
+        });
+        return qResponse;
+    }
+    /**
+     * Process limits for list requests
+     *
+     * @param opts.limit - The maximum number of items to fetch
+     * @param opts.pageSize - The maximum number of items to return with every request
+     *
+     */
+    readLimits(opts) {
+        var limit = opts.limit;
+        var pageSize = opts.pageSize;
+        if ((limit && !Number.isFinite(limit)) || limit <= 0) {
+            throw new TypeError("Parameter limit must be a positive integer");
+        }
+        if (pageSize && (!Number.isFinite(pageSize) || pageSize <= 0)) {
+            throw new TypeError("Parameter pageSize must be a positive integer");
+        }
+        if (limit && !pageSize) {
+            pageSize = limit;
+        }
+        return {
+            limit: limit,
+            pageSize: pageSize,
+        };
+    }
+    setPromiseCallback(operationPromise, callback) {
+        if (typeof callback === "function") {
+            operationPromise = operationPromise
+                .then((value) => callback(null, value))
+                .catch((error) => callback(error));
+        }
+        return operationPromise;
+    }
+    /**
+     * For each record instance, executes a provided callback function with that
+     * instance
+     *
+     * @param params - Parameters (Optional)
+     * @param params.limit - Optional maximum number of record instances to
+     *  fetch
+     * @param params.pageSize - Optional maximum number of records to return
+     *  with every request
+     * @param params.callback - Callback function to call with each
+     *  record instance
+     * @param params.done - Optional done function to call when all
+     *  records are processed, the limit is reached, or an error occurs.
+     *  Receives an error argument if an error occurs.
+     * @param callback - Callback function to call with each record.
+     *  Receives a done function argument that will short-circuit the for-each
+     *  loop that may accept an error argument.
+     * @returns Returns a promise that resolves when all records
+     *  processed or if the limit is reached, and rejects with an error if an
+     *  error occurs and is not handled in the user provided done function.
+     */
+    each(params, callback) {
+        if (typeof params === "function") {
+            callback = params;
+            params = {};
+        }
+        else {
+            params = params || {};
+        }
+        if (params.callback) {
+            callback = params.callback;
+        }
+        if (typeof callback === "undefined") {
+            throw new Error("Callback function must be provided");
+        }
+        let done = false;
+        let doneCalled = false;
+        let currentPage = 1;
+        let currentResource = 0;
+        let limits = {};
+        let pPending = true;
+        let pResolve;
+        let pReject;
+        if (this._version instanceof Version) {
+            limits = this._version.readLimits({
+                limit: params.limit,
+                pageSize: params.pageSize,
+            });
+        }
+        function onComplete(error) {
+            let unhandledError = error;
+            done = true;
+            if (typeof params.done === "function" && !doneCalled) {
+                try {
+                    params.done(unhandledError);
+                    unhandledError = null;
+                }
+                catch (e) {
+                    unhandledError = e;
+                }
+            }
+            doneCalled = true;
+            if (pPending) {
+                if (unhandledError) {
+                    pReject(unhandledError);
+                }
+                else {
+                    pResolve();
+                }
+                pPending = false;
+            }
+        }
+        function fetchNextPage(fn) {
+            let promise = fn();
+            if (typeof promise === "undefined") {
+                onComplete();
+                return;
+            }
+            promise.then((page) => {
+                try {
+                    page.instances.forEach(function (instance) {
+                        if (done ||
+                            (typeof params.limit !== "undefined" &&
+                                currentResource >= params.limit)) {
+                            done = true;
+                            return false;
+                        }
+                        currentResource++;
+                        callback?.(instance, onComplete);
+                    });
+                }
+                catch (e) {
+                    return onComplete(e);
+                }
+                if (!done) {
+                    currentPage++;
+                    fetchNextPage(page.nextPage.bind(page));
+                }
+                else {
+                    onComplete();
+                }
+            });
+            promise.catch(onComplete);
+        }
+        return new Promise((resolve, reject) => {
+            pResolve = resolve;
+            pReject = reject;
+            fetchNextPage(this.page.bind(this, Object.assign(params, limits)));
+        });
+    }
+    list(params, callback) {
+        if (typeof params === "function") {
+            callback = params;
+            params = {};
+        }
+        else {
+            params = params || {};
+        }
+        let allResources = [];
+        params.callback = function (resource, done) {
+            allResources.push(resource);
+            if (typeof params.limit !== "undefined" &&
+                allResources.length === params.limit) {
+                done();
+            }
+        };
+        let operationPromise = new Promise((resolve, reject) => {
+            params.done = function (error) {
+                if (typeof error === "undefined") {
+                    resolve(allResources);
+                }
+                else {
+                    reject(error);
+                }
+            };
+        });
+        if (this._version instanceof Version) {
+            operationPromise = this._version.setPromiseCallback(operationPromise, callback);
+        }
+        this.each(params);
+        return operationPromise;
+    }
+}
+exports.default = Version;

package/lib/base/deserialize.d.ts

@@ -0,0 +1,41 @@
+export interface NumberParser {
+    (n: string): number;
+}
+/**
+ * @namespace deserialize
+ */
+/**
+ * Parse a string into a Date object
+ *
+ * @param s - Date string in YYYY-MM-DD format
+ * @returns Date object, or the original date string if the argument is not a valid date
+ */
+export declare function iso8601Date(s: string): string | Date;
+/**
+ * Parse a string into a Date object
+ *
+ * @param s - Date string in YYYY-MM-DD[T]HH:mm:ss[Z] format
+ * @returns Date object, or the original date string if the argument is not a valid date
+ */
+export declare function iso8601DateTime(s: string): string | Date;
+/**
+ * Parse a string into a Date object
+ *
+ * @param s - Date string in ddd, DD MMM YYYY HH:mm:ss [+0000] format
+ * @returns Date object, or the original date string if the argument is not a valid date
+ */
+export declare function rfc2822DateTime(s: string): string | Date;
+/**
+ * Parse a string into a decimal
+ *
+ * @param d - Decimal value as string
+ * @returns Number, or the original string if the argument is NaN
+ */
+export declare function decimal(d: string): string | number;
+/**
+ * Parse a string into a integer
+ *
+ * @param i - Integer value as string
+ * @returns Number, or the original string if the argument is NaN
+ */
+export declare function integer(i: string): string | number;

package/lib/base/deserialize.js

@@ -1,94 +1,76 @@
-'use strict';
-
-var _ = require('lodash');
-var moment = require('moment');
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.integer = exports.decimal = exports.rfc2822DateTime = 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 deserialize
  */
-
-function parseDate(s, format) {
-  var m = moment.utc(s, format);
-  if (m.isValid()) {
-    return m.toDate();
-  }
-
-  return s;
-}
-
-function parseNumber(n, parser) {
-  var parsed = parser(n);
-  if (isNaN(parsed)) {
-    return n;
-  }
-
-  return parsed;
-}
-
 /**
- * @function iso8601Date
- * @memberOf deserialize
- * @description parse a string into a Date object
+ * Parse a string into a Date object
  *
- * @param  {string} s date string in YYYY-MM-DD format
- * @return {Date} Date object
+ * @param s - Date string in YYYY-MM-DD format
+ * @returns Date object, or the original date string if the argument is not a valid date
  */
 function iso8601Date(s) {
-  return parseDate(s, 'YYYY-MM-DD');
+    return parseDate(s, "YYYY-MM-DD");
 }
-
+exports.iso8601Date = iso8601Date;
 /**
- * @function iso8601DateTime
- * @memberOf deserialize
- * @description parse a string into a Date object
+ * Parse a string into a Date object
  *
- * @param  {String} s date string in YYYY-MM-DD[T]HH:mm:ss[Z] format
- * @return {Date} Date object
+ * @param s - Date string in YYYY-MM-DD[T]HH:mm:ss[Z] format
+ * @returns Date object, or the original date string if the argument is not a valid date
  */
 function iso8601DateTime(s) {
-  return parseDate(s, 'YYYY-MM-DD[T]HH:mm:ss[Z]');
+    return parseDate(s, "YYYY-MM-DD[T]HH:mm:ss[Z]");
 }
-
+exports.iso8601DateTime = iso8601DateTime;
 /**
- * @function rfc2822DateTime
- * @memberOf deserialize
- * @description parse a string into a Date object
+ * Parse a string into a Date object
  *
- * @param  {String} s date string in ddd, DD MMM YYYY HH:mm:ss [+0000] format
- * @return {Date} Date object
+ * @param s - Date string in ddd, DD MMM YYYY HH:mm:ss [+0000] format
+ * @returns Date object, or the original date string if the argument is not a valid date
  */
 function rfc2822DateTime(s) {
-  return parseDate(s, 'ddd, DD MMM YYYY HH:mm:ss [+0000]');
+    return parseDate(s, "ddd, DD MMM YYYY HH:mm:ss [+0000]");
 }
-
+exports.rfc2822DateTime = rfc2822DateTime;
 /**
- * @function decimal
- * @memberOf deserialize
- * @description parse a string into a decimal
+ * Parse a string into a decimal
  *
- * @param  {string} d decimal value as string
- * @return {number} number object
+ * @param d - Decimal value as string
+ * @returns Number, or the original string if the argument is NaN
  */
 function decimal(d) {
-  return parseNumber(d, parseFloat);
+    return parseNumber(d, parseFloat);
 }
-
+exports.decimal = decimal;
 /**
- * @function integer
- * @memberOf deserialize
- * @description parse a string into a integer
+ * Parse a string into a integer
  *
- * @param  {string} i integer value as string
- * @return {number} number object
+ * @param i - Integer value as string
+ * @returns Number, or the original string if the argument is NaN
  */
 function integer(i) {
-  return parseNumber(i, _.parseInt);
+    return parseNumber(i, parseInt);
+}
+exports.integer = integer;
+function parseDate(s, format) {
+    var m = dayjs_1.default.utc(s, format);
+    if (m.isValid()) {
+        return m.toDate();
+    }
+    return s;
+}
+function parseNumber(n, parser) {
+    var parsed = parser(n);
+    if (typeof parsed === "number" && isNaN(parsed)) {
+        return n;
+    }
+    return parsed;
 }
-
-module.exports = {
-  iso8601Date: iso8601Date,
-  iso8601DateTime: iso8601DateTime,
-  rfc2822DateTime: rfc2822DateTime,
-  decimal: decimal,
-  integer: integer,
-};