@pega/custom-dx-components/src/tasks/list-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,
  getC11NB2STokenAndStaticServer,
  getApplicationAndVersionFromToken,
  constructCompleteUrl,
  getHttpsAgent
} from '../../util.js';

import { listLibJSONResponse } from '@pega/constellation-dx-components-build-utils/index.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 getListLibraryQuestions = async (libraryName)  => {
addDebugLog("getListLibraryQuestions", `libraryName: ${libraryName}`, "");
  const defaultPegaConfig = await getPegaServerConfig();


  return [
    {
      name: 'sourceOfLibrary',
      type: 'rawlist',
      message: `List library ${chalk.bold.green(`${libraryName}`)} from Server or Local ?`,
      choices: Object.values(SOURCE_OF_COMPONENT_TYPES),
      default: defaultPegaConfig.sourceOfComponents,
    }
  ];
};


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

};

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

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

export const getServerLibraries = async() => {
  addDebugLog("listLibJSONResponse", "services call", "");
  // server
  const tokenAndStaticServer = await getC11NB2STokenAndStaticServer();
  const oLibList = await listLibJSONResponse(tokenAndStaticServer.C11NB2S, tokenAndStaticServer.appStaticContentServer);
addDebugLog("listLibJSONResponse", "services end", "");
  if (oLibList) {
    return Object.keys(oLibList);
  }

  return [];

}

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

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;
  // let urlParams = `/app-name/${ApplicationName}/app-version/${ApplicationVersion}/rulesetname/${rulesetName}/rulesetversion/${rulesetVersion}`;

  // currently want to get all published libraries for an application, so make ruleset/version blank
  let urlParams = `/app-name/${ApplicationName}/app-version/${ApplicationVersion}/rulesetname/""/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)}`);
    }
  });

}