hoppscotch/assets/js/curlparser.js

import * as cookie from "cookie";
import * as URL from "url";
import * as querystring from "querystring";


/**
 * given this: [ 'msg1=value1', 'msg2=value2' ]
 * output this: 'msg1=value1&msg2=value2'
 * @param dataArguments
 */
function joinDataArguments(dataArguments) {
    let data = '';
    dataArguments.forEach(function(argument, i) {
        if (i === 0) {
            data += argument;
        } else {
            data += '&' + argument;
        }
    })
    return data;
}

function parseCurlCommand(curlCommand) {
    let newlineFound = /\r|\n/.exec(curlCommand);
    if (newlineFound) {
        // remove newlines
        curlCommand = curlCommand.replace(/\\\r|\\\n/g, '');
    }
    // yargs parses -XPOST as separate arguments. just prescreen for it.
    curlCommand = curlCommand.replace(/ -XPOST/, ' -X POST');
    curlCommand = curlCommand.replace(/ -XGET/, ' -X GET');
    curlCommand = curlCommand.replace(/ -XPUT/, ' -X PUT');
    curlCommand = curlCommand.replace(/ -XPATCH/, ' -X PATCH');
    curlCommand = curlCommand.replace(/ -XDELETE/, ' -X DELETE');
    curlCommand = curlCommand.trim();
    let parsedArguments = require("yargs-parser")(curlCommand);
    let cookieString;
    let cookies;
    let url = parsedArguments._[1];
    if (!url) {
        for (let argName in parsedArguments) {
            if (typeof parsedArguments[argName] === 'string') {
                if (['http', 'www.'].includes(parsedArguments[argName])) {
                    url = parsedArguments[argName];
                }
            }
        }
    }
    let headers;

    let parseHeaders = function(headerFieldName) {
        if (parsedArguments[headerFieldName]) {
            if (!headers) {
                headers = {};
            }
            if (!Array.isArray(parsedArguments[headerFieldName])) {
                parsedArguments[headerFieldName] = [parsedArguments[headerFieldName]];
            }
            parsedArguments[headerFieldName].forEach(function(header) {
                if (header.includes('Cookie')) {
                    // stupid javascript tricks: closure
                    cookieString = header;
                } else {
                    let colonIndex = header.indexOf(':');
                    let headerName = header.substring(0, colonIndex);
                    let headerValue = header.substring(colonIndex + 1).trim();
                    headers[headerName] = headerValue;
                }
            })
        }
    }

    parseHeaders('H');
    parseHeaders('header');
    if (parsedArguments.A) {
        if (!headers) {
            headers = [];
        }
        headers['User-Agent'] = parsedArguments.A;
    } else if (parsedArguments['user-agent']) {
        if (!headers) {
            headers = [];
        }
        headers['User-Agent'] = parsedArguments['user-agent'];
    }

    if (parsedArguments.b) {
        cookieString = parsedArguments.b;
    }
    if (parsedArguments.cookie) {
        cookieString = parsedArguments.cookie;
    }
    let multipartUploads;
    if (parsedArguments.F) {
        multipartUploads = {};
        if (!Array.isArray(parsedArguments.F)) {
            parsedArguments.F = [parsedArguments.F];
        }
        parsedArguments.F.forEach(function(multipartArgument) {
            // input looks like key=value. value could be json or a file path prepended with an @
            let splitArguments = multipartArgument.split('=', 2);
            let key = splitArguments[0];
            let value = splitArguments[1];
            multipartUploads[key] = value;
        })
    }
    if (cookieString) {
        let cookieParseOptions = {
                decode: function(s) { return s }
            }
            // separate out cookie headers into separate data structure
            // note: cookie is case insensitive
        cookies = cookie.parse(cookieString.replace(/^Cookie: /gi, ''), cookieParseOptions);
    }
    let method;
    if (parsedArguments.X === 'POST') {
        method = 'post';
    } else if (parsedArguments.X === 'PUT' ||
        parsedArguments['T']) {
        method = 'put';
    } else if (parsedArguments.X === 'PATCH') {
        method = 'patch';
    } else if (parsedArguments.X === 'DELETE') {
        method = 'delete';
    } else if (parsedArguments.X === 'OPTIONS') {
        method = 'options';
    } else if ((parsedArguments['d'] ||
            parsedArguments['data'] ||
            parsedArguments['data-ascii'] ||
            parsedArguments['data-binary'] ||
            parsedArguments['F'] ||
            parsedArguments['form']) && !((parsedArguments['G'] || parsedArguments['get']))) {
        method = 'post';
    } else if (parsedArguments['I'] ||
        parsedArguments['head']) {
        method = 'head';
    } else {
        method = 'get';
    }

    let compressed = !!parsedArguments.compressed;
    let urlObject = URL.parse(url); // eslint-disable-line

    // if GET request with data, convert data to query string
    // NB: the -G flag does not change the http verb. It just moves the data into the url.
    if (parsedArguments['G'] || parsedArguments['get']) {
        urlObject.query = urlObject.query ? urlObject.query : '';
        let option = 'd' in parsedArguments ? 'd' : 'data' in parsedArguments ? 'data' : null;
        if (option) {
            let urlQueryString = '';

            if (!url.includes('?')) {
                url += '?';
            } else {
                urlQueryString += '&';
            }

            if (typeof(parsedArguments[option]) === 'object') {
                urlQueryString += parsedArguments[option].join('&');
            } else {
                urlQueryString += parsedArguments[option];
            }
            urlObject.query += urlQueryString;
            url += urlQueryString;
            delete parsedArguments[option];
        }
    }
    let query = querystring.parse(urlObject.query, null, null, { maxKeys: 10000 });

    urlObject.search = null // Clean out the search/query portion.
    let request = {
        url: url,
        urlWithoutQuery: URL.format(urlObject)
    }
    if (compressed) {
        request['compressed'] = true;
    }

    if (Object.keys(query).length > 0) {
        request.query = query;
    }
    if (headers) {
        request.headers = headers;
    }
    request['method'] = method;

    if (cookies) {
        request.cookies = cookies;
        request.cookieString = cookieString.replace('Cookie: ', '');
    }
    if (multipartUploads) {
        request.multipartUploads = multipartUploads;
    }
    if (parsedArguments.data) {
        request.data = parsedArguments.data;
    } else if (parsedArguments['data-binary']) {
        request.data = parsedArguments['data-binary']
        request.isDataBinary = true;
    } else if (parsedArguments['d']) {
        request.data = parsedArguments['d'];
    } else if (parsedArguments['data-ascii']) {
        request.data = parsedArguments['data-ascii'];
    }

    if (parsedArguments['u']) {
        request.auth = parsedArguments['u'];
    }
    if (parsedArguments['user']) {
        request.auth = parsedArguments['user'];
    }
    if (Array.isArray(request.data)) {
        request.dataArray = request.data
        request.data = joinDataArguments(request.data);
    }

    if (parsedArguments['k'] || parsedArguments['insecure']) {
        request.insecure = true;
    }
    return request;
}


export default parseCurlCommand;