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

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

@@ -1,10 +1,29 @@
 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';
+
 
 
 export const SOURCE_OF_COMPONENT_TYPES = {
@@ -228,6 +247,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", "", "");
@@ -240,21 +273,49 @@ addDebugLog("getFilePathQuestions", "", "");
     console.log("\tWindows:\tC:\\Users\\name\\...\n");
   }
 
+  // console.log(chalk.yellow("[Press arrows to search, press <tab> to select, press <enter> to return (after selecting via tab).]"));
+  console.log(chalk.yellow("[Manual typing, give search time to find paths]\n"));
+
   const configDef = getConfigDefaults();
 
   const currentDirectory = process.cwd();
   const arPathParts = currentDirectory.split(path.sep);
   let defaultPath = join(arPathParts[0], arPathParts[1], arPathParts[2], configDef.importRelativePath);
+  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 zip file location:',
-      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
     }
   ];
 };
@@ -275,7 +336,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]);
 
@@ -316,3 +376,188 @@ 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}`;
+
+      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)}`);
+        }
+      });
+
+    }