@scalar/snippetz 0.2.16 → 0.2.18

package/README.md

@@ -7,8 +7,6 @@
 
 A modern way to generate HTTP request examples for different languages and libraries.
 
-Check out some examples [here](https://scalar-snippetz-801498848929.us-central1.run.app/)
-
 ## Installation
 
 ```bash

package/dist/httpsnippet-lite/esm/targets/python/target.d.ts

@@ -24,21 +24,6 @@ export declare const python: {
                 method: any;
             }, options?: {}) => any;
         };
-        requests: {
-            info: {
-                key: string;
-                title: string;
-                link: string;
-                description: string;
-            };
-            convert: ({ queryObj, url, postData, allHeaders, method }: {
-                queryObj: any;
-                url: any;
-                postData: any;
-                allHeaders: any;
-                method: any;
-            }, options: any) => any;
-        };
     };
 };
 //# sourceMappingURL=target.d.ts.map

package/dist/httpsnippet-lite/esm/targets/python/target.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"target.d.ts","sourceRoot":"","sources":["../../../../../src/httpsnippet-lite/esm/targets/python/target.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWlB,CAAA"}
+{"version":3,"file":"target.d.ts","sourceRoot":"","sources":["../../../../../src/httpsnippet-lite/esm/targets/python/target.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;CAUlB,CAAA"}

package/dist/plugins/python/requests/requests.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"requests.d.ts","sourceRoot":"","sources":["../../../../src/plugins/python/requests/requests.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAEpD;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,MAQ5B,CAAA"}
+{"version":3,"file":"requests.d.ts","sourceRoot":"","sources":["../../../../src/plugins/python/requests/requests.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAIpD;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,MAsI5B,CAAA"}

package/dist/plugins/python/requests/requests.js

@@ -1,6 +1,4 @@
-import { requests } from '../../../httpsnippet-lite/esm/targets/python/requests/client.js';
-import { convertWithHttpSnippetLite } from '../../../utils/convertWithHttpSnippetLite.js';
-
+const LENGTH_CONSIDERED_AS_SHORT = 40;
 /**
  * python/requests
  */
@@ -8,9 +6,126 @@ const pythonRequests = {
     target: 'python',
     client: 'requests',
     title: 'Requests',
-    generate(request) {
-        // TODO: Write an own converter
-        return convertWithHttpSnippetLite(requests, request);
+    generate(request, configuration) {
+        // Normalize request with defaults
+        const normalizedRequest = {
+            url: 'https://example.com',
+            method: 'get',
+            ...request,
+        };
+        // Normalize method to lowercase for requests library
+        const method = normalizedRequest.method.toLowerCase();
+        // Build options object
+        const options = {};
+        // Add headers if present
+        if (normalizedRequest.headers?.length) {
+            options.headers = normalizedRequest.headers.reduce((acc, header) => {
+                if (!(header.name in acc)) {
+                    acc[header.name] = header.value;
+                }
+                return acc;
+            }, {});
+        }
+        // Add query parameters if present
+        if (normalizedRequest.queryString?.length) {
+            options.params = Object.fromEntries(normalizedRequest.queryString.map((q) => [q.name, q.value]));
+        }
+        // Add cookies if present
+        if (normalizedRequest.cookies?.length) {
+            options.cookies = Object.fromEntries(normalizedRequest.cookies.map((c) => [c.name, c.value]));
+        }
+        // Add auth if present
+        if (configuration?.auth?.username && configuration?.auth?.password) {
+            options.auth = [configuration.auth.username, configuration.auth.password];
+        }
+        // Handle request body
+        if (normalizedRequest.postData) {
+            const { mimeType, text, params } = normalizedRequest.postData;
+            if (mimeType === 'application/json' && text) {
+                try {
+                    options.json = JSON.parse(text);
+                }
+                catch {
+                    options.data = text;
+                }
+            }
+            else if (mimeType === 'application/octet-stream' && text) {
+                options.data = text; // Store raw text, we'll handle the b"..." formatting later
+            }
+            else if (mimeType === 'multipart/form-data' && params) {
+                const files = {};
+                const formData = {};
+                params.forEach((param) => {
+                    if (param.fileName !== undefined) {
+                        files[param.name] = `open("${param.fileName}", "rb")`;
+                    }
+                    else if (param.value !== undefined) {
+                        formData[param.name] = param.value;
+                    }
+                });
+                if (Object.keys(files).length) {
+                    options.files = files;
+                }
+                if (Object.keys(formData).length) {
+                    options.data = formData;
+                }
+            }
+            else if (mimeType === 'application/x-www-form-urlencoded' && params) {
+                options.data = Object.fromEntries(params.map((p) => [p.name, p.value]));
+            }
+        }
+        // Format all parameters
+        const formattedParams = [];
+        // Format URL based on length
+        const urlParam = `"${normalizedRequest.url}"`;
+        if (normalizedRequest.url.length > LENGTH_CONSIDERED_AS_SHORT) {
+            formattedParams.push(urlParam);
+        }
+        else {
+            // Will be handled in the return statement for short URLs
+            formattedParams.push('');
+        }
+        // Format options
+        for (const [key, value] of Object.entries(options)) {
+            if (key === 'auth') {
+                formattedParams.push(`${key}=(${JSON.stringify(value[0])}, ${JSON.stringify(value[1])})`);
+            }
+            else if (key === 'files') {
+                const filesStr = JSON.stringify(value)
+                    .replace(/"open\((.*?)\)"/g, 'open($1)')
+                    .replace(/":open/g, '": open')
+                    .replace(/\\"/g, '"');
+                formattedParams.push(`${key}=${filesStr}`);
+            }
+            else if (key === 'json') {
+                const jsonString = JSON.stringify(value, null, 2)
+                    .split('\n')
+                    .map((line, i) => (i === 0 ? line : '    ' + line))
+                    .join('\n');
+                formattedParams.push(`${key}=${jsonString}`);
+            }
+            else if (key === 'data' && normalizedRequest.postData?.mimeType === 'application/octet-stream') {
+                // Special handling for binary data
+                formattedParams.push(`${key}=b"${value}"`);
+            }
+            else {
+                const str = JSON.stringify(value, null, 2)
+                    .split('\n')
+                    .map((line, i) => (i === 0 ? line : '    ' + line))
+                    .join('\n');
+                formattedParams.push(`${key}=${str}`);
+            }
+        }
+        // Build the final request string with conditional URL formatting
+        if (normalizedRequest.url.length > LENGTH_CONSIDERED_AS_SHORT) {
+            return `requests.${method}(\n    ${formattedParams.join(',\n    ')}\n)`;
+        }
+        // For short URLs with no additional parameters, return a single-line format
+        if (formattedParams.length <= 1) {
+            return `requests.${method}(${urlParam})`;
+        }
+        // For short URLs with parameters, maintain the multi-line format
+        return `requests.${method}(${urlParam}${formattedParams.length > 1 ? ',' : ''}\n    ${formattedParams.slice(1).join(',\n    ')}\n)`;
     },
 };
 

package/dist/plugins/shell/curl/curl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"curl.d.ts","sourceRoot":"","sources":["../../../../src/plugins/shell/curl/curl.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAEpD;;GAEG;AACH,eAAO,MAAM,SAAS,EAAE,MAyGvB,CAAA"}
+{"version":3,"file":"curl.d.ts","sourceRoot":"","sources":["../../../../src/plugins/shell/curl/curl.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAEpD;;GAEG;AACH,eAAO,MAAM,SAAS,EAAE,MAqHvB,CAAA"}

package/dist/plugins/shell/curl/curl.js

@@ -67,9 +67,15 @@ const shellCurl = {
             if (normalizedRequest.postData.mimeType === 'application/json') {
                 // Pretty print JSON data
                 if (normalizedRequest.postData.text) {
-                    const jsonData = JSON.parse(normalizedRequest.postData.text);
-                    const prettyJson = JSON.stringify(jsonData, null, 2);
-                    parts.push(`--data '${prettyJson}'`);
+                    try {
+                        const jsonData = JSON.parse(normalizedRequest.postData.text);
+                        const prettyJson = JSON.stringify(jsonData, null, 2);
+                        parts.push(`--data '${prettyJson}'`);
+                    }
+                    catch {
+                        // If JSON parsing fails, use the original text
+                        parts.push(`--data '${normalizedRequest.postData.text}'`);
+                    }
                 }
             }
             else if (normalizedRequest.postData.mimeType === 'application/octet-stream') {
@@ -94,7 +100,15 @@ const shellCurl = {
                 });
             }
             else {
-                parts.push(`--data "${normalizedRequest.postData.text}"`);
+                // Try to parse and pretty print if it's JSON, otherwise use raw text
+                try {
+                    const jsonData = JSON.parse(normalizedRequest.postData.text ?? '');
+                    const prettyJson = JSON.stringify(jsonData, null, 2);
+                    parts.push(`--data '${prettyJson}'`);
+                }
+                catch {
+                    parts.push(`--data '${normalizedRequest.postData.text}'`);
+                }
             }
         }
         return parts.join(' \\\n  ');

package/package.json

@@ -9,7 +9,7 @@
     "url": "git+https://github.com/scalar/scalar.git",
     "directory": "packages/snippetz"
   },
-  "version": "0.2.16",
+  "version": "0.2.18",
   "engines": {
     "node": ">=18"
   },
@@ -212,8 +212,8 @@
   },
   "devDependencies": {
     "vite": "^5.4.10",
-    "@scalar/build-tooling": "0.1.16",
-    "@scalar/types": "0.0.39"
+    "@scalar/build-tooling": "0.1.17",
+    "@scalar/types": "0.1.3"
   },
   "scripts": {
     "build": "scalar-build-rollup",

package/dist/httpsnippet-lite/esm/targets/python/helpers.js

@@ -1,62 +0,0 @@
-// @ts-nocheck
-/**
- * Create a string corresponding to a Dictionary or Array literal representation with pretty option
- * and indentation.
- */
-function concatValues(concatType, values, pretty, indentation, indentLevel) {
-    const currentIndent = indentation.repeat(indentLevel);
-    const closingBraceIndent = indentation.repeat(indentLevel - 1);
-    const join = pretty ? `,\n${currentIndent}` : ', ';
-    const openingBrace = concatType === 'object' ? '{' : '[';
-    const closingBrace = concatType === 'object' ? '}' : ']';
-    if (pretty) {
-        return `${openingBrace}\n${currentIndent}${values.join(join)}\n${closingBraceIndent}${closingBrace}`;
-    }
-    if (concatType === 'object' && values.length > 0) {
-        return `${openingBrace} ${values.join(join)} ${closingBrace}`;
-    }
-    return `${openingBrace}${values.join(join)}${closingBrace}`;
-}
-/**
- * Create a valid Python string of a literal value according to its type.
- *
- * @param {*} value Any JavaScript literal
- * @param {object} opts Target options
- * @return {string}
- */
-const literalRepresentation = (value, opts, indentLevel) => {
-    indentLevel = indentLevel === undefined ? 1 : indentLevel + 1;
-    switch (Object.prototype.toString.call(value)) {
-        case '[object Number]':
-            return value;
-        case '[object Array]': {
-            let pretty = false;
-            const valuesRepresentation = value.map((v) => {
-                // Switch to prettify if the value is a dictionary with multiple keys
-                if (Object.prototype.toString.call(v) === '[object Object]') {
-                    pretty = Object.keys(v).length > 1;
-                }
-                return literalRepresentation(v, opts, indentLevel);
-            });
-            return concatValues('array', valuesRepresentation, pretty, opts.indent, indentLevel);
-        }
-        case '[object Object]': {
-            const keyValuePairs = [];
-            for (const key in value) {
-                keyValuePairs.push(`"${key}": ${literalRepresentation(value[key], opts, indentLevel)}`);
-            }
-            return concatValues('object', keyValuePairs, opts.pretty && keyValuePairs.length > 1, opts.indent, indentLevel);
-        }
-        case '[object Null]':
-            return 'None';
-        case '[object Boolean]':
-            return value ? 'True' : 'False';
-        default:
-            if (value === null || value === undefined) {
-                return '';
-            }
-            return `"${value.toString().replace(/"/g, '\\"')}"`;
-    }
-};
-
-export { literalRepresentation };

