Merge branch 'main' into fix/cli-not-following-redirects

packages/bruno-cli/src/utils/bru.js

@@ -15,6 +15,17 @@ const collectionBruToJson = (bru) => {
       }
     };
 
+    // add meta if it exists
+    // this is only for folder bru file
+    // in the future, all of this will be replaced by standard bru lang
+    const sequence = _.get(json, 'meta.seq');
+    if (json?.meta) {
+      transformedJson.meta = {
+        name: json.meta.name,
+        seq: !isNaN(sequence) ? Number(sequence) : 1
+      };
+    }
+
     return transformedJson;
   } catch (error) {
     return Promise.reject(error);

packages/bruno-cli/src/utils/collection.js

@@ -4,6 +4,112 @@ const fs = require('fs');
 const path = require('path');
 const { jsonToBruV2, envJsonToBruV2, jsonToCollectionBru } = require('@usebruno/lang');
 const { sanitizeName } = require('./filesystem');
+const { bruToJson, collectionBruToJson } = require('./bru');
+const constants = require('../constants');
+const chalk = require('chalk');
+
+const createCollectionJsonFromPathname = (collectionPath) => {
+  const environmentsPath = path.join(collectionPath, `environments`);
+    
+  // get the collection bruno json config [<collection-path>/bruno.json]
+  const brunoConfig = getCollectionBrunoJsonConfig(collectionPath);
+
+  // get the collection root [<collection-path>/collection.bru]
+  const collectionRoot = getCollectionRoot(collectionPath);
+
+  // get the collection items recursively
+  const traverse = (currentPath) => {
+    const filesInCurrentDir = fs.readdirSync(currentPath);
+    if (currentPath.includes('node_modules')) {
+      return;
+    }
+    const currentDirItems = [];
+    for (const file of filesInCurrentDir) {
+      const filePath = path.join(currentPath, file);
+      const stats = fs.lstatSync(filePath);
+      if (stats.isDirectory()) {
+        if (filePath === environmentsPath) continue;
+        if (filePath.startsWith('.git') || filePath.startsWith('node_modules')) continue;
+        
+        // get the folder root
+        let folderItem = { name: file, pathname: filePath, type: 'folder', items: traverse(filePath) }
+        const folderBruJson = getFolderRoot(filePath);
+        if (folderBruJson) {
+          folderItem.root = folderBruJson;
+          folderItem.seq = folderBruJson.meta.seq;
+        }
+        currentDirItems.push(folderItem);
+      }
+      else {
+        if (['collection.bru', 'folder.bru'].includes(file)) continue;
+        if (path.extname(filePath) !== '.bru') continue;
+
+        // get the request item
+        const bruContent = fs.readFileSync(filePath, 'utf8');
+        const requestItem = bruToJson(bruContent);
+        currentDirItems.push({
+          name: file,
+          pathname: filePath,
+          ...requestItem
+        });
+      }
+    }
+    let currentDirFolderItems = currentDirItems?.filter((iter) => iter.type === 'folder');
+    let sortedFolderItems = currentDirFolderItems?.sort((a, b) => a.seq - b.seq);
+
+    let currentDirRequestItems = currentDirItems?.filter((iter) => iter.type !== 'folder');
+    let sortedRequestItems = currentDirRequestItems?.sort((a, b) => a.seq - b.seq);
+
+    return sortedFolderItems?.concat(sortedRequestItems);
+  };
+  let collectionItems = traverse(collectionPath);
+
+  let collection = {
+    brunoConfig,
+    root: collectionRoot,
+    pathname: collectionPath,
+    items: collectionItems
+  }
+
+  return collection;
+};
+
+const getCollectionBrunoJsonConfig = (dir) => {
+  // right now, bru must be run from the root of the collection
+  // will add support in the future to run it from anywhere inside the collection
+  const brunoJsonPath = path.join(dir, 'bruno.json');
+  const brunoJsonExists = fs.existsSync(brunoJsonPath);
+  if (!brunoJsonExists) {
+    console.error(chalk.red(`You can run only at the root of a collection`));
+    process.exit(constants.EXIT_STATUS.ERROR_NOT_IN_COLLECTION);
+  }
+
+  const brunoConfigFile = fs.readFileSync(brunoJsonPath, 'utf8');
+  const brunoConfig = JSON.parse(brunoConfigFile);
+  return brunoConfig;
+}
+
+const getCollectionRoot = (dir) => {
+  const collectionRootPath = path.join(dir, 'collection.bru');
+  const exists = fs.existsSync(collectionRootPath);
+  if (!exists) {
+    return {};
+  }
+
+  const content = fs.readFileSync(collectionRootPath, 'utf8');
+  return collectionBruToJson(content);
+};
+
+const getFolderRoot = (dir) => {
+  const folderRootPath = path.join(dir, 'folder.bru');
+  const exists = fs.existsSync(folderRootPath);
+  if (!exists) {
+    return null;
+  }
+
+  const content = fs.readFileSync(folderRootPath, 'utf8');
+  return collectionBruToJson(content);
+};
 
 const mergeHeaders = (collection, request, requestTreePath) => {
   let headers = new Map();
@@ -204,6 +310,45 @@ const getTreePathFromCollectionToItem = (collection, _item) => {
   return path;
 };
 
+const mergeAuth = (collection, request, requestTreePath) => {
+  let collectionAuth = collection?.root?.request?.auth || { mode: 'none' };
+  let effectiveAuth = collectionAuth;
+
+  for (let i of requestTreePath) {
+    if (i.type === 'folder') {
+      const folderAuth = i?.root?.request?.auth;
+      if (folderAuth && folderAuth.mode && folderAuth.mode !== 'none' && folderAuth.mode !== 'inherit') {
+        effectiveAuth = folderAuth;
+      }
+    }
+  }
+
+  if (request.auth && request.auth.mode === 'inherit') {
+    request.auth = effectiveAuth;
+  }
+}
+
+const getAllRequestsInFolder = (folderItems = [], recursive = true) => {
+  let requests = [];
+
+  if (folderItems && folderItems.length) {
+    folderItems.forEach((item) => {
+      if (item.type !== 'folder') {
+        requests.push(item);
+      } else {
+        if (recursive) {
+          requests = requests.concat(getAllRequestsInFolder(item.items, recursive));
+        }
+      }
+    });
+  }
+  return requests;
+};
+
+const getAllRequestsAtFolderRoot = (folderItems = []) => {
+  return getAllRequestsInFolder(folderItems, false);
+}
+
 /**
  * Safe write file implementation to handle errors
  * @param {string} filePath - Path to write file
@@ -335,10 +480,14 @@ const processCollectionItems = async (items = [], currentPath) => {
 };
 
 module.exports = {
+  createCollectionJsonFromPathname,
   mergeHeaders,
   mergeVars,
   mergeScripts,
   findItemInCollection,
   getTreePathFromCollectionToItem,
-  createCollectionFromBrunoObject
+  createCollectionFromBrunoObject,
+  mergeAuth,
+  getAllRequestsInFolder,
+  getAllRequestsAtFolderRoot
 }