@pega/custom-dx-components 0.25.13 → 0.25.15

package/src/tasks/list-pub/index.js

@@ -1,11 +1,11 @@
 import inquirer from 'inquirer';
 import chalk from 'chalk';
 
-import {showVersion, getC11NB2STokenAndStaticServer, getLocalLibraries, getLocalLibraryVersions, getLocalLibraryVersionData, getLibraryBased, addDebugLog, checkLibraryAndArchives, getConfigDefaults, cleanUpTemp } from '../../util.js';
+import {showVersion, getC11NB2STokenAndStaticServer, getLocalLibraries, getLocalLibraryVersions, getLocalLibraryVersionData, getLibraryBased, addDebugLog, checkLibraryAndArchives, getConfigDefaults, cleanUpTemp, getPegaServerConfig, getLibraryBasedCL } from '../../util.js';
 
 import { listLibJSONResponse } from '@pega/constellation-dx-components-build-utils/index.js';
 
-import { getListLibraryQuestions, SOURCE_OF_COMPONENT_TYPES, getServerLibraries, getServerLocalQuestion } from './helper.js';
+import { getListLibraryQuestions, SOURCE_OF_COMPONENT_TYPES, getServerLibraries, getInfinityLibraries,  getServerLocalQuestion } from './helper.js';
 
 
 
