lets-mfa/src/lib/http.js

Free, secure, and quick way to add MFA to your existing app. No user migrations or re-architecture needed!

"use strict";
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 __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports._HTTP = exports.HTTP = void 0;
const http_1 = __importDefault(require("http"));
const https_1 = __importDefault(require("https"));
function HTTP(url, requestOptions, body) {
    return __awaiter(this, void 0, void 0, function* () {
        const urlParsed = new URL(url);
        requestOptions.protocol = urlParsed.protocol;
        requestOptions.hostname = urlParsed.hostname;
        requestOptions.port = urlParsed.port;
        requestOptions.path = urlParsed.pathname + urlParsed.search;
        let requestBody = undefined;
        if (body) {
            requestBody = JSON.stringify(body);
            requestOptions.headers = {
                "Content-Type": "application/json",
                "Content-Length": Buffer.byteLength(requestBody),
            };
        }
        return urlParsed.protocol === "http:"
            ? yield _HTTP(requestOptions, requestBody)
            : yield _HTTPS(requestOptions, requestBody);
    });
}
exports.HTTP = HTTP;
function _HTTPS(requestOptions, body) {
    return __awaiter(this, void 0, void 0, function* () {
        const httpMessage = yield new Promise((resolve, reject) => {
            const req = https_1.default.request(requestOptions, (incomingMessage) => {
                resolve(incomingMessage);
            });
            req.on("error", (err) => {
                reject(err);
            });
            if (body) {
                req.write(body);
            }
            req.end();
        });
        const responseObject = (yield parseIncomingMessage(httpMessage));
        return responseObject;
    });
}
function _HTTP(requestOptions, body) {
    return __awaiter(this, void 0, void 0, function* () {
        const httpMessage = yield new Promise((resolve, reject) => {
            const req = http_1.default.request(requestOptions, (incomingMessage) => {
                resolve(incomingMessage);
            });
            req.on("error", (err) => {
                reject(err);
            });
            if (body) {
                req.write(body);
            }
            req.end();
        });
        const responseObject = yield parseIncomingMessage(httpMessage);
        return responseObject;
    });
}
exports._HTTP = _HTTP;
function parseIncomingMessage(incomingMessage) {
    return __awaiter(this, void 0, void 0, function* () {
        return yield new Promise((resolve, reject) => {
            var data = "";
            incomingMessage.on("data", function (chunk) {
                data += chunk;
            });
            incomingMessage.on("end", function () {
                try {
                    if (incomingMessage.statusCode &&
                        (incomingMessage.statusCode < 200 || incomingMessage.statusCode > 299)) {
                        let message = "UNKNOWN_ERROR";
                        try {
                            const parsedError = JSON.parse(data);
                            if (parsedError.error) {
                                message = parsedError.error;
                            }
                        }
                        catch (err) {
                            // nothing to do
                        }
                        const errorObject = {
                            error: "HTTP_RESPONSE_NOT_OK",
                            statusCode: incomingMessage.statusCode,
                            response: data,
                            message,
                        };
                        reject(errorObject);
                        return;
                    }
                    const jsonResponse = JSON.parse(data);
                    resolve(jsonResponse);
                }
                catch (err) {
                    reject(err);
                }
            });
            incomingMessage.on("error", function (err) {
                reject(err);
            });
        });
    });
}