twilio 5.11.0 → 5.11.2

package/lib/auth_strategy/AuthStrategy.d.ts

@@ -0,0 +1,7 @@
+export default abstract class AuthStrategy {
+    private authType;
+    protected constructor(authType: string);
+    getAuthType(): string;
+    abstract getAuthString(): Promise<string>;
+    abstract requiresAuthentication(): boolean;
+}

package/lib/auth_strategy/AuthStrategy.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class AuthStrategy {
+    constructor(authType) {
+        this.authType = authType;
+    }
+    getAuthType() {
+        return this.authType;
+    }
+}
+exports.default = AuthStrategy;

package/lib/auth_strategy/BasicAuthStrategy.d.ts

@@ -0,0 +1,8 @@
+import AuthStrategy from "./AuthStrategy";
+export default class BasicAuthStrategy extends AuthStrategy {
+    private username;
+    private password;
+    constructor(username: string, password: string);
+    getAuthString(): Promise<string>;
+    requiresAuthentication(): boolean;
+}

package/lib/auth_strategy/BasicAuthStrategy.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const AuthStrategy_1 = __importDefault(require("./AuthStrategy"));
+class BasicAuthStrategy extends AuthStrategy_1.default {
+    constructor(username, password) {
+        super("basic");
+        this.username = username;
+        this.password = password;
+    }
+    getAuthString() {
+        const auth = Buffer.from(this.username + ":" + this.password).toString("base64");
+        return Promise.resolve(`Basic ${auth}`);
+    }
+    requiresAuthentication() {
+        return true;
+    }
+}
+exports.default = BasicAuthStrategy;

package/lib/auth_strategy/NoAuthStrategy.d.ts

@@ -0,0 +1,6 @@
+import AuthStrategy from "./AuthStrategy";
+export default class NoAuthStrategy extends AuthStrategy {
+    constructor();
+    getAuthString(): Promise<string>;
+    requiresAuthentication(): boolean;
+}

package/lib/auth_strategy/NoAuthStrategy.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const AuthStrategy_1 = __importDefault(require("./AuthStrategy"));
+class NoAuthStrategy extends AuthStrategy_1.default {
+    constructor() {
+        super("noauth");
+    }
+    getAuthString() {
+        return Promise.resolve("");
+    }
+    requiresAuthentication() {
+        return false;
+    }
+}
+exports.default = NoAuthStrategy;

package/lib/auth_strategy/TokenAuthStrategy.d.ts

@@ -0,0 +1,16 @@
+import AuthStrategy from "./AuthStrategy";
+import TokenManager from "../http/bearer_token/TokenManager";
+export default class TokenAuthStrategy extends AuthStrategy {
+    private token;
+    private tokenManager;
+    constructor(tokenManager: TokenManager);
+    getAuthString(): Promise<string>;
+    requiresAuthentication(): boolean;
+    fetchToken(): Promise<string>;
+    /**
+     * Function to check if the token is expired with a buffer of 30 seconds.
+     * @param token - The JWT token as a string.
+     * @returns Boolean indicating if the token is expired.
+     */
+    isTokenExpired(token: string): boolean;
+}

package/lib/auth_strategy/TokenAuthStrategy.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const AuthStrategy_1 = __importDefault(require("./AuthStrategy"));
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+class TokenAuthStrategy extends AuthStrategy_1.default {
+    constructor(tokenManager) {
+        super("token");
+        this.token = "";
+        this.tokenManager = tokenManager;
+    }
+    async getAuthString() {
+        return this.fetchToken()
+            .then((token) => {
+            this.token = token;
+            return `Bearer ${this.token}`;
+        })
+            .catch((error) => {
+            throw new Error(`Failed to fetch access token: ${error.message}`);
+        });
+    }
+    requiresAuthentication() {
+        return true;
+    }
+    async fetchToken() {
+        if (this.token == null ||
+            this.token.length === 0 ||
+            this.isTokenExpired(this.token)) {
+            return this.tokenManager.fetchToken();
+        }
+        return Promise.resolve(this.token);
+    }
+    /**
+     * Function to check if the token is expired with a buffer of 30 seconds.
+     * @param token - The JWT token as a string.
+     * @returns Boolean indicating if the token is expired.
+     */
+    isTokenExpired(token) {
+        try {
+            // Decode the token without verifying the signature, as we only want to read the expiration for this check
+            const decoded = jsonwebtoken_1.default.decode(token);
+            if (!decoded || !decoded.exp) {
+                // If the token doesn't have an expiration, consider it expired
+                return true;
+            }
+            const expiresAt = decoded.exp * 1000;
+            const bufferMilliseconds = 30 * 1000;
+            const bufferExpiresAt = expiresAt - bufferMilliseconds;
+            // Return true if the current time is after the expiration time with buffer
+            return Date.now() > bufferExpiresAt;
+        }
+        catch (error) {
+            // If there's an error decoding the token, consider it expired
+            return true;
+        }
+    }
+}
+exports.default = TokenAuthStrategy;

