@pega/custom-dx-components 8.8.17 → 8.8.19

package/src/tasks/init/template/test/functionTest/localPromoteRevertWP.test.js

@@ -0,0 +1,59 @@
+// import { exec } from 'child_process';
+const path = require('path');
+const fs = require('fs');
+const util = require('node:util');
+const exec = util.promisify(require('node:child_process').exec);
+
+describe('promote and revert webpack', () => {
+  it('npm run promoteWebPack', async () => {
+    const script = `npm run promoteWebPack`;
+
+    const { stdout, stderr } = await exec(script);
+    // console.log(stdout);
+    expect(stdout).not.toBeNull();
+    expect(stderr).not.toBeNull();
+
+    // want message to contain component name
+    expect(stdout).toContain('Bundler now using');
+    expect(stdout).toContain('webpack.config.js');
+
+    // utilize
+    expect(stdout).toContain('Utilize this file for webpack modifications.');
+
+    // verify new file exists
+    const webPackFile = path.resolve('webpack.config.js');
+
+    expect(fs.existsSync(webPackFile)).toBeTruthy();
+
+    // if (doesExist) {
+    //   // remove it
+    //   fs.rmdirSync(fileDir, { recursive: true });
+    // }
+  }, 10000);
+
+  it('npm run revertWebPack', async () => {
+    const script = `npm run revertWebPack`;
+
+    const { stdout, stderr } = await exec(script);
+    // console.log(stdout);
+    expect(stdout).not.toBeNull();
+    expect(stderr).not.toBeNull();
+
+    // want message to contain component name
+    expect(stdout).toContain('marked as not used.');
+    expect(stdout).toContain('webpack.config.js');
+
+    // message with bundler
+    expect(stdout).toContain('Bundler reverted to using internal webpack.config.js.');
+
+    // verify file marked as not used
+    const webPackFile = path.resolve('webpack.config.js.notused');
+
+    expect(fs.existsSync(webPackFile)).toBeTruthy();
+
+    // if (doesExist) {
+    //   // remove it
+    //   fs.rmdirSync(fileDir, { recursive: true });
+    // }
+  }, 10000);
+});

package/src/tasks/list/helper.js

@@ -1,18 +1,17 @@
 import fs from 'fs';
-import https from 'https';
 
 import chalk from 'chalk';
 import fetch from 'node-fetch';
 
-import { LIST_COMPONENT_SERVICE_REST_ENDPOINT, LP_LIST_COMPONENT_SERVICE_REST_ENDPOINT, TOKEN_PATH } from '../../constants.js';
-import { constructCompleteUrl, getComponents, getPegaServerConfig } from '../../util.js';
+import { LIST_COMPONENT_SERVICE_REST_ENDPOINT, LP_LIST_COMPONENT_SERVICE_REST_ENDPOINT, TOKEN_PATH, COMPONENT_SCHEMA } from '../../constants.js';
+import { constructCompleteUrl, getComponents, getPegaServerConfig, getHttpsAgent } from '../../util.js';
 
 export const SOURCE_OF_COMPONENT_TYPES = {
   SERVER: 'Server',
   LOCAL: 'Local'
 };
 
