telnyx 2.1.1 → 3.0.0-alpha

package/dist/TelnyxResource.js

@@ -1,430 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const http = __importStar(require("http"));
-const https = __importStar(require("https"));
-const path = __importStar(require("path"));
-const utils = __importStar(require("./utils.js"));
-const TelnyxError = __importStar(require("./Error.js"));
-const TelnyxMethod_js_1 = __importDefault(require("./TelnyxMethod.js"));
-const basicMethods = __importStar(require("./TelnyxMethod.basic.js"));
-const hasOwn = {}.hasOwnProperty;
-// Provide extension mechanism for Telnyx Resource Sub-Classes
-TelnyxResource.extend = utils.protoExtend;
-// Expose method-creator & prepared (basic) methods
-TelnyxResource.method = TelnyxMethod_js_1.default;
-TelnyxResource.BASIC_METHODS = basicMethods;
-TelnyxResource.MAX_BUFFERED_REQUEST_METRICS = 100;
-/**
- * Encapsulates request logic for a Telnyx Resource
- */
-function TelnyxResource(telnyx, urlData) {
-    this._telnyx = telnyx;
-    this._urlData = urlData || {};
-    this.basePath = utils.makeURLInterpolator(
-    // @ts-expect-error changing type of basePath
-    this.basePath || telnyx.getApiField('basePath'));
-    // @ts-expect-error changing type of path
-    this.resourcePath = this.path;
-    // @ts-expect-error changing type of path
-    this.path = utils.makeURLInterpolator(this.path);
-    if (this.includeBasic) {
-        this.includeBasic.forEach((methodName) => {
-            // @ts-expect-error TODO: cast `methodName` to `BASIC_METHODS` values
-            this[methodName] = TelnyxResource.BASIC_METHODS[methodName];
-        }, this);
-    }
-    if (this.nestedResources) {
-        for (const resource in this.nestedResources) {
-            // @ts-expect-error TODO: cast `resource` to  `nestedResources` values
-            this[utils.pascalToCamelCase(resource)] = new this.nestedResources[resource](telnyx);
-        }
-    }
-    if (this.instanceMethods) {
-        Object.assign(this, this.instanceMethods);
-    }
-    this.initialize.apply(this, [telnyx, urlData]);
-}
-TelnyxResource.prototype = {
-    _telnyx: null,
-    _urlData: null,
-    // @ts-expect-error the type of path changes in ctor
-    path: '',
-    resourcePath: '',
-    // Properties are set in the constructor above
-    // Methods that don't use the API's default '/v1' path can override it with this setting.
-    basePath: null,
-    includeBasic: null,
-    nestedResources: null,
-    instanceMethods: null,
-    initialize: function () { },
-    // Function to override the default data processor. This allows full control
-    // over how a TelnyxResource's request data will get converted into an HTTP
-    // body. This is useful for non-standard HTTP requests. The function should
-    // take method name, data, and headers as arguments.
-    requestDataProcessor: null,
-    // Function to add a validation checks before sending the request, errors should
-    // be thrown, and they will be passed to the callback/promise.
-    validateRequest: null,
-    createFullPath(commandPath, urlData) {
-        return path
-            .join(this.basePath(urlData), this.path(urlData), typeof commandPath == 'function' ? commandPath(urlData) : commandPath)
-            .replace(/\\/g, '/'); // ugly workaround for Windows
-    },
-    // Creates a relative resource path with symbols left in (unlike
-    // createFullPath which takes some data to replace them with). For example it
-    // might produce: /invoices/{id}
-    createResourcePathWithSymbols(pathWithSymbols) {
-        return ('/' +
-            path.join(this.resourcePath, pathWithSymbols || '').replace(/\\/g, '/')); // ugly workaround for Windows
-    },
-    createUrlData: function () {
-        const urlData = {};
-        // Merge in baseData
-        for (const i in this._urlData) {
-            if (hasOwn.call(this._urlData, i)) {
-                urlData[i] = this._urlData[i];
-            }
-        }
-        return urlData;
-    },
-    _timeoutHandler: function (timeout, req, callback) {
-        return () => {
-            const timeoutErr = new Error('ETIMEDOUT');
-            const connectionError = new TelnyxError.TelnyxConnectionError({
-                message: 'Request aborted due to timeout being reached (' + timeout + 'ms)',
-                detail: timeoutErr,
-            });
-            req._isAborted = true;
-            req.destroy(connectionError);
-            callback.call(this, connectionError, null);
-        };
-    },
-    _responseHandler(req, callback) {
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
-        const self = this;
-        return function (res) {
-            let response = '';
-            res.setEncoding('utf8');
-            res.on('data', function (chunk) {
-                response += chunk;
-            });
-            res.on('end', function () {
-                const headers = res.headers || {};
-                // NOTE: Telnyx responds with lowercase header names/keys.
-                // For convenience, make Request-Id easily accessible on
-                // lastResponse.
-                res.requestId = headers['request-id'] || headers['x-request-id'] || '';
-                const requestDurationMs = Date.now() - req._requestStart;
-                const responseEvent = utils.removeEmpty({
-                    method: req._requestEvent.method,
-                    path: req._requestEvent.path,
-                    status: res.statusCode,
-                    request_id: res.requestId,
-                    elapsed: requestDurationMs,
-                });
-                self._telnyx._emitter.emit('response', responseEvent);
-                let responseBody;
-                try {
-                    responseBody = utils.tryParseJSON(response);
-                    // JSON response might be empty on deletion operations
-                    if (!responseBody) {
-                        responseBody = {};
-                    }
-                    else if (responseBody.errors) {
-                        const error = {};
-                        error.errors =
-                            responseBody.errors;
-                        error.headers = headers;
-                        error.statusCode = res.statusCode;
-                        error.requestId = res.requestId;
-                        const err = self._buildError(error, res.statusCode);
-                        return callback.call(self, err, null);
-                    }
-                }
-                catch (e) {
-                    return callback.call(self, new TelnyxError.TelnyxAPIError({
-                        message: 'Invalid JSON received from the Telnyx API',
-                        responseBody: response,
-                        detail: e,
-                        requestId: res.requestId,
-                    }), null);
-                }
-                // Expose res object
-                Object.defineProperty(responseBody, 'lastResponse', {
-                    enumerable: false,
-                    writable: false,
-                    value: res,
-                });
-                // parsed json and found no errors so this is a valid response payload
-                callback.call(self, null, responseBody);
-            });
-        };
-    },
-    _buildError: function (error, statusCode) {
-        let err;
-        switch (statusCode) {
-            case 400:
-                err = new TelnyxError.TelnyxInvalidRequestError(error);
-                break;
-            case 401:
-                err = new TelnyxError.TelnyxAuthenticationError(error);
-                break;
-            case 403:
-                err = new TelnyxError.TelnyxPermissionError(error);
-                break;
-            case 404:
-                err = new TelnyxError.TelnyxResourceNotFoundError(error);
-                break;
-            case 405:
-                err = new TelnyxError.TelnyxMethodNotSupportedError(error);
-                break;
-            case 408:
-                err = new TelnyxError.TelnyxTimeoutError(error);
-                break;
-            case 415:
-                err = new TelnyxError.TelnyxUnsupportedMediaTypeError(error);
-                break;
-            case 422:
-                err = new TelnyxError.TelnyxInvalidParametersError(error);
-                break;
-            case 429:
-                err = new TelnyxError.TelnyxRateLimitError(error);
-                break;
-            case 500:
-                err = new TelnyxError.TelnyxAPIError(error);
-                break;
-            case 503:
-                err = new TelnyxError.TelnyxServiceUnavailableError(error);
-                break;
-            default:
-                err = new TelnyxError.TelnyxAPIError(error);
-        }
-        return err;
-    },
-    _generateConnectionErrorMessage(requestRetries) {
-        return ('An error occurred with our connection to Telnyx.' +
-            (requestRetries > 0
-                ? ' Request was retried ' + requestRetries + ' times.'
-                : ''));
-    },
-    _errorHandler: function (req, requestRetries, callback) {
-        return (error) => {
-            if (req._isAborted) {
-                // already handled
-                return;
-            }
-            callback.call(this, new TelnyxError.TelnyxConnectionError({
-                message: this._generateConnectionErrorMessage(requestRetries),
-                responseBody: error,
-            }), null);
-        };
-    },
-    _shouldRetry: function (res, numRetries, error) {
-        // if we have a connection error and we haven't already retried, do so.
-        if (error && numRetries === 0 && (error.code === 'ECONNRESET' || error.code === 'EPIPE')) {
-            return true;
-        }
-        // Do not retry if we are out of retries.
-        if (numRetries >= this._telnyx.getMaxNetworkRetries()) {
-            return false;
-        }
-        // Retry on connection error.
-        if (!res) {
-            return true;
-        }
-        // Retry on conflict and availability errors.
-        if (res.statusCode === 409 || res.statusCode === 503) {
-            return true;
-        }
-        // Retry on 5xx's, except POST's as that may not be safe.
-        if (res.statusCode &&
-            res.statusCode >= 500 &&
-            res.req._requestEvent?.method !== 'POST') {
-            return true;
-        }
-        return false;
-    },
-    _getSleepTimeInMS: function (numRetries) {
-        const initialNetworkRetryDelay = this._telnyx.getInitialNetworkRetryDelay();
-        const maxNetworkRetryDelay = this._telnyx.getMaxNetworkRetryDelay();
-        // Apply exponential backoff with initialNetworkRetryDelay on the
-        // number of numRetries so far as inputs. Do not allow the number to exceed
-        // maxNetworkRetryDelay.
-        let sleepSeconds = Math.min(initialNetworkRetryDelay * Math.pow(numRetries - 1, 2), maxNetworkRetryDelay);
-        // Apply some jitter by randomizing the value in the range of
-        // (sleepSeconds / 2) to (sleepSeconds).
-        sleepSeconds *= 0.5 * (1 + Math.random());
-        // But never sleep less than the base sleep seconds.
-        sleepSeconds = Math.max(initialNetworkRetryDelay, sleepSeconds);
-        return sleepSeconds * 1000;
-    },
-    _defaultHeaders: function (auth, requestData) {
-        let userAgentString = 'Telnyx/v2 NodeBindings/' + this._telnyx.getConstant('PACKAGE_VERSION');
-        if (this._telnyx._appInfo) {
-            userAgentString += ' ' + this._telnyx.getAppInfoAsString();
-        }
-        const headers = {
-            // Use specified auth token or use default from this telnyx instance:
-            Authorization: auth
-                ? 'Bearer ' + auth
-                : this._telnyx.getApiField('auth'),
-            Accept: '*/*',
-            'Content-Type': 'application/json',
-            'Content-Length': Buffer.byteLength(requestData),
-            'User-Agent': userAgentString,
-        };
-        return headers;
-    },
-    _request: function (method, _host, path, data, auth, options, callback) {
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
-        const self = this;
-        let requestData;
-        function makeRequestWithData(error, data) {
-            let headers = {};
-            if (error) {
-                return callback(error);
-            }
-            if (method == 'GET') {
-                if (data != '' && data != null) {
-                    path = path + '?' + data;
-                    requestData = '';
-                }
-                else {
-                    requestData = '';
-                }
-            }
-            else if (utils.isJsonString(data?.toString() || '')) {
-                requestData = data;
-            }
-            else if (data != '' && data != null) {
-                path = path + '?' + encodeURI(data.toString());
-                requestData = '';
-            }
-            else {
-                requestData = '';
-            }
-            headers = self._defaultHeaders(auth, requestData);
-            self._telnyx.getClientUserAgent(function (cua) {
-                headers['X-Telnyx-Client-User-Agent'] = cua;
-                if (options.headers) {
-                    Object.assign(headers, options.headers);
-                }
-                makeRequest(headers);
-            });
-        }
-        if (self.requestDataProcessor) {
-            self.requestDataProcessor(method, data, options.headers, makeRequestWithData);
-        }
-        else if (method == 'GET') {
-            makeRequestWithData(null, data ? utils.stringifyRequestData(data) : '');
-        }
-        else {
-            let parameters;
-            if (data) {
-                if (data.filter && Object.keys(data.filter).length) {
-                    parameters = utils.stringifyRequestData(data);
-                }
-                else {
-                    parameters = JSON.stringify(data);
-                    if (parameters === '{}') {
-                        parameters = '';
-                    }
-                }
-            }
-            else {
-                parameters = '';
-            }
-            makeRequestWithData(null, parameters);
-        }
-        function retryRequest(requestFn, headers, requestRetries) {
-            requestRetries += 1;
-            return setTimeout(requestFn, self._getSleepTimeInMS(requestRetries), headers, requestRetries);
-        }
-        function makeRequest(headers, numRetries) {
-            const timeout = self._telnyx.getApiField('timeout');
-            const isInsecureConnection = self._telnyx.getApiField('protocol') == 'http';
-            const agent = isInsecureConnection
-                ? self._telnyx.getApiField('http_agent')
-                : self._telnyx.getApiField('https_agent');
-            if (headers['Content-Length'] === 0) {
-                delete headers['Content-Length'];
-                delete headers['Content-Type'];
-            }
-            const req = (isInsecureConnection ? http : https).request({
-                host: self._telnyx.getApiField('host') || '127.0.0.1',
-                port: self._telnyx.getApiField('port'),
-                path: path,
-                method: method,
-                agent: agent,
-                headers: headers,
-                ciphers: 'DEFAULT:!aNULL:!eNULL:!LOW:!EXPORT:!SSLv2:!MD5',
-            });
-            const requestEvent = utils.removeEmpty({
-                method: method,
-                path: path,
-            });
-            const requestRetries = numRetries || 0;
-            req._requestEvent = requestEvent;
-            req._requestStart = Date.now();
-            self._telnyx._emitter.emit('request', requestEvent);
-            req.setTimeout(timeout, self._timeoutHandler(timeout, req, callback));
-            req.on('response', function (res) {
-                if (self._shouldRetry(res, requestRetries)) {
-                    return retryRequest(makeRequest, headers, requestRetries);
-                }
-                else {
-                    return self._responseHandler(req, callback)(res);
-                }
-            });
-            req.on('error', function (error) {
-                if (self._shouldRetry(null, requestRetries, error)) {
-                    return retryRequest(makeRequest, headers, requestRetries);
-                }
-                else {
-                    return self._errorHandler(req, requestRetries, callback)(error);
-                }
-            });
-            req.on('socket', function (socket) {
-                if (socket.connecting) {
-                    socket.on(isInsecureConnection ? 'connect' : 'secureConnect', function () {
-                        // Send payload; we're safe:
-                        req.write(requestData);
-                        req.end();
-                    });
-                }
-                else {
-                    // we're already connected
-                    req.write(requestData);
-                    req.end();
-                }
-            });
-        }
-    },
-};
-exports.default = TelnyxResource;