package/dist/httpsnippet-lite/esm/targets/python/requests/client.d.ts

@@ -1,16 +0,0 @@
-export declare const requests: {
-    info: {
-        key: string;
-        title: string;
-        link: string;
-        description: string;
-    };
-    convert: ({ queryObj, url, postData, allHeaders, method }: {
-        queryObj: any;
-        url: any;
-        postData: any;
-        allHeaders: any;
-        method: any;
-    }, options: any) => any;
-};
-//# sourceMappingURL=client.d.ts.map

package/dist/httpsnippet-lite/esm/targets/python/requests/client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../../../src/httpsnippet-lite/esm/targets/python/requests/client.ts"],"names":[],"mappings":"AAwBA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;CAqJpB,CAAA"}

package/dist/httpsnippet-lite/esm/targets/python/requests/client.js

@@ -1,176 +0,0 @@
-import { CodeBuilder } from '../../../helpers/code-builder.js';
-import { escapeForDoubleQuotes } from '../../../helpers/escape.js';
-import { getHeaderName } from '../../../helpers/headers.js';
-import { literalRepresentation } from '../helpers.js';
-
-// @ts-nocheck
-/**
- * @description
- * HTTP code snippet generator for Python using Requests
- *
- * @author
- * @montanaflynn
- *
- * for any questions or issues regarding the generated code snippet, please open an issue mentioning the author.
- */
-const builtInMethods = [
-    'HEAD',
-    'GET',
-    'POST',
-    'PUT',
-    'PATCH',
-    'DELETE',
-    'OPTIONS',
-];
-const requests = {
-    info: {
-        key: 'requests',
-        title: 'Requests',
-        link: 'http://docs.python-requests.org/en/latest/api/#requests.request',
-        description: 'Requests HTTP library',
-    },
-    convert: ({ queryObj, url, postData, allHeaders, method }, options) => {
-        const opts = {
-            indent: '    ',
-            pretty: true,
-            ...options,
-        };
-        // Start snippet
-        const { push, blank, join } = new CodeBuilder({ indent: opts.indent });
-        // Import requests
-        push('import requests');
-        blank();
-        // Set URL
-        push(`url = "${url}"`);
-        blank();
-        // Construct query string
-        let qs;
-        if (Object.keys(queryObj).length) {
-            qs = `querystring = ${JSON.stringify(queryObj)}`;
-            push(qs);
-            blank();
-        }
-        const headers = allHeaders;
-        // Construct payload
-        let payload = {};
-        const files = {};
-        let hasFiles = false;
-        let hasPayload = false;
-        let jsonPayload = false;
-        switch (postData === null || postData === void 0 ? void 0 : postData.mimeType) {
-            case 'application/json':
-                if (postData.jsonObj) {
-                    push(`payload = ${literalRepresentation(postData.jsonObj, opts)}`);
-                    jsonPayload = true;
-                    hasPayload = true;
-                }
-                break;
-            case 'multipart/form-data':
-                if (!postData.params) {
-                    break;
-                }
-                payload = {};
-                postData.params.forEach((p) => {
-                    if (p.fileName) {
-                        files[p.name] = `open('${p.fileName}', 'rb')`;
-                        hasFiles = true;
-                    }
-                    else {
-                        payload[p.name] = p.value;
-                        hasPayload = true;
-                    }
-                });
-                if (hasFiles) {
-                    push(`files = ${literalRepresentation(files, opts)}`);
-                    if (hasPayload) {
-                        push(`payload = ${literalRepresentation(payload, opts)}`);
-                    }
-                    // The requests library will only automatically add a `multipart/form-data` header if there are files being sent. If we're **only** sending form data we still need to send the boundary ourselves.
-                    const headerName = getHeaderName(headers, 'content-type');
-                    if (headerName) {
-                        delete headers[headerName];
-                    }
-                }
-                else {
-                    const nonFilePayload = JSON.stringify(postData.text);
-                    if (nonFilePayload) {
-                        push(`payload = ${nonFilePayload}`);
-                        hasPayload = true;
-                    }
-                }
-                break;
-            default: {
-                if (!postData) {
-                    break;
-                }
-                if (postData.mimeType === 'application/x-www-form-urlencoded' &&
-                    postData.paramsObj) {
-                    push(`payload = ${literalRepresentation(postData.paramsObj, opts)}`);
-                    hasPayload = true;
-                    break;
-                }
-                const payload = JSON.stringify(postData.text);
-                if (payload) {
-                    push(`payload = ${payload}`);
-                    hasPayload = true;
-                }
-            }
-        }
-        // Construct headers
-        const headerCount = Object.keys(headers).length;
-        if (headerCount === 0 && (hasPayload || hasFiles)) {
-            // If we don't have any heads but we do have a payload we should put a blank line here between that payload consturction and our execution of the requests library.
-            blank();
-        }
-        else if (headerCount === 1) {
-            for (const header in headers) {
-                push(`headers = {"${header}": "${escapeForDoubleQuotes(headers[header])}"}`);
-                blank();
-            }
-        }
-        else if (headerCount > 1) {
-            let count = 1;
-            push('headers = {');
-            for (const header in headers) {
-                if (count !== headerCount) {
-                    push(`"${header}": "${escapeForDoubleQuotes(headers[header])}",`, 1);
-                }
-                else {
-                    push(`"${header}": "${escapeForDoubleQuotes(headers[header])}"`, 1);
-                }
-                count += 1;
-            }
-            push('}');
-            blank();
-        }
-        // Construct request
-        let request = builtInMethods.includes(method)
-            ? `response = requests.${method.toLowerCase()}(url`
-            : `response = requests.request("${method}", url`;
-        if (hasPayload) {
-            if (jsonPayload) {
-                request += ', json=payload';
-            }
-            else {
-                request += ', data=payload';
-            }
-        }
-        if (hasFiles) {
-            request += ', files=files';
-        }
-        if (headerCount > 0) {
-            request += ', headers=headers';
-        }
-        if (qs) {
-            request += ', params=querystring';
-        }
-        request += ')';
-        push(request);
-        blank();
-        // Print response
-        push('print(response.json())');
-        return join();
-    },
-};
-
-export { requests };