postmark/dist/client/BaseClient.js

"use strict";
var __assign = (this && this.__assign) || Object.assign || function(t) {
    for (var s, i = 1, n = arguments.length; i < n; i++) {
        s = arguments[i];
        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
            t[p] = s[p];
    }
    return t;
};
Object.defineProperty(exports, "__esModule", { value: true });
var axios_1 = require("axios");
var ErrorHandler_1 = require("./ErrorHandler");
var packageJson = require("../../package.json");
var CLIENT_VERSION = packageJson.version;
/**
 * Base client class from which client classes can be implemented, in our case, AccountClient and ServerClient classes.
 * This class is NOT intended to be instantiated directly.
 */
var BaseClient = /** @class */ (function () {
    function BaseClient(token, authHeader, configOptions) {
        this.clientVersion = CLIENT_VERSION;
        this.token = token.trim();
        this.authHeader = authHeader;
        this.clientOptions = __assign({}, BaseClient.DefaultOptions, configOptions);
        this.httpClient = this.buildDefaultHttpClient();
        this.errorHandler = new ErrorHandler_1.ErrorHandler();
        this.verifyToken(token);
    }
    BaseClient.prototype.setClientOptions = function (configOptions) {
        this.clientOptions = __assign({}, BaseClient.DefaultOptions, configOptions);
        this.buildDefaultHttpClient();
    };
    BaseClient.prototype.getClientOptions = function () {
        return this.clientOptions;
    };
    /**
     * JSON object with default headers sent by HTTP request.
     */
    BaseClient.prototype.getComposedHttpRequestHeaders = function () {
        var _a;
        return _a = {},
            _a[this.authHeader] = this.token,
            _a["Accept"] = "application/json",
            _a["User-Agent"] = "Postmark.JS - " + this.clientVersion,
            _a;
    };
    /**
     * Process http request with sending body - data.
     *
     * @see processRequest for more details.
     */
    BaseClient.prototype.processRequestWithBody = function (method, path, body, callback) {
        return this.processRequest(method, path, {}, body, callback);
    };
    /**
     * Process http request without sending body - data.
     *
     * @see processRequest for more details.
     */
    BaseClient.prototype.processRequestWithoutBody = function (method, path, queryParameters, callback) {
        if (queryParameters === void 0) { queryParameters = {}; }
        return this.processRequest(method, path, queryParameters, null, callback);
    };
    /**
     * Set default values for count and offset when doing filtering with API requests if they are not specified by filter.
     */
    BaseClient.prototype.setDefaultPaginationValues = function (filter) {
        filter.count = filter.count || 100;
        filter.offset = filter.offset || 0;
    };
    /**
     * Process request for Postmark ClientOptions.
     *
     * @param method - see processHttpRequest for details
     * @param path - see processHttpRequest for details
     * @param queryParameters - see processHttpRequest for details
     * @param body - see processHttpRequest for details
     * @param callback - callback function to be executed.
     *
     * @returns A promise that will complete when the API responds (or an error occurs).
     */
    BaseClient.prototype.processRequest = function (method, path, queryParameters, body, callback) {
        var httpRequest = this.processHttpRequest(method, path, queryParameters, body);
        this.processCallbackRequest(httpRequest, callback);
        return httpRequest;
    };
    /**
     * Process HTTP request.
     *
     * @param method - Which type of http request will be executed.
     * @param path - API URL endpoint.
     * @param queryParameters - Querystring parameters used for http request.
     * @param body - Data sent with http request.
     *
     * @returns A promise that will complete when the API responds (or an error occurs).
     */
    BaseClient.prototype.processHttpRequest = function (method, path, queryParameters, body) {
        var _this = this;
        return this.httpRequest(method, path, queryParameters, body)
            .then(function (response) { return response; })
            .catch(function (error) {
            throw _this.errorHandler.buildRequestError(error);
        });
    };
    /**
     * Process callback function for HTTP request.
     *
     * @param httpRequest - HTTP request for which callback will be executed
     * @param callback - callback function to be executed.
     */
    BaseClient.prototype.processCallbackRequest = function (httpRequest, callback) {
        if (callback) {
            httpRequest
                .then(function (response) { return callback(null, response); })
                .catch(function (error) { return callback(error, null); });
        }
    };
    /**
     * Process http request.
     *
     * @param method - Which type of http request will be executed.
     * @param path - API URL endpoint.
     * @param queryParameters - Querystring parameters used for http request.
     * @param body - Data sent with http request.
     */
    BaseClient.prototype.httpRequest = function (method, path, queryParameters, body) {
        return this.httpClient.request({
            method: method,
            url: path,
            data: body,
            headers: this.getComposedHttpRequestHeaders(),
            params: queryParameters,
        });
    };
    /**
     * Create http client instance with default settings.
     *
     * @return {AxiosInstance}
     */
    BaseClient.prototype.buildDefaultHttpClient = function () {
        var httpClient = axios_1.default.create({
            baseURL: this.getBaseHttpRequestURL(),
            timeout: this.getRequestTimeoutInSeconds(),
            responseType: "json",
            maxContentLength: Infinity,
            maxBodyLength: Infinity,
            validateStatus: function (status) {
                return status >= 200 && status < 300;
            },
        });
        httpClient.interceptors.response.use(function (response) { return (response.data); });
        return httpClient;
    };
    BaseClient.prototype.getRequestTimeoutInSeconds = function () {
        return (this.clientOptions.timeout || 60) * 1000;
    };
    BaseClient.prototype.getBaseHttpRequestURL = function () {
        var scheme = this.clientOptions.useHttps ? "https" : "http";
        return scheme + "://" + this.clientOptions.requestHost;
    };
    /**
     * Token can't be empty.
     *
     * @param {string} token - HTTP request token
     */
    BaseClient.prototype.verifyToken = function (token) {
        if (!token || token.trim() === "") {
            throw this.errorHandler.buildGeneralError("A valid API token must be provided.");
        }
    };
    /**
     * Client connection configuration options.
     * You may modify these values and new clients will use them.
     * Any values provided to a Client constructor will override default options.
     */
    BaseClient.DefaultOptions = {
        useHttps: true,
        requestHost: "api.postmarkapp.com",
        timeout: 180,
    };
    return BaseClient;
}());
exports.default = BaseClient;
//# sourceMappingURL=BaseClient.js.map