@@ -139,37 +139,27 @@ addDebugLog("listPublished", "END", "-");
   }
   else {
 
-    const arLibs = await getServerLibraries();
-    if (arLibs && arLibs.length > 0) {
+    const isLibraryBasedCL =  getLibraryBasedCL();
+    if (isLibraryBasedCL) {
+      const arLibs = await getInfinityLibraries();
 
-      const libAnswers = await inquirer.prompt([
-        {
-          name: 'library',
-          type: 'rawlist',
-          message: 'Pick library',
-          choices: arLibs
-        }
-      ]);
+      if (arLibs && arLibs.pxResults && arLibs.pxResults.length > 0) {
 
-      libraryName = libAnswers.library;
-      const libVersions = await getServerLibraryVersions(libraryName);
+        const libs = arLibs.pxResults.map((oLib, index) => ({ name: oLib.pyLabel, value: index}));
 
-      if (libVersions) {
-        const keys = Object.keys(libVersions);
-        const libVersionAnswers = await inquirer.prompt([
 
+        const libAnswers = await inquirer.prompt([
           {
-            name: 'libVersion',
+            name: 'library',
             type: 'rawlist',
-            message: 'Enter version',
-            choices: keys
+            message: 'Pick library',
+            choices: libs
           }
         ]);
 
-        const selectedVersion = libVersionAnswers.libVersion;
+        const libraryIndex = libAnswers.library;
 
-        const versionData = libVersions[selectedVersion];
-        const data = JSON.parse(versionData);
+        const data = JSON.parse(arLibs.pxResults[libraryIndex].pxComponentDefinition);
 
         // get built on from first component if exists
         let builtOn = "(date unavailable)";
@@ -180,20 +170,78 @@ addDebugLog("listPublished", "END", "-");
         let libData = data.map((component) => ( {'Component': component.name, 'Label': component.label, 'Version': component.version, 'Type': component.type, 'Sub Type' : component.subtype}));
         console.log(chalk.bold.blueBright(`\nList of ${libraryName}:${selectedVersion} components built on ${builtOn}.`));
         console.table(libData, ['Component', 'Label', 'Version', 'Type', 'Sub Type']);
+
+      }
+      else {
+        // No library with that name
+        const serverConfig = await getPegaServerConfig();
+        console.log(chalk.redBright(`No server component libraries exist in given ruleset ${chalk.bold(`${serverConfig.rulesetName}:${serverConfig.rulesetVersion}`)}`));
+        console.log(chalk.redBright(`You need to publish a library to this ruleset first.`));
+  addDebugLog("listPublished", "END", "-");
+        process.exit(1);
+
+      }
     }
     else {
-      console.log(chalk.red("No libraries available on server."));
-    }
 
+      // old app static server
 
+      const arLibs = await getServerLibraries();
+      if (arLibs && arLibs.length > 0) {
 
-    }
-    else {
-      // No library with that name
-      console.log(chalk.redBright(`No server library named: ${libraryName} exists.`));
-      console.log(chalk.redBright(`You need to publish library: ${libraryName} first.`));
-addDebugLog("listPublished", "END", "-");
-      process.exit(1);
+        const libAnswers = await inquirer.prompt([
+          {
+            name: 'library',
+            type: 'rawlist',
+            message: 'Pick library',
+            choices: arLibs
+          }
+        ]);
+
+        libraryName = libAnswers.library;
+        const libVersions = await getServerLibraryVersions(libraryName);
+
+        if (libVersions) {
+          const keys = Object.keys(libVersions);
+          const libVersionAnswers = await inquirer.prompt([
+
+            {
+              name: 'libVersion',
+              type: 'rawlist',
+              message: 'Enter version',
+              choices: keys
+            }
+          ]);
+
+          const selectedVersion = libVersionAnswers.libVersion;
+
+          const versionData = libVersions[selectedVersion];
+          const data = JSON.parse(versionData);
+
+          // get built on from first component if exists
+          let builtOn = "(date unavailable)";
+          if (data[0] && data[0].buildDate) {
+            builtOn = data[0].buildDate;
+          }
+
+          let libData = data.map((component) => ( {'Component': component.name, 'Label': component.label, 'Version': component.version, 'Type': component.type, 'Sub Type' : component.subtype}));
+          console.log(chalk.bold.blueBright(`\nList of ${libraryName}:${selectedVersion} components built on ${builtOn}.`));
+          console.table(libData, ['Component', 'Label', 'Version', 'Type', 'Sub Type']);
+        }
+        else {
+          console.log(chalk.red("No libraries available on server."));
+        }
+
+
+      }
+      else {
+        // No library with that name
+        console.log(chalk.redBright(`No server library named: ${libraryName} exists.`));
+        console.log(chalk.redBright(`You need to publish library: ${libraryName} first.`));
+  addDebugLog("listPublished", "END", "-");
+        process.exit(1);
+
+      }
 
     }
 

package/src/tasks/publish/index.js

@@ -6,7 +6,7 @@ import fs from 'fs';
 import validate from '../validator/index.js';
 import bundleComponent from '../bundle/index.js';
 import { lintComponent } from '../linter/index.js';
-import { getComponentDirectoryPath, showVersion, getLibraryBased, addDebugLog, getPegaServerConfig, updateServerConfigRuleSetAndVersion, checkLibraryAndArchives, getConfigDevBuild, checkAccessTokenExpiration, checkJWTExpiration, getConfigDefaults } from '../../util.js';
+import { getComponentDirectoryPath, getPegaServerConfig, showVersion, getLibraryBased, addDebugLog, updateServerConfigRuleSetAndVersion, checkLibraryAndArchives, getConfigDevBuild, checkAccessTokenExpiration, checkJWTExpiration, getConfigDefaults, getLibraryBasedCL } from '../../util.js';
 
 import { getPublishComponentQuestions, publishComponentToServer, zipComponent } from './helper.js';
 import { default as buildLibrary } from '../build-lib/index.js';
@@ -21,11 +21,15 @@ export default async options => {
   await showVersion();
   await checkLibraryAndArchives();
   const isLibraryBased = getLibraryBased();
+  const isLibraryBasedCL = getLibraryBasedCL();
 
 addDebugLog("publish", "", "+");
 
   await checkAccessTokenExpiration();
 
+  //
+  // library based V2 publishing
+  //
   if (isLibraryBased) {
 
     await checkJWTExpiration();
@@ -38,6 +42,10 @@ addDebugLog("publish", "", "+");
     const currentOrgLib = orgLib.currentOrgLib;
     // const currentVersion = devBuild ? `${orgLib.version}-dev`: orgLib.version;
     const currentVersion = orgLib.buildVersion;
+    const serverConfg = await getPegaServerConfig();
+
+    console.log();
+    console.log(`Publishing to server: ${chalk.green.bold(`${serverConfg.server}`)}`);
 
     const publishThisVersion = await inquirer.prompt([
       {
@@ -79,7 +87,7 @@ addDebugLog("publish", "", "+");
       }
     }
 
-    if (okToPublish && !devBuild) {
+    if (okToPublish && !devBuild && !isLibraryBasedCL) {
       okToPublish = false;
       console.log("");
       const publishAnswers = await inquirer.prompt([
@@ -106,9 +114,15 @@ addDebugLog("publish", "", "+");
 
     }
 
+    // end of V2 publishing
     return true;
   }
 
+  // otherwise continue with original V1 publishig of individual components
+
+  //
+  // orginial V1 publish
+  //
 
   let OauthData;
   try {

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,257 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import fetch from 'node-fetch';
+import { join } from 'path';
+import fs from 'fs';
+
+
+import { zipUnArchiveToTempAndReturnBuffer, constructCompleteUrl, getHttpsAgent, getPegaServerConfig, addDebugLog, getConfigDefaults, zipVersionAndArchiveAndReturnBuffer } from '../../util.js';
+
+import { getPublishComponentQuestions } from './helper.js';
+
+import {
+  LP_PUBLISH_COMPONENT_SERVICE_REST_ENDPOINT,
+  PUBLISH_COMPONENT_ARCHIVE_SERVICE_REST_ENDPOINT,
+  TEMP_PATH,
+  TOKEN_PATH,
+  ARCHIVES_PATH
+} from '../../constants.js';
+
+
+export const publishComponentLibraryArchiveToServer = async (data, doFetch) => {
+  addDebugLog("publishComponentToServer", `data: ${data}`, "");
+    const { zipContent, 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;
+
+    if (isLaunchpad) {
+      // currently no launchpad records to rule resolve a library
+
+      // apiBody = {
+      //   type: 'CustomComponent',
+      //   zipContent,
+      //   componentName: JSON.parse(configContent).componentKey,
+      //   pxUpdateDateTime: '',
+      //   environmentID: defaultPegaServerConfig.isolationId
+      // };
+    } else {
+      apiBody = {
+        zipContent,
+        publishFor: 'constellation',
+        rulesetName,
+        rulesetVersion,
+        libraryName,
+        version,
+        category: ''
+      };
+    }
+
+    const defaultPegaConfig = await getPegaServerConfig();
+    const url = constructCompleteUrl(
+      defaultPegaConfig.server,
+      isLaunchpad ? launchpadRestEndpoint : PUBLISH_COMPONENT_ARCHIVE_SERVICE_REST_ENDPOINT
+    );
+
+    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}`;
+          }
+
+          const response = await fetch(url, {
+            method: 'POST',
+            agent: getHttpsAgent(defaultPegaConfig),
+            headers,
+            body: JSON.stringify(apiBody)
+          });
+
+          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) {
+              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;
+
+  let content = {
+    libraryName : orgLibName,
+    version : selectedVersion,
+    rulesetName, rulesetVersion
+  };
+
+
+  if (orgLibName === configDef.currentOrgLib && selectedVersion === configDef.buildVersion) {
+
+    console.log("\nYou've selected the current working library/version.");
+    console.log("Export store or the current.");
+    const archAnswers = await inquirer.prompt([
+      {
+        name: 'currentOrStore',
+        type: 'rawlist',
+        message: 'Select current or store',
+        default: "Current",
+        choices: ["Current", "Store"]
+      },
+    ]);
+
+    const currentOrStore = archAnswers.currentOrStore;
+
+    if (currentOrStore === "Current") {
+      archiveBeforeStore = true;
+    }
+
+    if (archiveBeforeStore) {
+
+      // returns both the output promise and the buffer that can be sent to PegaInfinity
+      let zipBuffer = await zipVersionAndArchiveAndReturnBuffer(configDef.currentOrgLib, configDef.buildVersion);
+
+      zipBuffer.output.on('close', function() {
+        if (zipBuffer.zipContent != null) {
+          content = { ...content, zipContent: zipBuffer.zipContent};
+
+          try {
+            publishComponentLibraryArchiveToServer(content, 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()));
+          }
+
+        }
+
+      });
+
+      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
+
+    const mainDirectory = process.cwd();
+    const archiveFileName = `${orgLibName}_${selectedVersion}.arch.zip`;
+    const archiveDirectory = join (mainDirectory, ARCHIVES_PATH, `${orgLibName}`, `${selectedVersion}`);
+    if (fs.existsSync(archiveDirectory)) {
+      const archiveFile = join(archiveDirectory, archiveFileName);
+
+      // 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, 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()));
+          }
+
+
+
+        }
+
+      });
+
+    }
+
+
+  }
+};