@pega/custom-dx-components 8.8.16 → 8.8.18

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

@@ -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();
+
+};