package/lib/base/BaseTwilio.d.ts

@@ -0,0 +1,122 @@
+import RequestClient from "./RequestClient";
+import { ValidationClientOptions } from "./ValidationClient";
+import { HttpMethod } from "../interfaces";
+import { Headers } from "../http/request";
+import AuthStrategy from "../auth_strategy/AuthStrategy";
+import CredentialProvider from "../credential_provider/CredentialProvider";
+declare namespace Twilio {
+    const regionToEdgeMap: Map<string, string>;
+    interface ClientOpts {
+        httpClient?: RequestClient;
+        accountSid?: string;
+        env?: NodeJS.ProcessEnv;
+        edge?: string;
+        region?: string;
+        lazyLoading?: boolean;
+        logLevel?: string;
+        userAgentExtensions?: string[];
+        autoRetry?: boolean;
+        maxRetryDelay?: number;
+        maxRetries?: number;
+        validationClient?: ValidationClientOptions;
+        /**
+         https.Agent options
+         */
+        timeout?: number;
+        keepAlive?: boolean;
+        keepAliveMsecs?: number;
+        maxSockets?: number;
+        maxTotalSockets?: number;
+        maxFreeSockets?: number;
+        scheduling?: "fifo" | "lifo" | undefined;
+        ca?: string | Buffer;
+    }
+    interface RequestOpts {
+        method?: HttpMethod;
+        uri?: string;
+        username?: string;
+        password?: string;
+        authStrategy?: AuthStrategy;
+        headers?: Headers;
+        params?: object;
+        data?: object;
+        timeout?: number;
+        allowRedirects?: boolean;
+        logLevel?: string;
+    }
+    /**
+     * Parent class for Twilio Client that implements request & validation logic
+     */
+    class Client {
+        username?: string;
+        password?: string;
+        accountSid: string;
+        credentialProvider?: CredentialProvider;
+        opts?: ClientOpts;
+        env?: NodeJS.ProcessEnv;
+        edge?: string;
+        region?: string;
+        logLevel?: string;
+        autoRetry?: boolean;
+        maxRetryDelay?: number;
+        maxRetries?: number;
+        validationClient?: ValidationClientOptions;
+        /**
+         https.Agent options
+         */
+        timeout?: number;
+        keepAlive?: boolean;
+        keepAliveMsecs?: number;
+        maxSockets?: number;
+        maxTotalSockets?: number;
+        maxFreeSockets?: number;
+        scheduling?: "fifo" | "lifo" | undefined;
+        ca?: string | Buffer;
+        userAgentExtensions?: string[];
+        _httpClient?: RequestClient;
+        /**
+         * Create a BaseTwilio instance
+         *
+         * @param username -
+         *          The username used for authentication. This is normally account sid, but if using key/secret auth will be
+         *          the api key sid.
+         * @param password -
+         *          The password used for authentication. This is normally auth token, but if using key/secret auth will be
+         *          the secret.
+         * @param opts - The options argument
+         *
+         * @returns A new instance of BaseTwilio
+         */
+        constructor(username?: string, password?: string, opts?: ClientOpts);
+        setOpts(opts?: ClientOpts): void;
+        setAccountSid(accountSid?: string): void;
+        setCredentialProvider(credentialProvider: CredentialProvider): void;
+        invalidateBasicAuth(): void;
+        invalidateOAuth(): void;
+        get httpClient(): RequestClient;
+        /**
+         * Makes a request to the Twilio API using the configured http client.
+         * Authentication information is automatically added if none is provided.
+         *
+         * @param opts - The options argument
+         */
+        request(opts: RequestOpts): Promise<any>;
+        /**
+         * Adds a region and/or edge to a given hostname
+         *
+         * @param hostname - A URI hostname (e.g. api.twilio.com)
+         * @param targetEdge - The targeted edge location (e.g. sydney)
+         * @param targetRegion - The targeted region location (e.g. au1)
+         */
+        getHostname(hostname: string, targetEdge: string | undefined, targetRegion: string | undefined): string;
+        /**
+         * Test if your environment is impacted by a TLS or certificate
+         * change is by sending an HTTP request to the test endpoint
+         *
+         * @throws RestException if the request fails
+         *
+         */
+        validateSslCert(): Promise<any>;
+    }
+}
+export = Twilio;

