extern/bruno
1
0
Fork 1
mirror of https://github.com/usebruno/bruno.git synced 2025-01-03 12:39:34 +01:00
Code Issues Packages Projects Releases Wiki Activity

chore(#197): ran prettier on packages/bruno-electron

Browse Source
This commit is contained in:
Anoop M D 2023-09-22 00:36:42 +05:30
parent ae692dde06
commit 67fe264494
18 changed files with 810 additions and 725 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
packages/bruno-electron/src/app/collections.js
View File

@ -16,28 +16,30 @@ const configSchema = Yup.object({
name: Yup.string().nullable().max(256, 'name must be 256 characters or less'), name: Yup.string().nullable().max(256, 'name must be 256 characters or less'),
type: Yup.string().oneOf(['collection']).required('type is required'), type: Yup.string().oneOf(['collection']).required('type is required'),
version: Yup.string().oneOf(['1']).required('type is required') version: Yup.string().oneOf(['1']).required('type is required')
}).noUnknown(true).strict(); })
.noUnknown(true)
.strict();
const readConfigFile = async (pathname) => { const readConfigFile = async (pathname) => {
try { try {
const jsonData = fs.readFileSync(pathname, 'utf8'); const jsonData = fs.readFileSync(pathname, 'utf8');
return JSON.parse(jsonData); return JSON.parse(jsonData);
} catch(err) { } catch (err) {
return Promise.reject(new Error("Unable to parse json in bruno.json")); return Promise.reject(new Error('Unable to parse json in bruno.json'));
} }
} };
const validateSchema = async (config) => { const validateSchema = async (config) => {
try { try {
await configSchema.validate(config); await configSchema.validate(config);
} catch(err) { } catch (err) {
return Promise.reject(new Error("bruno.json format is invalid")); return Promise.reject(new Error('bruno.json format is invalid'));
} }
}; };
const getCollectionConfigFile = async (pathname) => { const getCollectionConfigFile = async (pathname) => {
const configFilePath = path.join(pathname, 'bruno.json'); const configFilePath = path.join(pathname, 'bruno.json');
if (!fs.existsSync(configFilePath)){ if (!fs.existsSync(configFilePath)) {
throw new Error(`The collection is not valid (bruno.json not found)`); throw new Error(`The collection is not valid (bruno.json not found)`);
} }
@ -45,7 +47,7 @@ const getCollectionConfigFile = async (pathname) => {
await validateSchema(config); await validateSchema(config);
return config; return config;
} };
const openCollectionDialog = async (win, watcher) => { const openCollectionDialog = async (win, watcher) => {
const { filePaths } = await dialog.showOpenDialog(win, { const { filePaths } = await dialog.showOpenDialog(win, {
@ -60,20 +62,18 @@ const openCollectionDialog = async (win, watcher) => {
console.error(`[ERROR] Cannot open unknown folder: "${resolvedPath}"`); console.error(`[ERROR] Cannot open unknown folder: "${resolvedPath}"`);
} }
} }
} };
const openCollection = async (win, watcher, collectionPath, options = {}) => { const openCollection = async (win, watcher, collectionPath, options = {}) => {
if(!watcher.hasWatcher(collectionPath)) { if (!watcher.hasWatcher(collectionPath)) {
try { try {
const { const { name } = await getCollectionConfigFile(collectionPath);
name const uid = generateUidBasedOnHash(collectionPath);
} = await getCollectionConfigFile(collectionPath);
const uid = generateUidBasedOnHash(collectionPath);
win.webContents.send('main:collection-opened', collectionPath, uid, name); win.webContents.send('main:collection-opened', collectionPath, uid, name);
ipcMain.emit('main:collection-opened', win, collectionPath, uid); ipcMain.emit('main:collection-opened', win, collectionPath, uid);
} catch(err) { } catch (err) {
if(!options.dontSendDisplayErrors) { if (!options.dontSendDisplayErrors) {
win.webContents.send('main:display-error', { win.webContents.send('main:display-error', {
error: err.message || 'An error occured while opening the local collection' error: err.message || 'An error occured while opening the local collection'
}); });

10
packages/bruno-electron/src/app/last-opened-collections.js
View File

@ -18,8 +18,8 @@ class LastOpenedCollections {
add(collectionPath) { add(collectionPath) {
const collections = this.store.get('lastOpenedCollections') || []; const collections = this.store.get('lastOpenedCollections') || [];
if(isDirectory(collectionPath)) { if (isDirectory(collectionPath)) {
if(!collections.includes(collectionPath)) { if (!collections.includes(collectionPath)) {
collections.push(collectionPath); collections.push(collectionPath);
this.store.set('lastOpenedCollections', collections); this.store.set('lastOpenedCollections', collections);
} }
@ -29,8 +29,8 @@ class LastOpenedCollections {
remove(collectionPath) { remove(collectionPath) {
let collections = this.store.get('lastOpenedCollections') || []; let collections = this.store.get('lastOpenedCollections') || [];
if(collections.includes(collectionPath)) { if (collections.includes(collectionPath)) {
collections = _.filter(collections, c => c !== collectionPath); collections = _.filter(collections, (c) => c !== collectionPath);
this.store.set('lastOpenedCollections', collections); this.store.set('lastOpenedCollections', collections);
} }
} }
@ -38,6 +38,6 @@ class LastOpenedCollections {
removeAll() { removeAll() {
return this.store.set('lastOpenedCollections', []); return this.store.set('lastOpenedCollections', []);
} }
}; }
module.exports = LastOpenedCollections; module.exports = LastOpenedCollections;

47
packages/bruno-electron/src/app/menu-template.js
View File

@ -6,7 +6,7 @@ const template = [
submenu: [ submenu: [
{ {
label: 'Open Local Collection', label: 'Open Local Collection',
click () { click() {
ipcMain.emit('main:open-collection'); ipcMain.emit('main:open-collection');
} }
}, },
@ -14,40 +14,35 @@ const template = [
] ]
}, },
{ {
label: 'Edit', label: 'Edit',
submenu: [ submenu: [
{ role: 'undo'}, { role: 'undo' },
{ role: 'redo'}, { role: 'redo' },
{ type: 'separator'}, { type: 'separator' },
{ role: 'cut'}, { role: 'cut' },
{ role: 'copy'}, { role: 'copy' },
{ role: 'paste'} { role: 'paste' }
] ]
}, },
{ {
label: 'View', label: 'View',
submenu: [ submenu: [
{ role: 'toggledevtools'}, { role: 'toggledevtools' },
{ type: 'separator'}, { type: 'separator' },
{ role: 'resetzoom'}, { role: 'resetzoom' },
{ role: 'zoomin'}, { role: 'zoomin' },
{ role: 'zoomout'}, { role: 'zoomout' },
{ type: 'separator'}, { type: 'separator' },
{ role: 'togglefullscreen'} { role: 'togglefullscreen' }
] ]
}, },
{ {
role: 'window', role: 'window',
submenu: [ submenu: [{ role: 'minimize' }, { role: 'close' }]
{ role: 'minimize'},
{ role: 'close'}
]
}, },
{ {
role: 'help', role: 'help',
submenu: [ submenu: [{ label: 'Learn More' }]
{ label: 'Learn More'}
]
} }
]; ];

6
packages/bruno-electron/src/app/preferences.js
View File

@ -2,7 +2,7 @@
* The preferences are stored in the browser local storage. * The preferences are stored in the browser local storage.
* When the app is started, an IPC message is published from the renderer process to set the preferences. * When the app is started, an IPC message is published from the renderer process to set the preferences.
* The electron process uses this module to get the preferences. * The electron process uses this module to get the preferences.
* *
* { * {
* request: { * request: {
* sslVerification: boolean * sslVerification: boolean
@ -14,11 +14,11 @@ let preferences = {};
const getPreferences = () => { const getPreferences = () => {
return preferences; return preferences;
} };
const setPreferences = (newPreferences) => { const setPreferences = (newPreferences) => {
preferences = newPreferences; preferences = newPreferences;
} };
module.exports = { module.exports = {
getPreferences, getPreferences,

127
packages/bruno-electron/src/app/watcher.js
View File

@ -3,19 +3,9 @@ const fs = require('fs');
const path = require('path'); const path = require('path');
const chokidar = require('chokidar'); const chokidar = require('chokidar');
const { hasJsonExtension, hasBruExtension, writeFile } = require('../utils/filesystem'); const { hasJsonExtension, hasBruExtension, writeFile } = require('../utils/filesystem');
const { const { bruToEnvJson, envJsonToBru, bruToJson, jsonToBru } = require('../bru');
bruToEnvJson,
envJsonToBru,
bruToJson,
jsonToBru
} = require('../bru');
const { const { isLegacyEnvFile, migrateLegacyEnvFile, isLegacyBruFile, migrateLegacyBruFile } = require('../bru/migrate');
isLegacyEnvFile,
migrateLegacyEnvFile,
isLegacyBruFile,
migrateLegacyBruFile
} = require('../bru/migrate');
const { itemSchema } = require('@usebruno/schema'); const { itemSchema } = require('@usebruno/schema');
const { uuid } = require('../utils/common'); const { uuid } = require('../utils/common');
const { getRequestUid } = require('../cache/requestUids'); const { getRequestUid } = require('../cache/requestUids');
@ -46,16 +36,16 @@ const hydrateRequestWithUuid = (request, pathname) => {
const bodyFormUrlEncoded = _.get(request, 'request.body.formUrlEncoded', []); const bodyFormUrlEncoded = _.get(request, 'request.body.formUrlEncoded', []);
const bodyMultipartForm = _.get(request, 'request.body.multipartForm', []); const bodyMultipartForm = _.get(request, 'request.body.multipartForm', []);
params.forEach((param) => param.uid = uuid()); params.forEach((param) => (param.uid = uuid()));
headers.forEach((header) => header.uid = uuid()); headers.forEach((header) => (header.uid = uuid()));
requestVars.forEach((variable) => variable.uid = uuid()); requestVars.forEach((variable) => (variable.uid = uuid()));
responseVars.forEach((variable) => variable.uid = uuid()); responseVars.forEach((variable) => (variable.uid = uuid()));
assertions.forEach((assertion) => assertion.uid = uuid()); assertions.forEach((assertion) => (assertion.uid = uuid()));
bodyFormUrlEncoded.forEach((param) => param.uid = uuid()); bodyFormUrlEncoded.forEach((param) => (param.uid = uuid()));
bodyMultipartForm.forEach((param) => param.uid = uuid()); bodyMultipartForm.forEach((param) => (param.uid = uuid()));
return request; return request;
} };
const addEnvironmentFile = async (win, pathname, collectionUid) => { const addEnvironmentFile = async (win, pathname, collectionUid) => {
try { try {
@ -65,13 +55,13 @@ const addEnvironmentFile = async (win, pathname, collectionUid) => {
collectionUid, collectionUid,
pathname, pathname,
name: basename name: basename
}, }
}; };
let bruContent = fs.readFileSync(pathname, 'utf8'); let bruContent = fs.readFileSync(pathname, 'utf8');
// migrate old env json to bru file // migrate old env json to bru file
if(isLegacyEnvFile(bruContent)) { if (isLegacyEnvFile(bruContent)) {
bruContent = await migrateLegacyEnvFile(bruContent, pathname); bruContent = await migrateLegacyEnvFile(bruContent, pathname);
} }
@ -79,10 +69,10 @@ const addEnvironmentFile = async (win, pathname, collectionUid) => {
file.data.name = basename.substring(0, basename.length - 4); file.data.name = basename.substring(0, basename.length - 4);
file.data.uid = getRequestUid(pathname); file.data.uid = getRequestUid(pathname);
_.each(_.get(file, 'data.variables', []), (variable) => variable.uid = uuid()); _.each(_.get(file, 'data.variables', []), (variable) => (variable.uid = uuid()));
win.webContents.send('main:collection-tree-updated', 'addEnvironmentFile', file); win.webContents.send('main:collection-tree-updated', 'addEnvironmentFile', file);
} catch (err) { } catch (err) {
console.error(err) console.error(err);
} }
}; };
@ -101,14 +91,14 @@ const changeEnvironmentFile = async (win, pathname, collectionUid) => {
file.data = bruToEnvJson(bruContent); file.data = bruToEnvJson(bruContent);
file.data.name = basename.substring(0, basename.length - 4); file.data.name = basename.substring(0, basename.length - 4);
file.data.uid = getRequestUid(pathname); file.data.uid = getRequestUid(pathname);
_.each(_.get(file, 'data.variables', []), (variable) => variable.uid = uuid()); _.each(_.get(file, 'data.variables', []), (variable) => (variable.uid = uuid()));
// we are reusing the addEnvironmentFile event itself // we are reusing the addEnvironmentFile event itself
// this is because the uid of the pathname remains the same // this is because the uid of the pathname remains the same
// and the collection tree will be able to update the existing environment // and the collection tree will be able to update the existing environment
win.webContents.send('main:collection-tree-updated', 'addEnvironmentFile', file); win.webContents.send('main:collection-tree-updated', 'addEnvironmentFile', file);
} catch (err) { } catch (err) {
console.error(err) console.error(err);
} }
}; };
@ -118,24 +108,24 @@ const unlinkEnvironmentFile = async (win, pathname, collectionUid) => {
meta: { meta: {
collectionUid, collectionUid,
pathname, pathname,
name: path.basename(pathname), name: path.basename(pathname)
}, },
data: { data: {
uid: getRequestUid(pathname), uid: getRequestUid(pathname),
name: path.basename(pathname).substring(0, path.basename(pathname).length - 4), name: path.basename(pathname).substring(0, path.basename(pathname).length - 4)
} }
}; };
win.webContents.send('main:collection-tree-updated', 'unlinkEnvironmentFile', file); win.webContents.send('main:collection-tree-updated', 'unlinkEnvironmentFile', file);
} catch (err) { } catch (err) {
console.error(err) console.error(err);
} }
}; };
const add = async (win, pathname, collectionUid, collectionPath) => { const add = async (win, pathname, collectionUid, collectionPath) => {
console.log(`watcher add: ${pathname}`); console.log(`watcher add: ${pathname}`);
if(isJsonEnvironmentConfig(pathname, collectionPath)) { if (isJsonEnvironmentConfig(pathname, collectionPath)) {
try { try {
const dirname = path.dirname(pathname); const dirname = path.dirname(pathname);
const bruContent = fs.readFileSync(pathname, 'utf8'); const bruContent = fs.readFileSync(pathname, 'utf8');
@ -147,7 +137,7 @@ const add = async (win, pathname, collectionUid, collectionPath) => {
fs.mkdirSync(envDirectory); fs.mkdirSync(envDirectory);
} }
for(const env of jsonData) { for (const env of jsonData) {
const bruEnvFilename = path.join(envDirectory, `${env.name}.bru`); const bruEnvFilename = path.join(envDirectory, `${env.name}.bru`);
const bruContent = envJsonToBru(env); const bruContent = envJsonToBru(env);
await writeFile(bruEnvFilename, bruContent); await writeFile(bruEnvFilename, bruContent);
@ -161,12 +151,12 @@ const add = async (win, pathname, collectionUid, collectionPath) => {
return; return;
} }
if(isBruEnvironmentConfig(pathname, collectionPath)) { if (isBruEnvironmentConfig(pathname, collectionPath)) {
return addEnvironmentFile(win, pathname, collectionUid); return addEnvironmentFile(win, pathname, collectionUid);
} }
// migrate old json files to bru // migrate old json files to bru
if(hasJsonExtension(pathname)) { if (hasJsonExtension(pathname)) {
try { try {
const json = fs.readFileSync(pathname, 'utf8'); const json = fs.readFileSync(pathname, 'utf8');
const jsonData = JSON.parse(json); const jsonData = JSON.parse(json);
@ -178,7 +168,7 @@ const add = async (win, pathname, collectionUid, collectionPath) => {
const re = /(.*)\.json$/; const re = /(.*)\.json$/;
const subst = `$1.bru`; const subst = `$1.bru`;
const bruFilename = pathname.replace(re, subst); const bruFilename = pathname.replace(re, subst);
await writeFile(bruFilename, content); await writeFile(bruFilename, content);
await fs.unlinkSync(pathname); await fs.unlinkSync(pathname);
} catch (err) { } catch (err) {
@ -186,20 +176,20 @@ const add = async (win, pathname, collectionUid, collectionPath) => {
} }
} }
if(hasBruExtension(pathname)) { if (hasBruExtension(pathname)) {
const file = { const file = {
meta: { meta: {
collectionUid, collectionUid,
pathname, pathname,
name: path.basename(pathname), name: path.basename(pathname)
} }
} };
try { try {
let bruContent = fs.readFileSync(pathname, 'utf8'); let bruContent = fs.readFileSync(pathname, 'utf8');
// migrate old bru format to new bru format // migrate old bru format to new bru format
if(isLegacyBruFile(bruContent)) { if (isLegacyBruFile(bruContent)) {
bruContent = await migrateLegacyBruFile(bruContent, pathname); bruContent = await migrateLegacyBruFile(bruContent, pathname);
} }
@ -207,7 +197,7 @@ const add = async (win, pathname, collectionUid, collectionPath) => {
hydrateRequestWithUuid(file.data, pathname); hydrateRequestWithUuid(file.data, pathname);
win.webContents.send('main:collection-tree-updated', 'addFile', file); win.webContents.send('main:collection-tree-updated', 'addFile', file);
} catch (err) { } catch (err) {
console.error(err) console.error(err);
} }
} }
}; };
@ -215,7 +205,7 @@ const add = async (win, pathname, collectionUid, collectionPath) => {
const addDirectory = (win, pathname, collectionUid, collectionPath) => { const addDirectory = (win, pathname, collectionUid, collectionPath) => {
const envDirectory = path.join(collectionPath, 'environments'); const envDirectory = path.join(collectionPath, 'environments');
if(pathname === envDirectory) { if (pathname === envDirectory) {
return; return;
} }
@ -223,44 +213,43 @@ const addDirectory = (win, pathname, collectionUid, collectionPath) => {
meta: { meta: {
collectionUid, collectionUid,
pathname, pathname,
name: path.basename(pathname), name: path.basename(pathname)
} }
}; };
win.webContents.send('main:collection-tree-updated', 'addDir', directory); win.webContents.send('main:collection-tree-updated', 'addDir', directory);
}; };
const change = async (win, pathname, collectionUid, collectionPath) => { const change = async (win, pathname, collectionUid, collectionPath) => {
if(isBruEnvironmentConfig(pathname, collectionPath)) { if (isBruEnvironmentConfig(pathname, collectionPath)) {
return changeEnvironmentFile(win, pathname, collectionUid); return changeEnvironmentFile(win, pathname, collectionUid);
} }
if(hasBruExtension(pathname)) { if (hasBruExtension(pathname)) {
try { try {
const file = { const file = {
meta: { meta: {
collectionUid, collectionUid,
pathname, pathname,
name: path.basename(pathname), name: path.basename(pathname)
} }
}; };
const bru = fs.readFileSync(pathname, 'utf8'); const bru = fs.readFileSync(pathname, 'utf8');
file.data = bruToJson(bru); file.data = bruToJson(bru);
hydrateRequestWithUuid(file.data, pathname); hydrateRequestWithUuid(file.data, pathname);
win.webContents.send('main:collection-tree-updated', 'change', file); win.webContents.send('main:collection-tree-updated', 'change', file);
} catch (err) { } catch (err) {
console.error(err) console.error(err);
} }
} }
}; };
const unlink = (win, pathname, collectionUid, collectionPath) => { const unlink = (win, pathname, collectionUid, collectionPath) => {
if(isBruEnvironmentConfig(pathname, collectionPath)) { if (isBruEnvironmentConfig(pathname, collectionPath)) {
return unlinkEnvironmentFile(win, pathname, collectionUid); return unlinkEnvironmentFile(win, pathname, collectionUid);
} }
if(hasBruExtension(pathname)) { if (hasBruExtension(pathname)) {
const file = { const file = {
meta: { meta: {
collectionUid, collectionUid,
@ -270,12 +259,12 @@ const unlink = (win, pathname, collectionUid, collectionPath) => {
}; };
win.webContents.send('main:collection-tree-updated', 'unlink', file); win.webContents.send('main:collection-tree-updated', 'unlink', file);
} }
} };
const unlinkDir = (win, pathname, collectionUid, collectionPath) => { const unlinkDir = (win, pathname, collectionUid, collectionPath) => {
const envDirectory = path.join(collectionPath, 'environments'); const envDirectory = path.join(collectionPath, 'environments');
if(pathname === envDirectory) { if (pathname === envDirectory) {
return; return;
} }
@ -287,15 +276,15 @@ const unlinkDir = (win, pathname, collectionUid, collectionPath) => {
} }
}; };
win.webContents.send('main:collection-tree-updated', 'unlinkDir', directory); win.webContents.send('main:collection-tree-updated', 'unlinkDir', directory);
} };
class Watcher { class Watcher {
constructor () { constructor() {
this.watchers = {}; this.watchers = {};
} }
addWatcher (win, watchPath, collectionUid) { addWatcher(win, watchPath, collectionUid) {
if(this.watchers[watchPath]) { if (this.watchers[watchPath]) {
this.watchers[watchPath].close(); this.watchers[watchPath].close();
} }
@ -309,7 +298,7 @@ class Watcher {
const watcher = chokidar.watch(watchPath, { const watcher = chokidar.watch(watchPath, {
ignoreInitial: false, ignoreInitial: false,
usePolling: false, usePolling: false,
ignored: path => ["node_modules", ".git", "bruno.json"].some(s => path.includes(s)), ignored: (path) => ['node_modules', '.git', 'bruno.json'].some((s) => path.includes(s)),
persistent: true, persistent: true,
ignorePermissionErrors: true, ignorePermissionErrors: true,
awaitWriteFinish: { awaitWriteFinish: {
@ -318,28 +307,28 @@ class Watcher {
}, },
depth: 20 depth: 20
}); });
watcher watcher
.on('add', pathname => add(win, pathname, collectionUid, watchPath)) .on('add', (pathname) => add(win, pathname, collectionUid, watchPath))
.on('addDir', pathname => addDirectory(win, pathname, collectionUid, watchPath)) .on('addDir', (pathname) => addDirectory(win, pathname, collectionUid, watchPath))
.on('change', pathname => change(win, pathname, collectionUid, watchPath)) .on('change', (pathname) => change(win, pathname, collectionUid, watchPath))
.on('unlink', pathname => unlink(win, pathname, collectionUid, watchPath)) .on('unlink', (pathname) => unlink(win, pathname, collectionUid, watchPath))
.on('unlinkDir', pathname => unlinkDir(win, pathname, collectionUid, watchPath)) .on('unlinkDir', (pathname) => unlinkDir(win, pathname, collectionUid, watchPath));
self.watchers[watchPath] = watcher; self.watchers[watchPath] = watcher;
}, 100); }, 100);
} }
hasWatcher (watchPath) { hasWatcher(watchPath) {
return this.watchers[watchPath]; return this.watchers[watchPath];
} }
removeWatcher (watchPath, win) { removeWatcher(watchPath, win) {
if(this.watchers[watchPath]) { if (this.watchers[watchPath]) {
this.watchers[watchPath].close(); this.watchers[watchPath].close();
this.watchers[watchPath] = null; this.watchers[watchPath] = null;
} }
} }
}; }
module.exports = Watcher; module.exports = Watcher;

77
packages/bruno-electron/src/bru/index.js
View File

@ -1,10 +1,5 @@
const _ = require('lodash'); const _ = require('lodash');
const { const { bruToJsonV2, jsonToBruV2, bruToEnvJsonV2, envJsonToBruV2 } = require('@usebruno/lang');
bruToJsonV2,
jsonToBruV2,
bruToEnvJsonV2,
envJsonToBruV2
} = require('@usebruno/lang');
const { each } = require('lodash'); const { each } = require('lodash');
const bruToEnvJson = (bru) => { const bruToEnvJson = (bru) => {
@ -14,15 +9,15 @@ const bruToEnvJson = (bru) => {
// the app env format requires each variable to have a type // the app env format requires each variable to have a type
// this need to be evaulated and safely removed // this need to be evaulated and safely removed
// i don't see it being used in schema validation // i don't see it being used in schema validation
if(json && json.variables && json.variables.length) { if (json && json.variables && json.variables.length) {
each(json.variables, (v) => v.type = "text"); each(json.variables, (v) => (v.type = 'text'));
} }
return json; return json;
} catch (error) { } catch (error) {
return Promise.reject(e); return Promise.reject(e);
} }
} };
const envJsonToBru = (json) => { const envJsonToBru = (json) => {
try { try {
@ -31,14 +26,14 @@ const envJsonToBru = (json) => {
} catch (error) { } catch (error) {
return Promise.reject(e); return Promise.reject(e);
} }
} };
/** /**
* The transformer function for converting a BRU file to JSON. * The transformer function for converting a BRU file to JSON.
* *
* We map the json response from the bru lang and transform it into the DSL * We map the json response from the bru lang and transform it into the DSL
* format that the app users * format that the app users
* *
* @param {string} bru The BRU file content. * @param {string} bru The BRU file content.
* @returns {object} The JSON representation of the BRU file. * @returns {object} The JSON representation of the BRU file.
*/ */
@ -46,35 +41,35 @@ const bruToJson = (bru) => {
try { try {
const json = bruToJsonV2(bru); const json = bruToJsonV2(bru);
let requestType = _.get(json, "meta.type"); let requestType = _.get(json, 'meta.type');
if(requestType === "http") { if (requestType === 'http') {
requestType = "http-request" requestType = 'http-request';
} else if(requestType === "graphql") { } else if (requestType === 'graphql') {
requestType = "graphql-request"; requestType = 'graphql-request';
} else { } else {
requestType = "http-request"; requestType = 'http-request';
} }
const sequence = _.get(json, "meta.seq") const sequence = _.get(json, 'meta.seq');
const transformedJson = { const transformedJson = {
"type": requestType, type: requestType,
"name": _.get(json, "meta.name"), name: _.get(json, 'meta.name'),
"seq": !isNaN(sequence) ? Number(sequence) : 1, seq: !isNaN(sequence) ? Number(sequence) : 1,
"request": { request: {
"method": _.upperCase(_.get(json, "http.method")), method: _.upperCase(_.get(json, 'http.method')),
"url": _.get(json, "http.url"), url: _.get(json, 'http.url'),
"params": _.get(json, "query", []), params: _.get(json, 'query', []),
"headers": _.get(json, "headers", []), headers: _.get(json, 'headers', []),
"body": _.get(json, "body", {}), body: _.get(json, 'body', {}),
"script": _.get(json, "script", {}), script: _.get(json, 'script', {}),
"vars": _.get(json, "vars", {}), vars: _.get(json, 'vars', {}),
"assertions": _.get(json, "assertions", []), assertions: _.get(json, 'assertions', []),
"tests": _.get(json, "tests", "") tests: _.get(json, 'tests', '')
} }
}; };
transformedJson.request.body.mode = _.get(json, "http.body", "none"); transformedJson.request.body.mode = _.get(json, 'http.body', 'none');
return transformedJson; return transformedJson;
} catch (e) { } catch (e) {
@ -83,28 +78,28 @@ const bruToJson = (bru) => {
}; };
/** /**
* The transformer function for converting a JSON to BRU file. * The transformer function for converting a JSON to BRU file.
* *
* We map the json response from the app and transform it into the DSL * We map the json response from the app and transform it into the DSL
* format that the bru lang understands * format that the bru lang understands
* *
* @param {object} json The JSON representation of the BRU file. * @param {object} json The JSON representation of the BRU file.
* @returns {string} The BRU file content. * @returns {string} The BRU file content.
*/ */
const jsonToBru = (json) => { const jsonToBru = (json) => {
let type = _.get(json, 'type'); let type = _.get(json, 'type');
if (type === 'http-request') { if (type === 'http-request') {
type = "http"; type = 'http';
} else if (type === 'graphql-request') { } else if (type === 'graphql-request') {
type = "graphql"; type = 'graphql';
} else { } else {
type = "http"; type = 'http';
} }
const bruJson = { const bruJson = {
meta: { meta: {
name: _.get(json, 'name'), name: _.get(json, 'name'),
type: type, type: type,
seq: _.get(json, 'seq'), seq: _.get(json, 'seq')
}, },
http: { http: {
method: _.lowerCase(_.get(json, 'request.method')), method: _.lowerCase(_.get(json, 'request.method')),
@ -120,7 +115,7 @@ const jsonToBru = (json) => {
res: _.get(json, 'request.vars.res', []) res: _.get(json, 'request.vars.res', [])
}, },
assertions: _.get(json, 'request.assertions', []), assertions: _.get(json, 'request.assertions', []),
tests: _.get(json, 'request.tests', ''), tests: _.get(json, 'request.tests', '')
}; };
return jsonToBruV2(bruJson); return jsonToBruV2(bruJson);
@ -130,5 +125,5 @@ module.exports = {
bruToJson, bruToJson,
jsonToBru, jsonToBru,
bruToEnvJson, bruToEnvJson,
envJsonToBru, envJsonToBru
}; };

24
packages/bruno-electron/src/bru/migrate.js
View File

@ -34,15 +34,15 @@ const isLegacyBruFile = (bruContent = '') => {
for (let line of lines) { for (let line of lines) {
line = line.trim(); line = line.trim();
if (line.startsWith("name")) { if (line.startsWith('name')) {
hasName = true; hasName = true;
} else if (line.startsWith("method")) { } else if (line.startsWith('method')) {
hasMethod = true; hasMethod = true;
} else if (line.startsWith("url")) { } else if (line.startsWith('url')) {
hasUrl = true; hasUrl = true;
} }
} }
return hasName && hasMethod && hasUrl; return hasName && hasMethod && hasUrl;
}; };
@ -51,16 +51,16 @@ const migrateLegacyBruFile = async (bruContent, pathname) => {
let type = _.get(json, 'type'); let type = _.get(json, 'type');
if (type === 'http-request') { if (type === 'http-request') {
type = "http"; type = 'http';
} else if (type === 'graphql-request') { } else if (type === 'graphql-request') {
type = "graphql"; type = 'graphql';
} else { } else {
type = "http"; type = 'http';
} }
let script = {}; let script = {};
let legacyScript = _.get(json, 'request.script'); let legacyScript = _.get(json, 'request.script');
if(legacyScript && legacyScript.trim().length > 0) { if (legacyScript && legacyScript.trim().length > 0) {
script = { script = {
res: legacyScript res: legacyScript
}; };
@ -70,7 +70,7 @@ const migrateLegacyBruFile = async (bruContent, pathname) => {
meta: { meta: {
name: _.get(json, 'name'), name: _.get(json, 'name'),
type: type, type: type,
seq: _.get(json, 'seq'), seq: _.get(json, 'seq')
}, },
http: { http: {
method: _.lowerCase(_.get(json, 'request.method')), method: _.lowerCase(_.get(json, 'request.method')),
@ -81,7 +81,7 @@ const migrateLegacyBruFile = async (bruContent, pathname) => {
headers: _.get(json, 'request.headers', []), headers: _.get(json, 'request.headers', []),
body: _.get(json, 'request.body', {}), body: _.get(json, 'request.body', {}),
script: script, script: script,
tests: _.get(json, 'request.tests', ''), tests: _.get(json, 'request.tests', '')
}; };
const newBruContent = jsonToBruV2(bruJson); const newBruContent = jsonToBruV2(bruJson);
@ -89,11 +89,11 @@ const migrateLegacyBruFile = async (bruContent, pathname) => {
await writeFile(pathname, newBruContent); await writeFile(pathname, newBruContent);
return newBruContent; return newBruContent;
} };
module.exports = { module.exports = {
isLegacyEnvFile, isLegacyEnvFile,
migrateLegacyEnvFile, migrateLegacyEnvFile,
isLegacyBruFile, isLegacyBruFile,
migrateLegacyBruFile migrateLegacyBruFile
}; };

2
packages/bruno-electron/src/cache/requestUids.js vendored
View File

@ -2,7 +2,7 @@
* we maintain a cache of request uids to ensure that we * we maintain a cache of request uids to ensure that we
* preserve the same uid for a request even when the request * preserve the same uid for a request even when the request
* moves to a different location * moves to a different location
* *
* In the past, we used to generate unique ids based on the * In the past, we used to generate unique ids based on the
* pathname of the request, but we faced problems when implementing * pathname of the request, but we faced problems when implementing
* functionality where the user can move the request to a different * functionality where the user can move the request to a different

6
packages/bruno-electron/src/index.js
View File

@ -35,8 +35,8 @@ app.on('ready', async () => {
webPreferences: { webPreferences: {
nodeIntegration: true, nodeIntegration: true,
contextIsolation: true, contextIsolation: true,
preload: path.join(__dirname, "preload.js") preload: path.join(__dirname, 'preload.js')
}, }
}); });
const url = isDev const url = isDev
@ -50,7 +50,7 @@ app.on('ready', async () => {
mainWindow.loadURL(url); mainWindow.loadURL(url);
watcher = new Watcher(); watcher = new Watcher();
mainWindow.webContents.on('new-window', function(e, url) { mainWindow.webContents.on('new-window', function (e, url) {
e.preventDefault(); e.preventDefault();
require('electron').shell.openExternal(url); require('electron').shell.openExternal(url);
}); });

145
packages/bruno-electron/src/ipc/collection.js
View File

@ -2,11 +2,7 @@ const _ = require('lodash');
const fs = require('fs'); const fs = require('fs');
const path = require('path'); const path = require('path');
const { ipcMain } = require('electron'); const { ipcMain } = require('electron');
const { const { envJsonToBru, bruToJson, jsonToBru } = require('../bru');
envJsonToBru,
bruToJson,
jsonToBru
} = require('../bru');
const { const {
isValidPathname, isValidPathname,
@ -21,7 +17,7 @@ const { stringifyJson } = require('../utils/common');
const { openCollectionDialog, openCollection } = require('../app/collections'); const { openCollectionDialog, openCollection } = require('../app/collections');
const { generateUidBasedOnHash } = require('../utils/common'); const { generateUidBasedOnHash } = require('../utils/common');
const { moveRequestUid, deleteRequestUid } = require('../cache/requestUids'); const { moveRequestUid, deleteRequestUid } = require('../cache/requestUids');
const { setPreferences } = require("../app/preferences"); const { setPreferences } = require('../app/preferences');
const registerRendererEventHandlers = (mainWindow, watcher, lastOpenedCollections) => { const registerRendererEventHandlers = (mainWindow, watcher, lastOpenedCollections) => {
// browse directory // browse directory
@ -36,35 +32,38 @@ const registerRendererEventHandlers = (mainWindow, watcher, lastOpenedCollection
}); });
// create collection // create collection
ipcMain.handle('renderer:create-collection', async (event, collectionName, collectionFolderName, collectionLocation) => { ipcMain.handle(
try { 'renderer:create-collection',
const dirPath = path.join(collectionLocation, collectionFolderName); async (event, collectionName, collectionFolderName, collectionLocation) => {
if (fs.existsSync(dirPath)){ try {
throw new Error(`collection: ${dirPath} already exists`); const dirPath = path.join(collectionLocation, collectionFolderName);
if (fs.existsSync(dirPath)) {
throw new Error(`collection: ${dirPath} already exists`);
}
if (!isValidPathname(dirPath)) {
throw new Error(`collection: invalid pathname - ${dir}`);
}
await createDirectory(dirPath);
const uid = generateUidBasedOnHash(dirPath);
const content = await stringifyJson({
version: '1',
name: collectionName,
type: 'collection'
});
await writeFile(path.join(dirPath, 'bruno.json'), content);
mainWindow.webContents.send('main:collection-opened', dirPath, uid, collectionName);
ipcMain.emit('main:collection-opened', mainWindow, dirPath, uid);
return;
} catch (error) {
return Promise.reject(error);
} }
if(!isValidPathname(dirPath)) {
throw new Error(`collection: invalid pathname - ${dir}`);
}
await createDirectory(dirPath);
const uid = generateUidBasedOnHash(dirPath);
const content = await stringifyJson({
version: '1',
name: collectionName,
type: 'collection'
});
await writeFile(path.join(dirPath, 'bruno.json'), content);
mainWindow.webContents.send('main:collection-opened', dirPath, uid, collectionName);
ipcMain.emit('main:collection-opened', mainWindow, dirPath, uid);
return;
} catch (error) {
return Promise.reject(error);
} }
}); );
// rename collection // rename collection
ipcMain.handle('renderer:rename-collection', async (event, newName, collectionPathname) => { ipcMain.handle('renderer:rename-collection', async (event, newName, collectionPathname) => {
@ -94,7 +93,7 @@ const registerRendererEventHandlers = (mainWindow, watcher, lastOpenedCollection
// new request // new request
ipcMain.handle('renderer:new-request', async (event, pathname, request) => { ipcMain.handle('renderer:new-request', async (event, pathname, request) => {
try { try {
if (fs.existsSync(pathname)){ if (fs.existsSync(pathname)) {
throw new Error(`path: ${pathname} already exists`); throw new Error(`path: ${pathname} already exists`);
} }
@ -108,7 +107,7 @@ const registerRendererEventHandlers = (mainWindow, watcher, lastOpenedCollection
// save request // save request
ipcMain.handle('renderer:save-request', async (event, pathname, request) => { ipcMain.handle('renderer:save-request', async (event, pathname, request) => {
try { try {
if (!fs.existsSync(pathname)){ if (!fs.existsSync(pathname)) {
throw new Error(`path: ${pathname} does not exist`); throw new Error(`path: ${pathname} does not exist`);
} }
@ -123,12 +122,12 @@ const registerRendererEventHandlers = (mainWindow, watcher, lastOpenedCollection
ipcMain.handle('renderer:create-environment', async (event, collectionPathname, name) => { ipcMain.handle('renderer:create-environment', async (event, collectionPathname, name) => {
try { try {
const envDirPath = path.join(collectionPathname, 'environments'); const envDirPath = path.join(collectionPathname, 'environments');
if (!fs.existsSync(envDirPath)){ if (!fs.existsSync(envDirPath)) {
await createDirectory(envDirPath); await createDirectory(envDirPath);
} }
const envFilePath = path.join(envDirPath, `${name}.bru`); const envFilePath = path.join(envDirPath, `${name}.bru`);
if (fs.existsSync(envFilePath)){ if (fs.existsSync(envFilePath)) {
throw new Error(`environment: ${envFilePath} already exists`); throw new Error(`environment: ${envFilePath} already exists`);
} }
@ -145,12 +144,12 @@ const registerRendererEventHandlers = (mainWindow, watcher, lastOpenedCollection
ipcMain.handle('renderer:save-environment', async (event, collectionPathname, environment) => { ipcMain.handle('renderer:save-environment', async (event, collectionPathname, environment) => {
try { try {
const envDirPath = path.join(collectionPathname, 'environments'); const envDirPath = path.join(collectionPathname, 'environments');
if (!fs.existsSync(envDirPath)){ if (!fs.existsSync(envDirPath)) {
await createDirectory(envDirPath); await createDirectory(envDirPath);
} }
const envFilePath = path.join(envDirPath, `${environment.name}.bru`); const envFilePath = path.join(envDirPath, `${environment.name}.bru`);
if (!fs.existsSync(envFilePath)){ if (!fs.existsSync(envFilePath)) {
throw new Error(`environment: ${envFilePath} does not exist`); throw new Error(`environment: ${envFilePath} does not exist`);
} }
@ -166,12 +165,12 @@ const registerRendererEventHandlers = (mainWindow, watcher, lastOpenedCollection
try { try {
const envDirPath = path.join(collectionPathname, 'environments'); const envDirPath = path.join(collectionPathname, 'environments');
const envFilePath = path.join(envDirPath, `${environmentName}.bru`); const envFilePath = path.join(envDirPath, `${environmentName}.bru`);
if (!fs.existsSync(envFilePath)){ if (!fs.existsSync(envFilePath)) {
throw new Error(`environment: ${envFilePath} does not exist`); throw new Error(`environment: ${envFilePath} does not exist`);
} }
const newEnvFilePath = path.join(envDirPath, `${newName}.bru`); const newEnvFilePath = path.join(envDirPath, `${newName}.bru`);
if (fs.existsSync(newEnvFilePath)){ if (fs.existsSync(newEnvFilePath)) {
throw new Error(`environment: ${newEnvFilePath} already exists`); throw new Error(`environment: ${newEnvFilePath} already exists`);
} }
@ -186,7 +185,7 @@ const registerRendererEventHandlers = (mainWindow, watcher, lastOpenedCollection
try { try {
const envDirPath = path.join(collectionPathname, 'environments'); const envDirPath = path.join(collectionPathname, 'environments');
const envFilePath = path.join(envDirPath, `${environmentName}.bru`); const envFilePath = path.join(envDirPath, `${environmentName}.bru`);
if (!fs.existsSync(envFilePath)){ if (!fs.existsSync(envFilePath)) {
throw new Error(`environment: ${envFilePath} does not exist`); throw new Error(`environment: ${envFilePath} does not exist`);
} }
@ -199,18 +198,18 @@ const registerRendererEventHandlers = (mainWindow, watcher, lastOpenedCollection
// rename item // rename item
ipcMain.handle('renderer:rename-item', async (event, oldPath, newPath, newName) => { ipcMain.handle('renderer:rename-item', async (event, oldPath, newPath, newName) => {
try { try {
if (!fs.existsSync(oldPath)){ if (!fs.existsSync(oldPath)) {
throw new Error(`path: ${oldPath} does not exist`); throw new Error(`path: ${oldPath} does not exist`);
} }
if (fs.existsSync(newPath)){ if (fs.existsSync(newPath)) {
throw new Error(`path: ${oldPath} already exists`); throw new Error(`path: ${oldPath} already exists`);
} }
// if its directory, rename and return // if its directory, rename and return
if(isDirectory(oldPath)) { if (isDirectory(oldPath)) {
const bruFilesAtSource = await searchForBruFiles(oldPath); const bruFilesAtSource = await searchForBruFiles(oldPath);
for(let bruFile of bruFilesAtSource) { for (let bruFile of bruFilesAtSource) {
const newBruFilePath = bruFile.replace(oldPath, newPath); const newBruFilePath = bruFile.replace(oldPath, newPath);
moveRequestUid(bruFile, newBruFilePath); moveRequestUid(bruFile, newBruFilePath);
} }
@ -218,7 +217,7 @@ const registerRendererEventHandlers = (mainWindow, watcher, lastOpenedCollection
} }
const isBru = hasBruExtension(oldPath); const isBru = hasBruExtension(oldPath);
if(!isBru) { if (!isBru) {
throw new Error(`path: ${oldPath} is not a bru file`); throw new Error(`path: ${oldPath} is not a bru file`);
} }
@ -241,8 +240,8 @@ const registerRendererEventHandlers = (mainWindow, watcher, lastOpenedCollection
// new folder // new folder
ipcMain.handle('renderer:new-folder', async (event, pathname) => { ipcMain.handle('renderer:new-folder', async (event, pathname) => {
try { try {
if (!fs.existsSync(pathname)){ if (!fs.existsSync(pathname)) {
fs.mkdirSync(pathname); fs.mkdirSync(pathname);
} else { } else {
return Promise.reject(new Error('The directory already exists')); return Promise.reject(new Error('The directory already exists'));
} }
@ -254,20 +253,20 @@ const registerRendererEventHandlers = (mainWindow, watcher, lastOpenedCollection
// delete file/folder // delete file/folder
ipcMain.handle('renderer:delete-item', async (event, pathname, type) => { ipcMain.handle('renderer:delete-item', async (event, pathname, type) => {
try { try {
if(type === 'folder') { if (type === 'folder') {
if(!fs.existsSync(pathname)) { if (!fs.existsSync(pathname)) {
return Promise.reject(new Error('The directory does not exist')); return Promise.reject(new Error('The directory does not exist'));
} }
// delete the request uid mappings // delete the request uid mappings
const bruFilesAtSource = await searchForBruFiles(pathname); const bruFilesAtSource = await searchForBruFiles(pathname);
for(let bruFile of bruFilesAtSource) { for (let bruFile of bruFilesAtSource) {
deleteRequestUid(bruFile); deleteRequestUid(bruFile);
} }
fs.rmSync(pathname, { recursive: true, force: true}); fs.rmSync(pathname, { recursive: true, force: true });
} else if (['http-request', 'graphql-request'].includes(type)) { } else if (['http-request', 'graphql-request'].includes(type)) {
if(!fs.existsSync(pathname)) { if (!fs.existsSync(pathname)) {
return Promise.reject(new Error('The file does not exist')); return Promise.reject(new Error('The file does not exist'));
} }
@ -283,13 +282,13 @@ const registerRendererEventHandlers = (mainWindow, watcher, lastOpenedCollection
}); });
ipcMain.handle('renderer:open-collection', () => { ipcMain.handle('renderer:open-collection', () => {
if(watcher && mainWindow) { if (watcher && mainWindow) {
openCollectionDialog(mainWindow, watcher); openCollectionDialog(mainWindow, watcher);
} }
}); });
ipcMain.handle('renderer:remove-collection', async (event, collectionPath) => { ipcMain.handle('renderer:remove-collection', async (event, collectionPath) => {
if(watcher && mainWindow) { if (watcher && mainWindow) {
console.log(`watcher stopWatching: ${collectionPath}`); console.log(`watcher stopWatching: ${collectionPath}`);
watcher.removeWatcher(collectionPath, mainWindow); watcher.removeWatcher(collectionPath, mainWindow);
lastOpenedCollections.remove(collectionPath); lastOpenedCollections.remove(collectionPath);
@ -301,13 +300,13 @@ const registerRendererEventHandlers = (mainWindow, watcher, lastOpenedCollection
let collectionName = collection.name; let collectionName = collection.name;
let collectionPath = path.join(collectionLocation, collectionName); let collectionPath = path.join(collectionLocation, collectionName);
if (fs.existsSync(collectionPath)){ if (fs.existsSync(collectionPath)) {
throw new Error(`collection: ${collectionPath} already exists`); throw new Error(`collection: ${collectionPath} already exists`);
} }
// Recursive function to parse the collection items and create files/folders // Recursive function to parse the collection items and create files/folders
const parseCollectionItems = (items = [], currentPath) => { const parseCollectionItems = (items = [], currentPath) => {
items.forEach(item => { items.forEach((item) => {
if (['http-request', 'graphql-request'].includes(item.type)) { if (['http-request', 'graphql-request'].includes(item.type)) {
const content = jsonToBru(item); const content = jsonToBru(item);
const filePath = path.join(currentPath, `${item.name}.bru`); const filePath = path.join(currentPath, `${item.name}.bru`);
@ -317,7 +316,7 @@ const registerRendererEventHandlers = (mainWindow, watcher, lastOpenedCollection
const folderPath = path.join(currentPath, item.name); const folderPath = path.join(currentPath, item.name);
fs.mkdirSync(folderPath); fs.mkdirSync(folderPath);
if(item.items && item.items.length) { if (item.items && item.items.length) {
parseCollectionItems(item.items, folderPath); parseCollectionItems(item.items, folderPath);
} }
} }
@ -326,11 +325,11 @@ const registerRendererEventHandlers = (mainWindow, watcher, lastOpenedCollection
const parseEnvironments = (environments = [], collectionPath) => { const parseEnvironments = (environments = [], collectionPath) => {
const envDirPath = path.join(collectionPath, 'environments'); const envDirPath = path.join(collectionPath, 'environments');
if(!fs.existsSync(envDirPath)){ if (!fs.existsSync(envDirPath)) {
fs.mkdirSync(envDirPath); fs.mkdirSync(envDirPath);
} }
environments.forEach(env => { environments.forEach((env) => {
const content = envJsonToBru(env); const content = envJsonToBru(env);
const filePath = path.join(envDirPath, `${env.name}.bru`); const filePath = path.join(envDirPath, `${env.name}.bru`);
fs.writeFileSync(filePath, content); fs.writeFileSync(filePath, content);
@ -355,7 +354,6 @@ const registerRendererEventHandlers = (mainWindow, watcher, lastOpenedCollection
// create folder and files based on collection // create folder and files based on collection
await parseCollectionItems(collection.items, collectionPath); await parseCollectionItems(collection.items, collectionPath);
await parseEnvironments(collection.environments, collectionPath); await parseEnvironments(collection.environments, collectionPath);
} catch (error) { } catch (error) {
return Promise.reject(error); return Promise.reject(error);
} }
@ -363,11 +361,11 @@ const registerRendererEventHandlers = (mainWindow, watcher, lastOpenedCollection
ipcMain.handle('renderer:resequence-items', async (event, itemsToResequence) => { ipcMain.handle('renderer:resequence-items', async (event, itemsToResequence) => {
try { try {
for(let item of itemsToResequence) { for (let item of itemsToResequence) {
const bru = fs.readFileSync(item.pathname, 'utf8'); const bru = fs.readFileSync(item.pathname, 'utf8');
const jsonData = bruToJson(bru); const jsonData = bruToJson(bru);
if(jsonData.seq !== item.seq) { if (jsonData.seq !== item.seq) {
jsonData.seq = item.seq; jsonData.seq = item.seq;
const content = jsonToBru(jsonData); const content = jsonToBru(jsonData);
await writeFile(item.pathname, content); await writeFile(item.pathname, content);
@ -397,17 +395,17 @@ const registerRendererEventHandlers = (mainWindow, watcher, lastOpenedCollection
const folderName = path.basename(folderPath); const folderName = path.basename(folderPath);
const newFolderPath = path.join(destinationPath, folderName); const newFolderPath = path.join(destinationPath, folderName);
if(!fs.existsSync(folderPath)) { if (!fs.existsSync(folderPath)) {
throw new Error(`folder: ${folderPath} does not exist`); throw new Error(`folder: ${folderPath} does not exist`);
} }
if(fs.existsSync(newFolderPath)) { if (fs.existsSync(newFolderPath)) {
throw new Error(`folder: ${newFolderPath} already exists`); throw new Error(`folder: ${newFolderPath} already exists`);
} }
const bruFilesAtSource = await searchForBruFiles(folderPath); const bruFilesAtSource = await searchForBruFiles(folderPath);
for(let bruFile of bruFilesAtSource) { for (let bruFile of bruFilesAtSource) {
const newBruFilePath = bruFile.replace(folderPath, newFolderPath); const newBruFilePath = bruFile.replace(folderPath, newFolderPath);
moveRequestUid(bruFile, newBruFilePath); moveRequestUid(bruFile, newBruFilePath);
} }
@ -422,9 +420,9 @@ const registerRendererEventHandlers = (mainWindow, watcher, lastOpenedCollection
// reload last opened collections // reload last opened collections
const lastOpened = lastOpenedCollections.getAll(); const lastOpened = lastOpenedCollections.getAll();
if(lastOpened && lastOpened.length) { if (lastOpened && lastOpened.length) {
for(let collectionPath of lastOpened) { for (let collectionPath of lastOpened) {
if(isDirectory(collectionPath)) { if (isDirectory(collectionPath)) {
openCollection(mainWindow, watcher, collectionPath, { openCollection(mainWindow, watcher, collectionPath, {
dontSendDisplayErrors: true dontSendDisplayErrors: true
}); });
@ -440,7 +438,7 @@ const registerRendererEventHandlers = (mainWindow, watcher, lastOpenedCollection
const registerMainEventHandlers = (mainWindow, watcher, lastOpenedCollections) => { const registerMainEventHandlers = (mainWindow, watcher, lastOpenedCollections) => {
ipcMain.on('main:open-collection', () => { ipcMain.on('main:open-collection', () => {
if(watcher && mainWindow) { if (watcher && mainWindow) {
openCollectionDialog(mainWindow, watcher); openCollectionDialog(mainWindow, watcher);
} }
}); });
@ -449,12 +447,11 @@ const registerMainEventHandlers = (mainWindow, watcher, lastOpenedCollections) =
watcher.addWatcher(win, pathname, uid); watcher.addWatcher(win, pathname, uid);
lastOpenedCollections.add(pathname); lastOpenedCollections.add(pathname);
}); });
};
}
const registerCollectionsIpc = (mainWindow, watcher, lastOpenedCollections) => { const registerCollectionsIpc = (mainWindow, watcher, lastOpenedCollections) => {
registerRendererEventHandlers(mainWindow, watcher, lastOpenedCollections); registerRendererEventHandlers(mainWindow, watcher, lastOpenedCollections);
registerMainEventHandlers(mainWindow, watcher, lastOpenedCollections); registerMainEventHandlers(mainWindow, watcher, lastOpenedCollections);
} };
module.exports = registerCollectionsIpc; module.exports = registerCollectionsIpc;

6
packages/bruno-electron/src/ipc/network/helper.js
View File

@ -1,8 +1,4 @@
const { const { each, filter } = require('lodash');
each,
filter
} = require('lodash');
const sortCollection = (collection) => { const sortCollection = (collection) => {
const items = collection.items || []; const items = collection.items || [];

969
packages/bruno-electron/src/ipc/network/index.js
View File

File diff suppressed because it is too large Load Diff

22
packages/bruno-electron/src/ipc/network/interpolate-vars.js
View File

@ -6,9 +6,9 @@ Mustache.escape = function (value) {
return value; return value;
}; };
const interpolateVars = (request, envVars = {}, collectionVariables ={}) => { const interpolateVars = (request, envVars = {}, collectionVariables = {}) => {
const interpolate = (str) => { const interpolate = (str) => {
if(!str || !str.length || typeof str !== "string") { if (!str || !str.length || typeof str !== 'string') {
return str; return str;
} }
@ -27,29 +27,27 @@ const interpolateVars = (request, envVars = {}, collectionVariables ={}) => {
request.headers[key] = interpolate(value); request.headers[key] = interpolate(value);
}); });
if(request.headers["content-type"] === "application/json") { if (request.headers['content-type'] === 'application/json') {
if(typeof request.data === "object") { if (typeof request.data === 'object') {
try { try {
let parsed = JSON.stringify(request.data); let parsed = JSON.stringify(request.data);
parsed = interpolate(parsed); parsed = interpolate(parsed);
request.data = JSON.parse(parsed); request.data = JSON.parse(parsed);
} catch (err) { } catch (err) {}
}
} }
if(typeof request.data === "string") { if (typeof request.data === 'string') {
if(request.data.length) { if (request.data.length) {
request.data = interpolate(request.data); request.data = interpolate(request.data);
} }
} }
} else if(request.headers["content-type"] === "application/x-www-form-urlencoded") { } else if (request.headers['content-type'] === 'application/x-www-form-urlencoded') {
if(typeof request.data === "object") { if (typeof request.data === 'object') {
try { try {
let parsed = JSON.stringify(request.data); let parsed = JSON.stringify(request.data);
parsed = interpolate(parsed); parsed = interpolate(parsed);
request.data = JSON.parse(parsed); request.data = JSON.parse(parsed);
} catch (err) { } catch (err) {}
}
} }
} else { } else {
request.data = interpolate(request.data); request.data = interpolate(request.data);

6
packages/bruno-electron/src/ipc/network/prepare-gql-introspection-request.js
View File

@ -7,8 +7,8 @@ Mustache.escape = function (value) {
}; };
const prepareGqlIntrospectionRequest = (endpoint, envVars) => { const prepareGqlIntrospectionRequest = (endpoint, envVars) => {
if(endpoint && endpoint.length) { if (endpoint && endpoint.length) {
endpoint = Mustache.render(endpoint, envVars); endpoint = Mustache.render(endpoint, envVars);
} }
const introspectionQuery = getIntrospectionQuery(); const introspectionQuery = getIntrospectionQuery();
const queryParams = { const queryParams = {
@ -19,7 +19,7 @@ const prepareGqlIntrospectionRequest = (endpoint, envVars) => {
method: 'POST', method: 'POST',
url: endpoint, url: endpoint,
headers: { headers: {
'Accept': 'application/json', Accept: 'application/json',
'Content-Type': 'application/json' 'Content-Type': 'application/json'
}, },
data: JSON.stringify(queryParams) data: JSON.stringify(queryParams)

4
packages/bruno-electron/src/preload.js
View File

@ -3,7 +3,7 @@ const { ipcRenderer, contextBridge } = require('electron');
contextBridge.exposeInMainWorld('ipcRenderer', { contextBridge.exposeInMainWorld('ipcRenderer', {
invoke: (channel, ...args) => ipcRenderer.invoke(channel, ...args), invoke: (channel, ...args) => ipcRenderer.invoke(channel, ...args),
on: (channel, handler) => { on: (channel, handler) => {
// Deliberately strip event as it includes `sender` // Deliberately strip event as it includes `sender`
const subscription = (event, ...args) => handler(...args); const subscription = (event, ...args) => handler(...args);
ipcRenderer.on(channel, subscription); ipcRenderer.on(channel, subscription);
@ -11,4 +11,4 @@ contextBridge.exposeInMainWorld('ipcRenderer', {
ipcRenderer.removeListener(channel, subscription); ipcRenderer.removeListener(channel, subscription);
}; };
} }
}); });

4
packages/bruno-electron/src/utils/cancel-token.js
View File

@ -2,11 +2,11 @@ const cancelTokens = {};
const saveCancelToken = (uid, axiosRequest) => { const saveCancelToken = (uid, axiosRequest) => {
cancelTokens[uid] = axiosRequest; cancelTokens[uid] = axiosRequest;
} };
const deleteCancelToken = (uid) => { const deleteCancelToken = (uid) => {
delete cancelTokens[uid]; delete cancelTokens[uid];
} };
module.exports = { module.exports = {
cancelTokens, cancelTokens,

12
packages/bruno-electron/src/utils/common.js
View File

@ -4,7 +4,7 @@ const { customAlphabet } = require('nanoid');
const uuid = () => { const uuid = () => {
// https://github.com/ai/nanoid/blob/main/url-alphabet/index.js // https://github.com/ai/nanoid/blob/main/url-alphabet/index.js
const urlAlphabet = 'useandom26T198340PX75pxJACKVERYMINDBUSHWOLFGQZbfghjklqvwyzrict'; const urlAlphabet = 'useandom26T198340PX75pxJACKVERYMINDBUSHWOLFGQZbfghjklqvwyzrict';
const customNanoId = customAlphabet (urlAlphabet, 21); const customNanoId = customAlphabet(urlAlphabet, 21);
return customNanoId(); return customNanoId();
}; };
@ -12,18 +12,18 @@ const uuid = () => {
const stringifyJson = async (str) => { const stringifyJson = async (str) => {
try { try {
return JSON.stringify(str, null, 2); return JSON.stringify(str, null, 2);
} catch(err) { } catch (err) {
return Promise.reject(err); return Promise.reject(err);
} }
} };
const parseJson = async (obj) => { const parseJson = async (obj) => {
try { try {
return JSON.parse(obj); return JSON.parse(obj);
} catch(err) { } catch (err) {
return Promise.reject(err); return Promise.reject(err);
} }
} };
const simpleHash = (str) => { const simpleHash = (str) => {
let hash = 0; let hash = 0;
@ -39,7 +39,7 @@ const generateUidBasedOnHash = (str) => {
const hash = simpleHash(str); const hash = simpleHash(str);
return `${hash}`.padEnd(21, '0'); return `${hash}`.padEnd(21, '0');
} };
module.exports = { module.exports = {
uuid, uuid,

36
packages/bruno-electron/src/utils/filesystem.js
View File

@ -4,7 +4,7 @@ const fsPromises = require('fs/promises');
const { dialog } = require('electron'); const { dialog } = require('electron');
const isValidPathname = require('is-valid-path'); const isValidPathname = require('is-valid-path');
const exists = async p => { const exists = async (p) => {
try { try {
await fsPromises.access(p); await fsPromises.access(p);
return true; return true;
@ -13,7 +13,7 @@ const exists = async p => {
} }
}; };
const isSymbolicLink = filepath => { const isSymbolicLink = (filepath) => {
try { try {
return fs.existsSync(filepath) && fs.lstatSync(filepath).isSymbolicLink(); return fs.existsSync(filepath) && fs.lstatSync(filepath).isSymbolicLink();
} catch (_) { } catch (_) {
@ -21,7 +21,7 @@ const isSymbolicLink = filepath => {
} }
}; };
const isFile = filepath => { const isFile = (filepath) => {
try { try {
return fs.existsSync(filepath) && fs.lstatSync(filepath).isFile(); return fs.existsSync(filepath) && fs.lstatSync(filepath).isFile();
} catch (_) { } catch (_) {
@ -29,7 +29,7 @@ const isFile = filepath => {
} }
}; };
const isDirectory = dirPath => { const isDirectory = (dirPath) => {
try { try {
return fs.existsSync(dirPath) && fs.lstatSync(dirPath).isDirectory(); return fs.existsSync(dirPath) && fs.lstatSync(dirPath).isDirectory();
} catch (_) { } catch (_) {
@ -37,14 +37,14 @@ const isDirectory = dirPath => {
} }
}; };
const normalizeAndResolvePath = pathname => { const normalizeAndResolvePath = (pathname) => {
if (isSymbolicLink(pathname)) { if (isSymbolicLink(pathname)) {
const absPath = path.dirname(pathname); const absPath = path.dirname(pathname);
const targetPath = path.resolve(absPath, fs.readlinkSync(pathname)); const targetPath = path.resolve(absPath, fs.readlinkSync(pathname));
if (isFile(targetPath) || isDirectory(targetPath)) { if (isFile(targetPath) || isDirectory(targetPath)) {
return path.resolve(targetPath); return path.resolve(targetPath);
} }
console.error(`Cannot resolve link target "${pathname}" (${targetPath}).`) console.error(`Cannot resolve link target "${pathname}" (${targetPath}).`);
return ''; return '';
} }
return path.resolve(pathname); return path.resolve(pathname);
@ -53,29 +53,29 @@ const normalizeAndResolvePath = pathname => {
const writeFile = async (pathname, content) => { const writeFile = async (pathname, content) => {
try { try {
fs.writeFileSync(pathname, content, { fs.writeFileSync(pathname, content, {
encoding: "utf8" encoding: 'utf8'
}); });
} catch (err) { } catch (err) {
return Promise.reject(err); return Promise.reject(err);
} }
}; };
const hasJsonExtension = filename => { const hasJsonExtension = (filename) => {
if (!filename || typeof filename !== 'string') return false if (!filename || typeof filename !== 'string') return false;
return ['json'].some(ext => filename.toLowerCase().endsWith(`.${ext}`)) return ['json'].some((ext) => filename.toLowerCase().endsWith(`.${ext}`));
} };
const hasBruExtension = filename => { const hasBruExtension = (filename) => {
if (!filename || typeof filename !== 'string') return false if (!filename || typeof filename !== 'string') return false;
return ['bru'].some(ext => filename.toLowerCase().endsWith(`.${ext}`)) return ['bru'].some((ext) => filename.toLowerCase().endsWith(`.${ext}`));
} };
const createDirectory = async (dir) => { const createDirectory = async (dir) => {
if(!dir) { if (!dir) {
throw new Error(`directory: path is null`); throw new Error(`directory: path is null`);
} }
if (fs.existsSync(dir)){ if (fs.existsSync(dir)) {
throw new Error(`directory: ${dir} already exists`); throw new Error(`directory: ${dir} already exists`);
} }
@ -108,7 +108,7 @@ const searchForFiles = (dir, extension) => {
} }
} }
return results; return results;
} };
const searchForBruFiles = (dir) => { const searchForBruFiles = (dir) => {
return searchForFiles(dir, '.bru'); return searchForFiles(dir, '.bru');