From fdf5f66430e318bcd6a45a3d69849b7bd83d286f Mon Sep 17 00:00:00 2001
From: Jarod Gowgiel <jroddg@gmail.com>
Date: Sun, 1 Dec 2024 17:57:31 -0700
Subject: [PATCH 1/2] Add a new UI check for whether an existing collection
 should be updated

Introduces a new modal with two simple options that sets a new
flag in the collection import flow. This will be connected in future
commits to trigger alternative import logic that will update an
existing collection instead of creating a net-new collection.
---
 .../ConfirmCollectionImportUpdate/index.js    |  24 +++
 .../src/components/Sidebar/TitleBar/index.js  |  56 ++++++-
 .../bruno-app/src/components/Welcome/index.js |  56 ++++++-
 .../ReduxStore/slices/collections/actions.js  |  91 +++++-----
 packages/bruno-electron/src/ipc/collection.js | 155 +++++++++---------
 5 files changed, 254 insertions(+), 128 deletions(-)
 create mode 100644 packages/bruno-app/src/components/ConfirmCollectionImportUpdate/index.js

diff --git a/packages/bruno-app/src/components/ConfirmCollectionImportUpdate/index.js b/packages/bruno-app/src/components/ConfirmCollectionImportUpdate/index.js
new file mode 100644
index 0000000000..9639b7020c
--- /dev/null
+++ b/packages/bruno-app/src/components/ConfirmCollectionImportUpdate/index.js
@@ -0,0 +1,24 @@
+import Modal from 'components/Modal';
+import Portal from 'components/Portal/index';
+
+const ConfirmCollectionImportUpdate = ({ onConfirm, onCancel }) => {
+  return (
+    <Portal>
+      <Modal
+        size="md"
+        title="Update existing collection"
+        confirmText="Yes"
+        cancelText="No"
+        disableEscapeKey={true}
+        disableCloseOnOutsideClick={true}
+        handleConfirm={onConfirm}
+        handleCancel={onCancel}
+        hideClose={true}
+      >
+        <div>Would you like to add to the existing collection at this location?</div>
+      </Modal>
+    </Portal>
+  );
+};
+
+export default ConfirmCollectionImportUpdate;
diff --git a/packages/bruno-app/src/components/Sidebar/TitleBar/index.js b/packages/bruno-app/src/components/Sidebar/TitleBar/index.js
index bbd88fbcf2..0fad39502a 100644
--- a/packages/bruno-app/src/components/Sidebar/TitleBar/index.js
+++ b/packages/bruno-app/src/components/Sidebar/TitleBar/index.js
@@ -11,13 +11,16 @@ import { useDispatch } from 'react-redux';
 import { showHomePage } from 'providers/ReduxStore/slices/app';
 import { openCollection, importCollection } from 'providers/ReduxStore/slices/collections/actions';
 import StyledWrapper from './StyledWrapper';
