@bitmovin/api-sdk/dist/common/RestClient.js

Bitmovin JS/TS API SDK

"use strict";
var __extends = (this && this.__extends) || (function () {
    var extendStatics = function (d, b) {
        extendStatics = Object.setPrototypeOf ||
            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
        return extendStatics(d, b);
    };
    return function (d, b) {
        if (typeof b !== "function" && b !== null)
            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __generator = (this && this.__generator) || function (thisArg, body) {
    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
    function verb(n) { return function (v) { return step([n, v]); }; }
    function step(op) {
        if (f) throw new TypeError("Generator is already executing.");
        while (g && (g = 0, op[0] && (_ = 0)), _) try {
            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
            if (y = 0, t) op = [op[0] & 2, t.value];
            switch (op[0]) {
                case 0: case 1: t = op; break;
                case 4: _.label++; return { value: op[1], done: false };
                case 5: _.label++; y = op[1]; op = [0]; continue;
                case 7: op = _.ops.pop(); _.trys.pop(); continue;
                default:
                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                    if (t[2]) _.ops.pop();
                    _.trys.pop(); continue;
            }
            op = body.call(thisArg, _);
        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
    }
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.RestClient = void 0;
exports.copyAndPrepareBody = copyAndPrepareBody;
var e6p = require("es6-promise");
var urljoin = require("url-join");
var isomorphicFetch = require("isomorphic-fetch");
var BaseAPI_1 = require("./BaseAPI");
var NullLogger_1 = require("./NullLogger");
var BitmovinErrorBuilder_1 = require("./BitmovinErrorBuilder");
e6p.polyfill();
var BASE_URL = 'https://api.bitmovin.com/v1';
function prepareUrlParameterValue(parameterValue) {
    if (parameterValue instanceof Date) {
        return parameterValue.toISOString().replace(/\.\d+Z/, 'Z');
    }
    return parameterValue;
}
function queryParams(params) {
    if (!params) {
        return '';
    }
    var queryParameterString = '';
    var addSeperator = false;
    for (var _i = 0, _a = Object.keys(params); _i < _a.length; _i++) {
        var key = _a[_i];
        if (params[key] != null && typeof params[key] !== 'function' && params[key] !== "") {
            queryParameterString += (addSeperator ? '&' : '') + encodeURIComponent(key) + '=' + encodeURIComponent(prepareUrlParameterValue(params[key]));
            addSeperator = true;
        }
    }
    return queryParameterString;
}
function prepareUrl(baseUrl, url, urlParameterMap, queryStringParameters) {
    var modifiedUrl = url;
    if (urlParameterMap) {
        for (var _i = 0, _a = Object.keys(urlParameterMap); _i < _a.length; _i++) {
            var key = _a[_i];
            if (urlParameterMap[key] instanceof Date) {
                var date = urlParameterMap[key];
                var dd = date.getDate();
                var mm = date.getMonth() + 1;
                var yyyy = date.getFullYear();
                var padStart = function (input) { return input < 10 ? '0' + input : new String(input); };
                urlParameterMap[key] = "".concat(yyyy, "-").concat(padStart(mm), "-").concat(padStart(dd));
            }
            modifiedUrl = modifiedUrl.replace(new RegExp("{".concat(key, "}")), urlParameterMap[key]);
        }
    }
    if (modifiedUrl.search('{|}') > 0) {
        throw new Error('After replacing ' + url + ' with parameter map ' + JSON.stringify(urlParameterMap) + ' there are still some placeholders left for replacing. Please make sure to provide a urlParameterMap that replaces all placeholders');
    }
    modifiedUrl = urljoin(baseUrl, modifiedUrl);
    var queryString = queryParams(queryStringParameters);
    if (queryString) {
        modifiedUrl = urljoin(modifiedUrl, "?".concat(queryString));
    }
    return new URL(modifiedUrl);
}
function copyAndPrepareBody(value) {
    if (value == undefined || value == null) {
        return undefined;
    }
    if (value instanceof Date) {
        return value;
    }
    if (isPrimitive(value)) {
        return value;
    }
    if (Array.isArray(value)) {
        if (value.length == 0) {
            return undefined;
        }
        return value.map(function (element) { return copyAndPrepareBody(element); });
    }
    var cloned = {};
    for (var _i = 0, _a = Object.keys(value); _i < _a.length; _i++) {
        var property = _a[_i];
        var clonedProperty = copyAndPrepareBody(value[property]);
        if (clonedProperty == undefined) {
            continue;
        }
        cloned[property] = clonedProperty;
    }
    return cloned;
}
function isPrimitive(arg) {
    var type = typeof arg;
    return arg == null || (type != 'object' && type != 'function');
}
var RestClient = /** @class */ (function () {
    function RestClient(configuration) {
        this.GET = 'GET';
        this.PATCH = 'PATCH';
        this.POST = 'POST';
        this.PUT = 'PUT';
        this.DELETE = 'DELETE';
        if (!configuration) {
            throw new BaseAPI_1.RequiredError('Configuration must be initialized!');
        }
        if (!configuration.apiKey) {
            throw new BaseAPI_1.RequiredError('Api key must be set!');
        }
        this.apiKey = configuration.apiKey;
        this.tenantOrgId = configuration.tenantOrgId;
        this.baseUrl = configuration.baseUrl || BASE_URL;
        this.fetch = configuration.fetch || isomorphicFetch;
        this.logger = configuration.logger || new NullLogger_1.default();
        this.headers = configuration.headers;
        this.httpHandler = this.buildHttpHandler();
    }
    RestClient.prototype.buildHttpHandler = function () {
        var handlers = [
            new HeaderHandler(this.apiKey, this.tenantOrgId, this.headers),
            new ErrorHandler(),
            new LoggingHandler(this.logger)
        ];
        var httpHandler = handlers.reduce(function (innerHandler, outerHandler) {
            outerHandler.innerHandler = innerHandler;
            return outerHandler;
        }, new FetchHandler(this.fetch));
        return httpHandler;
    };
    RestClient.prototype.patch = function (url, urlParameterMap, body) {
        return this.request(this.PATCH, url, urlParameterMap, body);
    };
    RestClient.prototype.post = function (url, urlParameterMap, body) {
        return this.request(this.POST, url, urlParameterMap, body);
    };
    RestClient.prototype.get = function (url, urlParameterMap, queryStringParameters) {
        return this.request(this.GET, url, urlParameterMap, undefined, queryStringParameters);
    };
    RestClient.prototype.delete = function (url, urlParameterMap) {
        return this.request(this.DELETE, url, urlParameterMap);
    };
    RestClient.prototype.put = function (url, urlParameterMap, body) {
        return this.request(this.PUT, url, urlParameterMap, body);
    };
    RestClient.prototype.request = function (method, url, urlParameterMap, body, queryStringParameters) {
        return __awaiter(this, void 0, void 0, function () {
            var requestUrl, request, response, bodyResponse, jsonResponse;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        requestUrl = prepareUrl(this.baseUrl, url, urlParameterMap, queryStringParameters);
                        body = copyAndPrepareBody(body);
                        request = {
                            method: method,
                            url: requestUrl.toString(),
                            body: JSON.stringify(body),
                            headers: {}
                        };
                        return [4 /*yield*/, this.httpHandler.executeRequest(request)];
                    case 1:
                        response = _a.sent();
                        return [4 /*yield*/, response.text()];
                    case 2:
                        bodyResponse = _a.sent();
                        if (bodyResponse.length === 0) {
                            return [2 /*return*/, undefined];
                        }
                        try {
                            jsonResponse = JSON.parse(bodyResponse);
                            if (jsonResponse.data && jsonResponse.data.result) {
                                return [2 /*return*/, jsonResponse.data.result];
                            }
                            return [2 /*return*/, undefined];
                        }
                        catch (error) {
                            throw (0, BitmovinErrorBuilder_1.buildBitmovinError)("Response body could not be parsed to JSON", request, response, bodyResponse, error);
                        }
                        return [2 /*return*/];
                }
            });
        });
    };
    return RestClient;
}());
exports.RestClient = RestClient;
var DelegatingHandler = /** @class */ (function () {
    function DelegatingHandler() {
    }
    return DelegatingHandler;
}());
var HeaderHandler = /** @class */ (function (_super) {
    __extends(HeaderHandler, _super);
    function HeaderHandler(apiKey, tenantOrgId, additionalHeaders) {
        var _this = _super.call(this) || this;
        var headers = {
            'X-Api-Key': apiKey,
            'X-Api-Client': 'bitmovin-api-sdk-javascript',
            'X-Api-Client-Version': '1.245.1',
            'Content-Type': 'application/json'
        };
        if (tenantOrgId) {
            headers['X-Tenant-Org-Id'] = tenantOrgId;
        }
        _this.headers = Object.assign(headers, additionalHeaders);
        return _this;
    }
    HeaderHandler.prototype.executeRequest = function (request) {
        return __awaiter(this, void 0, void 0, function () {
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        request.headers = Object.assign(request.headers, this.headers);
                        return [4 /*yield*/, this.innerHandler.executeRequest(request)];
                    case 1: return [2 /*return*/, _a.sent()];
                }
            });
        });
    };
    return HeaderHandler;
}(DelegatingHandler));
var LoggingHandler = /** @class */ (function (_super) {
    __extends(LoggingHandler, _super);
    function LoggingHandler(logger) {
        var _this = _super.call(this) || this;
        _this.logger = logger;
        return _this;
    }
    LoggingHandler.prototype.executeRequest = function (request) {
        return __awaiter(this, void 0, void 0, function () {
            var response;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.logger.logRequest(request)];
                    case 1:
                        _a.sent();
                        return [4 /*yield*/, this.innerHandler.executeRequest(request)];
                    case 2:
                        response = _a.sent();
                        return [4 /*yield*/, this.logger.logResponse(response)];
                    case 3:
                        _a.sent();
                        return [2 /*return*/, response];
                }
            });
        });
    };
    return LoggingHandler;
}(DelegatingHandler));
var ErrorHandler = /** @class */ (function (_super) {
    __extends(ErrorHandler, _super);
    function ErrorHandler() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    ErrorHandler.prototype.executeRequest = function (request) {
        return __awaiter(this, void 0, void 0, function () {
            var response, error_1, bodyResponse, jsonError;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        _a.trys.push([0, 2, , 3]);
                        return [4 /*yield*/, this.innerHandler.executeRequest(request)];
                    case 1:
                        response = _a.sent();
                        if (response.status >= 200 && response.status <= 299) {
                            return [2 /*return*/, response];
                        }
                        return [3 /*break*/, 3];
                    case 2:
                        error_1 = _a.sent();
                        throw (0, BitmovinErrorBuilder_1.buildBitmovinErrorFromError)(request, error_1);
                    case 3: return [4 /*yield*/, response.text()];
                    case 4:
                        bodyResponse = _a.sent();
                        if (bodyResponse.length === 0) {
                            throw (0, BitmovinErrorBuilder_1.buildBitmovinError)("HTTP response code was ".concat(response.status, " ").concat(response.statusText, " (response body is empty)"), request, response, bodyResponse);
                        }
                        try {
                            jsonError = JSON.parse(bodyResponse);
                        }
                        catch (error) {
                            throw (0, BitmovinErrorBuilder_1.buildBitmovinError)("HTTP response code was ".concat(response.status, " ").concat(response.statusText, " (response body is invalid JSON)"), request, response, bodyResponse);
                        }
                        throw (0, BitmovinErrorBuilder_1.buildBitmovinError)("HTTP response code was ".concat(response.status, " ").concat(response.statusText), request, response, jsonError);
                }
            });
        });
    };
    return ErrorHandler;
}(DelegatingHandler));
var FetchHandler = /** @class */ (function () {
    function FetchHandler(fetch) {
        this.fetch = fetch;
    }
    FetchHandler.prototype.executeRequest = function (request) {
        return __awaiter(this, void 0, void 0, function () {
            var url, method, body, headers, response, bodyText;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        url = request.url, method = request.method, body = request.body, headers = request.headers;
                        return [4 /*yield*/, this.fetch(url, { method: method, body: body, headers: headers })];
                    case 1:
                        response = _a.sent();
                        return [4 /*yield*/, response.text()];
                    case 2:
                        bodyText = _a.sent();
                        response.text = function () { return new Promise(function (resolve) { return resolve(bodyText); }); };
                        return [2 /*return*/, response];
                }
            });
        });
    };
    return FetchHandler;
}());