@pega/custom-dx-components 24.2.16 → 25.1.10-alpha-0.1

package/src/tasks/publish-archive/helper.js

@@ -0,0 +1,58 @@
+import {
+  addDebugLog,
+  getPegaServerConfig,
+  validateRulesetVersion
+} from '../../util.js';
+
+
+export const getLibraryVersionQuestion = async(libVersions) => {
+addDebugLog("getLibraryVersionQuestion", `libVersions: ${libVersions}`, "");
+    return [
+      {
+        name: 'version',
+        type: 'rawlist',
+        message: 'Select library version to publish',
+        choices: libVersions
+      }
+    ];
+
+}
+
+export const getPublishComponentQuestions = async componentKey => {
+addDebugLog("getPublishComponentQuestions", `componentKey: ${componentKey}`, "");
+
+
+  const defaultPegaConfig = await getPegaServerConfig();
+
+  return [
+    {
+      name: 'rulesetName',
+      message: 'Enter ruleset name',
+      default: defaultPegaConfig.rulesetName,
+      validate: value => {
+        if (value.trim()) {
+          return true;
+        }
+        return 'Ruleset name cannot be empty';
+      },
+      when: () => {
+        return defaultPegaConfig.serverType === 'infinity';
+      }
+    },
+    {
+      name: 'rulesetVersion',
+      message: 'Enter ruleset version',
+      default: defaultPegaConfig.rulesetVersion,
+      validate: value => {
+        if (validateRulesetVersion(value)) {
+          return true;
+        }
+        return 'Please provide compatible version e.g 01-01-01';
+      },
+      when: () => {
+        return defaultPegaConfig.serverType === 'infinity';
+      }
+    }
+  ];
+
+};

package/src/tasks/publish-archive/index.js

@@ -0,0 +1,238 @@
+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 } 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
+  };
+
+
+  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("");
+            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()));
+        }
+
+      }
+
+    });
+
+  }
+
+};