@microsoft/microsoft-graph-client/lib/src/middleware/ChaosHandler.js

"use strict";
/**
 * -------------------------------------------------------------------------------------------
 * Copyright (c) Microsoft Corporation.  All Rights Reserved.  Licensed under the MIT License.
 * See License in the project root for license information.
 * -------------------------------------------------------------------------------------------
 */
Object.defineProperty(exports, "__esModule", { value: true });
var tslib_1 = require("tslib");
var MiddlewareControl_1 = require("./MiddlewareControl");
var MiddlewareUtil_1 = require("./MiddlewareUtil");
var ChaosHandlerData_1 = require("./options/ChaosHandlerData");
var ChaosHandlerOptions_1 = require("./options/ChaosHandlerOptions");
var ChaosStrategy_1 = require("./options/ChaosStrategy");
/**
 * Class representing ChaosHandler
 * @class
 * Class
 * @implements Middleware
 */
var ChaosHandler = /** @class */ (function () {
    /**
     * @public
     * @constructor
     * To create an instance of Testing Handler
     * @param {ChaosHandlerOptions} [options = new ChaosHandlerOptions()] - The testing handler options instance
     * @param manualMap - The Map passed by user containing url-statusCode info
     * @returns An instance of Testing Handler
     */
    function ChaosHandler(options, manualMap) {
        if (options === void 0) { options = new ChaosHandlerOptions_1.ChaosHandlerOptions(); }
        this.options = options;
        this.manualMap = manualMap;
    }
    /**
     * Generates responseHeader
     * @private
     * @param {number} statusCode - the status code to be returned for the request
     * @param {string} requestID - request id
     * @param {string} requestDate - date of the request
     * @returns response Header
     */
    ChaosHandler.prototype.createResponseHeaders = function (statusCode, requestID, requestDate) {
        var responseHeader = new Headers();
        responseHeader.append("Cache-Control", "no-store");
        responseHeader.append("request-id", requestID);
        responseHeader.append("client-request-id", requestID);
        responseHeader.append("x-ms-ags-diagnostic", "");
        responseHeader.append("Date", requestDate);
        responseHeader.append("Strict-Transport-Security", "");
        if (statusCode === 429) {
            // throttling case has to have a timeout scenario
            responseHeader.append("retry-after", "300");
        }
        return responseHeader;
    };
    /**
     * Generates responseBody
     * @private
     * @param {number} statusCode - the status code to be returned for the request
     * @param {string} statusMessage - the status message to be returned for the request
     * @param {string} requestID - request id
     * @param {string} requestDate - date of the request
     * @param {any?} requestBody - the request body to be returned for the request
     * @returns response body
     */
    ChaosHandler.prototype.createResponseBody = function (statusCode, statusMessage, requestID, requestDate, responseBody) {
        if (responseBody) {
            return responseBody;
        }
        var body;
        if (statusCode >= 400) {
            var codeMessage = ChaosHandlerData_1.httpStatusCode[statusCode];
            var errMessage = statusMessage;
            body = {
                error: {
                    code: codeMessage,
                    message: errMessage,
                    innerError: {
                        "request-id": requestID,
                        date: requestDate,
                    },
                },
            };
        }
        else {
            body = {};
        }
        return body;
    };
    /**
     * creates a response
     * @private
     * @param {ChaosHandlerOptions} ChaosHandlerOptions - The ChaosHandlerOptions object
     * @param {Context} context - Contains the context of the request
     */
    ChaosHandler.prototype.createResponse = function (chaosHandlerOptions, context) {
        try {
            var responseBody = void 0;
            var responseHeader = void 0;
            var requestID = void 0;
            var requestDate = void 0;
            var requestURL = context.request;
            requestID = MiddlewareUtil_1.generateUUID();
            requestDate = new Date();
            responseHeader = this.createResponseHeaders(chaosHandlerOptions.statusCode, requestID, requestDate.toString());
            responseBody = this.createResponseBody(chaosHandlerOptions.statusCode, chaosHandlerOptions.statusMessage, requestID, requestDate.toString(), chaosHandlerOptions.responseBody);
            var init = { url: requestURL, status: chaosHandlerOptions.statusCode, statusText: chaosHandlerOptions.statusMessage, headers: responseHeader };
            context.response = new Response(responseBody, init);
        }
        catch (error) {
            throw error;
        }
    };
    /**
     * Decides whether to send the request to the graph or not
     * @private
     * @param {ChaosHandlerOptions} chaosHandlerOptions - A ChaosHandlerOptions object
     * @param {Context} context - Contains the context of the request
     * @returns nothing
     */
    ChaosHandler.prototype.sendRequest = function (chaosHandlerOptions, context) {
        return tslib_1.__awaiter(this, void 0, void 0, function () {
            var error_1;
            return tslib_1.__generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        _a.trys.push([0, 4, , 5]);
                        this.setStatusCode(chaosHandlerOptions, context.request, context.options.method);
                        if (!!chaosHandlerOptions.statusCode) return [3 /*break*/, 2];
                        return [4 /*yield*/, this.nextMiddleware.execute(context)];
                    case 1:
                        _a.sent();
                        return [3 /*break*/, 3];
                    case 2:
                        this.createResponse(chaosHandlerOptions, context);
                        _a.label = 3;
                    case 3: return [3 /*break*/, 5];
                    case 4:
                        error_1 = _a.sent();
                        throw error_1;
                    case 5: return [2 /*return*/];
                }
            });
        });
    };
    /**
     * Fetches a random status code for the RANDOM mode from the predefined array
     * @private
     * @param {string} requestMethod - the API method for the request
     * @returns a random status code from a given set of status codes
     */
    ChaosHandler.prototype.getRandomStatusCode = function (requestMethod) {
        try {
            var statusCodeArray = ChaosHandlerData_1.methodStatusCode[requestMethod];
            return statusCodeArray[Math.floor(Math.random() * statusCodeArray.length)];
        }
        catch (error) {
            throw error;
        }
    };
    /**
     * To fetch the relative URL out of the complete URL using a predefined regex pattern
     * @private
     * @param {string} urlMethod - the complete URL
     * @returns the string as relative URL
     */
    ChaosHandler.prototype.getRelativeURL = function (urlMethod) {
        var pattern = /https?:\/\/graph\.microsoft\.com\/[^/]+(.+?)(\?|$)/;
        var relativeURL;
        if (pattern.exec(urlMethod) !== null) {
            relativeURL = pattern.exec(urlMethod)[1];
        }
        return relativeURL;
    };
    /**
     * To fetch the status code from the map(if needed), then returns response by calling createResponse
     * @private
     * @param {ChaosHandlerOptions} ChaosHandlerOptions - The ChaosHandlerOptions object
     * @param {string} requestURL - the URL for the request
     * @param {string} requestMethod - the API method for the request
     */
    ChaosHandler.prototype.setStatusCode = function (chaosHandlerOptions, requestURL, requestMethod) {
        var _this = this;
        try {
            if (chaosHandlerOptions.chaosStrategy === ChaosStrategy_1.ChaosStrategy.MANUAL) {
                if (chaosHandlerOptions.statusCode === undefined) {
                    // manual mode with no status code, can be a global level or request level without statusCode
                    var relativeURL_1 = this.getRelativeURL(requestURL);
                    if (this.manualMap.get(relativeURL_1) !== undefined) {
                        // checking Manual Map for exact match
                        if (this.manualMap.get(relativeURL_1).get(requestMethod) !== undefined) {
                            chaosHandlerOptions.statusCode = this.manualMap.get(relativeURL_1).get(requestMethod);
                        }
                        // else statusCode would be undefined
                    }
                    else {
                        // checking for regex match if exact match doesn't work
                        this.manualMap.forEach(function (value, key) {
                            var regexURL = new RegExp(key + "$");
                            if (regexURL.test(relativeURL_1)) {
                                if (_this.manualMap.get(key).get(requestMethod) !== undefined) {
                                    chaosHandlerOptions.statusCode = _this.manualMap.get(key).get(requestMethod);
                                }
                                // else statusCode would be undefined
                            }
                        });
                    }
                    // Case of redirection or request url not in map ---> statusCode would be undefined
                }
            }
            else {
                // Handling the case of Random here
                if (Math.floor(Math.random() * 100) < chaosHandlerOptions.chaosPercentage) {
                    chaosHandlerOptions.statusCode = this.getRandomStatusCode(requestMethod);
                }
                // else statusCode would be undefined
            }
        }
        catch (error) {
            throw error;
        }
    };
    /**
     * To get the options for execution of the middleware
     * @private
     * @param {Context} context - The context object
     * @returns options for middleware execution
     */
    ChaosHandler.prototype.getOptions = function (context) {
        var options;
        if (context.middlewareControl instanceof MiddlewareControl_1.MiddlewareControl) {
            options = context.middlewareControl.getMiddlewareOptions(ChaosHandlerOptions_1.ChaosHandlerOptions);
        }
        if (typeof options === "undefined") {
            options = Object.assign(new ChaosHandlerOptions_1.ChaosHandlerOptions(), this.options);
        }
        return options;
    };
    /**
     * To execute the current middleware
     * @public
     * @async
     * @param {Context} context - The context object of the request
     * @returns A Promise that resolves to nothing
     */
    ChaosHandler.prototype.execute = function (context) {
        return tslib_1.__awaiter(this, void 0, void 0, function () {
            var chaosHandlerOptions, error_2;
            return tslib_1.__generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        _a.trys.push([0, 2, , 3]);
                        chaosHandlerOptions = this.getOptions(context);
                        return [4 /*yield*/, this.sendRequest(chaosHandlerOptions, context)];
                    case 1: return [2 /*return*/, _a.sent()];
                    case 2:
                        error_2 = _a.sent();
                        throw error_2;
                    case 3: return [2 /*return*/];
                }
            });
        });
    };
    /**
     * @public
     * To set the next middleware in the chain
     * @param {Middleware} next - The middleware instance
     * @returns Nothing
     */
    ChaosHandler.prototype.setNext = function (next) {
        this.nextMiddleware = next;
    };
    return ChaosHandler;
}());
exports.ChaosHandler = ChaosHandler;
//# sourceMappingURL=ChaosHandler.js.map