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

package/src/tasks/delete-pub/helper.js

@@ -1,5 +1,15 @@
+import fs from 'fs';
 import chalk from 'chalk';
-import { getPegaServerConfig, addDebugLog } from '../../util.js';
+import fetch from 'node-fetch';
+
+import {
+  getPegaServerConfig,
+  addDebugLog,
+  getApplicationAndVersionFromToken,
+  constructCompleteUrl,
+  getHttpsAgent,
+  validateRulesetVersion } from '../../util.js';
+import { LIST_COMPONENT_LIBRARIES_SERVICE_REST_ENDPOINT, TOKEN_PATH } from '../../constants.js';
 
 export const SOURCE_OF_COMPONENT_TYPES = {
   SERVER: 'Server',
@@ -33,3 +43,134 @@ addDebugLog("getLibraryVersionQuestion", `libraryName: ${libraryName}`, "");
     }
   ];
 };
+
+export const getRulesetAndVersionQuestion = async (serverConfig) => {
+  return [
+    {
+      name: 'rulesetName',
+      message: 'Enter ruleset name',
+      default: serverConfig.rulesetName,
+      validate: value => {
+        if (value.trim()) {
+          return true;
+        }
+        return 'Ruleset name cannot be empty';
+      },
+      when: () => {
+        return serverConfig.serverType === 'infinity';
+      }
+    },
+    {
+      name: 'rulesetVersion',
+      message: 'Enter ruleset version',
+      default: serverConfig.rulesetVersion,
+      validate: value => {
+        if (validateRulesetVersion(value)) {
+          return true;
+        }
+        return 'Please provide compatible version e.g 01-01-01';
+      },
+      when: () => {
+        return serverConfig.serverType === 'infinity';
+      }
+    }
+  ];
+
+};
+
+
+async function fetchComponenLibrariessFromInfinity(apiUrl, headers) {
+addDebugLog("fetchComponenLibrariessFromInfinity", `apiUrl: ${apiUrl}`, "");
+  const serverConfig = await getPegaServerConfig();
+  return new Promise((resolve, reject) => {
+    let status = 500;
+    fetch(apiUrl, {
+      method: 'GET',
+      agent: getHttpsAgent(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}`);
+        }
+      })
+      // eslint-disable-next-line prefer-promise-reject-errors
+      .catch((e) => reject(`${chalk.bold.red(e)}`));
+  });
+}
+
+export const getInfinityLibraries = async(rulesetName, rulesetVersion) => {
+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;
+
+
+  // inquire
+
+  let urlParams = `/app-name/${ApplicationName}/app-version/${ApplicationVersion}/rulesetname/${rulesetName}/rulesetversion/${rulesetVersion}`;
+  //let urlParams = `&ApplicationName=${ApplicationName}&ApplicationVersion=${ApplicationVersion}&RulesetName=${rulesetName}&RulesetVersion=${rulesetVersion}`;
+  //urlParams = encodeURIComponent(urlParams);
+
+
+  url = url.concat(urlParams);
+
+  return new Promise((resolve, reject) => {
+    try {
+      fs.readFile(TOKEN_PATH, 'utf8', (err, data) => {
+        if (err) {
+          // eslint-disable-next-line prefer-promise-reject-errors
+          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}`;
+
+          fetchComponenLibrariessFromInfinity(url, headers)
+            .then((response) => resolve(response))
+            .catch((e) => reject(e));
+
+        }
+      });
+    } catch (error) {
+      console.log(`\n${chalk.bold.red(error)}`);
+      // eslint-disable-next-line prefer-promise-reject-errors
+      reject(`${chalk.bold.red(error)}`);
+    }
+  });
+
+}

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

@@ -1,11 +1,12 @@
 import inquirer from 'inquirer';
+import ora from 'ora';
 
 import chalk from 'chalk';
 
