@pega/custom-dx-components 0.0.1 → 0.1.10

package/src/tasks/list/helper.js

@@ -1,18 +1,23 @@
 import fs from 'fs';
-import https from 'https';
-
+import path from 'path';
 import chalk from 'chalk';
 import fetch from 'node-fetch';
+import { join } from 'path';
+import ora from 'ora';
+
+import inquirer from 'inquirer';
 
-import { 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, TASKS_CONFIG_JSON_FILENAME, COMPONENTS_DIRECTORY_PATH, COMPONENTS_PATH } from '../../constants.js';
+import { constructCompleteUrl, getComponents, getPegaServerConfig, getHttpsAgent, sanitize } 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 +34,55 @@ export const getListComponentsQuestions = async (options, sourceOfComponentsOpti
   ];
 };
 
-export const listLocalComponents = async sourceOfComponents => {
+export const getLaunchPadFilterQuestions = async () => {
+  const defaultPegaServerConfig = await getPegaServerConfig();
+  const currentDirectory = process.cwd();
+  const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
+
+  let data = fs.readFileSync(pegaConfigJsonPath, { encoding: 'utf8' });
+  data = data && JSON.parse(data);
+
+  if (!data[COMPONENTS_DIRECTORY_PATH]) {
+    console.error(
+      `${chalk.red.bold('ERROR')} Could not able find components directory path in config.json`
+    );
+    process.exit(1);
+  }
+
+  const componentData = data[COMPONENTS_PATH];
+
+  let { library } = componentData;
+  let { organization } = JSON.parse(fs.readFileSync(path.resolve('package.json'), 'utf8'));
+
+  return [
+    {
+      name: 'organization',
+      message: 'Enter component organization (required)',
+      default: organization,
+      validate: value => {
+        if (value) {
+          return true;
+        }
+        return 'Please provide value for organization';
+      }
+    },
+    {
+      name: 'library',
+      message: 'Enter library name (required)',
+      default: library,
+      validate: value => {
+        if (value) {
+          return true;
+        }
+        return 'Please provide value for library';
+      }
+    }
+  ];
+}
+
+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,78 +91,166 @@ 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 (library, organization) => {
   const defaultPegaServerConfig = await getPegaServerConfig();
+  const isLaunchpad = defaultPegaServerConfig.serverType === 'launchpad';
   const url = constructCompleteUrl(
     defaultPegaServerConfig.server,
-    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;
-          fetch(url, {
-            method: 'GET',
-            agent: new https.Agent({ rejectUnauthorized: false }),
-            headers: {
-              Authorization: `${tokenType} ${accessToken}`
-            }
-          })
-            .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)}`));
+          const { access_token: accessToken, token_type: tokenType } = JSON.parse(data);
+
+          const headers = {};
+
+          if (isLaunchpad) {
+            headers.cookie = `Pega-AAT=${accessToken}`;
+
+            fetchComponentsFromLaunchpad(url, headers)
+              .then((response) => {
+                response = response.filter(component => (component.library === library || library === "*" ) && (component.organization === organization || organization === "*"));
+                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 parsedData = JSON.parse(data);
-  const componentList = parsedData.pxResults?.map(({ label, pyRuleSet, pyRuleSetVersion }) => ({
-    'Rule name': label,
-    'Ruleset name': pyRuleSet,
-    'Ruleset version': pyRuleSetVersion
-  }));
+  const isLaunchpad = defaultPegaServerConfig.serverType === 'launchpad';
+  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, 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,24 +1,41 @@
 import inquirer from 'inquirer';
 import ora from 'ora';
-import chalk from 'chalk';
+
+import { showVersion, getPegaServerConfig } from '../../util.js';
 
 import {
   listLocalComponents,
   SOURCE_OF_COMPONENT_TYPES,
   getComponentsFromServer,
+  getLaunchPadFilterQuestions,
   displayServerComponents,
   getListComponentsQuestions
 } from './helper.js';
 
 const getList = async (sourceOfComponents, answers) => {
+  const defaultPegaServerConfig = await getPegaServerConfig();
+  const isLaunchpad = defaultPegaServerConfig.serverType === 'launchpad';
+
   switch (sourceOfComponents) {
     case SOURCE_OF_COMPONENT_TYPES.LOCAL: {
       await listLocalComponents(sourceOfComponents);
       break;
     }
     case SOURCE_OF_COMPONENT_TYPES.SERVER: {
+
+      let library;
+      let organization;
+
+      if (isLaunchpad) {
+        const questions = await getLaunchPadFilterQuestions();
+        const lpAnswers = await inquirer.prompt(questions);
+
+        ({library, organization} = lpAnswers);
+      }
+
+
       const spinner = ora('Fetching components from server\n').start();
-      const data = await getComponentsFromServer(answers);
+      const data = await getComponentsFromServer(library, organization);
       spinner.stop();
       await displayServerComponents(data, answers);
 
@@ -31,7 +48,9 @@ const getList = async (sourceOfComponents, answers) => {
   }
 };
 
-export default async options => {
+export default async (options) => {
+  showVersion();
+
   let sourceOfComponentsOption = SOURCE_OF_COMPONENT_TYPES.LOCAL;
 
   if (options.params[3] === 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();
+
+};