twilio 4.0.1 → 4.0.2

package/lib/base/Version.js

@@ -0,0 +1,335 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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;
+    }
+    get domain() {
+        return this._domain;
+    }
+    /**
+     * Generate absolute url from a uri
+     *
+     * @param uri - uri to transform
+     * @returns transformed url
+     */
+    absoluteUrl(uri) {
+        return this._domain.absoluteUrl(this.relativeUrl(uri));
+    }
+    /**
+     * 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;
+    }
+    /**
+     * 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 || ""),
+        });
+    }
+    /**
+     * 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

@@ -0,0 +1,76 @@
+"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
+ */
+/**
+ * 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
+ */
+function iso8601Date(s) {
+    return parseDate(s, "YYYY-MM-DD");
+}
+exports.iso8601Date = iso8601Date;
+/**
+ * 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
+ */
+function iso8601DateTime(s) {
+    return parseDate(s, "YYYY-MM-DD[T]HH:mm:ss[Z]");
+}
+exports.iso8601DateTime = iso8601DateTime;
+/**
+ * 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
+ */
+function rfc2822DateTime(s) {
+    return parseDate(s, "ddd, DD MMM YYYY HH:mm:ss [+0000]");
+}
+exports.rfc2822DateTime = rfc2822DateTime;
+/**
+ * Parse a string into a decimal
+ *
+ * @param d - Decimal value as string
+ * @returns Number, or the original string if the argument is NaN
+ */
+function decimal(d) {
+    return parseNumber(d, parseFloat);
+}
+exports.decimal = decimal;
+/**
+ * Parse a string into a integer
+ *
+ * @param i - Integer value as string
+ * @returns Number, or the original string if the argument is NaN
+ */
+function integer(i) {
+    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;
+}

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

@@ -0,0 +1,122 @@
+"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
+ */
+/**
+ * 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.
+ */
+function iso8601Date(date) {
+    if (!date || !(date instanceof Date)) {
+        return date;
+    }
+    else {
+        return dayjs_1.default.utc(date).format("YYYY-MM-DD");
+    }
+}
+exports.iso8601Date = iso8601Date;
+/**
+ * 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.
+ */
+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;
+}
+exports.prefixedCollapsibleMap = prefixedCollapsibleMap;
+function object(o) {
+    if (typeof o === "object") {
+        return JSON.stringify(o);
+    }
+    return o;
+}
+exports.object = object;
+/**
+ * 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
+ */
+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;
+/**
+ * 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.
+ */
+function map(input, transform) {
+    if (typeof input === "object" && Array.isArray(input)) {
+        return input.map((element) => transform(element));
+    }
+    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

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * @namespace values
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.of = void 0;
+/**
+ * Removes all undefined values of an object
+ *
+ * @param obj - object to filter
+ * @returns object with no undefined values
+ */
+function of(obj) {
+    return Object.fromEntries(Object.entries(obj).filter((entry) => entry[1] !== undefined));
+}
+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;
+}