feat: raw binary files handling in request body (#3734)

--------------
Co-authored-by: lohit <lohit@usebruno.com>
Co-authored-by: Anoop M D <anoop.md1421@gmail.com>

packages/bruno-app/src/utils/codegenerator/har.js

@@ -14,6 +14,8 @@ const createContentType = (mode) => {
       return 'application/json';
     case 'multipartForm':
       return 'multipart/form-data';
+    case 'binaryFile':
+      return 'application/octet-stream';
     default:
       return '';
   }
@@ -60,26 +62,48 @@ const createPostData = (body, type) => {
   }
 
   const contentType = createContentType(body.mode);
-  if (body.mode === 'formUrlEncoded' || body.mode === 'multipartForm') {
-    return {
-      mimeType: contentType,
-      params: body[body.mode]
-        .filter((param) => param.enabled)
-        .map((param) => ({
-          name: param.name,
-          value: param.value,
-          ...(param.type === 'file' && { fileName: param.value })
-        }))
-    };
-  } else {
-    return {
-      mimeType: contentType,
-      text: body[body.mode]
-    };
+
+  switch (body.mode) {
+    case 'formUrlEncoded':
+    case 'multipartForm':
+      return {
+        mimeType: contentType,
+        params: body[body.mode]
+          .filter((param) => param.enabled)
+          .map((param) => ({
+            name: param.name,
+            value: param.value,
+            ...(param.type === 'file' && { fileName: param.value })
+          }))
+      };
+    case 'binaryFile':
+      const binary = {
+        mimeType: 'application/octet-stream',
+        // mimeType: body[body.mode].filter((param) => param.enabled)[0].contentType,
+        params: body[body.mode]
+          .filter((param) => param.enabled)
+          .map((param) => ({
+            name: param.name,
+            value: param.value,
+            fileName: param.value
+          }))
+      };
+
+      console.log('curl-binary', binary);
+      return binary;
+    default:
+      return {
+        mimeType: contentType,
+        text: body[body.mode]
+      };
   }
 };
 
 export const buildHarRequest = ({ request, headers, type }) => {
+
+  console.log('buildHarRequest', request, headers, type);
+
+  console.log('buildHarRequest-postData', createPostData(request.body, type));
   return {
     method: request.method,
     url: encodeURI(request.url),
@@ -89,6 +113,7 @@ export const buildHarRequest = ({ request, headers, type }) => {
     queryString: createQuery(request.params),
     postData: createPostData(request.body, type),
     headersSize: 0,
-    bodySize: 0
+    bodySize: 0,
+    binary: true
   };
 };

packages/bruno-app/src/utils/collections/export.js

@@ -14,6 +14,7 @@ export const deleteUidsInItems = (items) => {
       each(get(item, 'request.vars.assertions'), (a) => delete a.uid);
       each(get(item, 'request.body.multipartForm'), (param) => delete param.uid);
       each(get(item, 'request.body.formUrlEncoded'), (param) => delete param.uid);
+      each(get(item, 'request.body.binaryFile'), (param) => delete param.uid);
     }
 
     if (item.items && item.items.length) {

packages/bruno-app/src/utils/collections/index.js

@@ -281,6 +281,19 @@ export const transformCollectionToSaveToExportAsFile = (collection, options = {}
     });
   };
 
+  const copyBinaryFileParams = (params = []) => {
+    return map(params, (param) => {
+      return {
+        uid: param.uid,
+        type: param.type,
+        name: param.name,
+        value: param.value,
+        contentType: param.contentType,
+        enabled: param.enabled
+      }
+    });
+  }
+
   const copyItems = (sourceItems, destItems) => {
     each(sourceItems, (si) => {
       if (!isItemAFolder(si) && !isItemARequest(si) && si.type !== 'js') {
@@ -308,7 +321,8 @@ export const transformCollectionToSaveToExportAsFile = (collection, options = {}
             graphql: si.request.body.graphql,
             sparql: si.request.body.sparql,
             formUrlEncoded: copyFormUrlEncodedParams(si.request.body.formUrlEncoded),
-            multipartForm: copyMultipartFormParams(si.request.body.multipartForm)
+            multipartForm: copyMultipartFormParams(si.request.body.multipartForm),
+            binaryFile: copyBinaryFileParams(si.request.body.binaryFile)
           },
           script: si.request.script,
           vars: si.request.vars,
@@ -661,6 +675,10 @@ export const humanizeRequestBodyMode = (mode) => {
       label = 'SPARQL';
       break;
     }
+    case 'binaryFile': {
+      label = 'Binary File';
+      break;
+    }
     case 'formUrlEncoded': {
       label = 'Form URL Encoded';
       break;
@@ -761,6 +779,7 @@ export const refreshUidsInItem = (item) => {
   each(get(item, 'request.params'), (param) => (param.uid = uuid()));
   each(get(item, 'request.body.multipartForm'), (param) => (param.uid = uuid()));
   each(get(item, 'request.body.formUrlEncoded'), (param) => (param.uid = uuid()));
+  each(get(item, 'request.body.binaryFile'), (param) => (param.uid = uuid()));
 
   return item;
 };
@@ -771,11 +790,13 @@ export const deleteUidsInItem = (item) => {
   const headers = get(item, 'request.headers', []);
   const bodyFormUrlEncoded = get(item, 'request.body.formUrlEncoded', []);
   const bodyMultipartForm = get(item, 'request.body.multipartForm', []);
+  const binaryFile = get(item, 'request.body.binaryFile', []);
 
   params.forEach((param) => delete param.uid);
   headers.forEach((header) => delete header.uid);
   bodyFormUrlEncoded.forEach((param) => delete param.uid);
   bodyMultipartForm.forEach((param) => delete param.uid);
+  binaryFile.forEach((param) => delete param.uid);
 
   return item;
 };

packages/bruno-app/src/utils/curl/curl-to-json.js

@@ -9,6 +9,7 @@
 import parseCurlCommand from './parse-curl';
 import * as querystring from 'query-string';
 import * as jsesc from 'jsesc';
+import * as path from 'path';
 
 function getContentType(headers = {}) {
   const contentType = Object.keys(headers).find((key) => key.toLowerCase() === 'content-type');
@@ -99,9 +100,36 @@ function getMultipleDataString(request, parsedQueryString) {
 function getFilesString(request) {
   const data = {};
 
-  data.files = {};
   data.data = {};
 
+  if (request.isDataBinary){
+
+    let filePath = ''
+
+    if(request.data.startsWith('@')){
+      filePath = request.data.slice(1);
+    }else{
+      filePath = request.data;
+    }
+
+    const fileName = path.basename(filePath);
+
+    data.data = [
+      {
+        name: repr(fileName),
+        value: [repr(filePath)],
+        enabled: true,
+        contentType: request.headers['Content-Type'],
+        type: 'binaryFile'
+      }
+    ];
+
+    return data;
+
+  }
+
+  data.files = {};
+
   for (const multipartKey in request.multipartUploads) {
     const multipartValue = request.multipartUploads[multipartKey];
     if (multipartValue.startsWith('@')) {
@@ -140,6 +168,7 @@ const curlToJson = (curlCommand) => {
   requestJson.url = request.urlWithoutQuery;
   requestJson.raw_url = request.url;
   requestJson.method = request.method;
+  requestJson.isDataBinary = request.isDataBinary;
 
   if (request.cookies) {
     const cookies = {};
@@ -163,11 +192,11 @@ const curlToJson = (curlCommand) => {
     requestJson.queries = getQueries(request);
   }
 
-  if (typeof request.data === 'string' || typeof request.data === 'number') {
-    Object.assign(requestJson, getDataString(request));
-  } else if (request.multipartUploads) {
+  else if (request.multipartUploads || request.isDataBinary) {
     Object.assign(requestJson, getFilesString(request));
-  }
+  } else if (typeof request.data === 'string' || typeof request.data === 'number') {
+    Object.assign(requestJson, getDataString(request));
+  } 
 
   if (request.insecure) {
     requestJson.insecure = false;

packages/bruno-app/src/utils/curl/curl-to-json.spec.js

@@ -86,4 +86,40 @@ describe('curlToJson', () => {
       method: 'get'
     });
   });
+
+  it('should return a parse a curl with a post body with binary file type', () => {
+    const curlCommand = `curl 'https://www.usebruno.com'
+    -H 'Accept: application/json, text/plain, */*'
+    -H 'Accept-Language: en-US,en;q=0.9,hi;q=0.8'
+    -H 'Content-Type: application/json;charset=utf-8'
+    -H 'Origin: https://www.usebruno.com'
+    -H 'Referer: https://www.usebruno.com/'
+    --data-binary '@/path/to/file'
+    `;
+
+    const result = curlToJson(curlCommand);
+
+    expect(result).toEqual({
+      url: 'https://www.usebruno.com',
+      raw_url: 'https://www.usebruno.com',
+      method: 'post',
+      headers: {
+        Accept: 'application/json, text/plain, */*',
+        'Accept-Language': 'en-US,en;q=0.9,hi;q=0.8',
+        'Content-Type': 'application/json;charset=utf-8',
+        Origin: 'https://www.usebruno.com',
+        Referer: 'https://www.usebruno.com/'
+      },
+      isDataBinary: true,
+      data: [
+        {
+          name: 'file',
+          value: ['/path/to/file'],
+          enabled: true,
+          contentType: 'application/json;charset=utf-8',
+          type: 'binaryFile'
+        }
+      ]
+    });
+  });
 });

packages/bruno-app/src/utils/curl/index.js

@@ -50,14 +50,18 @@ export const getRequestFromCurlCommand = (curlCommand, requestType = 'http-reque
       sparql: null,
       multipartForm: null,
       formUrlEncoded: null,
-      graphql: null
+      graphql: null,
+      binaryFile: null
     };
 
     if (parsedBody && contentType && typeof contentType === 'string') {
       if (requestType === 'graphql-request' && (contentType.includes('application/json') || contentType.includes('application/graphql'))) {
         body.mode = 'graphql';
         body.graphql = parseGraphQL(parsedBody);
-      } else if (contentType.includes('application/json')) {
+      } else if (requestType === 'http-request' && request.isDataBinary) {
+        body.mode = 'binaryFile';
+        body.binaryFile = parsedBody;
+      }else if (contentType.includes('application/json')) {
         body.mode = 'json';
         body.json = convertToCodeMirrorJson(parsedBody);
       } else if (contentType.includes('xml')) {

packages/bruno-app/src/utils/importers/common.js

@@ -35,6 +35,7 @@ export const updateUidsInCollection = (_collection) => {
       each(get(item, 'request.assertions'), (a) => (a.uid = uuid()));
       each(get(item, 'request.body.multipartForm'), (param) => (param.uid = uuid()));
       each(get(item, 'request.body.formUrlEncoded'), (param) => (param.uid = uuid()));
+      each(get(item, 'request.body.binaryFile'), (param) => (param.uid = uuid()));
 
       if (item.items && item.items.length) {
         updateItemUids(item.items);