@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 { join } from 'path';
import fs from 'fs';
import ora from 'ora';

import {
  zipUnArchiveToTempAndReturnBuffer,
  constructCompleteUrl,
  getFetchAgent,
  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',
          dispatcher: getFetchAgent(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()));
        }
      }
    });
  }
};