@pega/custom-dx-components/src/tasks/delete/helper.js

Utility for building custom UI components

import fs from 'fs';
import chalk from 'chalk';
import inquirer from 'inquirer';
import ora from 'ora';

import path from 'path';
import { join } from 'path';

import {
  deleteLocalComponent,
  deleteInfinityServerComponent,
  deleteLaunchpadServerComponent,
  getComponents,
  getPegaServerConfig,
  standardizeStr,
  addDebugLog,
  checkAccessTokenExpiration
} from '../../util.js';
import { getComponentsFromServer } from '../list/helper.js';

import { TASKS_CONFIG_JSON_FILENAME, COMPONENTS_DIRECTORY_PATH, COMPONENTS_PATH } from '../../constants.js';

export const SOURCE_OF_COMPONENT_TYPES = {
  SERVER: 'Server',
  LOCAL: 'Local'
};

let library;
let organization;


export const getDeleteComponentsQuestions = async (options) => {
addDebugLog("getDeleteComponentsQuestions", "", "");

  const defaultPegaServerConfig = await getPegaServerConfig();

  return [
    {
      name: 'sourceOfComponents',
      type: 'rawlist',
      message: 'Delete components from Server or Local ?',
      choices: Object.values(SOURCE_OF_COMPONENT_TYPES),
      default: defaultPegaServerConfig.sourceOfComponents,
      when() {
        return !options.params[3];
      }
    }
  ];
};

export const getLaunchPadFilterQuestions = async () => {
addDebugLog("getLaunchPadFilterQuestions", "", "");
  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')} Unable to find components directory path in config.json`
    );
    process.exit(1);
  }

  const componentData = data[COMPONENTS_PATH];

   ({ library } = componentData);
   ({ 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 deleteLocalComponents = async (sourceOfComponents, options) => {
addDebugLog("deleteLocalComponents", `sourceOfComponents: ${sourceOfComponents}`, "" );
  const localComponents = await getComponents();

  if (localComponents.length > 0) {
    if (options.params.length >= 6) {
      const componentKey = options.params[4];
      const sDeletion = options.params[5];
      const confirmDeletion = sDeletion === 'Y' || sDeletion === 'y' || sDeletion === true || sDeletion === 'true';
      if (confirmDeletion) {
        await deleteLocalComponent(componentKey);
      }
    } else {
      const answers = await inquirer.prompt([
        {
          name: 'componentKey',
          type: 'rawlist',
          message: 'Select component to delete',
          choices: localComponents
        },
        {
          name: 'confirmDeletion',
          type: 'confirm',
          message: 'Are you sure ?',
          default: false
        }
      ]);
      if (answers.confirmDeletion) {
        await deleteLocalComponent(answers.componentKey);
      }
    }
  } else {
    console.log(chalk.bold.redBright(`No custom components in ${sourceOfComponents}`));
  }
};

export const deleteServerComponents = async (sourceOfComponents, answers) => {
addDebugLog("deleteServerComponents", `sourceOfComponents: ${sourceOfComponents}`, "");
  const defaultPegaServerConfig = await getPegaServerConfig();
  const isLaunchpad = defaultPegaServerConfig.serverType === 'launchpad';

  if (!isLaunchpad) {
    await checkAccessTokenExpiration();
  }


  if (isLaunchpad) {
    const questions = await getLaunchPadFilterQuestions();
    const lpAnswers = await inquirer.prompt(questions);

    ({library, organization} = lpAnswers);
  }

  let spinner;
  let data;
  try {
    spinner = ora('Fetching components from server').start();
    data = await getComponentsFromServer(library, organization);
    spinner.stop();
  }
  catch (error) {
    spinner.stop();
    if (error.indexOf("ECONNREFUSED") >= 0) {
      console.log(`\n${chalk.bold.red('Error occurred in authentication. Please regenerate using authenticate')}`);
    }
    else {
      console.log(`${chalk.bold.red(error)}`);
    }

    // spinner.stop();
    process.exit(1);
  }


  let serverComponents;
  if (isLaunchpad) {
    serverComponents = data;

  } else {
    try {
      if (typeof data === 'object') {
        serverComponents = data.pxResults;
      } else {
        serverComponents = JSON.parse(data).pxResults;
      }
    } catch (ex) {
      /* empty */
    }
  }


  if (serverComponents && serverComponents?.length > 0) {
    if (isLaunchpad) {
      const choicesArr = serverComponents.map(({ name: componentName, type, version }) => {
        const name = `${standardizeStr(componentName, 45)} ${standardizeStr(type, 20)} ${standardizeStr(version, 20)}`;

        const value = `${componentName}~|~${type}~|~${version}`;
        const short = `\n Selected component : ${chalk.redBright(`${componentName} ${type} : ${version}`)}`;

        return { name, value, short };
      });

      const launchpadAnswers = await inquirer.prompt({
        name: 'componentToDelete',
        type: 'rawlist',
        pageSize: 10,
        message: `Select component to delete \n  ${standardizeStr('Component Name', 48)} ${standardizeStr('Type', 20)} ${standardizeStr(
          'Version',
          22
        )}`,
        choices: choicesArr
      });
      await deleteLaunchpadServerComponent(launchpadAnswers.componentToDelete);
    } else {
      // logic for Infinity
      const choicesArr = serverComponents.map(({ label, pyRuleSet, pyRuleSetVersion }) => {
        const name = `${standardizeStr(label, 45)} ${standardizeStr(pyRuleSet, 30)} ${standardizeStr(pyRuleSetVersion, 20)}`;

        const value = `${label}~|~${pyRuleSet}~|~${pyRuleSetVersion}`;
        const short = `\n Selected component : ${chalk.redBright(`${label} ${pyRuleSet} : ${pyRuleSetVersion}`)}`;

        return { name, value, short };
      });
      const infinityAnswers = await inquirer.prompt({
        name: 'componentToDelete',
        type: 'rawlist',
        pageSize: 10,
        message: `Select component to delete \n  ${standardizeStr('Rule name', 48)} ${standardizeStr('Ruleset name', 30)} ${standardizeStr(
          'Ruleset version',
          22
        )}`,
        choices: choicesArr
      });
      await deleteInfinityServerComponent(infinityAnswers.componentToDelete);
    }
  } else {
    console.log(chalk.bold.redBright(`No custom components in ${sourceOfComponents}`));
  }
};