@pega/custom-dx-components 0.25.18 → 0.25.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pega/custom-dx-components",
-  "version": "0.25.18",
+  "version": "0.25.20",
   "description": "Utility for building custom UI components",
   "bin": "./bin/index.js",
   "scripts": {

package/src/cli.js

@@ -32,6 +32,7 @@ import {
   moveComponent,
   renameLibrary,
   restoreConfig,
+  restore,
   revertWebPack,
   promoteWebPack,
   showStatus,
@@ -63,6 +64,7 @@ const TASKS = {
   RENAME: 'rename',
   RENAME_LIB: 'renameLibrary',
   RESTORE_CONFIG: 'restoreConfig',
+  RESTORE_LIB: 'restore',
   QUARANTINE: 'quarantine',
   MOVE: 'moveComponent',
   LIST: 'list',
@@ -170,6 +172,10 @@ export default async (args = []) => {
       restoreConfig(options);
       break;
     }
+    case TASKS.RESTORE_LIB: {
+      restore(options);
+      break;
+    }
     case TASKS.QUARANTINE: {
       quarantine(options);
       break;

package/src/constants.js

@@ -40,9 +40,11 @@ export const LP_DELETE_COMPONENT_SERVICE_REST_ENDPOINT =
   'pegalaunchpad/c11n/isolations/{isolationId}/v102/assetsUpdate';
 
 export const PUBLISH_COMPONENT_LIBRARY_SERVICE_REST_ENDPOINT = 'PRRestService/dev/v1/publish_component_library';
-export const PUBLISH_COMPONENT_ARCHIVE_SERVICE_REST_ENDPOINT = 'PRRestService/dev/v1/publish_component_archive';
+export const PUBLISH_COMPONENT_LIBRARY_ARCHIVE_SERVICE_REST_ENDPOINT = 'PRRestService/dev/v1/publish_component_library_archive';
 export const LIST_COMPONENT_LIBRARIES_SERVICE_REST_ENDPOINT = 'PRRestService/dev/v1/list_component_libraries';
+export const LIST_COMPONENT_LIBRARY_ARCHIVES_SERVICE_REST_ENDPOINT = 'PRRestService/dev/v1/list_component_library_archives';
 export const DELETE_COMPONENT_LIBRARY_SERVICE_REST_ENDPOINT = 'PRRestService/dev/v1/delete_component_library';
+export const COMPONENT_LIBRARY_ARCHIVE_SERVICE_REST_ENDPOINT = 'PRRestService/dev/v1/component_library_archive';
 
 
 export const FIELD_PATH = '/field';

package/src/tasks/build-jest-assets/index.js

@@ -5,7 +5,7 @@ import inquirer from 'inquirer';
 import { Listr } from 'listr2';
 import chalk from 'chalk';
 
-import { showVersion, getServerType, setServerType, getSubComponents, deleteLocalComponent, checkPathAccess, getComponents, getLibraryBased, setLibraryBased, forceDefaultsUpdate } from '../../util.js';
+import { showVersion, getServerType, setServerType, getSubComponents, deleteLocalComponent, checkPathAccess, getComponents, getLibraryBasedCL, setLibraryBasedCL, forceDefaultsUpdate } from '../../util.js';
 import createAll from '../create-all/index.js';
 import create from '../create/index.js';
 import createLib from '../create-lib/index.js';
@@ -220,9 +220,9 @@ export default async options => {
   if (buildAssets) {
     // get current server type
     const savedServerType = await getServerType();
-    const savedLibraryBased = getLibraryBased();
+    const savedLibraryBasedCL = getLibraryBasedCL();
 
-    await setLibraryBased(false);
+    await setLibraryBasedCL(false);
 
     // Constellation
     await setServerType("infinity");
@@ -233,7 +233,7 @@ export default async options => {
     await createJestOriginalAssets(true);
 
     // Constellation Library
-    await setLibraryBased(true);
+    await setLibraryBasedCL(true);
     await setServerType("infinity");
 
     await createJestLibraryAssets(false);
@@ -246,7 +246,7 @@ export default async options => {
 
     // restore serverType
     await setServerType(savedServerType);
-    await setLibraryBased(savedLibraryBased);
+    await setLibraryBasedCL(savedLibraryBasedCL);
 
   }
 

package/src/tasks/create-version/helper.js

@@ -80,3 +80,33 @@ addDebugLog("getCreateVersionComponentQuestions", "", "");
     },
   ];
 };
+
+
+export const getCreateVersionComponentCLQuestions = async () => {
+  addDebugLog("getCreateVersionComponentCLQuestions", "", "");
+    const componentDefaults =  getConfigDefaults();
+
+    // increment the version
+    const incrVersion = await getNextVersion();
+    console.log(`\nCurrent library: ${chalk.green(`${componentDefaults.currentOrgLib}`)}`);
+
+    return [
+      {
+        name: 'version',
+        message: 'Enter version ',
+        default: incrVersion,
+        validate: value => {
+          if (validateSemver(value)) {
+            return true;
+          }
+          return 'Please provide semver compatible version e.g 0.0.1';
+        }
+      },
+      {
+        name: 'copyExisting',
+        type: 'confirm',
+        message: 'Copy current components to new version ?',
+        default: true
+      },
+    ];
+  };

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

@@ -21,7 +21,7 @@ import {
   cleanUpTemp
 } from '../../util.js';
 
-import { getCreateVersionComponentQuestions, updateAllComponentsConfig } from './helper.js';
+import { getCreateVersionComponentQuestions, updateAllComponentsConfig, getCreateVersionComponentCLQuestions } from './helper.js';
 import { showCurrentStatus } from '../show-status/index.js';
 
 export default async options => {
@@ -65,9 +65,17 @@ addDebugLog("createVersion", "", "+");
     copyExisting = !!(copyExist === 'Y' || copyExist === 'y' || copyExist === true || copyExist === 'true');
 
   } else {
-    const questions = await getCreateVersionComponentQuestions();
-    const answers = await inquirer.prompt(questions);
-    ({ version, permBuild, copyExisting } = answers);
+    if (isLibraryBasedCL) {
+      const questions = await getCreateVersionComponentCLQuestions();
+      const answers = await inquirer.prompt(questions);
+      ({ version, copyExisting } = answers);
+    }
+    else {
+      const questions = await getCreateVersionComponentQuestions();
+      const answers = await inquirer.prompt(questions);
+      ({ version, permBuild, copyExisting } = answers);
+    }
+
   }
 
   if (isLibraryBasedCL) {

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

@@ -135,7 +135,7 @@ addDebugLog("getInfinityLibraries", '', "");
 
   // inquire
 
-  let urlParams = `/AppName/${ApplicationName}/AppVersion/${ApplicationVersion}/ruleset/${rulesetName}/rulesetVersion/${rulesetVersion}`;
+  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);
 

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

@@ -3,7 +3,7 @@ import ora from 'ora';
 
 import chalk from 'chalk';
 
-import { showVersion, getC11NB2STokenAndStaticServer, getLocalLibraryVersions, getLibraryBased, deleteLocalLibrary, deleteLocalLibraryVersion, addDebugLog, getConfigDefaults, getLibraryBasedCL, getPegaServerConfig, deleteInfinityServerComponentLibrary } 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, getRulesetAndVersionQuestion, SOURCE_OF_COMPONENT_TYPES, getInfinityLibraries } from './helper.js';
@@ -85,7 +85,12 @@ addDebugLog("deletePublished", "END", "-");
 
   }
   else {
+    // server
+
+    await checkAccessTokenExpiration();
+
     const isLibraryBasedCL =  getLibraryBasedCL();
+
     if (isLibraryBasedCL) {
 
       const serverConfg = await getPegaServerConfig();

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

@@ -111,18 +111,18 @@ 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'}],
-        defaut: 'Directory'
-      }
-    ];
-  };
+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 () => {
 

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

@@ -191,6 +191,7 @@ 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.");
@@ -212,6 +213,11 @@ addDebugLog("exportArch", `exportPath: ${exportPath}, orgLibName: ${orgLibName},
     if (currentOrStore === "Current") {
       archiveBeforeStore = true;
     }
+    */
+
+    // We are just going to archive before store and not ask
+    archiveBeforeStore = true;
+
   }
 
   if (!fs.existsSync(exportPath)) {

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

@@ -1,10 +1,11 @@
 import chalk from 'chalk';
 import fs from 'fs';
 import path from 'path';
+import fetch from 'node-fetch';
 import { join } from 'path';
 import { Listr } from 'listr2';
-import { addDebugLog, getConfigDefaults, convertIntoPascalCase, getComponents, getComponentDirectoryPath, getDirectoryFiles, setConfigImportRelativePath, forceDefaultsUpdate } from '../../util.js';
-import { TASKS_CONFIG_JSON_FILENAME, TEMP_PATH, PACKAGE_JSON_FILENAME } from '../../constants.js';
+import { addDebugLog, getHttpsAgent, getConfigDefaults, getPegaServerConfig, convertIntoPascalCase, getComponents, getComponentDirectoryPath, getDirectoryFiles, setConfigImportRelativePath, forceDefaultsUpdate, constructCompleteUrl } from '../../util.js';
+import { TASKS_CONFIG_JSON_FILENAME, TEMP_PATH, PACKAGE_JSON_FILENAME, LIST_COMPONENT_LIBRARY_ARCHIVES_SERVICE_REST_ENDPOINT, COMPONENT_LIBRARY_ARCHIVE_SERVICE_REST_ENDPOINT, TOKEN_PATH} from '../../constants.js';
 
 
 
@@ -229,6 +230,20 @@ export const updateTempArchive = async(libraryName, version, devBuild) => {
 
 }
 
+export const getServerOrDirectoryQuestion = async () => {
+addDebugLog("getLibraryVersionQuestion", "", "");
+
+    return [
+    {
+      name: 'importFrom',
+      type: 'rawlist',
+      message: `Import from`,
+      choices:  [{name: 'Local directory', value: 'Directory'}, {name: 'Server', value: 'Server'}],
+      defaut: 'Directory'
+    }
+  ];
+};
+
 
 export const getFilePathQuestions = async () => {
 addDebugLog("getFilePathQuestions", "", "");
@@ -304,7 +319,6 @@ addDebugLog("getFileNameQuestions", "", "");
 export const updateSavedFilePath = async(filePath) => {
   const currentDirectory = process.cwd();
   const arPathParts = currentDirectory.split(path.sep);
-  const configDef = getConfigDefaults();
 
   let defaultPath = join(path.sep, arPathParts[0], arPathParts[1], arPathParts[2]);
 
@@ -345,3 +359,191 @@ export const updateSavedFilePath = async(filePath) => {
   }
 
 }
+
+
+
+
+
+async function fetchComponentLibraryArchivesFromInfinity(apiUrl, headers) {
+  addDebugLog("fetchComponentLibraryArchivesFromInfinity", `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 getServerLibraryArchives = async() => {
+  addDebugLog("getServerLibraryArchives", '', "");
+
+    const defaultPegaServerConfig = await getPegaServerConfig();
+    let url = constructCompleteUrl(
+      defaultPegaServerConfig.server,
+      LIST_COMPONENT_LIBRARY_ARCHIVES_SERVICE_REST_ENDPOINT
+    );
+
+
+    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}`;
+
+            fetchComponentLibraryArchivesFromInfinity(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)}`);
+      }
+    });
+
+  }
+
+
+  export const getLibraryArchiveQuestion = async (archiveVersions) => {
+  addDebugLog("getLibraryArchiveQuestion", `archiveVersions: ${archiveVersions}`, "");
+    return [
+      {
+        name: 'archiveData',
+        type: 'rawlist',
+        message: `Select an archive`,
+        choices: archiveVersions
+      }
+    ];
+  };
+
+
+
+  async function fetchComponentLibraryArchiveFromInfinity(apiUrl, headers) {
+    addDebugLog("fetchComponentLibraryArchivesFromInfinity", `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 getServerLibraryArchive = async(appName, fileName, fileType, ruleSet, ruleSetVersion) => {
+    addDebugLog("getServerLibraryArchives", '', "");
+
+      const defaultPegaServerConfig = await getPegaServerConfig();
+      let url = constructCompleteUrl(
+        defaultPegaServerConfig.server,
+        COMPONENT_LIBRARY_ARCHIVE_SERVICE_REST_ENDPOINT
+      );
+
+      let urlParams = `/app-name/${appName}/file-name/${fileName}/file-type/${fileType}/rulesetname/${ruleSet}/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}`;
+
+              fetchComponentLibraryArchiveFromInfinity(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)}`);
+        }
+      });
+
+    }