├── .github
    └── workflows
    │   └── pr-validation.yaml
├── .gitignore
├── .npmrc
├── LICENSE
├── README.md
├── dist
    ├── bodies
    │   ├── body.d.ts
    │   ├── file-body.d.ts
    │   ├── form-body.d.ts
    │   ├── json-body.d.ts
    │   └── raw-body.d.ts
    ├── curl-generator.cjs.js
    ├── curl-generator.esm.js
    ├── curl-generator.umd.js
    └── main.d.ts
├── example
    └── parameters.ts
├── package-lock.json
├── package.json
├── rollup.config.js
├── src
    ├── bodies
    │   ├── body.ts
    │   ├── file-body.ts
    │   ├── form-body.ts
    │   ├── json-body.ts
    │   └── raw-body.ts
    └── main.ts
├── test.txt
├── test
    ├── __snapshots__
    │   └── main.test.ts.snap
    └── main.test.ts
└── tsconfig.json


/.github/workflows/pr-validation.yaml:
--------------------------------------------------------------------------------
 1 | name: Validate PR
 2 | 
 3 | on:
 4 |   workflow_dispatch:
 5 |   pull_request:
 6 |     branches: [master]
 7 | 
 8 | jobs:
 9 |   checks:
10 |     name: PR checks
11 |     runs-on: ubuntu-latest
12 |     steps:
13 |       - name: Checkout repository
14 |         uses: actions/checkout@v4
15 | 
16 |       - name: Install Node.js
17 |         uses: actions/setup-node@v4
18 |         with:
19 |           node-version: 20
20 | 
21 |       - name: Install dependencies
22 |         run: npm ci
23 | 
24 |       - name: "Typescript: type checking"
25 |         run: "npm run typecheck"
26 | 
27 |       - name: "Unit tests"
28 |         run: "npm run test"
29 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | .DS_Store
2 | node_modules
3 | coverage
4 | 


--------------------------------------------------------------------------------
/.npmrc:
--------------------------------------------------------------------------------
1 | registry = "https://registry.npmjs.com/"
2 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2020 Alberto De Agostini
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # CurlGenerator
  2 | 
  3 | CurlGenerator is a **small** (~1kb), dependecy free, library to generate curl snippets.
  4 | Currently it has only 1 API, but I'm open to suggestion on how to improve and to integrate with different http request libraries.
  5 | 
  6 | <a href="https://www.buymeacoffee.com/albertodeago" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me A Coffee" style="height: 60px !important;width: 217px !important;" ></a>
  7 | 
  8 | ## Getting started
  9 | 
 10 | install in your project
 11 | ```bash
 12 | npm install curl-generator
 13 | ```
 14 | 
 15 | Or you can download the file you need from the dist folder
 16 | 
 17 | #### Using it
 18 | ```js
 19 | import {CurlGenerator} from "curl-generator";
 20 | 
 21 | const curlSnippet = CurlGenerator({url: "https://jsonplaceholder.typicode.com/posts/1"}); 
 22 | // curlSnippet => curl "https://jsonplaceholder.typicode.com/posts/101"
 23 | ```
 24 | 
 25 | If you are going to import it with in node via require
 26 | ```js
 27 | const CurlGenerator = require("curl-generator").CurlGenerator;
 28 | ```
 29 | 
 30 | #### API
 31 | 
 32 | Currently the library export just CurlGenerator, and it's a function with just 1 object parameter with the following description:
 33 | ```js
 34 | /**
 35 |  * @param {string} url - the request url
 36 |  * @param {string} [param.method] - a value between ("GET" | "POST" | "PUT" | "PATCH" | "DELETE") it's case insensitive
 37 |  * @param {Object<string, string>} [param.headers] - an object containing the headers of the request
 38 |  * @param {Object} [body] - the body of the request
 39 |  */
 40 | ```
 41 | 
 42 | Example of a more "andvanced" use
 43 | ```js
 44 | import {CurlGenerator} from "curl-generator";
 45 | 
 46 | const params = {
 47 |     url: "https://jsonplaceholder.typicode.com/posts",
 48 |     method: "POST",
 49 |     headers: {
 50 |         "Content-type": "application/json; charset=UTF-8"
 51 |     },
 52 |     body: {
 53 |         "id": "123-456-789",
 54 |         "key1": "value 1",
 55 |         "key2": `a "complex" value`
 56 |     }
 57 | }
 58 | const curlSnippet = CurlGenerator(params); 
 59 | // curlSnippet => curl "https://jsonplaceholder.typicode.com/posts" -X POST -H "Content-type: application/json; charset=UTF-8" -d "{\"id\":\"123-456-789\",\"key1\":\"value 1\",\"key2\":\"a \\\"complex\\\" value\"}"
 60 | ```
 61 | 
 62 | You can also pass Curl options as additional options:
 63 | ```js
 64 | import {CurlGenerator} from "curl-generator";
 65 | 
 66 | const params = {
 67 |     url: "https://jsonplaceholder.typicode.com/posts/1"
 68 | }
 69 | const options = {
 70 |     output: "test.txt",
 71 |     silent: true
 72 | }
 73 | const curlSnippet = CurlGenerator(params, options); 
 74 | // curl "https://jsonplaceholder.typicode.com/posts/1" --output test.txt --silent
 75 | ```
 76 | Currently the following options are supported (you can submit a PR if you need others):
 77 | | Name              |      Type     |
 78 | |:-----------------:|:-------------:|
 79 | | compressed        | boolean       |
 80 | | compressedSsh     | boolean       |
 81 | | fail              | boolean       |
 82 | | failEarly         | boolean       |
 83 | | head              | boolean       |
 84 | | include           | boolean       |
 85 | | insecure          | boolean       |
 86 | | ipv4              | boolean       |
 87 | | ipv6              | boolean       |
 88 | | listOnly          | boolean       |
 89 | | location          | boolean       |
 90 | | locationTrusted   | boolean       |
 91 | | noKeepalive       | boolean       |
 92 | | output            | string        |
 93 | | showError         | boolean       |
 94 | | silent            | boolean       |
 95 | | ssl               | boolean       |
 96 | | sslv2             | boolean       |
 97 | | sslv3             | boolean       |
 98 | | verbose           | boolean       |
 99 | 
