@pega/dx-component-builder-sdk 0.1.0

package/src/util.js

@@ -0,0 +1,442 @@
+import fs from 'fs';
+import { join } from 'path';
+import { promisify } from 'util';
+import https from 'https';
+import inquirer from 'inquirer';
+
+import chalk from 'chalk';
+import mustache from 'mustache';
+import pascalCase from 'pascalcase';
+import fetch from 'node-fetch';
+
+import {
+  COMPONENTS_DIRECTORY_PATH,
+  DXCB_CONFIG_JSON_FILENAME,
+  TOKEN_PATH,
+  OOTB_COMPONENT_SERVICE_REST_ENDPOINT,
+  DELETE_COMPONENT_SERVICE_REST_ENDPOINT,
+  OOTB_COMPONENTS,
+  TOKEN_URL_V1,
+  FIELD_PATH,
+  WIDGET_PATH,
+  TEMPLATE_PATH,
+  COMPONENT_PREFIX_FIELD_PATH,
+  COMPONENT_PREFIX_TEMPLATE_PATH,
+  COMPONENT_PREFIX_WIDGET_PATH
+} from './constants.js';
+
+const access = promisify(fs.access);
+
+export const checkPathAccess = async (path, options = {}) => {
+  const { errorMessage } = options;
+
+  try {
+    await access(path, fs.constants.R_OK);
+  } catch (err) {
+    const message =
+      errorMessage || `${chalk.red.bold('ERROR')} Could not able to access path - ${path}`;
+    console.error(message);
+    process.exit(1);
+  }
+};
+
+export const deleteLocalComponent = async (componentKey, category = "custom") => {
+  const currentDirectory = process.cwd();
+  const pegaConfigJsonPath = join(currentDirectory, DXCB_CONFIG_JSON_FILENAME);
+  const categoryDirectory = join("/", category.toLowerCase());
+
+  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], categoryDirectory, componentKey);
+
+  fs.rmdir(directory, { recursive: true }, err => {
+    if (err) {
+      throw err;
+    }
+
+    console.log(`${chalk.red.bold(componentKey)} is deleted from Local`);
+  });
+};
+
+export const deleteServerComponent = async componentKey => {
+  const { server, user, password } = await getPegaServerConfig();
+  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) {
+      const {
+        access_token: accessToken,
+        token_type: tokenType,
+        refresh_token: refreshToken
+      } = JSON.parse(OauthData);
+      fetch(deleteUrl, {
+        method: 'DELETE',
+        agent: new https.Agent({ rejectUnauthorized: false }),
+        headers: {
+          Authorization: `${tokenType} ${accessToken}`
+        }
+      })
+        .then(response => response.text())
+        .then(resp => {
+          const respData = JSON.parse(resp);
+          if (respData.status == 200) {
+            console.log(chalk.bold.green(`Success : ${respData.message}`));
+          } else {
+            throw new Error(`${respData.message}`);
+          }
+        })
+        .catch(e => Promise.reject(`${chalk.bold.red(e)}`));
+    }
+  } catch (error) {
+    console.log(`\n${chalk.bold.red(error)}`);
+  }
+};
+
+export const getComponents = async (showSeparator = false, category = "custom") => {
+  const currentDirectory = process.cwd();
+  const pegaConfigJsonPath = join(currentDirectory, DXCB_CONFIG_JSON_FILENAME);
+  const categoryDirectory = join("/", category.toLowerCase());
+
+  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], categoryDirectory);
+
+  const fieldComps = await getSubComponents(directory, FIELD_PATH);
+  const templateComps = await getSubComponents(directory, TEMPLATE_PATH);
+  const widgetComps = await getSubComponents(directory, WIDGET_PATH);
+
+  let compList = new Array();
+
+  if (fieldComps.length > 0) {
+    if (showSeparator) compList.push(new inquirer.Separator("---- fields ----"));
+    compList.push(...fieldComps);
+  }
+
+  if (templateComps.length > 0) {
+    if (showSeparator) compList.push(new inquirer.Separator("---- templates ----"));
+    compList.push(...templateComps);
+  }
+
+  if (widgetComps.length > 0) {
+    if (showSeparator) compList.push(new inquirer.Separator("---- widgets ----"));
+    compList.push(...widgetComps);
+  }
+
+  return compList;
+
+};
+
+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);
+}
+
+export const getComponentsObj = async (showSeparator = false, category = "custom") => {
+  const currentDirectory = process.cwd();
+  const pegaConfigJsonPath = join(currentDirectory, DXCB_CONFIG_JSON_FILENAME);
+  const categoryDirectory = join("/", category.toLowerCase());
+
+  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], categoryDirectory);
+
+  const fieldComps = await getSubComponents(directory, FIELD_PATH);
+  const templateComps = await getSubComponents(directory, TEMPLATE_PATH);
+  const widgetComps = await getSubComponents(directory, WIDGET_PATH);
+
+  let compList = new Array();
+
+  if (fieldComps.length > 0) {
+    if (showSeparator) compList.push(new inquirer.Separator("---- fields ----"));
+
+    compList.push(...fieldComps.map(
+      name => {
+        const container = {};
+        container.name = name;
+        container.value = COMPONENT_PREFIX_FIELD_PATH + name;
+
+        return container;
+      }
+    ));
+  }
+
+  if (templateComps.length > 0) {
+    if (showSeparator) compList.push(new inquirer.Separator("---- templates ----"));
+    compList.push(...templateComps.map(
+      name => {
+        const container = {};
+        container.name = name;
+        container.value = COMPONENT_PREFIX_TEMPLATE_PATH + name;
+
+        return container;
+      }
+    ));
+  }
+
+  if (widgetComps.length > 0) {
+    if (showSeparator) compList.push(new inquirer.Separator("---- widgets ----"));
+    compList.push(...widgetComps.map(
+      name => {
+        const container = {};
+        container.name = name;
+        container.value = COMPONENT_PREFIX_WIDGET_PATH + name;
+
+        return container;
+      }
+    ));
+  }
+
+  return compList;
+}
+
+export const getSubComponentsAndDir = async (directory, type) => {
+
+  const subDirectory = join(directory, type);
+  const prefix = type.replace("/", "") + "/";
+
+  return fs
+  .readdirSync(subDirectory, { withFileTypes: true })
+  .filter(dirent => dirent.isDirectory())
+  .map(dirent => prefix + dirent.name);
+}
+
+export const getComponentsAndSubDirectory = async (category = "custom") => {
+  const currentDirectory = process.cwd();
+  const pegaConfigJsonPath = join(currentDirectory, DXCB_CONFIG_JSON_FILENAME);
+  const categoryDirectory = join("/", category.toLowerCase());
+
+  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], categoryDirectory);
+
+  const fieldComps = await getSubComponentsAndDir(directory, FIELD_PATH);
+  const templateComps = await getSubComponentsAndDir(directory, TEMPLATE_PATH);
+  const widgetComps = await getSubComponentsAndDir(directory, WIDGET_PATH);
+
+  let dirAndComp = new Array();
+  dirAndComp.push(...fieldComps);
+  dirAndComp.push(...templateComps);
+  dirAndComp.push(...widgetComps);
+
+  return dirAndComp;
+
+}
+
+export const removeComponentPrefix = (componentName) => {
+  if (componentName.indexOf(COMPONENT_PREFIX_FIELD_PATH) == 0) {
+    componentName = componentName.substring(COMPONENT_PREFIX_FIELD_PATH.length);
+  }
+  else if (componentName.indexOf(COMPONENT_PREFIX_TEMPLATE_PATH) == 0) {
+    componentName = componentName.substring(COMPONENT_PREFIX_TEMPLATE_PATH.length);
+  }
+  else if (componentName.indexOf(COMPONENT_PREFIX_WIDGET_PATH) == 0) {
+    componentName = componentName.substring(COMPONENT_PREFIX_WIDGET_PATH.length);
+  }
+
+  return componentName;
+}
+
+
+export const getPegaConfig = async () => {
+  const currentDirectory = process.cwd();
+  const pegaConfigJsonPath = join(currentDirectory, DXCB_CONFIG_JSON_FILENAME);
+
+  await checkPathAccess(pegaConfigJsonPath);
+
+  let data = fs.readFileSync(pegaConfigJsonPath, { encoding: 'utf8' });
+  data = JSON.parse(data);
+
+  return data;
+};
+
+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, category = "custom") => {
+  const currentDirectory = process.cwd();
+  const pegaConfigJsonPath = join(currentDirectory, DXCB_CONFIG_JSON_FILENAME);
+  const categoryDirectory = join("/", category.toLowerCase());
+
+  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);
+  }
+
+  return join(currentDirectory, data[COMPONENTS_DIRECTORY_PATH], categoryDirectory, componentKey);
+};
+
+export const compileMustacheTemplate = (file, data) => {
+  const content = fs.readFileSync(file, 'utf8');
+  return mustache.render(content, data);
+};
+
+export const isPascalCase = string => {
+  return string === pascalCase(string);
+};
+
+export const convertIntoPascalCase = string => {
+  return pascalCase(string);
+};
+
+export const constructCompleteUrl = (baseServer, endPoint) => {
+  return baseServer.endsWith('/') ? `${baseServer}${endPoint}` : `${baseServer}/${endPoint}`;
+};
+
+export const nodeFetch = (url, config) => {
+  const { method, user, password, headers, ...restConfig } = config;
+
+  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
+    }
+  });
+};
+
+export const sanitize = str => {
+  /* Allow only numbers and case insensitive alphabets */
+  str = str.replace(/[^a-zA-Z0-9 ]/g, '');
+  /* spaces will be replaced by - */
+  str = str.replace(/\s+/g, '-');
+  return 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 => {
+  /* Ruleset version range - 01-99 */
+  if (str.indexOf('00') !== -1) {
+    return false;
+  }
+  /* basic ruleset version validation - 01-01-01 */
+  const regex = /^\d\d-\d\d-\d\d$/g;
+  return regex.test(str);
+};
+
+export const getOOTBComponents = async () => {
+  return new Promise((resolve, reject) => {
+    fs.readFile(OOTB_COMPONENTS, 'utf-8', async (err, data) => {
+      if (err) {
+        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);
+            fetch(url, {
+              method: 'GET',
+              agent: new https.Agent({ rejectUnauthorized: false }),
+              headers: {
+                Authorization: `${tokenType} ${accessToken}`
+              }
+            })
+              .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 => {
+                    if (err) {
+                      console.error(err);
+                    }
+                    resolve(data.split(','));
+                  });
+                } else {
+                  data = JSON.parse(data);
+                  if (data && data.errors) {
+                    const errMessages = data.errors;
+                    errMessages.forEach(msgArr => {
+                      throw new Error(`Failed with error - ${JSON.stringify(msgArr.message)}`);
+                    });
+                  }
+                }
+              })
+              .catch(e => Promise.reject(`${chalk.bold.red(e)}`));
+          }
+        } catch (error) {
+          throw new Error('Error occurred in validation', error);
+        }
+      } else {
+        resolve(data.split(','));
+      }
+    });
+  });
+};
+
+export const getTokenUrl = async (server) => {
+  return server.endsWith('/') ? `${server}${TOKEN_URL_V1}` : `${server}/${TOKEN_URL_V1}`;
+};