package/lib/base/BaseTwilio.js

@@ -0,0 +1,254 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const RequestClient_1 = __importDefault(require("./RequestClient")); /* jshint ignore:line */
+const os = require("os"); /* jshint ignore:line */
+const url = require("url"); /* jshint ignore:line */
+const moduleInfo = require("../../package.json"); /* jshint ignore:line */
+const util = require("util"); /* jshint ignore:line */
+const RestException = require("../base/RestException"); /* jshint ignore:line */
+var Twilio;
+(function (Twilio) {
+    Twilio.regionToEdgeMap = new Map([
+        ["au1", "sydney"],
+        ["br1", "sao-paulo"],
+        ["de1", "frankfurt"],
+        ["ie1", "dublin"],
+        ["jp1", "tokyo"],
+        ["jp2", "osaka"],
+        ["sg1", "singapore"],
+        ["us1", "ashburn"],
+        ["us2", "umatilla"],
+    ]);
+    /* jshint ignore:start */
+    /**
+     * Parent class for Twilio Client that implements request & validation logic
+     */
+    /* jshint ignore:end */
+    class Client {
+        /* jshint ignore:start */
+        /**
+         * Create a BaseTwilio instance
+         *
+         * @param username -
+         *          The username used for authentication. This is normally account sid, but if using key/secret auth will be
+         *          the api key sid.
+         * @param password -
+         *          The password used for authentication. This is normally auth token, but if using key/secret auth will be
+         *          the secret.
+         * @param opts - The options argument
+         *
+         * @returns A new instance of BaseTwilio
+         */
+        /* jshint ignore:end */
+        constructor(username, password, opts) {
+            this.setOpts(opts);
+            this.username =
+                username ??
+                    this.env?.TWILIO_ACCOUNT_SID ??
+                    process.env.TWILIO_ACCOUNT_SID;
+            this.password =
+                password ??
+                    this.env?.TWILIO_AUTH_TOKEN ??
+                    process.env.TWILIO_AUTH_TOKEN;
+            this.accountSid = "";
+            this.setAccountSid(this.opts?.accountSid || this.username);
+            this.invalidateOAuth();
+        }
+        setOpts(opts) {
+            this.opts = opts || {};
+            this.env = this.opts.env || {};
+            this.edge =
+                this.opts.edge ?? this.env.TWILIO_EDGE ?? process.env.TWILIO_EDGE;
+            this.region =
+                this.opts.region ?? this.env.TWILIO_REGION ?? process.env.TWILIO_REGION;
+            this.logLevel =
+                this.opts.logLevel ??
+                    this.env.TWILIO_LOG_LEVEL ??
+                    process.env.TWILIO_LOG_LEVEL;
+            this.timeout = this.opts.timeout;
+            this.keepAlive = this.opts.keepAlive;
+            this.keepAliveMsecs = this.opts.keepAliveMsecs;
+            this.maxSockets = this.opts.maxSockets;
+            this.maxTotalSockets = this.opts.maxTotalSockets;
+            this.maxFreeSockets = this.opts.maxFreeSockets;
+            this.scheduling = this.opts.scheduling;
+            this.ca = this.opts.ca;
+            this.autoRetry = this.opts.autoRetry || false;
+            this.maxRetryDelay = this.opts.maxRetryDelay;
+            this.maxRetries = this.opts.maxRetries;
+            this.validationClient = this.opts.validationClient;
+            this.userAgentExtensions = this.opts.userAgentExtensions || [];
+            this._httpClient = this.opts.httpClient;
+            if (this.opts.lazyLoading === false) {
+                this._httpClient = this.httpClient;
+            }
+        }
+        setAccountSid(accountSid) {
+            this.accountSid = accountSid || "";
+            if (this.accountSid && !this.accountSid?.startsWith("AC")) {
+                const apiKeyMsg = this.accountSid?.startsWith("SK")
+                    ? ". The given SID indicates an API Key which requires the accountSid to be passed as an additional option"
+                    : "";
+                throw new Error("accountSid must start with AC" + apiKeyMsg);
+            }
+        }
+        setCredentialProvider(credentialProvider) {
+            this.credentialProvider = credentialProvider;
+            this.accountSid = "";
+            this.invalidateBasicAuth();
+        }
+        invalidateBasicAuth() {
+            this.username = undefined;
+            this.password = undefined;
+        }
+        invalidateOAuth() {
+            this.credentialProvider = undefined;
+        }
+        get httpClient() {
+            if (!this._httpClient) {
+                this._httpClient = new RequestClient_1.default({
+                    timeout: this.timeout,
+                    keepAlive: this.keepAlive,
+                    keepAliveMsecs: this.keepAliveMsecs,
+                    maxSockets: this.maxSockets,
+                    maxTotalSockets: this.maxTotalSockets,
+                    maxFreeSockets: this.maxFreeSockets,
+                    scheduling: this.scheduling,
+                    ca: this.ca,
+                    autoRetry: this.autoRetry,
+                    maxRetryDelay: this.maxRetryDelay,
+                    maxRetries: this.maxRetries,
+                    validationClient: this.validationClient,
+                });
+            }
+            return this._httpClient;
+        }
+        /* jshint ignore:start */
+        /**
+         * Makes a request to the Twilio API using the configured http client.
+         * Authentication information is automatically added if none is provided.
+         *
+         * @param opts - The options argument
+         */
+        /* jshint ignore:end */
+        request(opts) {
+            if ((this.edge !== undefined && this.region === undefined) ||
+                (this.edge === undefined && this.region !== undefined)) {
+                console.warn("[DEPRECATION WARNING] For regional processing, DNS is of format product.edge.region.twilio.com;otherwise use product.twilio.com");
+            }
+            if (this.region !== undefined && this.edge === undefined) {
+                const mappedEdge = Twilio.regionToEdgeMap.get(this.region);
+                if (mappedEdge) {
+                    console.warn("Setting edge value from the region mapping");
+                    this.edge = mappedEdge;
+                }
+            }
+            opts = opts || {};
+            if (!opts.method) {
+                throw new Error("method is required");
+            }
+            if (!opts.uri) {
+                throw new Error("uri is required");
+            }
+            const username = opts.username || this.username;
+            const password = opts.password || this.password;
+            const authStrategy = opts.authStrategy || this.credentialProvider?.toAuthStrategy();
+            if (!authStrategy) {
+                if (!username) {
+                    (() => {
+                        throw new Error("username is required");
+                    })();
+                }
+                if (!password) {
+                    (() => {
+                        throw new Error("password is required");
+                    })();
+                }
+            }
+            const headers = opts.headers || {};
+            const pkgVersion = moduleInfo.version;
+            const osName = os.platform();
+            const osArch = os.arch();
+            const nodeVersion = process.version;
+            headers["User-Agent"] = util.format("twilio-node/%s (%s %s) node/%s", pkgVersion, osName, osArch, nodeVersion);
+            this.userAgentExtensions?.forEach((extension) => {
+                headers["User-Agent"] += ` ${extension}`;
+            });
+            headers["Accept-Charset"] = "utf-8";
+            if ((opts.method === "post" || opts.method === "put") &&
+                !headers["Content-Type"]) {
+                headers["Content-Type"] = "application/x-www-form-urlencoded";
+            }
+            if (opts.method !== "delete" && !headers["Accept"]) {
+                headers["Accept"] = "application/json";
+            }
+            var uri = new url.URL(opts.uri);
+            uri.hostname = this.getHostname(uri.hostname, this.edge, this.region);
+            return this.httpClient?.request({
+                method: opts.method,
+                uri: uri.href,
+                username: username,
+                password: password,
+                authStrategy: authStrategy,
+                headers: headers,
+                params: opts.params,
+                data: opts.data,
+                timeout: opts.timeout,
+                allowRedirects: opts.allowRedirects,
+                // use the Twilio client's log-level if the httpClient's log-level is unspecified
+                logLevel: opts.logLevel || this.opts?.logLevel,
+            });
+        }
+        /* jshint ignore:start */
+        /**
+         * Adds a region and/or edge to a given hostname
+         *
+         * @param hostname - A URI hostname (e.g. api.twilio.com)
+         * @param targetEdge - The targeted edge location (e.g. sydney)
+         * @param targetRegion - The targeted region location (e.g. au1)
+         */
+        /* jshint ignore:end */
+        getHostname(hostname, targetEdge, targetRegion) {
+            const defaultRegion = "us1";
+            const domain = hostname.split(".").slice(-2).join(".");
+            const prefix = hostname.split("." + domain)[0];
+            let [product, edge, region] = prefix.split(".");
+            if (edge && !region) {
+                region = edge;
+                edge = undefined;
+            }
+            region = targetRegion || region || (targetEdge && defaultRegion);
+            if (!region) {
+                return hostname;
+            }
+            edge = targetEdge || edge;
+            return [product, edge, region, domain].filter((part) => part).join(".");
+        }
+        /* jshint ignore:start */
+        /**
+         * Test if your environment is impacted by a TLS or certificate
+         * change is by sending an HTTP request to the test endpoint
+         *
+         * @throws RestException if the request fails
+         *
+         */
+        /* jshint ignore:end */
+        validateSslCert() {
+            return this.httpClient
+                ?.request({
+                method: "get",
+                uri: "https://tls-test.twilio.com:443",
+            })
+                .then((response) => {
+                if (response["statusCode"] < 200 || response["statusCode"] >= 300) {
+                    throw new RestException(response);
+                }
+                return response;
+            });
+        }
+    }
+    Twilio.Client = Client;
+})(Twilio || (Twilio = {}));
+module.exports = Twilio;

