@backtrace/sourcemap-tools/lib/SymbolUploader.js

Backtrace-JavaScript sourcemap tools

"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.SymbolUploader = void 0;
const http_1 = __importDefault(require("http"));
const https_1 = __importDefault(require("https"));
const Result_1 = require("./models/Result");
/**
 * Class responsible for uploading symbols to Backtrace.
 *
 * Expects symbol upload responses.
 */
class SymbolUploader {
    constructor(url, _options) {
        this._options = _options;
        this._url = new URL(url);
    }
    createUploadRequest() {
        var _a, _b;
        const protocol = this._url.protocol === 'https:' ? https_1.default : http_1.default;
        const request = protocol.request(this._url, {
            method: 'POST',
            rejectUnauthorized: !((_a = this._options) === null || _a === void 0 ? void 0 : _a.ignoreSsl),
            headers: (_b = this._options) === null || _b === void 0 ? void 0 : _b.headers,
        });
        const promise = new Promise((resolve, reject) => {
            request.on('error', reject);
            request.on('response', (response) => {
                if (!response.statusCode) {
                    return resolve((0, Result_1.Err)('Failed to upload symbol: failed to make the request.'));
                }
                const data = [];
                response.on('data', (chunk) => {
                    data.push(chunk);
                });
                response.on('error', reject);
                response.on('end', () => {
                    const rawResponse = Buffer.concat(data).toString('utf-8');
                    if (!response.statusCode || response.statusCode < 200 || response.statusCode >= 300) {
                        return resolve((0, Result_1.Err)(`Failed to upload symbol: ${response.statusCode}. Response data: ${rawResponse}`));
                    }
                    try {
                        const responseData = JSON.parse(rawResponse);
                        if (responseData.response === 'ok') {
                            return resolve((0, Result_1.Ok)({
                                rxid: responseData._rxid,
                            }));
                        }
                        else {
                            return resolve((0, Result_1.Err)(`Non-OK response received from Coroner: ${rawResponse}`));
                        }
                    }
                    catch (err) {
                        return resolve((0, Result_1.Err)(`Cannot parse response from Coroner: ${rawResponse}`));
                    }
                });
            });
        });
        return { promise, request };
    }
    /**
     * Uploads the symbol to Backtrace.
     * @param content Symbol stream.
     */
    uploadSymbol(readable) {
        return __awaiter(this, void 0, void 0, function* () {
            const { request, promise } = this.createUploadRequest();
            readable.pipe(request);
            return promise;
        });
    }
}
exports.SymbolUploader = SymbolUploader;
//# sourceMappingURL=SymbolUploader.js.map