@pega/custom-dx-components 0.23.3 → 0.23.5

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

@@ -29,9 +29,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,7 +40,75 @@ export const listLocalComponents = async sourceOfComponents => {
   }
 };
 
-export const getComponentsFromServer = async data => {
+function fetchComponentsFromInfinity(apiUrl, headers) {
+  return new Promise((resolve, reject) => {
+    let status = 500;
+    fetch(apiUrl, {
+      method: 'GET',
+      agent: new https.Agent({ rejectUnauthorized: false }),
+      headers
+    })
+      .then((response) => {
+        status = response.status;
+        return response.json();
+      })
+      .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(`${resp.message}`);
+        }
+      })
+      // eslint-disable-next-line prefer-promise-reject-errors
+      .catch((e) => reject(`${chalk.bold.red(e)}`));
+  });
+}
+
+function fetchComponentsFromLaunchpad(apiUrl, headers) {
+  // constucting 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: new https.Agent({ rejectUnauthorized: false }),
+          headers
+        });
+      })
+    )
+      .then((responses) => {
+        return Promise.all(
+          responses.map((res) => {
+            statuses.push(res.status);
+            return res.json();
+          })
+        );
+      })
+      .then((data) => {
+        if (statuses.every((status) => status === 200)) {
+          const components = data.map((res) => res.components).flat();
+          resolve(components);
+        }
+        if (statuses.every((status) => [401, 503].includes(status))) {
+          throw new Error('Error occured in authentication. Please regenerate using authenticate');
+        } else {
+          throw new Error(`${data.map((resp) => resp.message || resp)}`);
+        }
+      })
+      // 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(
@@ -51,11 +119,8 @@ export const getComponentsFromServer = async data => {
     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 {
@@ -69,8 +134,18 @@ export const getComponentsFromServer = async data => {
             Authorization: `${tokenType} ${accessToken}`
           }
 
-          if(isLaunchpad) {
+          if (isLaunchpad) {
             headers.cookie = `Pega-AAT=${accessToken}`;
+
+            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));
           }
 
           fetch(url, {
@@ -101,24 +176,50 @@ export const getComponentsFromServer = async data => {
       });
     } 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;
+  // const parsedData = JSON.parse(data);
+  let list;
+  if (isLaunchpad) {
+    list = data;
+  }
+  else {
+    try {
+      if (typeof(data) == 'object') {
+        list = data.pxResults;
+      }
+      else {
+        list = JSON.parse(data).pxResults;
+      }
+
+    }
+    catch (ex) {}
+  }
+  //const list = isLaunchpad ? data : JSON.parse(data).pxResults;
   /**
    * TODO: Need to modify the components list mapping code to support Launchpad components
    */
-  const componentList = list?.map(({ label, pyRuleSet, 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(

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

@@ -0,0 +1,126 @@
+
+import fs from 'fs';
+import path from 'path';
+import { join } from 'path';
+import { URL, fileURLToPath } from 'url';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+
+import {
+  convertIntoPascalCase,
+  checkPathAccess,
+  showVersion
+} from '../../util.js';
+
+import {
+  WEBPACK_CONFIG_JS_FILENAME,
+  WEBPACK_PATHS_JS_FILENAME,
+  PACKAGE_JSON_FILENAME,
+  BUILDER_INDEX_FILE_PATH,
+  BUILDER_DIR_FILE_PATH
+} from '../../constants.js';
+
+
+
+let redirectFile = "";
+
+export const copyWebPack = async () => {
+
+   // first check to see if already have the file
+  const newWebPackConfigDir = path.resolve(WEBPACK_CONFIG_JS_FILENAME);
+  const newWebPackPathsDir = path.resolve(WEBPACK_PATHS_JS_FILENAME);
+  let override = true;
+  if (fs.existsSync(newWebPackConfigDir)) {
+
+    console.log("Promoted file " + chalk.bold.yellow(`${newWebPackConfigDir}`) + " already exists.");
+    const questions = [
+      {
+        name: 'override',
+        type: 'confirm',
+        message: `Overwrite`,
+        default: false
+      }
+    ];
+
+    await inquirer.prompt(questions).then(async answers => {
+      override = answers.override;
+      });
+
+  }
+
+
+  if (override) {
+
+    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 = newWebPackConfigDir;
+
+
+
+}
+
+export const updateBuilder = async () => {
+
+  const builderIndexDir = fileURLToPath(new URL(BUILDER_INDEX_FILE_PATH, import.meta.url));
+
+  let indexFileJS = fs.readFileSync(builderIndexDir, { encoding: 'utf8' });
+
+  if (indexFileJS.length > 0) {
+    // 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';");
+    }
+
+    // uncomment out promoted webpack reference
+    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 modifications.`));
+  }
+
+
+}
+
+export default async options => {
+  showVersion();
+
+  await copyWebPack();
+  await updateBuilder();
+
+};