@pega/custom-dx-components 0.23.3 → 0.23.4

package/src/util.js

@@ -1,16 +1,20 @@
 import fs from 'fs';
-import path from 'path';
 import { join } from 'path';
 import { promisify } from 'util';
 import https from 'https';
 
+
 import chalk from 'chalk';
 import mustache from 'mustache';
 import pascalCase from 'pascalcase';
 import fetch from 'node-fetch';
 import { createRequire } from 'module';
 
-import _ from 'lodash';
+import checkGit from 'check-git';
+
+import * as currentPath from "./currentPath.cjs";
+
+
 
 
 import {
@@ -19,17 +23,12 @@ import {
   TOKEN_PATH,
   OOTB_COMPONENT_SERVICE_REST_ENDPOINT,
   DELETE_COMPONENT_SERVICE_REST_ENDPOINT,
-  OOTB_COMPONENTS,
-  SERVICES_AI_REST_ENDPOINT,
-  BOOTSTRAP_SERVICE_REST_ENDPOINT,
-  DXCOMPGENAI_SERVICE_REST_ENDPOINT,
-  SERVICE_TOKEN_PATH
+  LP_DELETE_COMPONENT_SERVICE_REST_ENDPOINT,
+  OOTB_COMPONENTS
 } from './constants.js';
 
 const access = promisify(fs.access);
 
-let servicesToken = "";
-
 export const checkPathAccess = async (path, options = {}) => {
   const { errorMessage } = options;
 
@@ -43,7 +42,7 @@ export const checkPathAccess = async (path, options = {}) => {
   }
 };
 
-export const deleteLocalComponent = async componentKey => {
+export const deleteLocalComponent = async (componentKey) => {
   const currentDirectory = process.cwd();
   const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
 
@@ -61,13 +60,14 @@ export const deleteLocalComponent = async componentKey => {
 
   const directory = join(currentDirectory, data[COMPONENTS_DIRECTORY_PATH], componentKey);
 
-  fs.rm(directory, { recursive: true }, err => {
-    if (err) {
-      throw err;
-    }
-
+  try {
+    fs.rmSync(directory, { recursive: true });
     console.log(`${chalk.red.bold(componentKey)} is deleted from Local`);
-  });
+  }
+  catch (err) {
+    console.log("no file");
+    throw new Error (`No such file ${componentKey}`);
+  }
 };
 
 export const deleteServerComponent = async componentKey => {
@@ -84,9 +84,7 @@ export const deleteServerComponent = async componentKey => {
         token_type: tokenType,
         refresh_token: refreshToken
       } = JSON.parse(OauthData);
-
-
-      await fetch(deleteUrl, {
+      fetch(deleteUrl, {
         method: 'DELETE',
         agent: new https.Agent({ rejectUnauthorized: false }),
         headers: {
@@ -128,11 +126,12 @@ export const getComponents = async () => {
   await checkPathAccess(pegaConfigJsonPath);
 
   let data = fs.readFileSync(pegaConfigJsonPath, { encoding: 'utf8' });
+
   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`
+      `${chalk.red.bold('ERROR')} Could not find components directory path in config.json`
     );
     process.exit(1);
   }
@@ -144,46 +143,6 @@ export const getComponents = async () => {
     .map(dirent => dirent.name);
 };
 
-export const getComponentsOfType = async (componentType) => {
-  const componentList = await getComponents();
-  let filteredList = Array();
-  if (componentList.length > 0) {
-
-    const currentDirectory = process.cwd();
-    const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
-
-    await checkPathAccess(pegaConfigJsonPath);
-
-    let data = fs.readFileSync(pegaConfigJsonPath, { encoding: 'utf8' });
-    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 directory = join(currentDirectory, data[COMPONENTS_DIRECTORY_PATH]);
-    const arTypes = componentType.split(",");
-
-    for (let index in componentList) {
-      let compDir = directory + path.sep + componentList[index];
-      let type =  await getComponentConfigType(compDir);
-      if (arTypes.includes(type)) {
-        filteredList.push( componentList[index]);
-      }
-    }
-
-
-
-    return filteredList;
-  }
-  else {
-    return componentList;
-  }
-};
-
 
 
 
@@ -192,24 +151,21 @@ export const getSubComponents = async (directory, type) => {
   const subDirectory = join(directory, type);
   return fs
   .readdirSync(subDirectory, { withFileTypes: true })
-  .filter(dirent => dirent.isDirectory())
-  .map(dirent => dirent.name);
-}
-
+    .filter((dirent) => dirent.isDirectory())
+    .map((dirent) => dirent.name);
+};
 
 export const getDirectoryFiles = async (directory) => {
   return fs
   .readdirSync(directory, { withFileTypes: true })
-  .filter(dirent => !dirent.isDirectory())
-  .map(dirent => dirent.name);
-}
-
+    .filter((dirent) => !dirent.isDirectory())
+    .map((dirent) => dirent.name);
+};
 
 export const getComponentsObj = async () => {
+  const compList = [];
 
-  let compList = new Array();
-
-  //const componentList = await getDirectoryFiles(directory);
+  // const componentList = await getDirectoryFiles(directory);
   const componentList = await getComponents();
 
 
@@ -227,7 +183,7 @@ export const getComponentsObj = async () => {
   }
 
   return compList;
-}
+};
 
 export const getPegaConfig = async () => {
   const currentDirectory = process.cwd();
@@ -241,47 +197,17 @@ export const getPegaConfig = async () => {
   return data;
 };
 
-export const getAIPromptData = async (aiPromptPath) => {
-  await checkPathAccess(aiPromptPath);
-
-  let data = fs.readFileSync(aiPromptPath, { encoding: 'utf8' });
-
-  return data;
-}
-
-export const getComponentConfigJson = async (componentDirectory) => {
-
-  const filePath = join(componentDirectory, "config.json");
-  await checkPathAccess(filePath);
-
-  let data = fs.readFileSync(filePath, { encoding: 'utf8' });
-
-  data = _.unescape(data);
-
-  return data;
-}
-
-export const getComponentConfigType = async (componentDirectory) => {
-  const configData = await getComponentConfigJson(componentDirectory);
-
-  let data = JSON.parse(configData);
-
-  return data.type;
-
-}
-
 export const getPegaServerConfig = async () => {
   const config = await getPegaConfig();
   return config['server-config'];
 };
 
-
 export const getComponentDefaults = async () => {
   const config = await getPegaConfig();
   return config.component;
 };
 
-export const getComponentDirectoryPath = async componentKey => {
+export const getComponentDirectoryPath = async (componentKey) => {
   const currentDirectory = process.cwd();
   const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
 
@@ -305,11 +231,11 @@ export const compileMustacheTemplate = (file, data) => {
   return mustache.render(content, data);
 };
 
-export const isPascalCase = string => {
+export const isPascalCase = (string) => {
   return string === pascalCase(string);
 };
 
-export const convertIntoPascalCase = string => {
+export const convertIntoPascalCase = (string) => {
   return pascalCase(string);
 };
 
@@ -317,23 +243,23 @@ export const constructCompleteUrl = (baseServer, endPoint) => {
   return baseServer.endsWith('/') ? `${baseServer}${endPoint}` : `${baseServer}/${endPoint}`;
 };
 
-export const nodeFetch = (url, config) => {
-  const { method, user, password, headers, ...restConfig } = config;
+// export const nodeFetch = (url, config) => {
+//   const { method, user, password, headers, ...restConfig } = config;
 
-  if (url.startsWith('https')) restConfig.agent = new https.Agent({ rejectUnauthorized: false });
+//   if (url.startsWith('https')) restConfig.agent = new https.Agent({ rejectUnauthorized: false });
 
-  return fetch(url, {
-    method,
-    ...restConfig,
-    headers: {
-      'Content-Type': 'application/json;charset=utf-8',
-      Authorization: `Basic ${Buffer.from(`${user}:${password}`).toString('base64')}`,
-      ...headers
-    }
-  });
-};
+//   return fetch(url, {
+//     method,
+//     ...restConfig,
+//     headers: {
+//       'Content-Type': 'application/json;charset=utf-8',
+//       Authorization: `Basic ${Buffer.from(`${user}:${password}`).toString('base64')}`,
+//       ...headers
+//     }
+//   });
+// };
 
-export const sanitize = str => {
+export const sanitize = (str) => {
   /* Allow only numbers and case insensitive alphabets */
   str = str.replace(/[^a-zA-Z0-9 ]/g, '');
   /* spaces will be replaced by - */
@@ -341,13 +267,13 @@ export const sanitize = str => {
   return str;
 };
 
-export const validateSemver = str => {
+export const validateSemver = (str) => {
   /* basic semver version validation - 0.0.1-dev */
   const regex = /^[0-9]\d*\.\d+\.\d+(?:-[a-zA-Z0-9]+)?$/g;
   return regex.test(str);
 };
 
-export const validateRulesetVersion = str => {
+export const validateRulesetVersion = (str) => {
   /* Ruleset version range - 01-99 */
   if (str.indexOf('00') !== -1) {
     return false;
@@ -357,15 +283,21 @@ export const validateRulesetVersion = str => {
   return regex.test(str);
 };
 
+export const standardizeStr = (str, length) => {
+  return str.padEnd(length);
+};
+
 export const showVersion = () => {
   // get package version, so can display at start
-  const require = createRequire(import.meta.url);
+  // const require = createRequire(import.meta.url);
+  const require = createRequire(currentPath.default);
+
   const pData = require("@pega/custom-dx-components/package.json");
 
-  console.log(chalk.green("DX Component Builder v" + pData.version));
+  console.log(chalk.green(`DX Component Builder v${pData.version}`));
 
   // do a check of node version, it should be 18 or greater
-  const arNodeVersion  = process.versions.node.split(".");
+  const arNodeVersion = process.versions.node.split('.');
 
   const nodeMajorVersion = parseInt(arNodeVersion[0]);
   const nodeMinorVersion = parseInt(arNodeVersion[1]);
@@ -374,22 +306,27 @@ export const showVersion = () => {
     console.log(chalk.redBright("DX Component Builder - SDK requires node v18 or greater, current version: " + process.version));
     process.exit(1);
   }
+
+  const hasGit = checkGit(process.cwd());
+
+  if (!hasGit) {
+    console.log(chalk.redBright("DX Component Builder - SDK git to be installed."));
+    process.exit(1);
+  }
+
+
 };
 
 export const getOOTBComponents = async () => {
-  return new Promise((resolve, reject) => {
-    fs.readFile(OOTB_COMPONENTS, 'utf-8', async (err, data) => {
-      if (err) {
+  return new Promise((resolve) => {
+    fs.readFile(OOTB_COMPONENTS, 'utf-8', async (error, ootbComponentsData) => {
+      if (error) {
         try {
           const { server } = await getPegaServerConfig();
           const url = constructCompleteUrl(server, OOTB_COMPONENT_SERVICE_REST_ENDPOINT);
           const OauthData = fs.readFileSync(TOKEN_PATH, 'utf8');
           if (OauthData) {
-            const {
-              access_token: accessToken,
-              token_type: tokenType,
-              refresh_token: refreshToken
-            } = JSON.parse(OauthData);
+            const { access_token: accessToken, token_type: tokenType } = JSON.parse(OauthData);
             fetch(url, {
               method: 'GET',
               agent: new https.Agent({ rejectUnauthorized: false }),
@@ -397,12 +334,12 @@ export const getOOTBComponents = async () => {
                 Authorization: `${tokenType} ${accessToken}`
               }
             })
-              .then(response => response.text())
-              .then(data => {
+              .then((response) => response.text())
+              .then((data) => {
                 if (data.charAt() === '[') {
                   data = data.slice(1, -1);
                   data = data.replace(/\s/g, '');
-                  fs.writeFile(OOTB_COMPONENTS, data, err => {
+                  fs.writeFile(OOTB_COMPONENTS, data, (err) => {
                     if (err) {
                       console.error(err);
                     }
@@ -412,232 +349,134 @@ export const getOOTBComponents = async () => {
                   data = JSON.parse(data);
                   if (data && data.errors) {
                     const errMessages = data.errors;
-                    errMessages.forEach(msgArr => {
+                    errMessages.forEach((msgArr) => {
                       throw new Error(`Failed with error - ${JSON.stringify(msgArr.message)}`);
                     });
                   }
                 }
               })
-              .catch(e => Promise.reject(`${chalk.bold.red(e)}`));
+              // eslint-disable-next-line prefer-promise-reject-errors
+              .catch((e) => Promise.reject(`${chalk.bold.red(e)}`));
           }
-        } catch (error) {
-          throw new Error('Error occurred in validation', error);
+        } catch (e) {
+          throw new Error('Error occurred in validation', e);
         }
       } else {
-        resolve(data.split(','));
+        resolve(ootbComponentsData.split(','));
       }
     });
   });
 };
 
-
-
-export const storeServicesToken = async () => {
+export const deleteInfinityServerComponent = async (componentKey) => {
   const { server } = await getPegaServerConfig();
-  const url = constructCompleteUrl(server, BOOTSTRAP_SERVICE_REST_ENDPOINT);
-
-  let returnToken = "";
-
+  const url = constructCompleteUrl(server, DELETE_COMPONENT_SERVICE_REST_ENDPOINT);
+  const [componentName, rulesetName, rulesetVersion] = componentKey.split('~|~');
+  const deleteUrl = `${url}/${componentName}/rulesetname/${rulesetName}/rulesetversion/${rulesetVersion}`;
   try {
     const OauthData = fs.readFileSync(TOKEN_PATH, 'utf8');
-    if (OauthData) {
-      let {
-        access_token: accessToken,
-        token_type: tokenType,
-        refresh_token: refreshToken
-      } = JSON.parse(OauthData);
 
-      await fetch(url, {
-        method: 'GET',
+    let status = 500;
+
+    if (OauthData) {
+      const { access_token: accessToken, token_type: tokenType } = JSON.parse(OauthData);
+      fetch(deleteUrl, {
+        method: 'DELETE',
         agent: new https.Agent({ rejectUnauthorized: false }),
         headers: {
           Authorization: `${tokenType} ${accessToken}`
-        },
+        }
       })
-        .then(response => response.text())
-        .then(data => {
-
-          try {
-            const returnData = JSON.parse(data);
-
-            if (returnData != null && returnData.pyConfigJSON) {
-              const returnJSON = JSON.parse(returnData.pyConfigJSON);
-              const strToken = JSON.stringify(returnJSON.tokens, null, 2);
-
-
-              fs.writeFileSync(SERVICE_TOKEN_PATH, strToken, err => {
-                if (err) {
-                  Promise.reject(`${chalk.bold.red(err)}`);
-                }
-              });
-              //returnToken = returnJSON.tokens.C11NB2S;
-            }
-            else {
-              //returnToken = "";
-            }
-          }
-          catch {
-            Promise.reject(`${chalk.bold.red(data)}`);
-          }
-
-
+        .then((response) => {
+          status = response.status;
+          return response.text();
         })
-        .catch(e => Promise.reject(`${chalk.bold.red(e)}`));
-    }
-  }
-  catch (error) {
-    throw new Error('Error occurred in validation', error);
-  }
-
-  //return returnToken;
-
-}
-
-export const getAIComponent = async (prompt) => {
-
-
-  const { servicesServer } = await getPegaServerConfig();
-  if (servicesServer === undefined) {
-    Promise.reject(`${chalk.bold.red("ERROR: servicesServer not defined in tasks.config.json" )}`);
-  }
-
-  const serviceUrl = constructCompleteUrl(servicesServer, SERVICES_AI_REST_ENDPOINT);
-
-  const jsonBody = { "prompt" : prompt };
-
-  let returnCode = "";
-
-  try {
-    const OauthData = fs.readFileSync(TOKEN_PATH, 'utf8');
-    const ServicesData = fs.readFileSync(SERVICE_TOKEN_PATH, 'utf8');
-    if (OauthData && ServicesData) {
-      let {
-        access_token: accessToken,
-        token_type: tokenType,
-        refresh_token: refreshToken
-      } = JSON.parse(OauthData);
-
-      const { C11NB2S } = JSON.parse(ServicesData);
-
-      // services needs Bearer with a big "B"
-      tokenType = convertIntoPascalCase(tokenType);
-
-      await fetch(serviceUrl, {
-        method: 'POST',
-        agent: new https.Agent({ rejectUnauthorized: false }),
-        headers: {
-          Authorization: `${tokenType} ${C11NB2S}`,
-          'Accept': 'application/json',
-          'Content-Type': 'application/json'
-        },
-        body: JSON.stringify(jsonBody),
-      })
-        .then(response => response.text())
-        .then(data => {
-
+        .then((resp) => {
+          let respData;
           try {
-            const returnData = JSON.parse(data);
-
-            if (returnData != null && returnData.code) {
-              returnCode = returnData.code;
-            }
-            else {
-              returnCode = "";
-            }
-          }
-          catch {
-            Promise.reject(`Error in AI generation: \n ${chalk.bold.red(data)}`);
-            //throw new Error('Error occurred in validation', data);
+            respData = JSON.parse(resp);
+          } catch (e) {
+            console.log(chalk.bold.redBright(`Failure : ${resp}`));
+            process.exit(1);
           }
 
-
+          if (status === 200) {
+            console.log(chalk.bold.green(`Success : ${respData.message}`));
+          } else {
+            throw new Error(`${respData.message}`);
+          }
         })
-        .catch(e => Promise.reject(`Error in AI generation: \n ${chalk.bold.red(e)}`));
-    }
-  }
-  catch (error) {
-    if (error.code === 'ENOENT') {
-      Promise.reject(`${chalk.bold.red("ERROR: Need to authenticate or reauthenticate.")}`);
-    }
-    else {
-      throw new Error('Error occurred in validation', error);
+        .catch((e) => {
+          if (status === 403) {
+            // eslint-disable-next-line prefer-promise-reject-errors
+            Promise.reject(`${chalk.bold.red('Error forbidden: User does not have privileges to Delete.')}`);
+          } else {
+            // eslint-disable-next-line prefer-promise-reject-errors
+            Promise.reject(`${chalk.bold.red(e)}`);
+          }
+        });
     }
-
+  } catch (error) {
+    console.log(`\n${chalk.bold.red(error)}`);
   }
-
-  return returnCode;
 };
 
-
-export const getInfinityAIComponent = async (prompt) => {
-  const { server } = await getPegaServerConfig();
-  const dataPageUrl = constructCompleteUrl(server, DXCOMPGENAI_SERVICE_REST_ENDPOINT);
-
-  const jsonBody = { "dataViewParameters" :  { "Prompt" : prompt } };
-
-
-
-  let returnCode = "";
+export const deleteLaunchpadServerComponent = async (componentKey) => {
+  const { server, isolationId } = await getPegaServerConfig();
+  const deleteUrl = constructCompleteUrl(server, LP_DELETE_COMPONENT_SERVICE_REST_ENDPOINT.replace('{isolationId}', isolationId));
+  const [componentName] = componentKey.split('~|~');
 
   try {
     const OauthData = fs.readFileSync(TOKEN_PATH, 'utf8');
 
+    let status = 500;
+
     if (OauthData) {
-      let {
-        access_token: accessToken,
-        token_type: tokenType,
-        refresh_token: refreshToken
-      } = JSON.parse(OauthData);
+      const { access_token: accessToken, token_type: tokenType } = JSON.parse(OauthData);
+
+      const headers = {
+        Authorization: `${tokenType} ${accessToken}`,
+        cookie: `Pega-AAT=${accessToken}`,
+        'Content-Type': 'application/json'
+      };
 
-      // services needs Bearer with a big "B"
-      //tokenType = convertIntoPascalCase(tokenType);
+      const apiBody = {
+        type: 'CustomComponent',
+        componentName
+      };
 
-      await fetch(dataPageUrl, {
-        method: 'POST',
+      fetch(deleteUrl, {
+        method: 'DELETE',
         agent: new https.Agent({ rejectUnauthorized: false }),
-        headers: {
-          Authorization: `${tokenType} ${accessToken}`
-        },
-        body: JSON.stringify(jsonBody),
+        headers,
+        body: JSON.stringify(apiBody)
       })
-        .then(response => response.text())
-        .then(data => {
-
-          try {
-            const returnData = JSON.parse(data);
-
-            if (returnData != null && returnData.data) {
-              returnCode = returnData.data[0].pyValue;
-            }
-            else if (returnData != null && returnData.errors) {
-              if (returnData.errors[0].message.indexOf("token") >= 0) {
-                Promise.reject(`${chalk.bold.red("ERROR: Need to authenticate or reauthenticate.")}`);
-              }
-            }
-            else {
-              returnCode = "";
-              Promise.reject(`Error in AI generation: \n ${chalk.bold.red(data)}`);
-            }
-          }
-          catch {
-            Promise.reject(`Error in AI generation: \n ${chalk.bold.red(data)}`);
-            //throw new Error('Error occurred in validation', data);
+        .then((response) => {
+          status = response.status;
+          return response.text();
+        })
+        .then((response) => {
+          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 : ${response}`));
+          } else {
+            throw new Error(`${response.message}`);
           }
-
-
         })
-        .catch(e => Promise.reject(`Error in AI generation: \n ${chalk.bold.red(e)}`));
-    }
-  }
-  catch (error) {
-    if (error.code === 'ENOENT') {
-      Promise.reject(`${chalk.bold.red("ERROR: Need to authenticate or reauthenticate.")}`);
-    }
-    else {
-      throw new Error('Error occurred in validation', error);
+        .catch((e) => {
+          if (status === 403) {
+            // eslint-disable-next-line prefer-promise-reject-errors
+            Promise.reject(`${chalk.bold.red('Error forbidden: User does not have privileges to Delete.')}`);
+          } else {
+            // eslint-disable-next-line prefer-promise-reject-errors
+            Promise.reject(`${chalk.bold.red(e)}`);
+          }
+        });
     }
-
+  } catch (error) {
+    console.log(`\n${chalk.bold.red(error)}`);
   }
-
-  return returnCode;
 };