100 | ## Contributing
101 | 
102 | The library is written in typescript (it's my first typescript project so I'm very open to tips and suggestions) and it comes with 3 scripts
103 | Dev build with watch
104 | ```bash
105 | npm run dev
106 | ```
107 | Build bundle
108 | ```bash
109 | npm run build
110 | ```
111 | Test (I plan to move testing with jest if the library grows)
112 | ```bash
113 | npm run test
114 | ```
115 | 
116 | The build generate three files:
117 | * `dist/curl-generator.cjs.js`
118 |     A CommonJS bundle, suitable for use in Node.js, that `require`s the external dependency. This corresponds to the `"main"` field in package.json
119 | * `dist/curl-generator.esm.js`
120 |     an ES module bundle, suitable for use in other people's libraries and applications, that `import`s the external dependency. This corresponds to the `"module"` field in package.json
121 | * `dist/curl-generator.umd.js`
122 |     a UMD build, suitable for use in any environment (including the browser, as a `<script>` tag), that includes the external dependency. This corresponds to the `"browser"` field in package.json
123 | 
124 | ## Author and License
125 | 
126 | [Alberto De Agostini](https://twitter.com/albertodeago88)
127 | [MIT](LICENSE).
128 | 


--------------------------------------------------------------------------------
/dist/bodies/body.d.ts:
--------------------------------------------------------------------------------
1 | import { CurlFileBody } from "./file-body";
2 | import { CurlRawBody } from "./raw-body";
3 | import { CurlJsonBody } from "./json-body";
4 | import { CurlFormBody } from "./form-body";
5 | export declare type CurlBody = string | Record<string | number | symbol, unknown> | URLSearchParams | CurlFileBody | CurlRawBody | CurlJsonBody | CurlFormBody;
6 | export declare function bodyToString(body: CurlBody): string;
7 | export declare function bodyToCommand(body: CurlBody): string;
8 | 


--------------------------------------------------------------------------------
/dist/bodies/file-body.d.ts:
--------------------------------------------------------------------------------
 1 | export interface CurlFileBody {
 2 |     /**
 3 |      * File body type for using a file as the body data.
 4 |      */
 5 |     type: "file";
 6 |     /**
 7 |      * The file name without the @.
 8 |      */
 9 |     fileName: string;
10 | }
11 | export declare function isCurlFileBody(body: unknown): body is CurlFileBody;
12 | export declare function fileBodyToString(body: CurlFileBody): string;
13 | export declare function fileBodyToCommand(body: CurlFileBody): string;
14 | 


--------------------------------------------------------------------------------
/dist/bodies/form-body.d.ts:
--------------------------------------------------------------------------------
 1 | import { CurlFileBody } from "./file-body";
 2 | import { CurlRawBody } from "./raw-body";
 3 | export interface CurlFormBody {
 4 |     /**
 5 |      * Form body type for URL-encoded form data.
 6 |      */
 7 |     type: "form";
 8 |     /**
 9 |      * The content of the body.
10 |      */
11 |     content: Record<string, string | CurlFileBody | CurlRawBody> | URLSearchParams;
12 | }
13 | export declare function formBodyToString(body: CurlFormBody): string;
14 | export declare function isCurlFormBody(body: unknown): body is CurlFormBody;
15 | export declare function formBodyToCommand(body: CurlFormBody): string;
16 | 


--------------------------------------------------------------------------------
/dist/bodies/json-body.d.ts:
--------------------------------------------------------------------------------
 1 | export interface CurlJsonBody {
 2 |     /**
 3 |      * JSON body type for JSON objects.
 4 |      */
 5 |     type: "json";
 6 |     /**
 7 |      * The content of the body.
 8 |      */
 9 |     content: Record<string | number | symbol, unknown>;
10 | }
11 | export declare function isCurlJsonBody(body: unknown): body is CurlJsonBody;
12 | export declare function jsonContentToString(content: Record<string | number | symbol, unknown>): string;
13 | export declare function jsonBodyToString(body: CurlJsonBody): string;
14 | export declare function jsonBodyToCommand(body: CurlJsonBody): string;
15 | 


--------------------------------------------------------------------------------
/dist/bodies/raw-body.d.ts:
--------------------------------------------------------------------------------
 1 | export interface CurlRawBody {
 2 |     /**
 3 |      * Raw body type for strings/text.
 4 |      */
 5 |     type: "raw";
 6 |     /**
 7 |      * The content of the body.
 8 |      */
 9 |     content: string;
10 | }
11 | export declare function isCurlRawBody(body: unknown): body is CurlRawBody;
12 | export declare function rawBodyToString(body: CurlRawBody): string;
13 | export declare function rawBodyToCommand(body: CurlRawBody): string;
14 | 


--------------------------------------------------------------------------------
/dist/curl-generator.cjs.js:
--------------------------------------------------------------------------------
  1 | 'use strict';
  2 | 
  3 | Object.defineProperty(exports, '__esModule', { value: true });
  4 | 
  5 | function isCurlFileBody(body) {
  6 |     return typeof body === "object" && body !== null && "type" in body && body.type === "file" && "fileName" in body;
  7 | }
  8 | function fileBodyToString(body) {
  9 |     return "@" + body.fileName;
 10 | }
 11 | function fileBodyToCommand(body) {
 12 |     return "--data-binary " + fileBodyToString(body);
 13 | }
 14 | 
 15 | function isCurlRawBody(body) {
 16 |     return typeof body === "object" && body !== null && "type" in body && body.type === "raw" && "content" in body;
 17 | }
 18 | function rawBodyToString(body) {
 19 |     return body.content;
 20 | }
 21 | function rawBodyToCommand(body) {
 22 |     return "-d '" + rawBodyToString(body) + "'";
 23 | }
 24 | 
 25 | function isCurlJsonBody(body) {
 26 |     return typeof body === "object" && body !== null && "type" in body && body.type === "json" && "content" in body;
 27 | }
 28 | function jsonContentToString(content) {
 29 |     return JSON.stringify(content).replace(/([\\'])/g, "\\$1");
 30 | }
 31 | function jsonBodyToString(body) {
 32 |     return jsonContentToString(body.content);
 33 | }
 34 | function jsonBodyToCommand(body) {
 35 |     return "-d '" + jsonBodyToString(body) + "'";
 36 | }
 37 | 
 38 | function isCurlFormBody(body) {
 39 |     return typeof body === "object" && body !== null && "type" in body && body.type === "form" && "content" in body;
 40 | }
 41 | function formBodyToCommand(body) {
 42 |     if (body.content instanceof URLSearchParams) {
 43 |         return "-d '" + body.content.toString() + "'";
 44 |     }
 45 |     return Object.entries(body.content)
 46 |         .map(function (_a) {
 47 |         var key = _a[0], value = _a[1];
 48 |         if (typeof value === "string") {
 49 |             return "-F " + key + "=" + value;
 50 |         }
 51 |         if (value.type === "file") {
 52 |             return "-F " + key + "=@" + value.fileName;
 53 |         }
 54 |         if (value.type === "raw") {
 55 |             return "-F " + key + "=" + value.content;
 56 |         }
 57 |         throw new Error("Invalid form body value type: " + value);
 58 |     })
 59 |         .join(" \\\n ");
 60 | }
 61 | 
 62 | function bodyToCommand(body) {
 63 |     if (typeof body === "string") {
 64 |         return "-d '" + body + "'";
 65 |     }
 66 |     else if (body instanceof URLSearchParams) {
 67 |         return "-d '" + body.toString() + "'";
 68 |     }
 69 |     else if (isCurlFileBody(body)) {
 70 |         return fileBodyToCommand(body);
 71 |     }
 72 |     else if (isCurlRawBody(body)) {
 73 |         return rawBodyToCommand(body);
 74 |     }
 75 |     else if (isCurlJsonBody(body)) {
 76 |         return jsonBodyToCommand(body);
 77 |     }
 78 |     else if (isCurlFormBody(body)) {
 79 |         return formBodyToCommand(body);
 80 |     }
 81 |     else if (typeof body === "object") {
 82 |         return "-d '" + jsonContentToString(body) + "'";
 83 |     }
 84 |     throw new Error("Invalid body type: " + body);
 85 | }
 86 | 
 87 | // slash for connecting previous breakup line to current line for running cURL directly in Command Prompt
 88 | var slash = " \\";
 89 | var newLine = "\n";
 90 | /**
 91 |  * @param {string} [method]
 92 |  * @returns {string}
 93 |  */
 94 | var getCurlMethod = function (method) {
 95 |     var result = "";
 96 |     if (method) {
 97 |         var types = {
 98 |             GET: "-X GET",
 99 |             POST: "-X POST",
100 |             PUT: "-X PUT",
101 |             PATCH: "-X PATCH",
102 |             DELETE: "-X DELETE",
103 |         };
104 |         result = " " + types[method.toUpperCase()];
105 |     }
106 |     return slash + newLine + result;
107 | };
108 | /**
109 |  * @param {StringMap} headers
110 |  * @returns {string}
111 |  */
112 | var getCurlHeaders = function (headers) {
113 |     var result = "";
114 |     if (headers) {
115 |         Object.keys(headers).map(function (val) {
116 |             result += "" + slash + newLine + " -H '" + val + ": " + headers[val].replace(/(\\|')/g, "\\$1") + "'";
117 |         });
118 |     }
119 |     return result;
120 | };
121 | /**
122 |  * @param {CurlBody} body
123 |  * @returns {string}
124 |  */
125 | var getCurlBody = function (body) {
126 |     var result = "";
127 |     if (body) {
128 |         result += "" + slash + newLine + " " + bodyToCommand(body);
129 |     }
130 |     return result;
131 | };
132 | /**
133 |  * Given the curl additional options, turn them into curl syntax
134 |  * @param {CurlAdditionalOptions} [options]
135 |  * @returns {string}
136 |  */
137 | var getCurlOptions = function (options) {
138 |     var result = "";
139 |     if (options) {
140 |         Object.keys(options).forEach(function (key) {
141 |             var kebabKey = key.replace(/[A-Z]/g, function (letter) { return "-" + letter.toLowerCase(); });
142 |             if (!options[key]) {
143 |                 throw new Error("Invalid Curl option " + key);
144 |             }
145 |             else if (typeof options[key] === "boolean" && options[key]) {
146 |                 // boolean option, we just add --opt
147 |                 result += " --" + kebabKey;
148 |             }
149 |             else if (typeof options[key] === "string") {
150 |                 // string option, we have to add --opt=value
151 |                 result += " --" + kebabKey + " " + options[key];
152 |             }
153 |         });
154 |     }
155 |     return result ? "" + slash + newLine + result : result;
156 | };
157 | /**
158 |  * @param {CurlRequest} params
159 |  * @param {CurlAdditionalOptions} [options]
160 |  * @returns {string}
161 |  */
162 | var CurlGenerator = function (params, options) {
163 |     var curlSnippet = "curl ";
164 |     curlSnippet += params.url;
165 |     curlSnippet += getCurlMethod(params.method);
166 |     curlSnippet += getCurlHeaders(params.headers);
167 |     curlSnippet += getCurlBody(params.body);
168 |     curlSnippet += getCurlOptions(options);
169 |     return curlSnippet.trim();
170 | };
171 | 
172 | exports.CurlGenerator = CurlGenerator;
173 | 


--------------------------------------------------------------------------------
/dist/curl-generator.esm.js:
--------------------------------------------------------------------------------
  1 | function isCurlFileBody(body) {
  2 |     return typeof body === "object" && body !== null && "type" in body && body.type === "file" && "fileName" in body;
  3 | }
  4 | function fileBodyToString(body) {
  5 |     return "@" + body.fileName;
  6 | }
  7 | function fileBodyToCommand(body) {
  8 |     return "--data-binary " + fileBodyToString(body);
  9 | }
 10 | 
 11 | function isCurlRawBody(body) {
 12 |     return typeof body === "object" && body !== null && "type" in body && body.type === "raw" && "content" in body;
 13 | }
 14 | function rawBodyToString(body) {
 15 |     return body.content;
 16 | }
 17 | function rawBodyToCommand(body) {
 18 |     return "-d '" + rawBodyToString(body) + "'";
 19 | }
 20 | 
 21 | function isCurlJsonBody(body) {
 22 |     return typeof body === "object" && body !== null && "type" in body && body.type === "json" && "content" in body;
 23 | }
 24 | function jsonContentToString(content) {
 25 |     return JSON.stringify(content).replace(/([\\'])/g, "\\$1");
 26 | }
 27 | function jsonBodyToString(body) {
 28 |     return jsonContentToString(body.content);
 29 | }
 30 | function jsonBodyToCommand(body) {
 31 |     return "-d '" + jsonBodyToString(body) + "'";
 32 | }
 33 | 
 34 | function isCurlFormBody(body) {
 35 |     return typeof body === "object" && body !== null && "type" in body && body.type === "form" && "content" in body;
 36 | }
 37 | function formBodyToCommand(body) {
 38 |     if (body.content instanceof URLSearchParams) {
 39 |         return "-d '" + body.content.toString() + "'";
 40 |     }
 41 |     return Object.entries(body.content)
 42 |         .map(function (_a) {
 43 |         var key = _a[0], value = _a[1];
 44 |         if (typeof value === "string") {
 45 |             return "-F " + key + "=" + value;
 46 |         }
 47 |         if (value.type === "file") {
 48 |             return "-F " + key + "=@" + value.fileName;
 49 |         }
 50 |         if (value.type === "raw") {
 51 |             return "-F " + key + "=" + value.content;
 52 |         }
 53 |         throw new Error("Invalid form body value type: " + value);
 54 |     })
 55 |         .join(" \\\n ");
 56 | }
 57 | 
 58 | function bodyToCommand(body) {
 59 |     if (typeof body === "string") {
 60 |         return "-d '" + body + "'";
 61 |     }
 62 |     else if (body instanceof URLSearchParams) {
 63 |         return "-d '" + body.toString() + "'";
 64 |     }
 65 |     else if (isCurlFileBody(body)) {
 66 |         return fileBodyToCommand(body);
 67 |     }
 68 |     else if (isCurlRawBody(body)) {
 69 |         return rawBodyToCommand(body);
 70 |     }
 71 |     else if (isCurlJsonBody(body)) {
 72 |         return jsonBodyToCommand(body);
 73 |     }
 74 |     else if (isCurlFormBody(body)) {
 75 |         return formBodyToCommand(body);
 76 |     }
 77 |     else if (typeof body === "object") {
 78 |         return "-d '" + jsonContentToString(body) + "'";
 79 |     }
 80 |     throw new Error("Invalid body type: " + body);
 81 | }
 82 | 
 83 | // slash for connecting previous breakup line to current line for running cURL directly in Command Prompt
 84 | var slash = " \\";
 85 | var newLine = "\n";
 86 | /**
 87 |  * @param {string} [method]
 88 |  * @returns {string}
 89 |  */
 90 | var getCurlMethod = function (method) {
 91 |     var result = "";
 92 |     if (method) {
 93 |         var types = {
 94 |             GET: "-X GET",
 95 |             POST: "-X POST",
 96 |             PUT: "-X PUT",
 97 |             PATCH: "-X PATCH",
 98 |             DELETE: "-X DELETE",
 99 |         };
100 |         result = " " + types[method.toUpperCase()];
101 |     }
102 |     return slash + newLine + result;
103 | };
104 | /**
105 |  * @param {StringMap} headers
106 |  * @returns {string}
107 |  */
108 | var getCurlHeaders = function (headers) {
109 |     var result = "";
110 |     if (headers) {
111 |         Object.keys(headers).map(function (val) {
112 |             result += "" + slash + newLine + " -H '" + val + ": " + headers[val].replace(/(\\|')/g, "\\$1") + "'";
113 |         });
114 |     }
115 |     return result;
116 | };
117 | /**
118 |  * @param {CurlBody} body
119 |  * @returns {string}
120 |  */
121 | var getCurlBody = function (body) {
122 |     var result = "";
123 |     if (body) {
124 |         result += "" + slash + newLine + " " + bodyToCommand(body);
125 |     }
126 |     return result;
127 | };
128 | /**
129 |  * Given the curl additional options, turn them into curl syntax
130 |  * @param {CurlAdditionalOptions} [options]
131 |  * @returns {string}
132 |  */
133 | var getCurlOptions = function (options) {
134 |     var result = "";
135 |     if (options) {
136 |         Object.keys(options).forEach(function (key) {
137 |             var kebabKey = key.replace(/[A-Z]/g, function (letter) { return "-" + letter.toLowerCase(); });
138 |             if (!options[key]) {
139 |                 throw new Error("Invalid Curl option " + key);
140 |             }
141 |             else if (typeof options[key] === "boolean" && options[key]) {
142 |                 // boolean option, we just add --opt
143 |                 result += " --" + kebabKey;
144 |             }
145 |             else if (typeof options[key] === "string") {
146 |                 // string option, we have to add --opt=value
147 |                 result += " --" + kebabKey + " " + options[key];
148 |             }
149 |         });
150 |     }
151 |     return result ? "" + slash + newLine + result : result;
152 | };
153 | /**
154 |  * @param {CurlRequest} params
155 |  * @param {CurlAdditionalOptions} [options]
156 |  * @returns {string}
157 |  */
158 | var CurlGenerator = function (params, options) {
159 |     var curlSnippet = "curl ";
160 |     curlSnippet += params.url;
161 |     curlSnippet += getCurlMethod(params.method);
162 |     curlSnippet += getCurlHeaders(params.headers);
163 |     curlSnippet += getCurlBody(params.body);
164 |     curlSnippet += getCurlOptions(options);
165 |     return curlSnippet.trim();
166 | };
167 | 
168 | export { CurlGenerator };
169 | 


--------------------------------------------------------------------------------
/dist/curl-generator.umd.js:
--------------------------------------------------------------------------------
  1 | (function (global, factory) {
  2 |   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
  3 |   typeof define === 'function' && define.amd ? define(['exports'], factory) :
  4 |   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["curl-generator"] = {}));
  5 | })(this, (function (exports) { 'use strict';
  6 | 
  7 |   function isCurlFileBody(body) {
  8 |       return typeof body === "object" && body !== null && "type" in body && body.type === "file" && "fileName" in body;
  9 |   }
 10 |   function fileBodyToString(body) {
 11 |       return "@" + body.fileName;
 12 |   }
 13 |   function fileBodyToCommand(body) {
 14 |       return "--data-binary " + fileBodyToString(body);
 15 |   }
 16 | 
 17 |   function isCurlRawBody(body) {
 18 |       return typeof body === "object" && body !== null && "type" in body && body.type === "raw" && "content" in body;
 19 |   }
 20 |   function rawBodyToString(body) {
 21 |       return body.content;
 22 |   }
 23 |   function rawBodyToCommand(body) {
 24 |       return "-d '" + rawBodyToString(body) + "'";
 25 |   }
 26 | 
 27 |   function isCurlJsonBody(body) {
 28 |       return typeof body === "object" && body !== null && "type" in body && body.type === "json" && "content" in body;
 29 |   }
 30 |   function jsonContentToString(content) {
 31 |       return JSON.stringify(content).replace(/([\\'])/g, "\\$1");
 32 |   }
 33 |   function jsonBodyToString(body) {
 34 |       return jsonContentToString(body.content);
 35 |   }
 36 |   function jsonBodyToCommand(body) {
 37 |       return "-d '" + jsonBodyToString(body) + "'";
 38 |   }
 39 | 
 40 |   function isCurlFormBody(body) {
 41 |       return typeof body === "object" && body !== null && "type" in body && body.type === "form" && "content" in body;
 42 |   }
 43 |   function formBodyToCommand(body) {
 44 |       if (body.content instanceof URLSearchParams) {
 45 |           return "-d '" + body.content.toString() + "'";
 46 |       }
 47 |       return Object.entries(body.content)
 48 |           .map(function (_a) {
 49 |           var key = _a[0], value = _a[1];
 50 |           if (typeof value === "string") {
 51 |               return "-F " + key + "=" + value;
 52 |           }
 53 |           if (value.type === "file") {
 54 |               return "-F " + key + "=@" + value.fileName;
 55 |           }
 56 |           if (value.type === "raw") {
 57 |               return "-F " + key + "=" + value.content;
 58 |           }
 59 |           throw new Error("Invalid form body value type: " + value);
 60 |       })
 61 |           .join(" \\\n ");
 62 |   }
 63 | 
 64 |   function bodyToCommand(body) {
 65 |       if (typeof body === "string") {
 66 |           return "-d '" + body + "'";
 67 |       }
 68 |       else if (body instanceof URLSearchParams) {
 69 |           return "-d '" + body.toString() + "'";
 70 |       }
 71 |       else if (isCurlFileBody(body)) {
 72 |           return fileBodyToCommand(body);
 73 |       }
 74 |       else if (isCurlRawBody(body)) {
 75 |           return rawBodyToCommand(body);
 76 |       }
 77 |       else if (isCurlJsonBody(body)) {
 78 |           return jsonBodyToCommand(body);
 79 |       }
 80 |       else if (isCurlFormBody(body)) {
 81 |           return formBodyToCommand(body);
 82 |       }
 83 |       else if (typeof body === "object") {
 84 |           return "-d '" + jsonContentToString(body) + "'";
 85 |       }
 86 |       throw new Error("Invalid body type: " + body);
 87 |   }
 88 | 
 89 |   // slash for connecting previous breakup line to current line for running cURL directly in Command Prompt
 90 |   var slash = " \\";
 91 |   var newLine = "\n";
 92 |   /**
 93 |    * @param {string} [method]
 94 |    * @returns {string}
 95 |    */
 96 |   var getCurlMethod = function (method) {
 97 |       var result = "";
 98 |       if (method) {
 99 |           var types = {
100 |               GET: "-X GET",
101 |               POST: "-X POST",
102 |               PUT: "-X PUT",
103 |               PATCH: "-X PATCH",
104 |               DELETE: "-X DELETE",
105 |           };
106 |           result = " " + types[method.toUpperCase()];
107 |       }
108 |       return slash + newLine + result;
109 |   };
110 |   /**
111 |    * @param {StringMap} headers
112 |    * @returns {string}
113 |    */
114 |   var getCurlHeaders = function (headers) {
115 |       var result = "";
116 |       if (headers) {
117 |           Object.keys(headers).map(function (val) {
118 |               result += "" + slash + newLine + " -H '" + val + ": " + headers[val].replace(/(\\|')/g, "\\$1") + "'";
119 |           });
120 |       }
121 |       return result;
122 |   };
123 |   /**
124 |    * @param {CurlBody} body
125 |    * @returns {string}
126 |    */
127 |   var getCurlBody = function (body) {
128 |       var result = "";
129 |       if (body) {
130 |           result += "" + slash + newLine + " " + bodyToCommand(body);
131 |       }
132 |       return result;
133 |   };
134 |   /**
135 |    * Given the curl additional options, turn them into curl syntax
136 |    * @param {CurlAdditionalOptions} [options]
137 |    * @returns {string}
138 |    */
139 |   var getCurlOptions = function (options) {
140 |       var result = "";
141 |       if (options) {
142 |           Object.keys(options).forEach(function (key) {
143 |               var kebabKey = key.replace(/[A-Z]/g, function (letter) { return "-" + letter.toLowerCase(); });
144 |               if (!options[key]) {
145 |                   throw new Error("Invalid Curl option " + key);
146 |               }
147 |               else if (typeof options[key] === "boolean" && options[key]) {
148 |                   // boolean option, we just add --opt
149 |                   result += " --" + kebabKey;
150 |               }
151 |               else if (typeof options[key] === "string") {
152 |                   // string option, we have to add --opt=value
153 |                   result += " --" + kebabKey + " " + options[key];
154 |               }
155 |           });
156 |       }
157 |       return result ? "" + slash + newLine + result : result;
158 |   };
159 |   /**
160 |    * @param {CurlRequest} params
161 |    * @param {CurlAdditionalOptions} [options]
162 |    * @returns {string}
163 |    */
164 |   var CurlGenerator = function (params, options) {
165 |       var curlSnippet = "curl ";
166 |       curlSnippet += params.url;
167 |       curlSnippet += getCurlMethod(params.method);
168 |       curlSnippet += getCurlHeaders(params.headers);
169 |       curlSnippet += getCurlBody(params.body);
170 |       curlSnippet += getCurlOptions(options);
171 |       return curlSnippet.trim();
172 |   };
173 | 
174 |   exports.CurlGenerator = CurlGenerator;
175 | 
176 |   Object.defineProperty(exports, '__esModule', { value: true });
177 | 
178 | }));
179 | 


--------------------------------------------------------------------------------
/dist/main.d.ts:
--------------------------------------------------------------------------------
 1 | import { CurlBody } from "./bodies/body";
 2 | declare type StringMap = {
 3 |     [key: string]: string;
 4 | };
 5 | /**
 6 |  * Additional options for curl command.
 7 |  *
 8 |  * --compressed        ->   Request compressed response
 9 |  * --compressed-ssh    ->   Enable SSH compression
10 |  * --fail              ->   Fail silently (no output at all) on HTTP errors
11 |  * --fail-early        ->   Fail on first transfer error, do not continue
12 |  * --head              ->   Show document info only
13 |  * --include           ->   Include protocol response headers in the output
14 |  * --insecure          ->   Allow insecure server connections when using SSL
15 |  * --ipv4              ->   Resolve names to IPv4 addresses
16 |  * --ipv6              ->   Resolve names to IPv6 addresses
17 |  * --list-only         ->   List only mode
18 |  * --location          ->   Follow redirects
19 |  * --location-trusted  ->   Like --location, and send auth to other hosts
20 |  * --no-keepalive      ->   Disable TCP keepalive on the connection
21 |  * --show-error        ->   Show error even when -s is used
22 |  * --silent            ->   Silent mode
23 |  * --ssl               ->   Try SSL/TLS
24 |  * --sslv2             ->   Use SSLv2
25 |  * --sslv3             ->   Use SSLv3
26 |  * --verbose           ->   Make the operation more talkative
27 |  */
28 | declare type CurlAdditionalOptions = {
29 |     compressed?: boolean;
30 |     compressedSsh?: boolean;
31 |     fail?: boolean;
32 |     failEarly?: boolean;
33 |     head?: boolean;
34 |     include?: boolean;
35 |     insecure?: boolean;
36 |     ipv4?: boolean;
37 |     ipv6?: boolean;
38 |     listOnly?: boolean;
39 |     location?: boolean;
40 |     locationTrusted?: boolean;
41 |     noKeepalive?: boolean;
42 |     output?: string;
43 |     showError?: boolean;
44 |     silent?: boolean;
45 |     ssl?: boolean;
46 |     sslv2?: boolean;
47 |     sslv3?: boolean;
48 |     verbose?: boolean;
49 | };
50 | declare type CurlRequest = {
51 |     method?: "GET" | "get" | "POST" | "post" | "PUT" | "put" | "PATCH" | "patch" | "DELETE" | "delete";
52 |     headers?: StringMap;
53 |     body?: CurlBody;
54 |     url: string;
55 | };
56 | /**
57 |  * @param {CurlRequest} params
58 |  * @param {CurlAdditionalOptions} [options]
59 |  * @returns {string}
60 |  */
61 | declare const CurlGenerator: (params: CurlRequest, options?: CurlAdditionalOptions | undefined) => string;
62 | export { CurlGenerator };
63 | 


--------------------------------------------------------------------------------
/example/parameters.ts:
--------------------------------------------------------------------------------
  1 | export const get1 = { url: "https://jsonplaceholder.typicode.com/posts/101" };
  2 | 
  3 | export const get2 = {
  4 |   url: "https://jsonplaceholder.typicode.com/todos/1",
  5 |   method: "GET",
  6 | };
  7 | 
  8 | export const getWithHeaders = {
  9 |   url: "https://jsonplaceholder.typicode.com/todos/1",
 10 |   method: "GET",
 11 |   headers: {
 12 |     "Content-Type": "application/json",
 13 |   },
 14 | };
 15 | 
 16 | export const getEscapeHeaders = {
 17 |   url: "https://jsonplaceholder.typicode.com/todos/1",
 18 |   method: "GET",
 19 |   headers: {
 20 |     key: `a "strange" value`,
 21 |   },
 22 | };
 23 | 
 24 | export const post1 = {
 25 |   url: "https://jsonplaceholder.typicode.com/posts",
 26 |   method: "post",
 27 |   headers: {
 28 |     "Content-type": "application/json; charset=UTF-8",
 29 |   },
 30 |   body: {
 31 |     id: "123-456-789",
 32 |     key1: "value 1",
 33 |     key2: `a "complex" value`,
 34 |   },
 35 | };
 36 | 
 37 | export const put1 = {
 38 |   url: "https://jsonplaceholder.typicode.com/posts/1",
 39 |   method: "PUT",
 40 |   body: {
 41 |     id: 1,
 42 |     title: "foo",
 43 |     body: "barzzz",
 44 |     userId: 1,
 45 |   },
 46 |   headers: {
 47 |     "Content-type": "application/json; charset=UTF-8",
 48 |   },
 49 | };
 50 | 
 51 | export const patch1 = {
 52 |   url: "https://jsonplaceholder.typicode.com/posts/1",
 53 |   method: "PATCH",
 54 |   body: {
 55 |     title: "foo patched",
 56 |   },
 57 |   headers: {
 58 |     "Content-type": "application/json; charset=UTF-8",
 59 |   },
 60 | };
 61 | 
 62 | export const del1 = {
 63 |   url: "https://jsonplaceholder.typicode.com/posts/1",
 64 |   method: "DELETE",
 65 | };
 66 | 
 67 | export const opt1 = {
 68 |   url: "https://jsonplaceholder.typicode.com/posts/1",
 69 |   options: {
 70 |     silent: true,
 71 |     showError: true,
 72 |   },
 73 | };
 74 | 
 75 | export const opt2 = {
 76 |   url: "https://jsonplaceholder.typicode.com/posts/1",
 77 |   options: {
 78 |     output: "test.txt",
 79 |     silent: true,
 80 |   },
 81 | };
 82 | 
 83 | export const searchParamsBody = {
 84 |   url: "https://jsonplaceholder.typicode.com/posts",
 85 |   method: "POST",
 86 |   headers: {
 87 |     "Content-Type": "text/plain",
 88 |   },
 89 |   body: new URLSearchParams("key1=value 1"),
 90 | };
 91 | 
 92 | export const rawBody1 = {
 93 |   url: "https://jsonplaceholder.typicode.com/posts",
 94 |   method: "POST",
 95 |   headers: {
 96 |     "Content-Type": "text/plain",
 97 |   },
 98 |   body: "string data",
 99 | };
100 | 
101 | export const rawBody2 = {
102 |   url: "https://jsonplaceholder.typicode.com/posts",
103 |   method: "POST",
104 |   headers: {
105 |     "Content-Type": "text/plain",
106 |   },
107 |   body: {
108 |     type: "raw",
109 |     content: "string data",
110 |   },
111 | };
112 | 
113 | export const fileBody = {
114 |   url: "https://jsonplaceholder.typicode.com/posts",
115 |   method: "POST",
116 |   headers: {
117 |     "Content-Type": "application/json",
118 |   },
119 |   body: {
120 |     type: "file",
121 |     fileName: "data.json",
122 |   },
123 | };
124 | 
125 | export const formBody1 = {
126 |   url: "https://jsonplaceholder.typicode.com/posts",
127 |   method: "POST",
128 |   headers: {
129 |     "Content-Type": "application/x-www-form-urlencoded",
130 |   },
131 |   body: {
132 |     type: "form",
133 |     content: {
134 |       name: "foo",
135 |     },
136 |   },
137 | };
138 | 
139 | export const formBody2 = {
140 |   url: "https://jsonplaceholder.typicode.com/posts",
141 |   method: "POST",
142 |   headers: {
143 |     "Content-Type": "multipart/form-data",
144 |   },
145 |   body: {
146 |     type: "form",
147 |     content: {
148 |       file1: {
149 |         type: "file",
150 |         fileName: "data.json",
151 |       },
152 |     },
153 |   },
154 | };
155 | 
156 | export const formBody3 = {
157 |   url: "https://jsonplaceholder.typicode.com/posts",
158 |   method: "POST",
159 |   headers: {
160 |     "Content-Type": "application/x-www-form-urlencoded",
161 |   },
162 |   body: {
163 |     type: "form",
164 |     content: {
165 |       file1: {
166 |         type: "raw",
167 |         content: "string data",
168 |       },
169 |     },
170 |   },
171 | };
172 | 
173 | export const formBody4 = {
174 |   url: "https://jsonplaceholder.typicode.com/posts",
175 |   method: "POST",
176 |   headers: {
177 |     "Content-Type": "application/x-www-form-urlencoded",
178 |   },
179 |   body: {
180 |     type: "form",
181 |     content: new URLSearchParams("key1=value 1"),
182 |   },
183 | };
184 | 
185 | export const jsonBody = {
186 |   url: "https://jsonplaceholder.typicode.com/posts",
187 |   method: "POST",
188 |   headers: {
189 |     "Content-Type": "application/json",
190 |   },
191 |   body: {
192 |     type: "json",
193 |     content: {
194 |       name: "foo",
195 |     },
196 |   },
197 | };
198 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "curl-generator",
 3 |     "author": "albertodeagostini.dev@gmail.com",
 4 |     "version": "0.4.2",
 5 |     "main": "dist/curl-generator.cjs.js",
 6 |     "module": "dist/curl-generator.esm.js",
 7 |     "browser": "dist/curl-generator.umd.js",
 8 |     "typings": "dist/main.d.ts",
 9 |     "license": "MIT",
10 |     "dependencies": {
11 |         "ms": "^2.0.0"
12 |     },
13 |     "devDependencies": {
14 |         "@rollup/plugin-commonjs": "^17.0.0",
15 |         "@rollup/plugin-node-resolve": "^11.1.0",
16 |         "@types/ms": "^0.7.30",
17 |         "@vitest/coverage-v8": "^2.1.9",
18 |         "rollup": "^2.79.2",
19 |         "rollup-plugin-typescript2": "^0.29.0",
20 |         "tslib": "^1.9.3",
21 |         "typescript": "^3.8.3",
22 |         "vitest": "^2.1.9"
23 |     },
24 |     "scripts": {
25 |         "build": "rollup -c",
26 |         "dev": "rollup -c -w",
27 |         "test": "vitest",
28 |         "coverage": "vitest run --coverage",
29 |         "typecheck": "tsc --noEmit"
30 |     },
31 |     "files": [
32 |         "dist"
33 |     ],
34 |     "repository": {
35 |         "type": "git",
36 |         "url": "https://github.com/albertodeago/curl-generator.git"
37 |     },
38 |     "bugs": {
39 |         "url": "https://github.com/albertodeago/curl-generator/issues"
40 |     },
41 |     "homepage": "https://github.com/albertodeago/curl-generator"
42 | }
43 | 


--------------------------------------------------------------------------------
/rollup.config.js:
--------------------------------------------------------------------------------
 1 | import resolve from '@rollup/plugin-node-resolve';
 2 | import commonjs from '@rollup/plugin-commonjs';
 3 | import typescript from 'rollup-plugin-typescript2';
 4 | import pkg from './package.json';
 5 | 
 6 | export default [
 7 | 	// browser-friendly UMD build
 8 | 	{
 9 | 		input: 'src/main.ts',
10 | 		output: {
11 | 			name: 'curl-generator',
12 | 			file: pkg.browser,
13 | 			format: 'umd'
14 | 		},
15 | 		plugins: [
16 | 			resolve(),   // so Rollup can find `ms`
17 | 			commonjs(),  // so Rollup can convert `ms` to an ES module
18 | 			typescript() // so Rollup can convert TypeScript to JavaScript
19 | 		]
20 | 	},
21 | 
22 | 	// CommonJS (for Node) and ES module (for bundlers) build.
23 | 	// (We could have three entries in the configuration array
24 | 	// instead of two, but it's quicker to generate multiple
25 | 	// builds from a single configuration where possible, using
26 | 	// an array for the `output` option, where we can specify 
27 | 	// `file` and `format` for each target)
28 | 	{
29 | 		input: 'src/main.ts',
30 | 		external: ['ms'],
31 | 		plugins: [
32 | 			typescript() // so Rollup can convert TypeScript to JavaScript
33 | 		],
34 | 		output: [
35 | 			{ file: pkg.main, format: 'cjs' },
36 | 			{ file: pkg.module, format: 'es' }
37 | 		]
38 | 	}
39 | ];
40 | 


--------------------------------------------------------------------------------
/src/bodies/body.ts:
--------------------------------------------------------------------------------
 1 | import { CurlFileBody, fileBodyToCommand, fileBodyToString, isCurlFileBody } from "./file-body";
 2 | import { CurlRawBody, isCurlRawBody, rawBodyToCommand, rawBodyToString } from "./raw-body";
 3 | import { CurlJsonBody, isCurlJsonBody, jsonBodyToCommand, jsonBodyToString, jsonContentToString } from "./json-body";
 4 | import { CurlFormBody, formBodyToCommand, formBodyToString, isCurlFormBody } from "./form-body";
 5 | 
 6 | export type CurlBody =
 7 |   // Raw string, same as type: "raw"
 8 |   | string
 9 |   // JSON object, same as type: "json"
10 |   | Record<string | number | symbol, unknown>
11 |   | URLSearchParams
12 |   | CurlFileBody
13 |   | CurlRawBody
14 |   | CurlJsonBody
15 |   | CurlFormBody;
16 | 
17 | export function bodyToString(body: CurlBody): string {
18 |   if (typeof body === "string") {
19 |     return body;
20 |   } else if (body instanceof URLSearchParams) {
21 |     return body.toString();
22 |   } else if (isCurlFileBody(body)) {
23 |     return fileBodyToString(body);
24 |   } else if (isCurlRawBody(body)) {
25 |     return rawBodyToString(body);
26 |   } else if (isCurlJsonBody(body)) {
27 |     return jsonBodyToString(body);
28 |   } else if (isCurlFormBody(body)) {
29 |     return formBodyToString(body);
30 |   } else if (typeof body === "object") {
31 |     return jsonContentToString(body);
32 |   }
33 | 
34 |   throw new Error(`Invalid body type: ${body}`);
35 | }
36 | 
37 | export function bodyToCommand(body: CurlBody): string {
38 |   if (typeof body === "string") {
39 |     return `-d '${body}'`;
40 |   } else if (body instanceof URLSearchParams) {
41 |     return `-d '${body.toString()}'`;
42 |   } else if (isCurlFileBody(body)) {
43 |     return fileBodyToCommand(body);
44 |   } else if (isCurlRawBody(body)) {
45 |     return rawBodyToCommand(body);
46 |   } else if (isCurlJsonBody(body)) {
47 |     return jsonBodyToCommand(body);
48 |   } else if (isCurlFormBody(body)) {
49 |     return formBodyToCommand(body);
50 |   } else if (typeof body === "object") {
51 |     return `-d '${jsonContentToString(body)}'`;
52 |   }
53 | 
54 |   throw new Error(`Invalid body type: ${body}`);
55 | }
56 | 


--------------------------------------------------------------------------------
/src/bodies/file-body.ts:
--------------------------------------------------------------------------------
 1 | export interface CurlFileBody {
 2 |   /**
 3 |    * File body type for using a file as the body data.
 4 |    */
 5 |   type: "file",
 6 |   /**
 7 |    * The file name without the @.
 8 |    */
 9 |   fileName: string,
10 | }
11 | 
12 | export function isCurlFileBody(body: unknown): body is CurlFileBody {
13 |   return typeof body === "object" && body !== null && "type" in body && (body as {
14 |     [key: string]: unknown
15 |   }).type === "file" && "fileName" in body;
16 | }
17 | 
18 | export function fileBodyToString(body: CurlFileBody): string {
19 |   return `@${body.fileName}`;
20 | }
21 | 
22 | export function fileBodyToCommand(body: CurlFileBody): string {
23 |   return `--data-binary ${fileBodyToString(body)}`;
24 | }
25 | 


--------------------------------------------------------------------------------
/src/bodies/form-body.ts:
--------------------------------------------------------------------------------
 1 | import { CurlFileBody } from "./file-body";
 2 | import { CurlRawBody } from "./raw-body";
 3 | 
 4 | export interface CurlFormBody {
 5 |   /**
 6 |    * Form body type for URL-encoded form data.
 7 |    */
 8 |   type: "form",
 9 |   /**
10 |    * The content of the body.
11 |    */
12 |   content: Record<string, string | CurlFileBody | CurlRawBody> | URLSearchParams,
13 | }
14 | 
15 | export function formBodyToString(body: CurlFormBody): string {
16 |   if (body.content instanceof URLSearchParams) {
17 |     return body.content.toString();
18 |   }
19 | 
20 |   return Object.entries(body.content)
21 |     .map(([key, value]) => {
22 |       if (typeof value === "string") {
23 |         return `${key}=${value}`;
24 |       }
25 | 
26 |       if (value.type === "file") {
27 |         throw new Error(`Cannot use file body in form body when converting to string. Please use formBodyToCommand instead.`);
28 |       }
29 | 
30 |       if (value.type === "raw") {
31 |         return `${key}=${value.content}`;
32 |       }
33 | 
34 |       throw new Error(`Invalid form body value type: ${value}`);
35 |     })
36 |     .join("&");
37 | }
38 | 
39 | export function isCurlFormBody(body: unknown): body is CurlFormBody {
40 |   return typeof body === "object" && body !== null && "type" in body && (body as {
41 |     [key: string]: unknown
42 |   }).type === "form" && "content" in body;
43 | }
44 | 
45 | export function formBodyToCommand(body: CurlFormBody): string {
46 |   if (body.content instanceof URLSearchParams) {
47 |     return `-d '${body.content.toString()}'`;
48 |   }
49 | 
50 |   return Object.entries(body.content)
51 |     .map(([key, value]) => {
52 |       if (typeof value === "string") {
53 |         return `-F ${key}=${value}`;
54 |       }
55 | 
56 |       if (value.type === "file") {
57 |         return `-F ${key}=@${value.fileName}`;
58 |       }
59 | 
60 |       if (value.type === "raw") {
61 |         return `-F ${key}=${value.content}`;
62 |       }
63 | 
64 |       throw new Error(`Invalid form body value type: ${value}`);
65 |     })
66 |     .join(" \\\n ");
67 | }
68 | 


--------------------------------------------------------------------------------
/src/bodies/json-body.ts:
--------------------------------------------------------------------------------
 1 | export interface CurlJsonBody {
 2 |   /**
 3 |    * JSON body type for JSON objects.
 4 |    */
 5 |   type: "json",
 6 |   /**
 7 |    * The content of the body.
 8 |    */
 9 |   content: Record<string | number | symbol, unknown>,
10 | }
11 | 
12 | export function isCurlJsonBody(body: unknown): body is CurlJsonBody {
13 |   return typeof body === "object" && body !== null && "type" in body && (body as {
14 |     [key: string]: unknown
15 |   }).type === "json" && "content" in body;
16 | }
17 | 
18 | export function jsonContentToString(content: Record<string | number | symbol, unknown>): string {
19 |   return JSON.stringify(content).replace(
20 |     /([\\'])/g,
21 |     "\\$1"
22 |   );
23 | }
24 | 
25 | export function jsonBodyToString(body: CurlJsonBody): string {
26 |   return jsonContentToString(body.content);
27 | }
28 | 
29 | export function jsonBodyToCommand(body: CurlJsonBody): string {
30 |   return `-d '${jsonBodyToString(body)}'`;
31 | }
32 | 


--------------------------------------------------------------------------------
/src/bodies/raw-body.ts:
--------------------------------------------------------------------------------
 1 | export interface CurlRawBody {
 2 |   /**
 3 |    * Raw body type for strings/text.
 4 |    */
 5 |   type: "raw",
 6 |   /**
 7 |    * The content of the body.
 8 |    */
 9 |   content: string,
10 | }
11 | 
12 | export function isCurlRawBody(body: unknown): body is CurlRawBody {
13 |   return typeof body === "object" && body !== null && "type" in body && (body as {
14 |     [key: string]: unknown
15 |   }).type === "raw" && "content" in body;
16 | }
17 | 
18 | export function rawBodyToString(body: CurlRawBody): string {
19 |   return body.content;
20 | }
21 | 
22 | export function rawBodyToCommand(body: CurlRawBody): string {
23 |   return `-d '${rawBodyToString(body)}'`;
24 | }
25 | 


--------------------------------------------------------------------------------
/src/main.ts:
--------------------------------------------------------------------------------
  1 | import { bodyToCommand, CurlBody } from "./bodies/body";
  2 | 
  3 | type StringMap = { [key: string]: string };
  4 | 
  5 | /**
  6 |  * Additional options for curl command.
  7 |  *
  8 |  * --compressed        ->   Request compressed response
  9 |  * --compressed-ssh    ->   Enable SSH compression
 10 |  * --fail              ->   Fail silently (no output at all) on HTTP errors
 11 |  * --fail-early        ->   Fail on first transfer error, do not continue
 12 |  * --head              ->   Show document info only
 13 |  * --include           ->   Include protocol response headers in the output
 14 |  * --insecure          ->   Allow insecure server connections when using SSL
 15 |  * --ipv4              ->   Resolve names to IPv4 addresses
 16 |  * --ipv6              ->   Resolve names to IPv6 addresses
 17 |  * --list-only         ->   List only mode
 18 |  * --location          ->   Follow redirects
 19 |  * --location-trusted  ->   Like --location, and send auth to other hosts
 20 |  * --no-keepalive      ->   Disable TCP keepalive on the connection
 21 |  * --show-error        ->   Show error even when -s is used
 22 |  * --silent            ->   Silent mode
 23 |  * --ssl               ->   Try SSL/TLS
 24 |  * --sslv2             ->   Use SSLv2
 25 |  * --sslv3             ->   Use SSLv3
 26 |  * --verbose           ->   Make the operation more talkative
 27 |  */
 28 | type CurlAdditionalOptions = {
 29 |   compressed?:        boolean,
 30 |   compressedSsh?:     boolean,
 31 |   fail?:              boolean,
 32 |   failEarly?:         boolean,
 33 |   head?:              boolean,
 34 |   include?:           boolean,
 35 |   insecure?:          boolean,
 36 |   ipv4?:              boolean,
 37 |   ipv6?:              boolean,
 38 |   listOnly?:          boolean,
 39 |   location?:          boolean,
 40 |   locationTrusted?:   boolean,
 41 |   noKeepalive?:       boolean,
 42 |   output?:            string,
 43 |   showError?:         boolean,
 44 |   silent?:            boolean,
 45 |   ssl?:               boolean,
 46 |   sslv2?:             boolean,
 47 |   sslv3?:             boolean,
 48 |   verbose?:           boolean,
 49 | };
 50 | 
 51 | type CurlRequest = {
 52 |   method?: "GET" | "get" | "POST" | "post" | "PUT" | "put" | "PATCH" | "patch" | "DELETE" | "delete",
 53 |   headers?: StringMap,
 54 |   body?: CurlBody,
 55 |   url: string,
 56 | };
 57 | 
 58 | // slash for connecting previous breakup line to current line for running cURL directly in Command Prompt
 59 | const slash = " \\";
 60 | const newLine = "\n";
 61 | 
 62 | /**
 63 |  * @param {string} [method]
 64 |  * @returns {string}
 65 |  */
 66 | const getCurlMethod = function (method?: string): string {
 67 |   let result: string = "";
 68 |   if (method) {
 69 |     const types: StringMap = {
 70 |       GET: "-X GET",
 71 |       POST: "-X POST",
 72 |       PUT: "-X PUT",
 73 |       PATCH: "-X PATCH",
 74 |       DELETE: "-X DELETE",
 75 |     };
 76 |     result = ` ${types[method.toUpperCase()]}`;
 77 |   }
 78 |   return slash + newLine + result;
 79 | };
 80 | 
 81 | /**
 82 |  * @param {StringMap} headers
 83 |  * @returns {string}
 84 |  */
 85 | const getCurlHeaders = function (headers?: StringMap): string {
 86 |   let result = "";
 87 |   if (headers) {
 88 |     Object.keys(headers).map((val) => {
 89 |       result += `${slash}${newLine} -H '${val}: ${headers[val].replace(
 90 |         /(\\|')/g,
 91 |         "\\$1"
 92 |       )}'`;
 93 |     });
 94 |   }
 95 |   return result;
 96 | };
 97 | 
 98 | /**
 99 |  * @param {CurlBody} body
100 |  * @returns {string}
101 |  */
102 | const getCurlBody = function (body?: CurlBody): string {
103 |   let result = "";
104 |   if (body) {
105 |     result += `${slash}${newLine} ${bodyToCommand(body)}`;
106 |   }
107 |   return result;
108 | };
109 | 
110 | /**
111 |  * Given the curl additional options, turn them into curl syntax
112 |  * @param {CurlAdditionalOptions} [options]
113 |  * @returns {string}
114 |  */
115 | const getCurlOptions = function (options?: CurlAdditionalOptions): string {
116 |   let result = "";
117 |   if (options) {
118 |     (Object.keys(options) as Array<keyof CurlAdditionalOptions>).forEach(
119 |       (key: keyof CurlAdditionalOptions) => {
120 |         const kebabKey = key.replace(
121 |           /[A-Z]/g,
122 |           (letter) => `-${letter.toLowerCase()}`
123 |         );
124 | 
125 |         if (!options[key]) {
126 |           throw new Error(`Invalid Curl option ${key}`);
127 |         } else if (typeof options[key] === "boolean" && options[key]) {
128 |           // boolean option, we just add --opt
129 |           result += ` --${kebabKey}`;
130 |         } else if (typeof options[key] === "string") {
131 |           // string option, we have to add --opt=value
132 |           result += ` --${kebabKey} ${options[key]}`;
133 |         }
134 |       }
135 |     );
136 |   }
137 | 
138 |   return result ? `${slash}${newLine}${result}` : result;
139 | };
140 | 
141 | /**
142 |  * @param {CurlRequest} params
143 |  * @param {CurlAdditionalOptions} [options]
144 |  * @returns {string}
145 |  */
146 | const CurlGenerator = function (
147 |   params: CurlRequest,
148 |   options?: CurlAdditionalOptions
149 | ): string {
150 |   let curlSnippet = "curl ";
151 |   curlSnippet += params.url;
152 |   curlSnippet += getCurlMethod(params.method);
153 |   curlSnippet += getCurlHeaders(params.headers);
154 |   curlSnippet += getCurlBody(params.body);
155 |   curlSnippet += getCurlOptions(options);
156 |   return curlSnippet.trim();
157 | };
158 | 
159 | export { CurlGenerator };
160 | 


--------------------------------------------------------------------------------
/test.txt:
--------------------------------------------------------------------------------
1 | {
2 |   "userId": 1,
3 |   "id": 1,
4 |   "title": "sunt aut facere repellat provident occaecati excepturi optio reprehenderit",
5 |   "body": "quia et suscipit\nsuscipit recusandae consequuntur expedita et cum\nreprehenderit molestiae ut ut quas totam\nnostrum rerum est autem sunt rem eveniet architecto"
6 | }


--------------------------------------------------------------------------------
/test/__snapshots__/main.test.ts.snap:
--------------------------------------------------------------------------------
  1 | // Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
  2 | 
  3 | exports[`del1 1`] = `
  4 | "curl https://jsonplaceholder.typicode.com/posts/1 \\
  5 |  -X DELETE"
  6 | `;
  7 | 
  8 | exports[`fileBody 1`] = `
  9 | "curl https://jsonplaceholder.typicode.com/posts \\
 10 |  -X POST \\
 11 |  -H 'Content-Type: application/json' \\
 12 |  --data-binary @data.json"
 13 | `;
 14 | 
 15 | exports[`formBody1 1`] = `
 16 | "curl https://jsonplaceholder.typicode.com/posts \\
 17 |  -X POST \\
 18 |  -H 'Content-Type: application/x-www-form-urlencoded' \\
 19 |  -F name=foo"
 20 | `;
 21 | 
 22 | exports[`formBody2 1`] = `
 23 | "curl https://jsonplaceholder.typicode.com/posts \\
 24 |  -X POST \\
 25 |  -H 'Content-Type: multipart/form-data' \\
 26 |  -F file1=@data.json"
 27 | `;
 28 | 
 29 | exports[`formBody3 1`] = `
 30 | "curl https://jsonplaceholder.typicode.com/posts \\
 31 |  -X POST \\
 32 |  -H 'Content-Type: application/x-www-form-urlencoded' \\
 33 |  -F file1=string data"
 34 | `;
 35 | 
 36 | exports[`formBody4 1`] = `
 37 | "curl https://jsonplaceholder.typicode.com/posts \\
 38 |  -X POST \\
 39 |  -H 'Content-Type: application/x-www-form-urlencoded' \\
 40 |  -d 'key1=value+1'"
 41 | `;
 42 | 
 43 | exports[`get1 1`] = `"curl https://jsonplaceholder.typicode.com/posts/101 \\"`;
 44 | 
 45 | exports[`get2 1`] = `
 46 | "curl https://jsonplaceholder.typicode.com/todos/1 \\
 47 |  -X GET"
 48 | `;
 49 | 
 50 | exports[`getEscapeHeaders 1`] = `
 51 | "curl https://jsonplaceholder.typicode.com/todos/1 \\
 52 |  -X GET \\
 53 |  -H 'key: a "strange" value'"
 54 | `;
 55 | 
 56 | exports[`getWithHeaders 1`] = `
 57 | "curl https://jsonplaceholder.typicode.com/todos/1 \\
 58 |  -X GET \\
 59 |  -H 'Content-Type: application/json'"
 60 | `;
 61 | 
 62 | exports[`jsonBody 1`] = `
 63 | "curl https://jsonplaceholder.typicode.com/posts \\
 64 |  -X POST \\
 65 |  -H 'Content-Type: application/json' \\
 66 |  -d '{"name":"foo"}'"
 67 | `;
 68 | 
 69 | exports[`opt1 1`] = `
 70 | "curl https://jsonplaceholder.typicode.com/posts/1 \\
 71 |  \\
 72 |  --silent --show-error"
 73 | `;
 74 | 
 75 | exports[`opt2 1`] = `
 76 | "curl https://jsonplaceholder.typicode.com/posts/1 \\
 77 |  \\
 78 |  --output test.txt --silent"
 79 | `;
 80 | 
 81 | exports[`patch1 1`] = `
 82 | "curl https://jsonplaceholder.typicode.com/posts/1 \\
 83 |  -X PATCH \\
 84 |  -H 'Content-type: application/json; charset=UTF-8' \\
 85 |  -d '{"title":"foo patched"}'"
 86 | `;
 87 | 
 88 | exports[`post1 1`] = `
 89 | "curl https://jsonplaceholder.typicode.com/posts \\
 90 |  -X POST \\
 91 |  -H 'Content-type: application/json; charset=UTF-8' \\
 92 |  -d '{"id":"123-456-789","key1":"value 1","key2":"a \\\\"complex\\\\" value"}'"
 93 | `;
 94 | 
 95 | exports[`put1 1`] = `
 96 | "curl https://jsonplaceholder.typicode.com/posts/1 \\
 97 |  -X PUT \\
 98 |  -H 'Content-type: application/json; charset=UTF-8' \\
 99 |  -d '{"id":1,"title":"foo","body":"barzzz","userId":1}'"
100 | `;
101 | 
102 | exports[`rawBody1 1`] = `
103 | "curl https://jsonplaceholder.typicode.com/posts \\
104 |  -X POST \\
105 |  -H 'Content-Type: text/plain' \\
106 |  -d 'string data'"
107 | `;
108 | 
109 | exports[`rawBody2 1`] = `
110 | "curl https://jsonplaceholder.typicode.com/posts \\
111 |  -X POST \\
112 |  -H 'Content-Type: text/plain' \\
113 |  -d 'string data'"
114 | `;
115 | 
116 | exports[`searchParamsBody 1`] = `
117 | "curl https://jsonplaceholder.typicode.com/posts \\
118 |  -X POST \\
119 |  -H 'Content-Type: text/plain' \\
120 |  -d 'key1=value+1'"
121 | `;
122 | 


--------------------------------------------------------------------------------
/test/main.test.ts:
--------------------------------------------------------------------------------
 1 | import { expect, test } from "vitest";
 2 | import { CurlGenerator } from "../src/main";
 3 | import * as params from "../example/parameters";
 4 | 
 5 | Object.keys(params).forEach((key) => {
 6 |   test(key, () => {
 7 |     const result = CurlGenerator(params[key], params[key].options);
 8 |     expect(result).toMatchSnapshot();
 9 |   });
10 | });
11 | 
12 | test("error body type", () => {
13 |   expect(() =>
14 |     CurlGenerator({
15 |       url: "https://jsonplaceholder.typicode.com/posts",
16 |       method: "POST",
17 |       headers: {
18 |         "Content-Type": "application/json",
19 |       },
20 |       body: 123 as unknown as string,
21 |     })
22 |   ).toThrowError(/^Invalid body type/);
23 | });
24 | 
25 | test("error form type", () => {
26 |   expect(() =>
27 |     CurlGenerator({
28 |       url: "https://jsonplaceholder.typicode.com/posts",
29 |       method: "POST",
30 |       headers: {
31 |         "Content-Type": "application/json",
32 |       },
33 |       body: {
34 |         type: "form",
35 |         content: {
36 |           file1: {
37 |             type: "blob",
38 |           },
39 |         },
40 |       },
41 |     })
42 |   ).toThrowError(/^Invalid form body value type/);
43 | });
44 | 
45 | test("error options", () => {
46 |   expect(() =>
47 |     CurlGenerator(
48 |       { url: "https://jsonplaceholder.typicode.com/posts/1" },
49 |       {
50 |         silent: false,
51 |       }
52 |     )
53 |   ).toThrowError(/^Invalid Curl option/);
54 | });
55 | 


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "include": ["src"],
 3 |   "compilerOptions": {
 4 |     /* Basic Options */
 5 |     "target": "es5",                          /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017','ES2018' or 'ESNEXT'. */
 6 |     "module": "ESNext",                       /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', or 'ESNext'. */
 7 |     // "lib": [],                             /* Specify library files to be included in the compilation. */
 8 |     // "allowJs": true,                       /* Allow javascript files to be compiled. */
 9 |     // "checkJs": true,                       /* Report errors in .js files. */
10 |     // "jsx": "preserve",                     /* Specify JSX code generation: 'preserve', 'react-native', or 'react'. */
11 |     "declaration": true,                      /* Generates corresponding '.d.ts' file. */
12 |     // "declarationMap": true,                /* Generates a sourcemap for each corresponding '.d.ts' file. */
13 |     // "sourceMap": true,                     /* Generates corresponding '.map' file. */
14 |     // "outFile": "./",                       /* Concatenate and emit output to single file. */
15 |     "outDir": "./dist",                       /* Redirect output structure to the directory. */
16 |     // "rootDir": "./",                       /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
17 |     // "composite": true,                     /* Enable project compilation */
18 |     // "removeComments": true,                /* Do not emit comments to output. */
19 |     // "noEmit": true,                        /* Do not emit outputs. */
20 |     // "importHelpers": true,                 /* Import emit helpers from 'tslib'. */
21 |     // "downlevelIteration": true,            /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
22 |     // "isolatedModules": true,               /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
23 | 
24 |     /* Strict Type-Checking Options */
25 |     "strict": true,                           /* Enable all strict type-checking options. */
26 |     // "noImplicitAny": true,                 /* Raise error on expressions and declarations with an implied 'any' type. */
27 |     // "strictNullChecks": true,              /* Enable strict null checks. */
28 |     // "strictFunctionTypes": true,           /* Enable strict checking of function types. */
29 |     // "strictBindCallApply": true,           /* Enable strict 'bind', 'call', and 'apply' methods on functions. */
30 |     // "strictPropertyInitialization": true,  /* Enable strict checking of property initialization in classes. */
31 |     // "noImplicitThis": true,                /* Raise error on 'this' expressions with an implied 'any' type. */
32 |     // "alwaysStrict": true,                  /* Parse in strict mode and emit "use strict" for each source file. */
33 | 
34 |     /* Additional Checks */
35 |     // "noUnusedLocals": true,                /* Report errors on unused locals. */
36 |     // "noUnusedParameters": true,            /* Report errors on unused parameters. */
37 |     // "noImplicitReturns": true,             /* Report error when not all code paths in function return a value. */
38 |     // "noFallthroughCasesInSwitch": true,    /* Report errors for fallthrough cases in switch statement. */
39 | 
40 |     /* Module Resolution Options */
41 |     // "moduleResolution": "node",            /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
42 |     // "baseUrl": "./",                       /* Base directory to resolve non-absolute module names. */
43 |     // "paths": {},                           /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
44 |     // "rootDirs": [],                        /* List of root folders whose combined content represents the structure of the project at runtime. */
45 |     // "typeRoots": [],                       /* List of folders to include type definitions from. */
46 |     // "types": [],                           /* Type declaration files to be included in compilation. */
47 |     // "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
48 |     "esModuleInterop": true                   /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
49 |     // "preserveSymlinks": true,              /* Do not resolve the real path of symlinks. */
50 | 
51 |     /* Source Map Options */
52 |     // "sourceRoot": "",                      /* Specify the location where debugger should locate TypeScript files instead of source locations. */
53 |     // "mapRoot": "",                         /* Specify the location where debugger should locate map files instead of generated locations. */
54 |     // "inlineSourceMap": true,               /* Emit a single file with source maps instead of having a separate file. */
55 |     // "inlineSources": true,                 /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
56 | 
57 |     /* Experimental Options */
58 |     // "experimentalDecorators": true,        /* Enables experimental support for ES7 decorators. */
59 |     // "emitDecoratorMetadata": true,         /* Enables experimental support for emitting type metadata for decorators. */
60 |   }
61 | }


--------------------------------------------------------------------------------