@pega/custom-dx-components/src/tasks/publish-archive/index.js

Utility for building custom UI components

import inquirer from 'inquirer';
import chalk from 'chalk';
import fetch from 'node-fetch';
import { join } from 'path';
import fs from 'fs';
import ora from 'ora';

import {
  zipUnArchiveToTempAndReturnBuffer,
  constructCompleteUrl,
  getHttpsAgent,
  getPegaServerConfig,
  addDebugLog,
  getConfigDefaults,
  zipVersionAndArchive,
  updateServerConfigArchiveRuleSetAndVersion } from '../../util.js';

import { getPublishComponentQuestions } from './helper.js';

import {
  LP_PUBLISH_COMPONENT_SERVICE_REST_ENDPOINT,
  PUBLISH_COMPONENT_LIBRARY_ARCHIVE_SERVICE_REST_ENDPOINT,
  TEMP_PATH,
  TOKEN_PATH,
  ARCHIVES_PATH
} from '../../constants.js';


export const publishComponentLibraryArchiveToServer = async (data, zipContent, doFetch) => {
  addDebugLog("publishComponentToServer", `data: ${data}`, "");
    const { rulesetName, rulesetVersion, libraryName, version } = data;

    const defaultPegaServerConfig = await getPegaServerConfig();
    const { serverType, isolationId } = defaultPegaServerConfig;
    const isLaunchpad = serverType === 'launchpad';
    const launchpadRestEndpoint = LP_PUBLISH_COMPONENT_SERVICE_REST_ENDPOINT.replace(
      '{isolationId}',
      isolationId || 'undefined'
    );
    let apiBody;
    let urlParams;

    if (isLaunchpad) {
      // currently no launchpad records to rule resolve a library

    } else {
      urlParams = `/library-name/${libraryName}/library-version/${version}/rulesetname/${rulesetName}/rulesetversion/${rulesetVersion}`;

    }

    const defaultPegaConfig = await getPegaServerConfig();
    let url = constructCompleteUrl(
      defaultPegaConfig.server,
      isLaunchpad ? launchpadRestEndpoint : PUBLISH_COMPONENT_LIBRARY_ARCHIVE_SERVICE_REST_ENDPOINT
    );

    url = url.concat(urlParams);

    if (doFetch) {
      try {
        const OauthData = fs.readFileSync(TOKEN_PATH, 'utf8');
        if (OauthData) {
          const {
            access_token: accessToken,
            token_type: tokenType
            // refresh_token: refreshToken
          } = JSON.parse(OauthData);
          let status = 500;
          let headers = {};

          if (isLaunchpad) {
            headers.cookie = `Pega-AAT=${accessToken}`;
            headers['Content-Type'] = 'application/json';
          } else {
            headers.Authorization = `${tokenType} ${accessToken}`;
            headers['Content-Type'] = 'application/json';
          }


          const response = await fetch(url, {
            method: 'POST',
            agent: getHttpsAgent(defaultPegaConfig),
            headers,
            body: JSON.stringify(zipContent)
          });

          status = response.status;
          if (!response.ok) {
            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 === 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');
            } else if (response.status === 403) {
              throw new Error('Error forbidden: User does not have privileges to Publish.');
            }
          }

          try {
            const respData = isLaunchpad ? await response.text() : await response.json();
            console.log(chalk.bold.green(`Success : ${isLaunchpad ? respData : respData.message}`));

            if (status === 500) {
              status = 999;
              throw new Error(respData.message);
            }
          } catch (err) {
            if (status === 500) {
              const respData = isLaunchpad ? await response.text() : await response.json();
              throw new Error(
                `Error occurred in authentication. Please regenerate using authenticate`
              );
            } else if (status === 999) {
              throw new Error(err);
            }
          }
        } else {
          throw new Error(`Error occurred in authentication. Please regenerate using authenticate`);
        }
      } catch (err) {
        // throw new Error(`Error occurred in authentication. Please regenerate using authenticate`);
        throw Error(err);
      }
    }
  };




export default async (orgLibName, selectedVersion) => {
  // console.log(orgLibName + ", " + selectedVersion);
  const configDef = await getConfigDefaults();
  let archiveBeforeStore = false;


  const rulesetQuestions = await getPublishComponentQuestions();
  const rulesetAnswers = await inquirer.prompt(rulesetQuestions);
  const { rulesetName, rulesetVersion} = rulesetAnswers;
  const mainDirectory = process.cwd();

  let content = {
    libraryName : orgLibName,
    version : selectedVersion,
    rulesetName, rulesetVersion
  };

  // update so will get archived
  updateServerConfigArchiveRuleSetAndVersion(content.rulesetName, content.rulesetVersion);

  if (orgLibName === configDef.currentOrgLib && selectedVersion === configDef.buildVersion) {

    archiveBeforeStore = true;

    if (archiveBeforeStore) {

      const archiveFileName = `${orgLibName}_${selectedVersion}.arch.zip`;
      const archiveDirectory = join (mainDirectory, ARCHIVES_PATH, `${orgLibName}`, `${selectedVersion}`);
      const defaultPegaConfig = await getPegaServerConfig();
      if (fs.existsSync(archiveDirectory)) {
        const archiveFile = join(archiveDirectory, archiveFileName);

        let zipContent = fs.readFileSync(archiveFile).toString("base64");

        if (zipContent != null) {

          zipContent = zipContent.replaceAll('"', "");

         let spinner;
          try {
            console.log("");
            // archive it, which will save updated archiveRuleset/Version
            await zipVersionAndArchive(content.libraryName, content.version);

            spinner = ora(`Exporting to server ${defaultPegaConfig.server}. \n`).start();
            publishComponentLibraryArchiveToServer(content, zipContent, true )
            .then( () => {
              spinner.stop();
              console.log(chalk.green.bold(`Success: Published Archive ${content.libraryName}/${content.version} to server.`));
            })
            .catch( (err) =>  {
              spinner.stop();
              console.log(chalk.red.bold(err));
            })
          }
          catch (err) {
            spinner.stop();
            console.log(chalk.bold.red(err.toString()));
          }



        }
      }

      return;

    }
  }
  else {

    // for now, to get a "buffer" from a zip file, need to unzip it in a /temp directory
    // then re-zip.  During the re-zip, create a buffer that can be passed to PegaInfinity

    // unzip to /temp, then re-zip and retrieve the buffer (remove /temp later)
    let zipBuffer = await zipUnArchiveToTempAndReturnBuffer(orgLibName, selectedVersion);

    zipBuffer.output.on('close', function() {

      // get rid of temp directory, regardless
      const tempDirectory = join (mainDirectory, TEMP_PATH);
      if (fs.existsSync(tempDirectory)) {
        fs.rmSync(tempDirectory, { recursive: true });
      }

      if (zipBuffer.zipContent != null) {

        content = { ...content, zipContent: zipBuffer.zipContent};

        try {
          publishComponentLibraryArchiveToServer(content, zipBuffer.zipContent, true )
          .then( () => {
            console.log(chalk.green.bold(`Success: Published Archive ${content.libraryName}/${content.version} to server.`));
          })
          .catch( (err) =>  {
            console.log(chalk.red.bold(err));
          })
        }
        catch (err) {
          console.log(chalk.bold.red(err.toString()));
        }

      }

    });

  }



};