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

Utility for building custom UI components

import fs from 'fs';
import chalk from 'chalk';
import fetch from 'node-fetch';

import {
  getPegaServerConfig,
  addDebugLog,
  getApplicationAndVersionFromToken,
  constructCompleteUrl,
  getHttpsAgent,
  validateRulesetVersion } from '../../util.js';
import { LIST_COMPONENT_LIBRARIES_SERVICE_REST_ENDPOINT, TOKEN_PATH } from '../../constants.js';

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


export const getDeleteLibraryQuestions = async () => {
addDebugLog("getDeleteLibraryQuestions", "", "");
  const defaultPegaConfig = await getPegaServerConfig();

  return [
    {
      name: 'sourceOfLibrary',
      type: 'rawlist',
      message: 'Delete library from Server or Local ?',
      choices: Object.values(SOURCE_OF_COMPONENT_TYPES),
      default: defaultPegaConfig.sourceOfComponents
    }
  ];
};

export const getLibraryVersionQuestion = async (libraryName, libVersions) => {
addDebugLog("getLibraryVersionQuestion", `libraryName: ${libraryName}`, "");
  return [
    {
      name: 'version',
      type: 'rawlist',
      message: `Select ${chalk.green.bold(`${libraryName}`)} library version (or ALL) to delete`,
      choices: libVersions
    }
  ];
};

export const getRulesetAndVersionQuestion = async (serverConfig) => {
  return [
    {
      name: 'rulesetName',
      message: 'Enter ruleset name',
      default: serverConfig.rulesetName,
      validate: value => {
        if (value.trim()) {
          return true;
        }
        return 'Ruleset name cannot be empty';
      },
      when: () => {
        return serverConfig.serverType === 'infinity';
      }
    },
    {
      name: 'rulesetVersion',
      message: 'Enter ruleset version',
      default: serverConfig.rulesetVersion,
      validate: value => {
        if (validateRulesetVersion(value)) {
          return true;
        }
        return 'Please provide compatible version e.g 01-01-01';
      },
      when: () => {
        return serverConfig.serverType === 'infinity';
      }
    }
  ];

};


async function fetchComponentLibrariesFromInfinity(apiUrl, headers) {
addDebugLog("fetchComponentLibrariesFromInfinity", `apiUrl: ${apiUrl}`, "");
  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;
        if (status === 401) {
          throw new Error('Error occurred in authentication. Please regenerate using authenticate');
        }
        else if (status === 404){
          throw new Error('404: Server resource not found');
        }
        else if (status === 405){
          throw new Error('405: Server method not allowed');
        }
        else if (status === 408){
          throw new Error('408: Server timed out');
        }
        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)}`));
  });
}

//  const getInfinityLibraries = async(rulesetName, rulesetVersion) => {
export const getInfinityLibraries = async() => {
addDebugLog("getInfinityLibraries", '', "");

  const { app_name, app_version } = await getApplicationAndVersionFromToken();
  const defaultPegaServerConfig = await getPegaServerConfig();
  let url = constructCompleteUrl(
    defaultPegaServerConfig.server,
    LIST_COMPONENT_LIBRARIES_SERVICE_REST_ENDPOINT
  );

  const ApplicationName = app_name;
  const ApplicationVersion = app_version;
  // const rulesetName = defaultPegaServerConfig.rulesetName;
  // const rulesetVersion = defaultPegaServerConfig.rulesetVersion;


  // inquire

  // want to get a list of all for application, so make ruleset/version blank
  let urlParams = `/app-name/${ApplicationName}/app-version/${ApplicationVersion}/rulesetname/""/rulesetversion/""`;
  // let urlParams = `/app-name/${ApplicationName}/app-version/${ApplicationVersion}/rulesetname/${rulesetName}/rulesetversion/${rulesetVersion}`;

  url = url.concat(urlParams);

  return new Promise((resolve, reject) => {
    try {
      fs.readFile(TOKEN_PATH, 'utf8', (err, data) => {
        if (err) {
          // 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 } = JSON.parse(data);

          const headers = {};
          headers.Authorization = `${tokenType} ${accessToken}`;

          fetchComponentLibrariesFromInfinity(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)}`);
    }
  });

}