-import { showVersion, getC11NB2STokenAndStaticServer, getLocalLibraryVersions, getLibraryBased, deleteLocalLibrary, deleteLocalLibraryVersion, addDebugLog, getConfigDefaults } from '../../util.js';
+import { showVersion, getC11NB2STokenAndStaticServer, getLocalLibraryVersions, getLibraryBased, deleteLocalLibrary, deleteLocalLibraryVersion, addDebugLog, getConfigDefaults, getLibraryBasedCL, getPegaServerConfig, deleteInfinityServerComponentLibrary, checkAccessTokenExpiration } from '../../util.js';
 import { deleteLib } from '@pega/constellation-dx-components-build-utils/index.js';
 
-import { getDeleteLibraryQuestions, getLibraryVersionQuestion, SOURCE_OF_COMPONENT_TYPES } from './helper.js';
+import { getDeleteLibraryQuestions, getLibraryVersionQuestion, getRulesetAndVersionQuestion, SOURCE_OF_COMPONENT_TYPES, getInfinityLibraries } from './helper.js';
 
 
 
@@ -85,17 +86,81 @@ addDebugLog("deletePublished", "END", "-");
   }
   else {
     // server
-    const tokenAndStaticServer = await getC11NB2STokenAndStaticServer();
 
-    if (tokenAndStaticServer.C11NB2S === undefined) {
-      console.log(chalk.redBright("Need to authenticate, missing services token.\nDeleting a library requires authentication to acquire a token to delete."));
-addDebugLog("deletePublished", "END", "-");
-      process.exit(1);
+    await checkAccessTokenExpiration();
+
+    const isLibraryBasedCL =  getLibraryBasedCL();
+
+    if (isLibraryBasedCL) {
+
+      const serverConfg = await getPegaServerConfig();
+
+      console.log();
+      console.log(`Current server: ${chalk.green.bold(`${serverConfg.server}`)}`);
+
+      const questions = await getRulesetAndVersionQuestion(serverConfg);
+      const answers = await inquirer.prompt(questions);
+      const { rulesetName, rulesetVersion } = answers;
+
+      const arLibs = await getInfinityLibraries(rulesetName, rulesetVersion);
+
+      if (arLibs && arLibs.pxResults && arLibs.pxResults.length > 0) {
+
+        const libs = arLibs.pxResults.map((oLib, index) => ({ name: oLib.pyLabel, value: oLib.pyRuleName}));
+
+        const libAnswers = await inquirer.prompt([
+          {
+            name: 'library',
+            type: 'rawlist',
+            message: 'Pick component library to delete',
+            choices: libs
+          }
+        ]);
+
+        const libraryName = libAnswers.library;
+        // let spinner;
+
+
+          try {
+            await deleteInfinityServerComponentLibrary(libraryName, rulesetName, rulesetVersion);
+          }
+          catch (err) {
+            let sErr = err.toString();
+            sErr = sErr.replaceAll("Error: ", "");
+            console.log(chalk.redBright.bold("Error: " + sErr));
+          }
+
+          // spinner.stop();
+
+
+
+      }
+      else {
+        // No library with that name
+        const serverConfig = await getPegaServerConfig();
+        console.log(chalk.redBright(`No server component libraries exist in given ruleset ${chalk.bold(`${rulesetName}:${rulesetVersion}`)}`));
+  addDebugLog("listPublished", "END", "-");
+        process.exit(1);
+
+      }
+
     }
+    else {
+      // ap static server
+      const tokenAndStaticServer = await getC11NB2STokenAndStaticServer();
+
+      if (tokenAndStaticServer.C11NB2S === undefined) {
+        console.log(chalk.redBright("Need to authenticate, missing services token.\nDeleting a library requires authentication to acquire a token to delete."));
+  addDebugLog("deletePublished", "END", "-");
+        process.exit(1);
+      }
+
+  addDebugLog("deleteLib", "services call", "");
+      await deleteLib(tokenAndStaticServer.C11NB2S, tokenAndStaticServer.appStaticContentServer);
+  addDebugLog("deleteLib", "services end", "");
+    }
+
 
-addDebugLog("deleteLib", "services call", "");
-    await deleteLib(tokenAndStaticServer.C11NB2S, tokenAndStaticServer.appStaticContentServer);
-addDebugLog("deleteLib", "services end", "");
   }
 
 

package/src/tasks/delete-version/index.js

@@ -1,9 +1,9 @@
-import inquirer from 'inquirer';
 import chalk from 'chalk';
 
 import {
   showVersion,
   getLibraryBased,
+  getLibraryBasedCL,
   checkLibraryAndArchives,
   getConfigDefaults,
   addDebugLog,
@@ -18,6 +18,7 @@ import { deleteLibraryVersion } from '../delete-lib/index.js';
 
 export default async (options) => {
   const isLibraryBased = getLibraryBased();
+  const isLibraryBasedCL = getLibraryBasedCL();
   const useInputConfig = getUseInputConfig();
 
   if (!isLibraryBased) {
@@ -42,7 +43,12 @@ addDebugLog("deleteVersion", "", "+");
     const inputConfig = await getInputConfigForCommand("deleteLibVersion");
     version = inputConfig.libraryVersion;
     const isPermanent = inputConfig.isPermanent;
-    const permBuild = convertYNToBoolean(isPermanent);
+    let permBuild = convertYNToBoolean(isPermanent);
+
+    if (isLibraryBasedCL) {
+      // no -dev for PegaInfinity
+      permBuild = true;
+    }
 
     if (!permBuild && version != "ALL") {
       version = version.concat("-dev");

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

@@ -1,7 +1,13 @@
 import chalk from 'chalk';
 import path from 'path';
 import { join } from 'path';
-import { addDebugLog, getConfigDefaults, getLibraryArchiveDirectories, getLibraryArchivesVersions, setConfigExportRelativePath, forceDefaultsUpdate } from '../../util.js';
+import {
+  addDebugLog,
+  getConfigDefaults,
+  getLibraryArchiveDirectories,
+  getLibraryArchivesVersions,
+  setConfigExportRelativePath,
+  forceDefaultsUpdate } from '../../util.js';
 
 export const SOURCE_OF_COMPONENT_TYPES = {
   SERVER: 'Server',
@@ -25,16 +31,40 @@ addDebugLog("getFilePathQuestions", "", "");
   const currentDirectory = process.cwd();
   const arPathParts = currentDirectory.split(path.sep);
   let defaultPath = join(arPathParts[0], arPathParts[1], arPathParts[2], configDef.exportRelativePath);
+  let startDirectory = join(arPathParts[0], arPathParts[1], arPathParts[2]);
+
   if (path.sep === "/") {
     defaultPath = "/".concat(defaultPath);
+    startDirectory = "/".concat(startDirectory).concat("/");
   }
 
-
   return [
     {
       name: 'filePath',
+      type: 'fuzzypath',
       message: 'Enter full file path of directory to export zip file:',
-      default: defaultPath
+      default: defaultPath,
+      excludePath: nodePath => nodePath.startsWith('node_modules'),
+        // excludePath :: (String) -> Bool
+        // excludePath to exclude some paths from the file-system scan
+      excludeFilter: nodePath => nodePath.indexOf('/.') >= 0,
+        // excludeFilter :: (String) -> Bool
+        // excludeFilter to exclude some paths from the final list, e.g. '.'
+      itemType: 'directory',
+        // itemType :: 'any' | 'directory' | 'file'
+        // specify the type of nodes to display
+        // default value: 'any'
+        // example: itemType: 'file' - hides directories from the item list
+      rootPath: startDirectory,
+        // rootPath :: String
+        // Root search directory
+      suggestOnly: false,
+        // suggestOnly :: Bool
+        // Restrict prompt answer to available choices or use them as suggestions
+      depthLimit: 2,
+        // depthLimit :: integer >= 0
+        // Limit the depth of sub-folders to scan
+        // Defaults to infinite depth if undefined
     }
   ];
 };
@@ -86,6 +116,20 @@ addDebugLog("getLibraryVersionQuestion", "", "");
   ];
 };
 
+export const getServerOrDirectoryQuestion = async () => {
+addDebugLog("getLibraryVersionQuestion", "", "");
+
+    return [
+    {
+      name: 'exportTo',
+      type: 'rawlist',
+      message: `Export to`,
+      choices:  [{name: 'Local directory', value: 'Directory'}, {name: 'Server', value: 'Server'}],
+      default: 'Directory'
+    }
+  ];
+};
+
 export const getFullArchiveQuestions = async () => {
 
   return [

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

@@ -1,7 +1,6 @@
 import fs from 'fs';
 import { promisify } from 'util';
 import { join } from 'path';
-import path from 'path';
 
 import inquirer from 'inquirer';
 import ncp from 'ncp';
@@ -14,13 +13,18 @@ import {
   checkLibraryAndArchives,
   getConfigDefaults,
   getLibraryBased,
+  getLibraryBasedCL,
   zipVersionAndArchive,
   zipVersionAndArchiveCL,
-  cleanUpTemp
+  cleanUpTemp,
+  checkAccessTokenExpiration
  } from '../../util.js';
 import { TASKS_CONFIG_JSON_FILENAME, ARCHIVES_PATH, BIN_ARCHIVES_PATH } from '../../constants.js';
-import { getFilePathQuestions, getLibraryQuestion, getLibraryVersionQuestion, updateSavedExportFilePath, getFullArchiveQuestions  } from './helper.js';
+import { getFilePathQuestions, getLibraryQuestion, getLibraryVersionQuestion, updateSavedExportFilePath, getServerOrDirectoryQuestion  } from './helper.js';
 import { localBuildLibrary } from '../build-lib/index.js';
+import publishArchive from '../publish-archive/index.js';
+
+import inquirerFuzzyPath from '@pega/inquirer-fuzzy-path';
 
 export const DXCB_CONFIG_INTERNAL_JSON_FILENAME = 'src/dxcb.config.json';
 const currentDirectory = process.cwd();
@@ -138,8 +142,6 @@ addDebugLog("exportCLArch", `exportPath: ${exportPath}, orgLibName: ${orgLibName
         }
       }
 
-
-
       // archive it
       output = await zipVersionAndArchiveCL(configDef.currentOrgLib, configDef.buildVersion);
 
@@ -158,9 +160,6 @@ addDebugLog("exportCLArch", `exportPath: ${exportPath}, orgLibName: ${orgLibName
 
 
 
-
-
-
 }
 
 
@@ -168,7 +167,7 @@ export const exportArch = async(exportPath, orgLibName, selectedVersion, fullArc
 addDebugLog("exportArch", `exportPath: ${exportPath}, orgLibName: ${orgLibName}, selectedVersion: ${selectedVersion}`, "");
   const currentDirectory = process.cwd();
   const archiveDirectory = join (currentDirectory, ARCHIVES_PATH, `${orgLibName}`, `${selectedVersion}`);
-  const fileName = `${orgLibName}_${selectedVersion}.zip`;
+  const fileName = `${orgLibName}_${selectedVersion}.arch.zip`;
   const archFileName = join(archiveDirectory, fileName);
   const configDef = await getConfigDefaults();
 
@@ -186,27 +185,9 @@ addDebugLog("exportArch", `exportPath: ${exportPath}, orgLibName: ${orgLibName},
 
   if (orgLibName === configDef.currentOrgLib && selectedVersion === configDef.buildVersion) {
 
-    let currentOrStore = currentOrArchive;
-    if (currentOrArchive === "") {
-      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"]
-        },
-      ]);
-
-      currentOrStore = archAnswers.currentOrStore;
+    // We are just going to archive before store and not ask
+    archiveBeforeStore = true;
 
-    }
-
-    if (currentOrStore === "Current") {
-      archiveBeforeStore = true;
-    }
   }
 
   if (!fs.existsSync(exportPath)) {
@@ -251,6 +232,8 @@ addDebugLog("exportArch", `exportPath: ${exportPath}, orgLibName: ${orgLibName},
 
 
   if (archiveBeforeStore) {
+
+
     // archive it
     output = await zipVersionAndArchive(configDef.currentOrgLib, configDef.buildVersion);
 
@@ -291,22 +274,26 @@ export default async options => {
   await checkLibraryAndArchives();
 
   await checkPathAccess(pegaConfigJsonPath);
+
   const isLibraryBased = getLibraryBased();
   if (!isLibraryBased) {
     console.log(`Command only supported for ${chalk.bold.green('library mode')} components.`)
     process.exit();
   }
+  const isLibraryBasedCL = getLibraryBasedCL();
 
   await cleanUpTemp();
 
   addDebugLog("exportArchive", "", "+");
 
+  let exportTo = "";
 
   if (options.params.length >= 8) {
     let fullArchive = options.params[3];
     const libraryName = options.params[4];
     const libraryVersion = options.params[5];
     const filePath = options.params[6];
+    exportTo = "Directory";
 
 
     const currentOrArchive = options.params[7];
@@ -319,6 +306,7 @@ export default async options => {
     let selectedVersion = "";
     let fullArchive = "";
 
+
     if (options.params.length >= 5) {
       fullArchive = options.params[3];
       orgLibName = options.params[4];
@@ -327,11 +315,13 @@ export default async options => {
       }
     }
 
-    if (fullArchive === "" ) {
-      const fullArchiveQuestions = await getFullArchiveQuestions();
-      const fullArchiveAnswers = await inquirer.prompt(fullArchiveQuestions);
-      ({ fullArchive } = fullArchiveAnswers);
-    }
+    // diable question to build "CL"
+    // if (fullArchive === "" ) {
+    //   const fullArchiveQuestions = await getFullArchiveQuestions();
+    //   const fullArchiveAnswers = await inquirer.prompt(fullArchiveQuestions);
+    //   ({ fullArchive } = fullArchiveAnswers);
+    // }
+    fullArchive = "Full";
 
     let filePathQuestions;
     let filePathAnswers;
@@ -340,6 +330,9 @@ export default async options => {
     // if Binary, then we need to just build the current library, get the results and
     // and export an archive as zip
     if (fullArchive === "Binary") {
+
+      inquirer.registerPrompt('fuzzypath', inquirerFuzzyPath);
+
       filePathQuestions = await getFilePathQuestions();
       filePathAnswers = await inquirer.prompt(filePathQuestions);
       ({ filePath } = filePathAnswers);
@@ -365,22 +358,55 @@ export default async options => {
         ({ selectedVersion } = libraryVersionAnswer);
       }
 
+      //  when we can export to server, un comment this out
+      if (isLibraryBasedCL) {
+        if (exportTo === "") {
+          const serverOrDirectoryQuestion = await getServerOrDirectoryQuestion();
+          const serverOrDirectoryAnswer = await inquirer.prompt(serverOrDirectoryQuestion);
+          ({ exportTo } = serverOrDirectoryAnswer);
+        }
+      }
+      else {
+        exportTo = "Directory";
+      }
 
-      filePathQuestions = await getFilePathQuestions();
-      filePathAnswers = await inquirer.prompt(filePathQuestions);
-      ({ filePath } = filePathAnswers);
+      //exportTo = "Directory"; // remove this line when above is uncommented out
+
+
+      if (exportTo === "Directory") {
+        inquirer.registerPrompt('fuzzypath', inquirerFuzzyPath);
+
+        filePathQuestions = await getFilePathQuestions();
+        filePathAnswers = await inquirer.prompt(filePathQuestions);
+        ({ filePath } = filePathAnswers);
+
+        await updateSavedExportFilePath(filePath);
+
+        // if (path.sep === "/") {
+        //   if (filePath.lastIndexOf(path.sep) != filePath.length - 1) {
+        //     filePath = filePath.concat(path.sep);
+        //   }
+        // }
+
+        await exportArch( filePath, orgLibName, selectedVersion, fullArchive);
+
+      }
+      else {
+        await checkAccessTokenExpiration();
+
+        // archive it
+        await zipVersionAndArchive(orgLibName, selectedVersion);
+
+
+        // publish to server
+        await publishArchive(orgLibName, selectedVersion);
+
+      }
 
-      await updateSavedExportFilePath(filePath);
 
     }
 
-    // if (path.sep === "/") {
-    //   if (filePath.lastIndexOf(path.sep) != filePath.length - 1) {
-    //     filePath = filePath.concat(path.sep);
-    //   }
-    // }
 
-    await exportArch( filePath, orgLibName, selectedVersion, fullArchive);
 
   }