@readme/httpsnippet 3.1.3 → 4.0.2

package/dist/src/helpers/reducer.js

@@ -0,0 +1,19 @@
+"use strict";
+exports.__esModule = true;
+exports.reducer = void 0;
+var reducer = function (accumulator, pair) {
+    var currentValue = accumulator[pair.name];
+    if (currentValue === undefined) {
+        accumulator[pair.name] = pair.value;
+        return accumulator;
+    }
+    // If we already have it as array just push the value
+    if (Array.isArray(currentValue)) {
+        currentValue.push(pair.value);
+        return accumulator;
+    }
+    // convert to array since now we have more than one value for this key
+    accumulator[pair.name] = [currentValue, pair.value];
+    return accumulator;
+};
+exports.reducer = reducer;

package/dist/src/helpers/shell.js

@@ -0,0 +1,20 @@
+"use strict";
+exports.__esModule = true;
+exports.escape = exports.quote = void 0;
+/**
+ * Use 'strong quoting' using single quotes so that we only need to deal with nested single quote characters.
+ * see: http://wiki.bash-hackers.org/syntax/quoting#strong_quoting
+ */
+var quote = function (value) {
+    if (value === void 0) { value = ''; }
+    var safe = /^[a-z0-9-_/.@%^=:]+$/i;
+    var isShellSafe = safe.test(value);
+    if (isShellSafe) {
+        return value;
+    }
+    // if the value is not shell safe, then quote it
+    return "'".concat(value.replace(/'/g, "'\\''"), "'");
+};
+exports.quote = quote;
+var escape = function (value) { return value.replace(/\r/g, '\\r').replace(/\n/g, '\\n'); };
+exports.escape = escape;

package/dist/src/helpers/utils.js

@@ -0,0 +1,21 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+exports.__esModule = true;
+exports.extname = exports.availableTargets = void 0;
+var targets_1 = require("../targets/targets");
+var availableTargets = function () {
+    return Object.keys(targets_1.targets).map(function (targetId) { return (__assign(__assign({}, targets_1.targets[targetId].info), { clients: Object.keys(targets_1.targets[targetId].clientsById).map(function (clientId) { return targets_1.targets[targetId].clientsById[clientId].info; }) })); });
+};
+exports.availableTargets = availableTargets;
+var extname = function (targetId) { var _a; return ((_a = targets_1.targets[targetId]) === null || _a === void 0 ? void 0 : _a.info.extname) || ''; };
+exports.extname = extname;

package/dist/src/index.js

@@ -0,0 +1,285 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+exports.HTTPSnippet = exports.addTargetClient = exports.addTarget = exports.extname = exports.availableTargets = void 0;
+var event_stream_1 = require("event-stream");
+var form_data_1 = __importDefault(require("form-data"));
+var qs_1 = require("qs");
+// eslint-disable-next-line node/no-deprecated-api
+var url_1 = require("url");
+var form_data_2 = require("./helpers/form-data");
+var har_validator_1 = require("./helpers/har-validator");
+var headers_1 = require("./helpers/headers");
+var reducer_1 = require("./helpers/reducer");
+var targets_1 = require("./targets/targets");
+var utils_1 = require("./helpers/utils");
+__createBinding(exports, utils_1, "availableTargets");
+__createBinding(exports, utils_1, "extname");
+var targets_2 = require("./targets/targets");
+__createBinding(exports, targets_2, "addTarget");
+__createBinding(exports, targets_2, "addTargetClient");
+var DEBUG_MODE = false;
+var debug = {
+    // eslint-disable-next-line @typescript-eslint/no-empty-function -- intentional noop
+    info: DEBUG_MODE ? console.info : function () { }
+};
+var isHarEntry = function (value) {
+    return typeof value === 'object' &&
+        'log' in value &&
+        typeof value.log === 'object' &&
+        'entries' in value.log &&
+        Array.isArray(value.log.entries);
+};
+var HTTPSnippet = /** @class */ (function () {
+    function HTTPSnippet(input, opts) {
+        if (opts === void 0) { opts = {}; }
+        var _this = this;
+        this.requests = [];
+        this.prepare = function (harRequest, options) {
+            var e_1, _a;
+            var _b, _c, _d;
+            var request = __assign(__assign({}, harRequest), { fullUrl: '', uriObj: {}, queryObj: {}, headersObj: {}, cookiesObj: {}, allHeaders: {} });
+            // construct query objects
+            if (request.queryString && request.queryString.length) {
+                debug.info('queryString found, constructing queryString pair map');
+                request.queryObj = request.queryString.reduce(reducer_1.reducer, {});
+            }
+            // construct headers objects
+            if (request.headers && request.headers.length) {
+                var http2VersionRegex_1 = /^HTTP\/2/;
+                request.headersObj = request.headers.reduce(function (accumulator, _a) {
+                    var _b;
+                    var name = _a.name, value = _a.value;
+                    var headerName = http2VersionRegex_1.exec(request.httpVersion) ? name.toLocaleLowerCase() : name;
+                    return __assign(__assign({}, accumulator), (_b = {}, _b[headerName] = value, _b));
+                }, {});
+            }
+            // construct headers objects
+            if (request.cookies && request.cookies.length) {
+                request.cookiesObj = request.cookies.reduceRight(function (accumulator, _a) {
+                    var _b;
+                    var name = _a.name, value = _a.value;
+                    return (__assign(__assign({}, accumulator), (_b = {}, _b[name] = value, _b)));
+                }, {});
+            }
+            // construct Cookie header
+            var cookies = (_b = request.cookies) === null || _b === void 0 ? void 0 : _b.map(function (_a) {
+                var name = _a.name, value = _a.value;
+                if (options.harIsAlreadyEncoded) {
+                    return "".concat(name, "=").concat(value);
+                }
+                return "".concat(encodeURIComponent(name), "=").concat(encodeURIComponent(value));
+            });
+            if (cookies === null || cookies === void 0 ? void 0 : cookies.length) {
+                request.allHeaders.cookie = cookies.join('; ');
+            }
+            switch (request.postData.mimeType) {
+                case 'multipart/mixed':
+                case 'multipart/related':
+                case 'multipart/form-data':
+                case 'multipart/alternative':
+                    // reset values
+                    request.postData.text = '';
+                    request.postData.mimeType = 'multipart/form-data';
+                    if ((_c = request.postData) === null || _c === void 0 ? void 0 : _c.params) {
+                        var form_1 = new form_data_1["default"]();
+                        // The `form-data` module returns one of two things: a native FormData object, or its own polyfill
+                        // Since the polyfill does not support the full API of the native FormData object, when this library is running in a browser environment it'll fail on two things:
+                        //
+                        //  1. The API for `form.append()` has three arguments and the third should only be present when the second is a
+                        //    Blob or USVString.
+                        //  1. `FormData.pipe()` isn't a function.
+                        //
+                        // Since the native FormData object is iterable, we easily detect what version of `form-data` we're working with here to allow `multipart/form-data` requests to be compiled under both browser and Node environments.
+                        //
+                        // This hack is pretty awful but it's the only way we can use this library in the browser as if we code this against just the native FormData object, we can't polyfill that back into Node because Blob and File objects, which something like `formdata-polyfill` requires, don't exist there.
+                        // @ts-expect-error TODO
+                        var isNativeFormData_1 = typeof form_1[Symbol.iterator] === 'function';
+                        // TODO: THIS ABSOLUTELY MUST BE REMOVED.
+                        // IT BREAKS SOME USE-CASES FOR MULTIPART FORMS THAT DEPEND ON BEING ABLE TO SET THE BOUNDARY.
+                        // easter egg
+                        var boundary = '---011000010111000001101001'; // this is binary for "api". yep.
+                        if (!isNativeFormData_1) {
+                            // @ts-expect-error THIS IS WRONG.  VERY WRONG.
+                            form_1._boundary = boundary;
+                        }
+                        (_d = request.postData) === null || _d === void 0 ? void 0 : _d.params.forEach(function (param) {
+                            var name = param.name;
+                            var value = param.value || '';
+                            var filename = param.fileName || null;
+                            if (isNativeFormData_1) {
+                                if ((0, form_data_2.isBlob)(value)) {
+                                    // @ts-expect-error TODO
+                                    form_1.append(name, value, filename);
+                                }
+                                else {
+                                    form_1.append(name, value);
+                                }
+                            }
+                            else {
+                                form_1.append(name, value, {
+                                    // @ts-expect-error TODO
+                                    filename: filename,
+                                    // @ts-expect-error TODO
+                                    contentType: param.contentType || null
+                                });
+                            }
+                        });
+                        if (isNativeFormData_1) {
+                            try {
+                                // eslint-disable-next-line no-restricted-syntax
+                                for (var _e = __values((0, form_data_2.formDataIterator)(form_1, boundary)), _f = _e.next(); !_f.done; _f = _e.next()) {
+                                    var data_1 = _f.value;
+                                    request.postData.text += data_1;
+                                }
+                            }
+                            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                            finally {
+                                try {
+                                    if (_f && !_f.done && (_a = _e["return"])) _a.call(_e);
+                                }
+                                finally { if (e_1) throw e_1.error; }
+                            }
+                        }
+                        else {
+                            form_1.pipe(
+                            // @ts-expect-error TODO
+                            (0, event_stream_1.map)(function (data) {
+                                request.postData.text += data;
+                            }));
+                        }
+                        request.postData.boundary = boundary;
+                        // Since headers are case-sensitive we need to see if there's an existing `Content-Type` header that we can override.
+                        var contentTypeHeader = (0, headers_1.getHeaderName)(request.headersObj, 'content-type') || 'content-type';
+                        request.headersObj[contentTypeHeader] = "multipart/form-data; boundary=".concat(boundary);
+                    }
+                    break;
+                case 'application/x-www-form-urlencoded':
+                    if (!request.postData.params) {
+                        request.postData.text = '';
+                    }
+                    else {
+                        // @ts-expect-error the `har-format` types make this challenging
+                        request.postData.paramsObj = request.postData.params.reduce(reducer_1.reducer, {});
+                        // always overwrite
+                        request.postData.text = (0, qs_1.stringify)(request.postData.paramsObj);
+                    }
+                    break;
+                case 'text/json':
+                case 'text/x-json':
+                case 'application/json':
+                case 'application/x-json':
+                    request.postData.mimeType = 'application/json';
+                    if (request.postData.text) {
+                        try {
+                            request.postData.jsonObj = JSON.parse(request.postData.text);
+                        }
+                        catch (e) {
+                            debug.info(e);
+                            // force back to `text/plain` if headers have proper content-type value, then this should also work
+                            request.postData.mimeType = 'text/plain';
+                        }
+                    }
+                    break;
+            }
+            // create allHeaders object
+            var allHeaders = __assign(__assign({}, request.allHeaders), request.headersObj);
+            var urlWithParsedQuery = (0, url_1.parse)(request.url, true, true); //?
+            // query string key/value pairs in with literal querystrings containd within the url
+            request.queryObj = __assign(__assign({}, request.queryObj), urlWithParsedQuery.query); //?
+            // reset uriObj values for a clean url
+            var search;
+            if (options.harIsAlreadyEncoded) {
+                search = (0, qs_1.stringify)(request.queryObj, {
+                    encode: false,
+                    indices: false
+                });
+            }
+            else {
+                search = (0, qs_1.stringify)(request.queryObj, {
+                    indices: false
+                });
+            }
+            var uriObj = __assign(__assign({}, urlWithParsedQuery), { query: request.queryObj, search: search, path: search ? "".concat(urlWithParsedQuery.pathname, "?").concat(search) : urlWithParsedQuery.pathname });
+            // keep the base url clean of queryString
+            var url = (0, url_1.format)(__assign(__assign({}, urlWithParsedQuery), { query: null, search: null })); //?
+            var fullUrl = (0, url_1.format)(__assign(__assign({}, urlWithParsedQuery), uriObj)); //?
+            return __assign(__assign({}, request), { allHeaders: allHeaders, fullUrl: fullUrl, url: url, uriObj: uriObj });
+        };
+        this.convert = function (targetId, clientId, options) {
+            if (!options && clientId) {
+                options = clientId;
+            }
+            var target = targets_1.targets[targetId];
+            if (!target) {
+                return false;
+            }
+            var convert = target.clientsById[clientId || target.info["default"]].convert;
+            var results = _this.requests.map(function (request) { return convert(request, options); });
+            return results.length === 1 ? results[0] : results;
+        };
+        var entries = [];
+        var options = __assign({ harIsAlreadyEncoded: false }, opts);
+        // prep the main container
+        this.requests = [];
+        // is it har?
+        if (isHarEntry(input)) {
+            entries = input.log.entries;
+        }
+        else {
+            entries = [
+                {
+                    request: input
+                },
+            ];
+        }
+        entries.forEach(function (_a) {
+            var _b;
+            var request = _a.request;
+            // add optional properties to make validation successful
+            var req = __assign({ bodySize: 0, headersSize: 0, headers: [], cookies: [], httpVersion: 'HTTP/1.1', queryString: [], postData: {
+                    mimeType: ((_b = request.postData) === null || _b === void 0 ? void 0 : _b.mimeType) || 'application/octet-stream'
+                } }, request);
+            if ((0, har_validator_1.validateHarRequest)(req)) {
+                _this.requests.push(_this.prepare(req, options));
+            }
+        });
+    }
+    return HTTPSnippet;
+}());
+exports.HTTPSnippet = HTTPSnippet;

package/dist/src/targets/c/libcurl/client.js

@@ -0,0 +1,43 @@
+"use strict";
+exports.__esModule = true;
+exports.libcurl = void 0;
+var code_builder_1 = require("../../../helpers/code-builder");
+exports.libcurl = {
+    info: {
+        key: 'libcurl',
+        title: 'Libcurl',
+        link: 'http://curl.haxx.se/libcurl',
+        description: 'Simple REST and HTTP API Client for C'
+    },
+    convert: function (_a) {
+        var method = _a.method, fullUrl = _a.fullUrl, headersObj = _a.headersObj, allHeaders = _a.allHeaders, postData = _a.postData;
+        var _b = new code_builder_1.CodeBuilder(), push = _b.push, blank = _b.blank, join = _b.join;
+        push('CURL *hnd = curl_easy_init();');
+        blank();
+        push("curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, \"".concat(method.toUpperCase(), "\");"));
+        push("curl_easy_setopt(hnd, CURLOPT_URL, \"".concat(fullUrl, "\");"));
+        // Add headers, including the cookies
+        var headers = Object.keys(headersObj);
+        // construct headers
+        if (headers.length) {
+            blank();
+            push('struct curl_slist *headers = NULL;');
+            headers.forEach(function (header) {
+                push("headers = curl_slist_append(headers, \"".concat(header, ": ").concat(headersObj[header], "\");"));
+            });
+            push('curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);');
+        }
+        // construct cookies
+        if (allHeaders.cookie) {
+            blank();
+            push("curl_easy_setopt(hnd, CURLOPT_COOKIE, \"".concat(allHeaders.cookie, "\");"));
+        }
+        if (postData.text) {
+            blank();
+            push("curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, ".concat(JSON.stringify(postData.text), ");"));
+        }
+        blank();
+        push('CURLcode ret = curl_easy_perform(hnd);');
+        return join();
+    }
+};

package/dist/src/targets/c/target.js

@@ -0,0 +1,15 @@
+"use strict";
+exports.__esModule = true;
+exports.c = void 0;
+var client_1 = require("./libcurl/client");
+exports.c = {
+    info: {
+        key: 'c',
+        title: 'C',
+        extname: '.c',
+        "default": 'libcurl'
+    },
+    clientsById: {
+        libcurl: client_1.libcurl
+    }
+};

package/dist/src/targets/clojure/clj_http/client.js

@@ -0,0 +1,184 @@
+"use strict";
+/**
+ * @description
+ * HTTP code snippet generator for Clojure using clj-http.
+ *
+ * @author
+ * @tggreene
+ *
+ * for any questions or issues regarding the generated code snippet, please open an issue mentioning the author.
+ */
+exports.__esModule = true;
+exports.clj_http = void 0;
+var code_builder_1 = require("../../../helpers/code-builder");
+var headers_1 = require("../../../helpers/headers");
+var Keyword = /** @class */ (function () {
+    function Keyword(name) {
+        var _this = this;
+        this.name = '';
+        this.toString = function () { return ":".concat(_this.name); };
+        this.name = name;
+    }
+    return Keyword;
+}());
+var File = /** @class */ (function () {
+    function File(path) {
+        var _this = this;
+        this.path = '';
+        this.toString = function () { return "(clojure.java.io/file \"".concat(_this.path, "\")"); };
+        this.path = path;
+    }
+    return File;
+}());
+var jsType = function (input) {
+    if (input === undefined) {
+        return null;
+    }
+    if (input === null) {
+        return 'null';
+    }
+    return input.constructor.name.toLowerCase();
+};
+var objEmpty = function (input) {
+    if (jsType(input) === 'object') {
+        return Object.keys(input).length === 0;
+    }
+    return false;
+};
+var filterEmpty = function (input) {
+    Object.keys(input)
+        .filter(function (x) { return objEmpty(input[x]); })
+        .forEach(function (x) {
+        delete input[x];
+    });
+    return input;
+};
+var padBlock = function (padSize, input) {
+    var padding = ' '.repeat(padSize);
+    return input.replace(/\n/g, "\n".concat(padding));
+};
+var jsToEdn = function (js) {
+    switch (jsType(js)) {
+        case 'string':
+            return "\"".concat(js.replace(/"/g, '\\"'), "\"");
+        case 'file':
+            return js.toString();
+        case 'keyword':
+            return js.toString();
+        case 'null':
+            return 'nil';
+        case 'regexp':
+            return "#\"".concat(js.source, "\"");
+        case 'object': {
+            // simple vertical format
+            var obj = Object.keys(js)
+                .reduce(function (accumulator, key) {
+                var val = padBlock(key.length + 2, jsToEdn(js[key]));
+                return "".concat(accumulator, ":").concat(key, " ").concat(val, "\n ");
+            }, '')
+                .trim();
+            return "{".concat(padBlock(1, obj), "}");
+        }
+        case 'array': {
+            // simple horizontal format
+            var arr = js.reduce(function (accumulator, value) { return "".concat(accumulator, " ").concat(jsToEdn(value)); }, '').trim();
+            return "[".concat(padBlock(1, arr), "]");
+        }
+        default: // 'number' 'boolean'
+            return js.toString();
+    }
+};
+exports.clj_http = {
+    info: {
+        key: 'clj_http',
+        title: 'clj-http',
+        link: 'https://github.com/dakrone/clj-http',
+        description: 'An idiomatic clojure http client wrapping the apache client.'
+    },
+    convert: function (_a, options) {
+        var queryObj = _a.queryObj, method = _a.method, postData = _a.postData, url = _a.url, allHeaders = _a.allHeaders;
+        var _b = new code_builder_1.CodeBuilder({ indent: options === null || options === void 0 ? void 0 : options.indent }), push = _b.push, join = _b.join;
+        var methods = ['get', 'post', 'put', 'delete', 'patch', 'head', 'options'];
+        method = method.toLowerCase();
+        if (!methods.includes(method)) {
+            push('Method not supported');
+            return join();
+        }
+        var params = {
+            headers: allHeaders,
+            'query-params': queryObj
+        };
+        switch (postData.mimeType) {
+            case 'application/json':
+                {
+                    params['content-type'] = new Keyword('json');
+                    params['form-params'] = postData.jsonObj;
+                    var header = (0, headers_1.getHeaderName)(params.headers, 'content-type');
+                    if (header) {
+                        delete params.headers[header];
+                    }
+                }
+                break;
+            case 'application/x-www-form-urlencoded':
+                {
+                    params['form-params'] = postData.paramsObj;
+                    var header = (0, headers_1.getHeaderName)(params.headers, 'content-type');
+                    if (header) {
+                        delete params.headers[header];
+                    }
+                }
+                break;
+            case 'text/plain':
+                {
+                    params.body = postData.text;
+                    var header = (0, headers_1.getHeaderName)(params.headers, 'content-type');
+                    if (header) {
+                        delete params.headers[header];
+                    }
+                }
+                break;
+            case 'multipart/form-data': {
+                if (postData.params) {
+                    params.multipart = postData.params.map(function (param) {
+                        if (param.fileName && !param.value) {
+                            return {
+                                name: param.name,
+                                content: new File(param.fileName)
+                            };
+                        }
+                        return {
+                            name: param.name,
+                            content: param.value
+                        };
+                    });
+                    var header = (0, headers_1.getHeaderName)(params.headers, 'content-type');
+                    if (header) {
+                        delete params.headers[header];
+                    }
+                }
+                break;
+            }
+        }
+        switch ((0, headers_1.getHeader)(params.headers, 'accept')) {
+            case 'application/json':
+                {
+                    params.accept = new Keyword('json');
+                    var header = (0, headers_1.getHeaderName)(params.headers, 'accept');
+                    if (header) {
+                        delete params.headers[header];
+                    }
+                }
+                break;
+        }
+        push("(require '[clj-http.client :as client])\n");
+        if (objEmpty(filterEmpty(params))) {
+            push("(client/".concat(method, " \"").concat(url, "\")"));
+        }
+        else {
+            var padding = 11 + method.length + url.length;
+            var formattedParams = padBlock(padding, jsToEdn(filterEmpty(params)));
+            push("(client/".concat(method, " \"").concat(url, "\" ").concat(formattedParams, ")"));
+        }
+        return join();
+    }
+};

package/dist/src/targets/clojure/target.js

@@ -0,0 +1,15 @@
+"use strict";
+exports.__esModule = true;
+exports.clojure = void 0;
+var client_1 = require("./clj_http/client");
+exports.clojure = {
+    info: {
+        key: 'clojure',
+        title: 'Clojure',
+        extname: '.clj',
+        "default": 'clj_http'
+    },
+    clientsById: {
+        clj_http: client_1.clj_http
+    }
+};