mns-node-sdk/dist/lib/helper.js

unofficial sdk for Aliyun mns

"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());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const _ = require("lodash");
const xml2js = require("xml2js");
const requestPromise = require("request-promise-native");
// tslint:disable-next-line: no-require-imports
const escape = require("xml-escape");
function requestRetry(uri, options, retries) {
    return __awaiter(this, void 0, void 0, function* () {
        return requestPromise(uri, options).catch(err => {
            if (retries <= 0) {
                if (err.response) {
                    return err.response;
                }
                throw err.error;
            }
            return requestRetry(uri, options, retries - 1);
        });
    });
}
exports.requestRetry = requestRetry;
function parseXML(input) {
    return __awaiter(this, void 0, void 0, function* () {
        return new Promise((resolve, reject) => {
            xml2js.parseString(input, (err, obj) => {
                if (err) {
                    return reject(err);
                }
                resolve(obj);
            });
        });
    });
}
exports.parseXML = parseXML;
function extract(arr) {
    if (arr && arr.length === 1 && typeof arr[0] === 'string') {
        return arr[0];
    }
    arr.forEach((item) => {
        _.keys(item).forEach(key => {
            item[key] = extract(item[key]);
        });
    });
    return arr;
}
exports.extract = extract;
function toXMLBuffer(entityType, params, subType) {
    let xml = '<?xml version="1.0" encoding="UTF-8"?>';
    xml += `<${entityType} xmlns="http://mns.aliyuncs.com/doc/v1/">`;
    if (Array.isArray(params)) {
        params.forEach(item => {
            xml += `<${subType}>`;
            xml += _format(item);
            xml += `</${subType}>`;
        });
    }
    else {
        xml += _format(params);
    }
    xml += `</${entityType}>`;
    return Buffer.from(xml, 'utf8');
}
exports.toXMLBuffer = toXMLBuffer;
function _format(params) {
    if (typeof params === 'string') {
        return escape(params);
    }
    if (typeof params === 'number' || typeof params === 'boolean') {
        return escape(params.toString());
    }
    let xml = '';
    _.keys(params).forEach(key => {
        const value = params[key];
        if (_.isNil(value)) {
            return;
        }
        xml += `<${key}>${_format(value)}</${key}>`;
    });
    return xml;
}
function getResponseHeaders(headers, attentions) {
    const result = {};
    _.forEach(attentions, key => {
        result[key] = headers[key];
    });
    return result;
}
exports.getResponseHeaders = getResponseHeaders;
function getEndpoint(accountId, region, secure, internal, vpc) {
    return {
        endpoint: `${secure ? 'https' : 'http'}://${accountId}.mns.${region}${internal ? '-internal' : ''}${vpc ? '-vpc' : ''}.aliyuncs.com`,
        domain: `${accountId}.mns.${region}${internal ? '-internal' : ''}${vpc ? '-vpc' : ''}.aliyuncs.com`,
    };
}
exports.getEndpoint = getEndpoint;
function getCanonicalizedMNSHeaders(headers) {
    return _.keys(headers)
        .filter(key => key.startsWith('x-mns-'))
        .sort()
        .map(key => `${key}:${headers[key]}\n`)
        .join('');
}
exports.getCanonicalizedMNSHeaders = getCanonicalizedMNSHeaders;
//# sourceMappingURL=helper.js.map