package/dist/Webhooks.js

@@ -1,80 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const tweetnacl_1 = __importDefault(require("tweetnacl"));
-const TelnyxError = __importStar(require("./Error.js"));
-const Webhooks = {
-    DEFAULT_TOLERANCE: 300, // 5 minutes
-    decoder: new TextDecoder('utf8'),
-    constructEvent: function (payload, signatureHeader, timestampHeader = '', publicKey, tolerance) {
-        this.signature.verifySignature(payload, signatureHeader, timestampHeader, publicKey, tolerance || Webhooks.DEFAULT_TOLERANCE);
-        const jsonPayload = JSON.parse(payload);
-        return jsonPayload;
-    },
-    signature: {
-        verifySignature: function (payload, signatureHeader, timestampHeader, publicKey, tolerance) {
-            const payloadBuffer = Buffer.from(`${timestampHeader}|${payload}`, 'utf8');
-            const signature = signatureHeader || Buffer.from('', 'base64');
-            let verification;
-            try {
-                // https://bun.sh/guides/binary/buffer-to-typedarray
-                verification = tweetnacl_1.default.sign.detached.verify(payloadBuffer, signature, publicKey);
-            }
-            catch (_e) {
-                console.log(_e);
-                throwSignatureVerificationError(payload, signature, timestampHeader);
-            }
-            if (!verification) {
-                throwSignatureVerificationError(payload, signature, timestampHeader);
-            }
-            const timestampAge = Math.floor(Date.now() / 1000) - parseInt(timestampHeader);
-            if (tolerance && tolerance > 0 && timestampAge > tolerance) {
-                throw new TelnyxError.TelnyxSignatureVerificationError({
-                    message: 'Timestamp outside the tolerance zone',
-                    detail: {
-                        signatureHeader: signatureHeader,
-                        timestampHeader: timestampHeader,
-                        payload: payload,
-                    },
-                });
-            }
-            return true;
-        },
-    },
-};
-function throwSignatureVerificationError(payload, signatureHeader, timestampHeader) {
-    throw new TelnyxError.TelnyxSignatureVerificationError({
-        message: 'Signature is invalid and does not match the payload',
-        detail: {
-            signatureHeader: signatureHeader,
-            timestampHeader: timestampHeader,
-            payload: payload,
-        },
-    });
-}
-exports.default = Webhooks;