-export const getListComponentsQuestions = async (options, sourceOfComponentsOption) => {
+export const getListComponentsQuestions = async (options) => {
   const defaultPegaServerConfig = await getPegaServerConfig();
 
   return [
@@ -29,9 +28,9 @@ export const getListComponentsQuestions = async (options, sourceOfComponentsOpti
   ];
 };
 
-export const listLocalComponents = async sourceOfComponents => {
+export const listLocalComponents = async (sourceOfComponents) => {
   let localComponents = await getComponents();
-  localComponents = localComponents.map(name => ({ 'Rule name': name }));
+  localComponents = localComponents.map((name) => ({ 'Rule name': name }));
   if (localComponents.length > 0) {
     console.log(chalk.bold.blueBright(`List of custom components in ${sourceOfComponents}`));
     console.table(localComponents, ['Rule name']);
@@ -40,91 +39,160 @@ export const listLocalComponents = async sourceOfComponents => {
   }
 };
 
-export const getComponentsFromServer = async data => {
+async function fetchComponentsFromInfinity(apiUrl, headers) {
+  const serverConfig = await getPegaServerConfig();
+  return new Promise((resolve, reject) => {
+    let status = 500;
+    fetch(apiUrl, {
+      method: 'GET',
+      agent: getHttpsAgent(serverConfig),
+      headers
+    })
+      .then((response) => {
+        status = response.status;
+        return response.json();
+      })
+      .then((resp) => {
+        // const respData = JSON.parse(resp);
+        if (status === 401) {
+          throw new Error('Error occurred in authentication. Please regenerate using authenticate');
+          // console.log(accessTokenUri, refreshToken);
+          /* TODO - Handle refresh_token */
+        } else if (status === 200) {
+          resolve(resp);
+        } else {
+          throw new Error(`${resp.message}`);
+        }
+      })
+      // eslint-disable-next-line prefer-promise-reject-errors
+      .catch((e) => reject(`${chalk.bold.red(e)}`));
+  });
+}
+
+async function fetchComponentsFromLaunchpad(apiUrl, headers) {
+  const serverConfig = await getPegaServerConfig();
+  // constructing urls for all type of components
+  const urls = COMPONENT_SCHEMA.type.map((type) => apiUrl.replace('{type}', type.value));
+  const statuses = [];
+
+  return new Promise((resolve, reject) => {
+    Promise.all(
+      urls.map(async (url) => {
+        return fetch(url, {
+          method: 'GET',
+          agent: getHttpsAgent(serverConfig),
+          headers
+        });
+      })
+    )
+      .then((responses) => {
+        return Promise.all(
+          responses.map((res) => {
+            statuses.push(res.status);
+            if (res.status === 401 || res.status === 503) {
+              // Finding a 503 response is sometimes being returned from Launchpad in expired authentication scenario
+              throw new Error('Authorization error. Please regenerate using authenticate');
+            } else if (res.ok) {
+              return res.json();
+            } else {
+              throw new Error(`Unexpected Error ${res.status} encountered. ${res.message}`);
+            }
+          })
+        );
+      })
+      .then((data) => {
+        const components = data.map((res) => res.components).flat();
+        resolve(components);
+      })
+      // eslint-disable-next-line prefer-promise-reject-errors
+      .catch((e) => reject(`${chalk.bold.red(e)}`));
+  });
+}
+
+export const getComponentsFromServer = async () => {
   const defaultPegaServerConfig = await getPegaServerConfig();
   const isLaunchpad = defaultPegaServerConfig.serverType === 'launchpad';
   const url = constructCompleteUrl(
     defaultPegaServerConfig.server,
-    isLaunchpad ? LP_LIST_COMPONENT_SERVICE_REST_ENDPOINT :  LIST_COMPONENT_SERVICE_REST_ENDPOINT
+    isLaunchpad ? LP_LIST_COMPONENT_SERVICE_REST_ENDPOINT : LIST_COMPONENT_SERVICE_REST_ENDPOINT
   );
   return new Promise((resolve, reject) => {
     try {
       fs.readFile(TOKEN_PATH, 'utf8', (err, data) => {
         if (err) {
-          reject(
-            `\n${chalk.bold.red(
-              'Error occured in authentication. Please regenerate using authenticate'
-            )}`
-          );
+          // eslint-disable-next-line prefer-promise-reject-errors
+          reject(`\n${chalk.bold.red('Error occurred in authentication. Please regenerate using authenticate')}`);
         }
         if (data) {
-          const {
-            access_token: accessToken,
-            token_type: tokenType,
-            refresh_token: refreshToken
-          } = JSON.parse(data);
-          let status = 500;
-
-          const headers = {
-            Authorization: `${tokenType} ${accessToken}`
-          }
+          const { access_token: accessToken, token_type: tokenType } = JSON.parse(data);
+
+          const headers = {};
 
-          if(isLaunchpad) {
+          if (isLaunchpad) {
             headers.cookie = `Pega-AAT=${accessToken}`;
-          }
 
-          fetch(url, {
-            method: 'GET',
-            agent: new https.Agent({ rejectUnauthorized: false }),
-            headers
-          })
-            .then(response => {
-              status = response.status;
-              return response.text();
-            })
-            .then(resp => {
-              const respData = JSON.parse(resp);
-              if (status === 401) {
-                throw new Error(
-                  'Error occured in authentication. Please regenerate using authenticate'
-                );
-                // console.log(accessTokenUri, refreshToken);
-                /* TODO - Handle refresh_token */
-              } else if (status == 200) {
-                resolve(resp);
-              } else {
-                throw new Error(`${respData.message}`);
-              }
-            })
-            .catch(e => reject(`${chalk.bold.red(e)}`));
+            fetchComponentsFromLaunchpad(url, headers)
+              .then((response) => resolve(response))
+              .catch((e) => reject(e));
+          } else {
+            headers.Authorization = `${tokenType} ${accessToken}`;
+
+            fetchComponentsFromInfinity(url, headers)
+              .then((response) => resolve(response))
+              .catch((e) => reject(e));
+          }
         }
       });
     } catch (error) {
       console.log(`\n${chalk.bold.red(error)}`);
+      // eslint-disable-next-line prefer-promise-reject-errors
       reject(`${chalk.bold.red(error)}`);
     }
   });
 };
 
-export const displayServerComponents = async data => {
+export const displayServerComponents = async (data) => {
   const defaultPegaServerConfig = await getPegaServerConfig();
   const isLaunchpad = defaultPegaServerConfig.serverType === 'launchpad';
-  const parsedData = JSON.parse(data);
-  const list = isLaunchpad ? parsedData.components : parsedData.pxResults;
+  let list;
+  if (isLaunchpad) {
+    list = data;
+  } else {
+    try {
+      if (typeof data === 'object') {
+        list = data.pxResults;
+      } else {
+        list = JSON.parse(data).pxResults;
+      }
+    } catch (ex) {
+      /* empty */
+    }
+  }
   /**
    * TODO: Need to modify the components list mapping code to support Launchpad components
    */
-  const componentList = list?.map(({ label, pyRuleSet, pyRuleSetVersion }) => ({
-    'Rule name': label,
-    'Ruleset name': pyRuleSet,
-    'Ruleset version': pyRuleSetVersion
-  }));
+  const componentList = list?.map(({ label, pyRuleSet, pyRuleSetVersion, type }) => {
+    if (isLaunchpad) {
+      return {
+        'Component Name': label,
+        Type: type
+      };
+    }
+
+    return {
+      'Rule name': label,
+      'Ruleset name': pyRuleSet,
+      'Ruleset version': pyRuleSetVersion
+    };
+  });
 
   if (componentList && componentList.length > 0) {
-    console.log(
-      chalk.bold.blueBright(`List of custom components in ${defaultPegaServerConfig.server}`)
-    );
-    console.table(componentList, ['Rule name', 'Ruleset name', 'Ruleset version']);
+    console.log(chalk.bold.blueBright(`List of custom components in ${defaultPegaServerConfig.server}`));
+    if (isLaunchpad) {
+      console.table(componentList, ['Component Name', 'Type']);
+    } else {
+      console.table(componentList, ['Rule name', 'Ruleset name', 'Ruleset version']);
+    }
   } else {
     console.log(chalk.bold.redBright(`No custom components in ${defaultPegaServerConfig.server}`));
   }

package/src/tasks/list/index.js

@@ -1,6 +1,7 @@
 import inquirer from 'inquirer';
 import ora from 'ora';
-import chalk from 'chalk';
+
+import { showVersion } from '../../util.js';
 
 import {
   listLocalComponents,
@@ -10,8 +11,6 @@ import {
   getListComponentsQuestions
 } from './helper.js';
 
-import { showVersion } from '../../util.js';
-
 const getList = async (sourceOfComponents, answers) => {
   switch (sourceOfComponents) {
     case SOURCE_OF_COMPONENT_TYPES.LOCAL: {
@@ -33,7 +32,7 @@ const getList = async (sourceOfComponents, answers) => {
   }
 };
 
-export default async options => {
+export default async (options) => {
   showVersion();
 
   let sourceOfComponentsOption = SOURCE_OF_COMPONENT_TYPES.LOCAL;

package/src/tasks/promote-webpack/index.js

@@ -8,12 +8,16 @@ import inquirer from 'inquirer';
 
 import {
   convertIntoPascalCase,
+  checkPathAccess,
   showVersion
 } from '../../util.js';
 
 import {
   WEBPACK_CONFIG_JS_FILENAME,
-  BUILDER_INDEX_FILE_PATH
+  WEBPACK_PATHS_JS_FILENAME,
+  PACKAGE_JSON_FILENAME,
+  BUILDER_INDEX_FILE_PATH,
+  BUILDER_DIR_FILE_PATH
 } from '../../constants.js';
 
 
@@ -23,11 +27,12 @@ let redirectFile = "";
 export const copyWebPack = async () => {
 
    // first check to see if already have the file
-  const newWebPackDir = path.resolve(WEBPACK_CONFIG_JS_FILENAME);
+  const newWebPackConfigDir = path.resolve(WEBPACK_CONFIG_JS_FILENAME);
+  const newWebPackPathsDir = path.resolve(WEBPACK_PATHS_JS_FILENAME);
   let override = true;
-  if (fs.existsSync(newWebPackDir)) {
+  if (fs.existsSync(newWebPackConfigDir)) {
 
-    console.log("Promoted file " + chalk.bold.yellow(`${newWebPackDir}`) + " already exists.");
+    console.log("Promoted file " + chalk.bold.yellow(`${newWebPackConfigDir}`) + " already exists.");
     const questions = [
       {
         name: 'override',
@@ -45,15 +50,42 @@ export const copyWebPack = async () => {
 
 
   if (override) {
-    // call this function from top level
-    //fs.copyFileSync("./webpack.config.js", "webpack.config.js")
-    const promoteWebPackDir = fileURLToPath(new URL(WEBPACK_CONFIG_JS_FILENAME, import.meta.url));
 
-    fs.copyFileSync(promoteWebPackDir, newWebPackDir);
+    const currentDirectory = process.cwd();
+    const packageJsonPath = join(currentDirectory, PACKAGE_JSON_FILENAME);
+
+    await checkPathAccess(packageJsonPath);
+
+    let data = fs.readFileSync(packageJsonPath, { encoding: 'utf8' });
+    data = JSON.parse(data);
+
+    // if top level package.json is of type=module, then promote standard webpack.config.js that is being
+    // used in builder (along with paths.js file), otherwise promote the local copy in promote-webpack directory, which is a version
+    // modified to support "require" instead of "import" (and paths code is inside the webpack.config.js file)
+    if (data["type"] && data["type"] === "module") {
+      const builderIndexDir = fileURLToPath(new URL(BUILDER_DIR_FILE_PATH, import.meta.url));
+
+      const promoteWebPackConfigDir = path.resolve(path.join(builderIndexDir, WEBPACK_CONFIG_JS_FILENAME));
+      const promoteWebPackPathsDir = path.resolve(path.join(builderIndexDir, WEBPACK_PATHS_JS_FILENAME));
+
+      fs.copyFileSync(promoteWebPackConfigDir, newWebPackConfigDir);
+      fs.copyFileSync(promoteWebPackPathsDir, newWebPackPathsDir);
+    }
+    else {
+      const newWebPackDir = path.resolve(WEBPACK_CONFIG_JS_FILENAME);
+      const promoteWebPackDir = fileURLToPath(new URL(WEBPACK_CONFIG_JS_FILENAME, import.meta.url));
+
+      fs.copyFileSync(promoteWebPackDir, newWebPackDir);
+    }
+
+
+
+
+
 
   }
 
-  redirectFile = newWebPackDir;
+  redirectFile = newWebPackConfigDir;
 
 
 
@@ -69,17 +101,17 @@ export const updateBuilder = async () => {
     // comment out original webpack reference
 
     // if not commented out, comment out
-    if (indexFileJS.indexOf("//import configFactory from './webpack.config.js';") < 0) {
-      indexFileJS = indexFileJS.replaceAll("import configFactory from './webpack.config.js';", "//import configFactory from './webpack.config.js';");
+    if (indexFileJS.indexOf("// import configFactory from './webpack.config.js';") < 0) {
+      indexFileJS = indexFileJS.replaceAll("import configFactory from './webpack.config.js';", "// import configFactory from './webpack.config.js';");
     }
 
     // uncomment out promoted webpack reference
-    indexFileJS = indexFileJS.replaceAll("//import configFactory from '../../../../../../../webpack.config.js';", "import configFactory from '../../../../../../../webpack.config.js';");
+    indexFileJS = indexFileJS.replaceAll("// import configFactory from '../../../../../../../webpack.config.js';", "import configFactory from '../../../../../../../webpack.config.js';");
 
     fs.writeFileSync(builderIndexDir, indexFileJS, { encoding: 'utf8' });
 
     console.log(chalk.bold.green(`Bundler now using ${redirectFile}.`));
-    console.log(chalk.bold.green(`Utilize this file for webpack mofifications.`));
+    console.log(chalk.bold.green(`Utilize this file for webpack modifications.`));
   }
 
 

package/src/tasks/publish/helper.js

@@ -1,6 +1,5 @@
 import fs from 'fs';
 import path from 'path';
-import https from 'https';
 
 import fetch from 'node-fetch';
 import AdmZip from 'adm-zip';
@@ -11,20 +10,17 @@ import {
   getComponentDirectoryPath,
   getComponents,
   getPegaServerConfig,
-  validateRulesetVersion
+  validateRulesetVersion,
+  getHttpsAgent
 } from '../../util.js';
-import {
-  PUBLISH_COMPONENT_SERVICE_REST_ENDPOINT,
-  LP_PUBLISH_COMPONENT_SERVICE_REST_ENDPOINT,
-  TOKEN_PATH
-} from '../../constants.js';
+import { PUBLISH_COMPONENT_SERVICE_REST_ENDPOINT, LP_PUBLISH_COMPONENT_SERVICE_REST_ENDPOINT, TOKEN_PATH } from '../../constants.js';
 
 export const getPublishComponentQuestions = async () => {
   const components = await getComponents();
 
-  if (components.length == 0) {
-    console.log(chalk.redBright("No components to publish"));
-    process.exit(1);
+  if (components.length === 0) {
+    console.log(chalk.redBright('No components to publish'));
+    process.exit();
   }
 
   const defaultPegaConfig = await getPegaServerConfig();
@@ -40,7 +36,7 @@ export const getPublishComponentQuestions = async () => {
       name: 'rulesetName',
       message: 'Enter ruleset name',
       default: defaultPegaConfig.rulesetName,
-      validate: value => {
+      validate: (value) => {
         if (value.trim()) {
           return true;
         }
@@ -54,7 +50,7 @@ export const getPublishComponentQuestions = async () => {
       name: 'rulesetVersion',
       message: 'Enter ruleset version',
       default: defaultPegaConfig.rulesetVersion,
-      validate: value => {
+      validate: (value) => {
         if (validateRulesetVersion(value)) {
           return true;
         }
@@ -80,7 +76,7 @@ export const getPublishComponentQuestions = async () => {
   ];
 };
 
-export const zipComponent = async componentKey => {
+export const zipComponent = async (componentKey) => {
   const srcDirectory = await getComponentDirectoryPath(componentKey);
   const buildDirectory = await path.join(path.resolve(), 'dist/components', componentKey);
   const configJson = `${srcDirectory}/config.json`;
@@ -94,7 +90,7 @@ export const zipComponent = async componentKey => {
 
   const configContent = Buffer.from(fs.readFileSync(`${srcDirectory}/config.json`)).toString();
 
-  fs.rmdir('dist', { recursive: true }, err => {
+  fs.rmdir('dist', { recursive: true }, (err) => {
     if (err) {
       throw err;
     }
@@ -103,16 +99,13 @@ export const zipComponent = async componentKey => {
   return { zipContent, configContent };
 };
 
-export const publishComponentToServer = async data => {
+export const publishComponentToServer = async (data, doFetch) => {
   const { configContent, zipContent, rulesetName, rulesetVersion } = data;
 
   const defaultPegaServerConfig = await getPegaServerConfig();
   const { serverType, isolationId } = defaultPegaServerConfig;
   const isLaunchpad = serverType === 'launchpad';
-  const launchpadRestEndpoint = LP_PUBLISH_COMPONENT_SERVICE_REST_ENDPOINT.replace(
-    '{isolationId}',
-    isolationId
-  );
+  const launchpadRestEndpoint = LP_PUBLISH_COMPONENT_SERVICE_REST_ENDPOINT.replace('{isolationId}', isolationId);
   let apiBody;
 
   if (isLaunchpad) {
@@ -136,79 +129,66 @@ export const publishComponentToServer = async data => {
   }
 
   const defaultPegaConfig = await getPegaServerConfig();
-  const url = constructCompleteUrl(
-    defaultPegaConfig.server,
-    isLaunchpad ? launchpadRestEndpoint : PUBLISH_COMPONENT_SERVICE_REST_ENDPOINT
-  );
-
-  try {
-    const OauthData = fs.readFileSync(TOKEN_PATH, 'utf8');
-    if (OauthData) {
-      const {
-        access_token: accessToken,
-        token_type: tokenType
-        // refresh_token: refreshToken
-      } = JSON.parse(OauthData);
-      let status = 500;
-      const headers = {};
-
-      if (isLaunchpad) {
-        headers.cookie = `Pega-AAT=${accessToken}`;
-        headers['Content-Type'] = 'application/json';
-      } else {
-        headers.Authorization = `${tokenType} ${accessToken}`;
-      }
+  const url = constructCompleteUrl(defaultPegaConfig.server, isLaunchpad ? launchpadRestEndpoint : PUBLISH_COMPONENT_SERVICE_REST_ENDPOINT);
+
+  if (doFetch) {
+    try {
+      const OauthData = fs.readFileSync(TOKEN_PATH, 'utf8');
+      if (OauthData) {
+        const {
+          access_token: accessToken,
+          token_type: tokenType
+          // refresh_token: refreshToken
+        } = JSON.parse(OauthData);
+        let status = 500;
+        const headers = {
+          Authorization: `${tokenType} ${accessToken}`
+        };
+
+        if (isLaunchpad) {
+          headers.cookie = `Pega-AAT=${accessToken}`;
+          headers['Content-Type'] = 'application/json';
+        }
 
-      fetch(url, {
-        method: 'POST',
-        agent: new https.Agent({ rejectUnauthorized: false }),
-        headers,
-        body: JSON.stringify(apiBody)
-      })
-        .then(response => {
-          status = response.status;
-          return response.text();
+        fetch(url, {
+          method: 'POST',
+          agent: getHttpsAgent(defaultPegaConfig),
+          headers,
+          body: JSON.stringify(apiBody)
         })
-        .then(resp => {
-          const respData = isLaunchpad ? resp : JSON.parse(resp);
-          if (status === 401) {
-            throw new Error(
-              'Error occurred in authentication. Please regenerate using authenticate'
-            );
-            // console.log(accessTokenUri, refreshToken);
-            /* TODO - Handle refresh_token */
-          } else if (status === 200 || status === 201) {
-            console.log(chalk.bold.green(`Success : ${isLaunchpad ? respData : respData.message}`));
-          } else {
-            throw new Error(`${respData.message}`);
-          }
-        })
-        .catch(e => {
-          if (e.code === 'ECONNREFUSED') {
-            // eslint-disable-next-line prefer-promise-reject-errors
-            Promise.reject(
-              `${chalk.bold.red(
-                'Error occurred in authentication. Please regenerate using authenticate'
-              )}`
-            );
-          }
-          else if (status === 403) {
-            // eslint-disable-next-line prefer-promise-reject-errors
-            Promise.reject(
-              `${chalk.bold.red(
-                'Error forbidden: User does not have privileges to Publish.'
-              )}`
-            );
-          }
-          else {
-            // eslint-disable-next-line prefer-promise-reject-errors
-            Promise.reject(`${chalk.bold.red(e)}`);
-          }
-        });
-    } else {
+          .then((response) => {
+            status = response.status;
+            return response.text();
+          })
+          .then((resp) => {
+            const respData = isLaunchpad ? resp : JSON.parse(resp);
+            if (status === 401) {
+              throw new Error('Error occurred in authentication. Please regenerate using authenticate');
+              // console.log(accessTokenUri, refreshToken);
+              /* TODO - Handle refresh_token */
+            } else if (status === 200 || status === 201) {
+              console.log(chalk.bold.green(`Success : ${isLaunchpad ? respData : respData.message}`));
+            } else {
+              throw new Error(`${respData.message}`);
+            }
+          })
+          .catch((e) => {
+            if (e.code === 'ECONNREFUSED') {
+              // eslint-disable-next-line prefer-promise-reject-errors
+              Promise.reject(`${chalk.bold.red('Error occurred in authentication. Please regenerate using authenticate')}`);
+            } else if (status === 403) {
+              // eslint-disable-next-line prefer-promise-reject-errors
+              Promise.reject(`${chalk.bold.red('Error forbidden: User does not have privileges to Publish.')}`);
+            } else {
+              // eslint-disable-next-line prefer-promise-reject-errors
+              Promise.reject(`${chalk.bold.red(e)}`);
+            }
+          });
+      } else {
+        throw new Error(`Error occurred in authentication. Please regenerate using authenticate`);
+      }
+    } catch (err) {
       throw new Error(`Error occurred in authentication. Please regenerate using authenticate`);
     }
-  } catch (err) {
-    throw new Error(`Error occurred in authentication. Please regenerate using authenticate`);
   }
 };