package/lib/base/Domain.d.ts

@@ -0,0 +1,29 @@
+import { Client as BaseTwilio, RequestOpts } from "./BaseTwilio";
+/**
+ * Base domain object
+ */
+export default class Domain {
+    twilio: BaseTwilio;
+    baseUrl: string;
+    /**
+     * Creates a Domain instance
+     *
+     * @param twilio - A Twilio Client
+     * @param baseUrl - Base url for this domain
+     */
+    constructor(twilio: BaseTwilio, baseUrl: string);
+    /**
+     * Turn a uri into an absolute url
+     *
+     * @param uri - uri to transform
+     * @returns absolute url
+     */
+    absoluteUrl(uri?: string): string;
+    /**
+     * Make request to this domain
+     *
+     * @param opts - request options
+     * @returns request promise
+     */
+    request(opts: RequestOpts): Promise<any>;
+}

package/lib/base/Domain.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utility_1 = require("./utility");
+/**
+ * Base domain object
+ */
+class Domain {
+    /**
+     * Creates a Domain instance
+     *
+     * @param twilio - A Twilio Client
+     * @param baseUrl - Base url for this domain
+     */
+    constructor(twilio, baseUrl) {
+        this.twilio = twilio;
+        this.baseUrl = baseUrl;
+    }
+    /**
+     * Turn a uri into an absolute url
+     *
+     * @param uri - uri to transform
+     * @returns absolute url
+     */
+    absoluteUrl(uri) {
+        var result = "";
+        if (typeof this.baseUrl === "string") {
+            const cleanBaseUrl = (0, utility_1.trim)(this.baseUrl, "/");
+            result += cleanBaseUrl;
+            result += "/";
+        }
+        if (typeof uri === "string") {
+            uri = (0, utility_1.trim)(uri, "/");
+            if (result === "") {
+                result += "/";
+            }
+            result += uri;
+        }
+        return result;
+    }
+    /**
+     * Make request to this domain
+     *
+     * @param opts - request options
+     * @returns request promise
+     */
+    request(opts) {
+        return this.twilio.request({
+            ...opts,
+            uri: this.absoluteUrl(opts.uri),
+        });
+    }
+}
+exports.default = Domain;