@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 {
  getPegaServerConfig,
  addDebugLog,
  getC11NB2STokenAndStaticServer,
  getApplicationAndVersionFromToken,
  constructCompleteUrl,
  getFetchAgent
} 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',
      dispatcher: getFetchAgent(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}`);
        }
      })

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

      reject(`${chalk.bold.red(error)}`);
    }
  });
};