+import ConfirmCollectionImportUpdate from 'components/ConfirmCollectionImportUpdate/index';
 
 const TitleBar = () => {
   const [importedCollection, setImportedCollection] = useState(null);
+  const [importedCollectionLocation, setImportedCollectionLocation] = useState(null);
   const [importedTranslationLog, setImportedTranslationLog] = useState({});
   const [createCollectionModalOpen, setCreateCollectionModalOpen] = useState(false);
   const [importCollectionModalOpen, setImportCollectionModalOpen] = useState(false);
   const [importCollectionLocationModalOpen, setImportCollectionLocationModalOpen] = useState(false);
+  const [confirmCollectionImportUpdateModalOpen, setConfirmCollectionImportUpdateModalOpen] = useState(false);
   const dispatch = useDispatch();
   const { ipcRenderer } = window;
 
@@ -30,20 +33,55 @@ const TitleBar = () => {
     setImportCollectionLocationModalOpen(true);
   };
 
+  const cleanupAfterSuccessfulImport = () => {
+    setImportCollectionLocationModalOpen(false);
+    setImportedCollection(null);
+    setImportedCollectionLocation(null);
+    toast.success('Collection imported successfully');
+  };
+
+  const cleanupAndShowImportError = (err) => {
+    setImportCollectionLocationModalOpen(false);
+    setImportedCollection(null);
+    setImportedCollectionLocation(null);
+    console.error(err);
+    toast.error('An error occurred while importing the collection. Check the logs for more information.');
+  };
+
   const handleImportCollectionLocation = (collectionLocation) => {
+    setImportedCollectionLocation(collectionLocation);
+    setImportCollectionLocationModalOpen(false);
     dispatch(importCollection(importedCollection, collectionLocation))
       .then(() => {
-        setImportCollectionLocationModalOpen(false);
-        setImportedCollection(null);
-        toast.success('Collection imported successfully');
+        cleanupAfterSuccessfulImport();
       })
       .catch((err) => {
-        setImportCollectionLocationModalOpen(false);
-        console.error(err);
-        toast.error('An error occurred while importing the collection. Check the logs for more information.');
+        // Note: the string here must exactly match the start of the error thrown in
+        // `bruno-electron/src/ipc/collection.js` when the folder already exists
+        if (err instanceof Error && err.message.includes('collection already exists')) {
+          setConfirmCollectionImportUpdateModalOpen(true);
+        } else {
+          cleanupAndShowImportError(err);
+        }
       });
   };
 
+  const handleConfirmCollectionImportUpdate = (shouldUpdate) => {
+    setConfirmCollectionImportUpdateModalOpen(false);
+    setImportCollectionLocationModalOpen(false);
+    if (shouldUpdate) {
+      dispatch(importCollection(importedCollection, importedCollectionLocation, true))
+        .then(() => {
+          cleanupAfterSuccessfulImport();
+        })
+        .catch((err) => {
+          cleanupAndShowImportError(err);
+        });
+    } else {
+      cleanupAndShowImportError();
+    }
+  };
+
   const menuDropdownTippyRef = useRef();
   const onMenuDropdownCreate = (ref) => (menuDropdownTippyRef.current = ref);
   const MenuIcon = forwardRef((props, ref) => {
@@ -80,6 +118,12 @@ const TitleBar = () => {
           handleSubmit={handleImportCollectionLocation}
         />
       ) : null}
+      {confirmCollectionImportUpdateModalOpen ? (
+        <ConfirmCollectionImportUpdate
+          onConfirm={() => handleConfirmCollectionImportUpdate(true)}
+          onCancel={() => handleConfirmCollectionImportUpdate(false)}
+        />
+      ) : null}
 
       <div className="flex items-center">
         <button className="flex items-center gap-2 text-sm font-medium" onClick={handleTitleClick}>
diff --git a/packages/bruno-app/src/components/Welcome/index.js b/packages/bruno-app/src/components/Welcome/index.js
index 64100224c0..ca3ed3de1e 100644
--- a/packages/bruno-app/src/components/Welcome/index.js
+++ b/packages/bruno-app/src/components/Welcome/index.js
@@ -10,15 +10,18 @@ import CreateCollection from 'components/Sidebar/CreateCollection';
 import ImportCollection from 'components/Sidebar/ImportCollection';
 import ImportCollectionLocation from 'components/Sidebar/ImportCollectionLocation';
 import StyledWrapper from './StyledWrapper';
+import ConfirmCollectionImportUpdate from 'components/ConfirmCollectionImportUpdate/index';
 
 const Welcome = () => {
   const dispatch = useDispatch();
   const { t } = useTranslation();
   const [importedCollection, setImportedCollection] = useState(null);
+  const [importedCollectionLocation, setImportedCollectionLocation] = useState(null);
   const [importedTranslationLog, setImportedTranslationLog] = useState({});
   const [createCollectionModalOpen, setCreateCollectionModalOpen] = useState(false);
   const [importCollectionModalOpen, setImportCollectionModalOpen] = useState(false);
   const [importCollectionLocationModalOpen, setImportCollectionLocationModalOpen] = useState(false);
+  const [confirmCollectionImportUpdateModalOpen, setConfirmCollectionImportUpdateModalOpen] = useState(false);
 
   const handleOpenCollection = () => {
     dispatch(openCollection()).catch((err) => console.log(err) && toast.error(t('WELCOME.COLLECTION_OPEN_ERROR')));
@@ -33,20 +36,55 @@ const Welcome = () => {
     setImportCollectionLocationModalOpen(true);
   };
 
+  const cleanupAfterSuccessfulImport = () => {
+    setImportCollectionLocationModalOpen(false);
+    setImportedCollection(null);
+    setImportedCollectionLocation(null);
+    toast.success(t('WELCOME.COLLECTION_IMPORT_SUCCESS'));
+  };
+
+  const cleanupAndShowImportError = (err) => {
+    setImportCollectionLocationModalOpen(false);
+    setImportedCollection(null);
+    setImportedCollectionLocation(null);
+    console.error(err);
+    toast.error(t('WELCOME.COLLECTION_IMPORT_ERROR'));
+  };
+
   const handleImportCollectionLocation = (collectionLocation) => {
+    setImportedCollectionLocation(collectionLocation);
+    setImportCollectionLocationModalOpen(false);
     dispatch(importCollection(importedCollection, collectionLocation))
       .then(() => {
-        setImportCollectionLocationModalOpen(false);
-        setImportedCollection(null);
-        toast.success(t('WELCOME.COLLECTION_IMPORT_SUCCESS'));
+        cleanupAfterSuccessfulImport();
       })
       .catch((err) => {
-        setImportCollectionLocationModalOpen(false);
-        console.error(err);
-        toast.error(t('WELCOME.COLLECTION_IMPORT_ERROR'));
+        // Note: the string here must exactly match the start of the error thrown in
+        // `bruno-electron/src/ipc/collection.js` when the folder already exists
+        if (err instanceof Error && err.message.includes('collection already exists')) {
+          setConfirmCollectionImportUpdateModalOpen(true);
+        } else {
+          cleanupAndShowImportError(err);
+        }
       });
   };
 
+  const handleConfirmCollectionImportUpdate = (shouldUpdate) => {
+    setConfirmCollectionImportUpdateModalOpen(false);
+    setImportCollectionLocationModalOpen(false);
+    if (shouldUpdate) {
+      dispatch(importCollection(importedCollection, importedCollectionLocation, true))
+        .then(() => {
+          cleanupAfterSuccessfulImport();
+        })
+        .catch((err) => {
+          cleanupAndShowImportError(err);
+        });
+    } else {
+      cleanupAndShowImportError();
+    }
+  };
+
   return (
     <StyledWrapper className="pb-4 px-6 mt-6">
       {createCollectionModalOpen ? <CreateCollection onClose={() => setCreateCollectionModalOpen(false)} /> : null}
@@ -61,6 +99,12 @@ const Welcome = () => {
           handleSubmit={handleImportCollectionLocation}
         />
       ) : null}
+      {confirmCollectionImportUpdateModalOpen ? (
+        <ConfirmCollectionImportUpdate
+          onConfirm={() => handleConfirmCollectionImportUpdate(true)}
+          onCancel={() => handleConfirmCollectionImportUpdate(false)}
+        />
+      ) : null}
 
       <div aria-hidden className="">
         <Bruno width={50} />
diff --git a/packages/bruno-app/src/providers/ReduxStore/slices/collections/actions.js b/packages/bruno-app/src/providers/ReduxStore/slices/collections/actions.js
index 75c6f2cb90..981141ad8e 100644
--- a/packages/bruno-app/src/providers/ReduxStore/slices/collections/actions.js
+++ b/packages/bruno-app/src/providers/ReduxStore/slices/collections/actions.js
@@ -185,7 +185,7 @@ export const saveFolderRoot = (collectionUid, folderUid) => (dispatch, getState)
 
 export const sendCollectionOauth2Request = (collectionUid, itemUid) => (dispatch, getState) => {
   const state = getState();
-  const { globalEnvironments, activeGlobalEnvironmentUid } = state.globalEnvironments;  
+  const { globalEnvironments, activeGlobalEnvironmentUid } = state.globalEnvironments;
   const collection = findCollectionByUid(state.collections.collections, collectionUid);
 
   return new Promise((resolve, reject) => {
@@ -196,7 +196,10 @@ export const sendCollectionOauth2Request = (collectionUid, itemUid) => (dispatch
     let collectionCopy = cloneDeep(collection);
 
     // add selected global env variables to the collection object
-    const globalEnvironmentVariables = getGlobalEnvironmentVariables({ globalEnvironments, activeGlobalEnvironmentUid });
+    const globalEnvironmentVariables = getGlobalEnvironmentVariables({
+      globalEnvironments,
+      activeGlobalEnvironmentUid
+    });
     collectionCopy.globalEnvironmentVariables = globalEnvironmentVariables;
 
     const environment = findEnvironmentInCollection(collectionCopy, collection.activeEnvironmentUid);
@@ -219,7 +222,7 @@ export const sendCollectionOauth2Request = (collectionUid, itemUid) => (dispatch
 
 export const sendRequest = (item, collectionUid) => (dispatch, getState) => {
   const state = getState();
-  const { globalEnvironments, activeGlobalEnvironmentUid } = state.globalEnvironments;  
+  const { globalEnvironments, activeGlobalEnvironmentUid } = state.globalEnvironments;
   const collection = findCollectionByUid(state.collections.collections, collectionUid);
 
   return new Promise((resolve, reject) => {
@@ -231,7 +234,10 @@ export const sendRequest = (item, collectionUid) => (dispatch, getState) => {
     let collectionCopy = cloneDeep(collection);
 
     // add selected global env variables to the collection object
-    const globalEnvironmentVariables = getGlobalEnvironmentVariables({ globalEnvironments, activeGlobalEnvironmentUid });
+    const globalEnvironmentVariables = getGlobalEnvironmentVariables({
+      globalEnvironments,
+      activeGlobalEnvironmentUid
+    });
     collectionCopy.globalEnvironmentVariables = globalEnvironmentVariables;
 
     const environment = findEnvironmentInCollection(collectionCopy, collectionCopy.activeEnvironmentUid);
@@ -297,7 +303,7 @@ export const cancelRunnerExecution = (cancelTokenUid) => (dispatch) => {
 
 export const runCollectionFolder = (collectionUid, folderUid, recursive, delay) => (dispatch, getState) => {
   const state = getState();
-  const { globalEnvironments, activeGlobalEnvironmentUid } = state.globalEnvironments;  
+  const { globalEnvironments, activeGlobalEnvironmentUid } = state.globalEnvironments;
   const collection = findCollectionByUid(state.collections.collections, collectionUid);
 
   return new Promise((resolve, reject) => {
@@ -308,7 +314,10 @@ export const runCollectionFolder = (collectionUid, folderUid, recursive, delay)
     let collectionCopy = cloneDeep(collection);
 
     // add selected global env variables to the collection object
-    const globalEnvironmentVariables = getGlobalEnvironmentVariables({ globalEnvironments, activeGlobalEnvironmentUid });
+    const globalEnvironmentVariables = getGlobalEnvironmentVariables({
+      globalEnvironments,
+      activeGlobalEnvironmentUid
+    });
     collectionCopy.globalEnvironmentVariables = globalEnvironmentVariables;
 
     const folder = findItemInCollection(collectionCopy, folderUid);
@@ -989,15 +998,16 @@ export const selectEnvironment = (environmentUid, collectionUid) => (dispatch, g
 
     const collectionCopy = cloneDeep(collection);
 
-    const environmentName = environmentUid 
-      ? findEnvironmentInCollection(collectionCopy, environmentUid)?.name 
-      : null;
+    const environmentName = environmentUid ? findEnvironmentInCollection(collectionCopy, environmentUid)?.name : null;
 
     if (environmentUid && !environmentName) {
       return reject(new Error('Environment not found'));
-    }  
-    
-    ipcRenderer.invoke('renderer:update-ui-state-snapshot', { type: 'COLLECTION_ENVIRONMENT', data: { collectionPath: collection?.pathname, environmentName }});
+    }
+
+    ipcRenderer.invoke('renderer:update-ui-state-snapshot', {
+      type: 'COLLECTION_ENVIRONMENT',
+      data: { collectionPath: collection?.pathname, environmentName }
+    });
 
     dispatch(_selectEnvironment({ environmentUid, collectionUid }));
     resolve();
@@ -1140,11 +1150,14 @@ export const collectionAddEnvFileEvent = (payload) => (dispatch, getState) => {
   });
 };
 
-export const importCollection = (collection, collectionLocation) => (dispatch, getState) => {
+export const importCollection = (collection, collectionLocation, updateExistingCollection) => (dispatch, getState) => {
   return new Promise((resolve, reject) => {
     const { ipcRenderer } = window;
 
-    ipcRenderer.invoke('renderer:import-collection', collection, collectionLocation).then(resolve).catch(reject);
+    ipcRenderer
+      .invoke('renderer:import-collection', collection, collectionLocation, updateExistingCollection)
+      .then(resolve)
+      .catch(reject);
   });
 };
 
@@ -1164,32 +1177,30 @@ export const saveCollectionSecurityConfig = (collectionUid, securityConfig) => (
   });
 };
 
-
 export const hydrateCollectionWithUiStateSnapshot = (payload) => (dispatch, getState) => {
-    const collectionSnapshotData = payload;
-    return new Promise((resolve, reject) => {
-      const state = getState();
-      try {
-        if(!collectionSnapshotData) resolve();
-        const { pathname, selectedEnvironment } = collectionSnapshotData;
-        const collection = findCollectionByPathname(state.collections.collections, pathname);
-        const collectionCopy = cloneDeep(collection);
-        const collectionUid = collectionCopy?.uid;
-
-        // update selected environment
-        if (selectedEnvironment) {
-          const environment = findEnvironmentInCollectionByName(collectionCopy, selectedEnvironment);
-          if (environment) {
-            dispatch(_selectEnvironment({ environmentUid: environment?.uid, collectionUid }));
-          }
+  const collectionSnapshotData = payload;
+  return new Promise((resolve, reject) => {
+    const state = getState();
+    try {
+      if (!collectionSnapshotData) resolve();
+      const { pathname, selectedEnvironment } = collectionSnapshotData;
+      const collection = findCollectionByPathname(state.collections.collections, pathname);
+      const collectionCopy = cloneDeep(collection);
+      const collectionUid = collectionCopy?.uid;
+
+      // update selected environment
+      if (selectedEnvironment) {
+        const environment = findEnvironmentInCollectionByName(collectionCopy, selectedEnvironment);
+        if (environment) {
+          dispatch(_selectEnvironment({ environmentUid: environment?.uid, collectionUid }));
         }
-
-        // todo: add any other redux state that you want to save
-        
-        resolve();
-      }
-      catch(error) {
-        reject(error);
       }
-    });
-  };
\ No newline at end of file
+
+      // todo: add any other redux state that you want to save
+
+      resolve();
+    } catch (error) {
+      reject(error);
+    }
+  });
+};
diff --git a/packages/bruno-electron/src/ipc/collection.js b/packages/bruno-electron/src/ipc/collection.js
index 38261cdb7d..6d58641d7b 100644
--- a/packages/bruno-electron/src/ipc/collection.js
+++ b/packages/bruno-electron/src/ipc/collection.js
@@ -459,100 +459,103 @@ const registerRendererEventHandlers = (mainWindow, watcher, lastOpenedCollection
     }
   });
 
-  ipcMain.handle('renderer:import-collection', async (event, collection, collectionLocation) => {
-    try {
-      let collectionName = sanitizeDirectoryName(collection.name);
-      let collectionPath = path.join(collectionLocation, collectionName);
-
-      if (fs.existsSync(collectionPath)) {
-        throw new Error(`collection: ${collectionPath} already exists`);
-      }
+  ipcMain.handle(
+    'renderer:import-collection',
+    async (event, collection, collectionLocation, updateExistingCollection = false) => {
+      try {
+        let collectionName = sanitizeDirectoryName(collection.name);
+        let collectionPath = path.join(collectionLocation, collectionName);
 
-      // Recursive function to parse the collection items and create files/folders
-      const parseCollectionItems = (items = [], currentPath) => {
-        items.forEach((item) => {
-          if (['http-request', 'graphql-request'].includes(item.type)) {
-            const content = jsonToBru(item);
-            const filePath = path.join(currentPath, `${item.name}.bru`);
-            fs.writeFileSync(filePath, content);
-          }
-          if (item.type === 'folder') {
-            const folderPath = path.join(currentPath, item.name);
-            fs.mkdirSync(folderPath);
+        if (fs.existsSync(collectionPath)) {
+          throw new Error(`collection already exists: ${collectionPath}`);
+        }
 
-            if (item?.root?.meta?.name) {
-              const folderBruFilePath = path.join(folderPath, 'folder.bru');
-              const folderContent = jsonToCollectionBru(
-                item.root,
-                true // isFolder
-              );
-              fs.writeFileSync(folderBruFilePath, folderContent);
+        // Recursive function to parse the collection items and create files/folders
+        const parseCollectionItems = (items = [], currentPath) => {
+          items.forEach((item) => {
+            if (['http-request', 'graphql-request'].includes(item.type)) {
+              const content = jsonToBru(item);
+              const filePath = path.join(currentPath, `${item.name}.bru`);
+              fs.writeFileSync(filePath, content);
             }
+            if (item.type === 'folder') {
+              const folderPath = path.join(currentPath, item.name);
+              fs.mkdirSync(folderPath);
+
+              if (item?.root?.meta?.name) {
+                const folderBruFilePath = path.join(folderPath, 'folder.bru');
+                const folderContent = jsonToCollectionBru(
+                  item.root,
+                  true // isFolder
+                );
+                fs.writeFileSync(folderBruFilePath, folderContent);
+              }
 
-            if (item.items && item.items.length) {
-              parseCollectionItems(item.items, folderPath);
+              if (item.items && item.items.length) {
+                parseCollectionItems(item.items, folderPath);
+              }
             }
-          }
-          // Handle items of type 'js'
-          if (item.type === 'js') {
-            const filePath = path.join(currentPath, `${item.name}.js`);
-            fs.writeFileSync(filePath, item.fileContent);
-          }
-        });
-      };
+            // Handle items of type 'js'
+            if (item.type === 'js') {
+              const filePath = path.join(currentPath, `${item.name}.js`);
+              fs.writeFileSync(filePath, item.fileContent);
+            }
+          });
+        };
 
-      const parseEnvironments = (environments = [], collectionPath) => {
-        const envDirPath = path.join(collectionPath, 'environments');
-        if (!fs.existsSync(envDirPath)) {
-          fs.mkdirSync(envDirPath);
-        }
+        const parseEnvironments = (environments = [], collectionPath) => {
+          const envDirPath = path.join(collectionPath, 'environments');
+          if (!fs.existsSync(envDirPath)) {
+            fs.mkdirSync(envDirPath);
+          }
 
-        environments.forEach((env) => {
-          const content = envJsonToBru(env);
-          const filePath = path.join(envDirPath, `${env.name}.bru`);
-          fs.writeFileSync(filePath, content);
-        });
-      };
+          environments.forEach((env) => {
+            const content = envJsonToBru(env);
+            const filePath = path.join(envDirPath, `${env.name}.bru`);
+            fs.writeFileSync(filePath, content);
+          });
+        };
 
-      const getBrunoJsonConfig = (collection) => {
-        let brunoConfig = collection.brunoConfig;
+        const getBrunoJsonConfig = (collection) => {
+          let brunoConfig = collection.brunoConfig;
 
-        if (!brunoConfig) {
-          brunoConfig = {
-            version: '1',
-            name: collection.name,
-            type: 'collection',
-            ignore: ['node_modules', '.git']
-          };
-        }
+          if (!brunoConfig) {
+            brunoConfig = {
+              version: '1',
+              name: collection.name,
+              type: 'collection',
+              ignore: ['node_modules', '.git']
+            };
+          }
 
-        return brunoConfig;
-      };
+          return brunoConfig;
+        };
 
-      await createDirectory(collectionPath);
+        await createDirectory(collectionPath);
 
-      const uid = generateUidBasedOnHash(collectionPath);
-      const brunoConfig = getBrunoJsonConfig(collection);
-      const stringifiedBrunoConfig = await stringifyJson(brunoConfig);
+        const uid = generateUidBasedOnHash(collectionPath);
+        const brunoConfig = getBrunoJsonConfig(collection);
+        const stringifiedBrunoConfig = await stringifyJson(brunoConfig);
 
-      // Write the Bruno configuration to a file
-      await writeFile(path.join(collectionPath, 'bruno.json'), stringifiedBrunoConfig);
+        // Write the Bruno configuration to a file
+        await writeFile(path.join(collectionPath, 'bruno.json'), stringifiedBrunoConfig);
 
-      const collectionContent = jsonToCollectionBru(collection.root);
-      await writeFile(path.join(collectionPath, 'collection.bru'), collectionContent);
+        const collectionContent = jsonToCollectionBru(collection.root);
+        await writeFile(path.join(collectionPath, 'collection.bru'), collectionContent);
 
-      mainWindow.webContents.send('main:collection-opened', collectionPath, uid, brunoConfig);
-      ipcMain.emit('main:collection-opened', mainWindow, collectionPath, uid, brunoConfig);
+        mainWindow.webContents.send('main:collection-opened', collectionPath, uid, brunoConfig);
+        ipcMain.emit('main:collection-opened', mainWindow, collectionPath, uid, brunoConfig);
 
-      lastOpenedCollections.add(collectionPath);
+        lastOpenedCollections.add(collectionPath);
 
-      // create folder and files based on collection
-      await parseCollectionItems(collection.items, collectionPath);
-      await parseEnvironments(collection.environments, collectionPath);
-    } catch (error) {
-      return Promise.reject(error);
+        // create folder and files based on collection
+        await parseCollectionItems(collection.items, collectionPath);
+        await parseEnvironments(collection.environments, collectionPath);
+      } catch (error) {
+        return Promise.reject(error);
+      }
     }
-  });
+  );
 
   ipcMain.handle('renderer:clone-folder', async (event, itemFolder, collectionPath) => {
     try {

From 9690aaa7995e01297f3519fb199639e2ab919886 Mon Sep 17 00:00:00 2001
From: Jarod Gowgiel <jroddg@gmail.com>
Date: Sat, 7 Dec 2024 08:10:23 -0800
Subject: [PATCH 2/2] Update 'import-collection' logic to handle pre-existing
 directories

This enables an 'updateExistingCollection' flow which creates any missing
directories while leaving (and traversing) existing directories in place.

For example, if you are working from an OpenAPI file, and the structure
of that file is updated (e.g. by a third party) you can now re-import
that file in order to have any new endpoints be added to an existing
collection. Existing directories, endpoints, or organization are left
untouched.
---
 packages/bruno-electron/src/ipc/collection.js | 52 ++++++++++++++-----
 1 file changed, 38 insertions(+), 14 deletions(-)

diff --git a/packages/bruno-electron/src/ipc/collection.js b/packages/bruno-electron/src/ipc/collection.js
index 6d58641d7b..d173fa5676 100644
--- a/packages/bruno-electron/src/ipc/collection.js
+++ b/packages/bruno-electron/src/ipc/collection.js
@@ -466,21 +466,47 @@ const registerRendererEventHandlers = (mainWindow, watcher, lastOpenedCollection
         let collectionName = sanitizeDirectoryName(collection.name);
         let collectionPath = path.join(collectionLocation, collectionName);
 
-        if (fs.existsSync(collectionPath)) {
+        if (fs.existsSync(collectionPath) && !updateExistingCollection) {
           throw new Error(`collection already exists: ${collectionPath}`);
         }
 
+        /**
+         * @returns whether the the given file was written. If this method returns,
+         * the file now definitely exists
+         */
+        const writeContentIfFileDoesNotExist = (filePath, content) => {
+          if (fs.existsSync(filePath)) {
+            return false;
+          } else {
+            fs.writeFileSync(filePath, content);
+            return true;
+          }
+        };
+
+        /**
+         * @returns whether the the given directory was created. If this method returns,
+         * the directory now definitely exists
+         */
+        const createDirectoryIfDirectoryDoesNotExist = (folderPath) => {
+          if (!fs.existsSync(folderPath)) {
+            fs.mkdirSync(folderPath);
+            return true;
+          } else {
+            return false;
+          }
+        };
+
         // Recursive function to parse the collection items and create files/folders
         const parseCollectionItems = (items = [], currentPath) => {
           items.forEach((item) => {
             if (['http-request', 'graphql-request'].includes(item.type)) {
               const content = jsonToBru(item);
               const filePath = path.join(currentPath, `${item.name}.bru`);
-              fs.writeFileSync(filePath, content);
+              writeContentIfFileDoesNotExist(filePath, content);
             }
             if (item.type === 'folder') {
               const folderPath = path.join(currentPath, item.name);
-              fs.mkdirSync(folderPath);
+              createDirectoryIfDirectoryDoesNotExist(folderPath);
 
               if (item?.root?.meta?.name) {
                 const folderBruFilePath = path.join(folderPath, 'folder.bru');
@@ -488,7 +514,7 @@ const registerRendererEventHandlers = (mainWindow, watcher, lastOpenedCollection
                   item.root,
                   true // isFolder
                 );
-                fs.writeFileSync(folderBruFilePath, folderContent);
+                writeContentIfFileDoesNotExist(folderBruFilePath, folderContent);
               }
 
               if (item.items && item.items.length) {
@@ -498,21 +524,19 @@ const registerRendererEventHandlers = (mainWindow, watcher, lastOpenedCollection
             // Handle items of type 'js'
             if (item.type === 'js') {
               const filePath = path.join(currentPath, `${item.name}.js`);
-              fs.writeFileSync(filePath, item.fileContent);
+              writeContentIfFileDoesNotExist(filePath, item.fileContent);
             }
           });
         };
 
         const parseEnvironments = (environments = [], collectionPath) => {
           const envDirPath = path.join(collectionPath, 'environments');
-          if (!fs.existsSync(envDirPath)) {
-            fs.mkdirSync(envDirPath);
-          }
+          createDirectoryIfDirectoryDoesNotExist(envDirPath);
 
           environments.forEach((env) => {
             const content = envJsonToBru(env);
             const filePath = path.join(envDirPath, `${env.name}.bru`);
-            fs.writeFileSync(filePath, content);
+            writeContentIfFileDoesNotExist(filePath, content);
           });
         };
 
@@ -531,17 +555,17 @@ const registerRendererEventHandlers = (mainWindow, watcher, lastOpenedCollection
           return brunoConfig;
         };
 
-        await createDirectory(collectionPath);
+        createDirectoryIfDirectoryDoesNotExist(collectionPath);
 
         const uid = generateUidBasedOnHash(collectionPath);
         const brunoConfig = getBrunoJsonConfig(collection);
         const stringifiedBrunoConfig = await stringifyJson(brunoConfig);
 
         // Write the Bruno configuration to a file
-        await writeFile(path.join(collectionPath, 'bruno.json'), stringifiedBrunoConfig);
+        writeContentIfFileDoesNotExist(path.join(collectionPath, 'bruno.json'), stringifiedBrunoConfig);
 
         const collectionContent = jsonToCollectionBru(collection.root);
-        await writeFile(path.join(collectionPath, 'collection.bru'), collectionContent);
+        writeContentIfFileDoesNotExist(path.join(collectionPath, 'collection.bru'), collectionContent);
 
         mainWindow.webContents.send('main:collection-opened', collectionPath, uid, brunoConfig);
         ipcMain.emit('main:collection-opened', mainWindow, collectionPath, uid, brunoConfig);
@@ -549,8 +573,8 @@ const registerRendererEventHandlers = (mainWindow, watcher, lastOpenedCollection
         lastOpenedCollections.add(collectionPath);
 
         // create folder and files based on collection
-        await parseCollectionItems(collection.items, collectionPath);
-        await parseEnvironments(collection.environments, collectionPath);
+        parseCollectionItems(collection.items, collectionPath);
+        parseEnvironments(collection.environments, collectionPath);
       } catch (error) {
         return Promise.reject(error);
       }