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

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

@@ -7,28 +7,35 @@ import ncp from 'ncp';
 import chalk from 'chalk';
 import { Listr } from 'listr2';
 
+import StreamZip from 'node-stream-zip';
+
+import inquirerFuzzyPath from '@pega/inquirer-fuzzy-path';
+
 import {
   sanitize,
   checkPathAccess,
   showVersion,
   getDirectoryFiles,
   addDebugLog,
-  checkLibraryAndArchives,
+  checkAccessTokenExpiration,
   getConfigDefaults,
   getLibraryBased,
+  getLibraryBasedCL,
   unZipFromArchive,
   zipVersionAndArchive,
   getLibraryArchiveDirectories,
+  getHaveDependencyDifference,
   hasLibraryAndVersion,
   cleanUpTemp,
   hasArchives,
   restoreFromArchive,
   forceDefaultsUpdate,
   getUseInputConfig,
-  getInputConfigForCommand
+  getInputConfigForCommand,
+  getPegaServerConfig
  } from '../../util.js';
 import { TASKS_CONFIG_JSON_FILENAME, ARCHIVES_PATH, TEMP_PATH } from '../../constants.js';
-import { getFilePathQuestions, getFileNameQuestions, updateTempArchive, updateSavedFilePath  } from './helper.js';
+import { getFilePathQuestions, getFileNameQuestions, updateTempArchive, updateSavedFilePath, getServerOrDirectoryQuestion, getLibraryArchiveQuestion, getServerLibraryArchives, getServerLibraryArchive  } from './helper.js';
 import { showCurrentStatus } from '../show-status/index.js';
 
 export const DXCB_CONFIG_INTERNAL_JSON_FILENAME = 'src/dxcb.config.json';
@@ -164,11 +171,18 @@ export const getPackgeOrg = async(packagePath) => {
 }
 
 export const getLocalConfigData = async(tasksPath) => {
+  const isLibraryBasedCL = getLibraryBasedCL();
   let configData = { library: "", version: "", buildVersion: "", devBuild: false};
   const sTaskData = fs.readFileSync(tasksPath, { encoding: 'utf8' });
   const taskData = sTaskData && JSON.parse(sTaskData);
 
-  const devBuild = taskData["server-config"].devBuild;
+  let devBuild = taskData["server-config"].devBuild;
+
+  // no -dev in PegaInfinity
+  if (isLibraryBasedCL) {
+    devBuild = false;
+  }
+
   configData.library = taskData["component"].library;
   configData.version = taskData["component"].version;
   configData.devBuild = devBuild;
@@ -184,7 +198,7 @@ export const moveComp = async(componentKey, orgLibName, version, copyShared, opt
     const currentDirectory = process.cwd();
     const tempDirectory = join(currentDirectory, TEMP_PATH);
     const archiveDirectory = join (currentDirectory, ARCHIVES_PATH, `${orgLibName}`, `${version}`);
-    const fileName = `${orgLibName}_${version}.zip`;
+    const fileName = `${orgLibName}_${version}.arch.zip`;
     const archFileName = join(archiveDirectory, fileName);
 
 
@@ -221,28 +235,256 @@ export const moveComp = async(componentKey, orgLibName, version, copyShared, opt
     fs.rmSync(tempDirectory, { recursive: true, force: true, maxRetries: 2  });
 }
 
+
 export const importArch = async(filePath, fileName, hadArchive) => {
+  addDebugLog("importArch", `filePath: ${filePath}, fileName: ${fileName}`, "");
+
+    const currentDirectory = process.cwd();
+
+    const storeDirectory = join (currentDirectory, ARCHIVES_PATH);
+    if (!fs.existsSync(storeDirectory)) {
+      fs.mkdirSync(storeDirectory);
+    }
+
+    const tempDirectory = join(currentDirectory, TEMP_PATH);
+
+
+    const zipFilePath = join(filePath, fileName);
+
+
+    // we are going to use node stream zip to list contents of archive first,
+    // before we un archive to a temp directory.  If pass, then un archive
+    let passCount = 0;
+
+    // check to see if have a tasks.config.json  and package,json file, if not, archive not good
+    const tempTasksConfig = join(tempDirectory, "tasks.config.json");
+    const tempPackage = join(tempDirectory, "package.json");
+    const tasksConfig = "tasks.config.json";
+    const packageJson = "package.json";
+    try {
+      const testZip = new StreamZip.async({ file: zipFilePath});
+      const entries = await testZip.entries();
+
+      for (const entry of Object.values(entries)) {
+        if ( entry.name.indexOf(packageJson) >= 0 || entry.name.indexOf(tasksConfig) >= 0) {
+          passCount++;
+        }
+      }
+
+      // Do not forget to close the file once you're done
+      await testZip.close();
+    }
+    catch (ex) {
+      passCount = 0;
+    }
+
+
+    if (passCount < 2) {
+      console.log(chalk.red.bold(`Zip file: ${fileName} not a compatible DX Component archive.`));
+      process.exit(1);
+
+    }
+
+    await unZipFromArchive(zipFilePath);
+
+    // need to get info from tasks.config and package.json
+    // we won't rely on name of file, as owner can change it
+
+    let organization = await getPackgeOrg(tempPackage);
+    let localConfig = await getLocalConfigData(tempTasksConfig);
+
+    let libName = localConfig.library;
+    let orgLibName = `${organization}_${libName}`;
+    const version = localConfig.buildVersion;
+    const devBuild = localConfig.devBuild;
+
+    const configDef = getConfigDefaults();
+
+    if (organization !== configDef.organization) {
+      console.log(`\nImported ${chalk.yellow(`${orgLibName}/${version}`)} is not the same organization as your current organization: ${chalk.yellow(`${configDef.organization}`)}.`);
+      console.log(`\nTo import, the organization of the components will be changed to match your organization.`);
+      console.log(`\n\t>>> If you don't want this to happen, then end and create a new project with an organization`);
+      console.log(`\t    of ${chalk.yellow(`${organization}`)} and import there.\n`);
+
+      const proceedAnswers = await inquirer.prompt([
+
+        {
+          name: 'okToContinue',
+          type: 'confirm',
+          message: `Ok to proceed ?`,
+          default: true
+        }
+      ]);
+
+      if (proceedAnswers.okToContinue) {
+        // check if new version matches existing
+        // -dev is already on version, if present, so "false", for devBuild here
+        const alreadyExists = await hasLibraryAndVersion(libName, version, false);
+        if (alreadyExists) {
+          console.log(`${chalk.yellow(`${configDef.organization}_${libName}/${version}`)} already exists.`);
+          const archDirectories = await getLibraryArchiveDirectories();
+          const newLibNameAnswers = await inquirer.prompt([
+            {
+              name: 'libraryName',
+              message: 'Enter new libray name',
+              validate: value => {
+                /* value should not be empty
+                It should not have spaces
+                It should not start with a number
+                Only case-insensitive alphanumeric values are allowed
+              */
+                if (value && !/^\d/.test(value) && value === sanitize(value)) {
+                  if (archDirectories && archDirectories.length > 0) {
+                    const newOrgLib = `${configDef.organization}_${value}`;
+                    if (archDirectories.includes(newOrgLib)) {
+                      return `Library ${value} already exists.`;
+                    }
+                    else {
+                      return true;
+                    }
+                  }
+                  else {
+                    return true;
+                  }
+
+                }
+                else {
+                  return 'Only alphanumeric values are allowed, starting with alphabets, no spaces.';
+                }
+              }
+            }
+          ]);
+
+          libName = newLibNameAnswers.libraryName;
+        }
+
+        // rename orgLibName
+        orgLibName = `${configDef.organization}_${libName}`;
+
+        // update temp with new info
+        await updateTempArchive(libName, version, devBuild);
+
+      }
+      else {
+        process.exit();
+      }
+
+
+    }
+
+    // rearchive temp directory
+    await zipVersionAndArchive(orgLibName, version, tempDirectory);
+
+    // delete temp directory
+    fs.rmSync(tempDirectory, { recursive: true, force: true, maxRetries: 2  });
+
+
+    if (hadArchive) {
+      console.log(`\n${chalk.green(`${fileName}`)} has been imported!`);
+      console.log(`You can switch to ${chalk.green(`${orgLibName}/${version}`)} via npm run switchLib.`);
+      console.log("");
+    }
+    else {
+      const switchToFileName = `${orgLibName}_${version}.arch.zip`;
+
+      const tasks = new Listr(
+        [
+          {
+            title: `Restoring ${orgLibName}/${version}`,
+            task: async () => {
+              await restoreFromArchive(switchToFileName, orgLibName, version);
+            }
+          }
+        ],
+        { concurrent: false, exitOnError: true }
+      );
+
+      console.log(`\n${chalk.green(`${fileName}`)} has been imported!`);
+
+      await tasks.run().catch(err => {
+        console.log(chalk.bold.red(err.toString()));
+        process.exit(1);
+      });
+
+      console.log(`${chalk.bold.green(`\nSwitched to ${orgLibName}/${version}!\n`)}`);
+
+      await forceDefaultsUpdate();
+      await showCurrentStatus();
+
+      if (getHaveDependencyDifference()) {
+        console.log('\n***************************************************************');
+        console.log(chalk.bold.yellow('Dependencies have changed between versions, recommend updating.'));
+        console.log(`>>> PLEASE run ${chalk.bold.yellow("'npm update'")}.`);
+        console.log('***************************************************************\n');
+      }
+
+    }
+
+
+  }
+
+export const importArchServer = async(filePath, fileName, hadArchive) => {
 addDebugLog("importArch", `filePath: ${filePath}, fileName: ${fileName}`, "");
 
   const currentDirectory = process.cwd();
+  const storeDirectory = join (currentDirectory, ARCHIVES_PATH);
+  if (!fs.existsSync(storeDirectory)) {
+    fs.mkdirSync(storeDirectory);
+  }
+
   const tempDirectory = join(currentDirectory, TEMP_PATH);
+
   const zipFilePath = join(filePath, fileName);
 
-  await unZipFromArchive(zipFilePath);
+  // we are going to use node stream zip to list contents of archive first,
+  // before we un archive to a temp directory.  If pass, then un archive
+  let passCount = 0;
 
-  // check to see if have a tasks.config.json file, if not, archive not good
+  // check to see if have a tasks.config.json  and package,json file, if not, archive not good
   const tempTasksConfig = join(tempDirectory, "tasks.config.json");
   const tempPackage = join(tempDirectory, "package.json");
+  const tasksConfig = "tasks.config.json";
+  const packageJson = "package.json";
+  let testZip;
+  try {
+    testZip = new StreamZip.async({ file: zipFilePath});
+    const entries = await testZip.entries();
+
+    for (const entry of Object.values(entries)) {
+      if ( entry.name.indexOf(packageJson) >= 0 || entry.name.indexOf(tasksConfig) >= 0) {
+        passCount++;
+      }
+    }
+
+  }
+  catch (ex) {
+    passCount = 0;
+  }
 
-  if (!fs.existsSync(tempTasksConfig) || !fs.existsSync(tempPackage)) {
+  if (passCount < 2) {
     console.log(chalk.red.bold(`Zip file: ${fileName} not a compatible DX Component archive.`));
-    console.log(chalk.red.bold("Cleaning up..."));
-    fs.rmSync(tempDirectory, { recursive: true, force: true, maxRetries: 5  });
-    console.log(chalk.red.bold("Done."));
+    // Do not forget to close the file once you're done
+    await testZip.close();
+
     process.exit(1);
 
   }
 
+  // make directory in temp dir, can NOT be the same directory as the zip file is in
+  const dirName = fileName.replaceAll(".zip", "");
+  const newDirPath = join(TEMP_PATH, dirName);
+  fs.mkdirSync(newDirPath);
+
+  const count = await testZip.extract(null, newDirPath);
+
+  // Do not forget to close the file once you're done
+  await testZip.close();
+
+  // we want file contents to be in the TEMP_PATH (copying, but temp directory eventually will be deleted)
+  fs.cpSync(newDirPath, TEMP_PATH, {recursive: true});
+
+  // await unZipFromArchive(zipFilePath);
+
   // need to get info from tasks.config and package.json
   // we won't rely on name of file, as owner can change it
 
@@ -337,10 +579,11 @@ addDebugLog("importArch", `filePath: ${filePath}, fileName: ${fileName}`, "");
 
   if (hadArchive) {
     console.log(`\n${chalk.green(`${fileName}`)} has been imported!`);
-    console.log(`You can switch to ${chalk.green(`${orgLibName}/${version}`)} via npm run switchLib.\n`);
+    console.log(`You can switch to ${chalk.green(`${orgLibName}/${version}`)} via npm run switchLib.`);
+    console.log("");
   }
   else {
-    const switchToFileName = `${orgLibName}_${version}.zip`;
+    const switchToFileName = `${orgLibName}_${version}.arch.zip`;
 
     const tasks = new Listr(
       [
@@ -366,10 +609,13 @@ addDebugLog("importArch", `filePath: ${filePath}, fileName: ${fileName}`, "");
     await forceDefaultsUpdate();
     await showCurrentStatus();
 
-    console.log('\n***************************************************************');
-    console.log(chalk.bold.yellow('Dependencies have changed between versions, recommend updating.'));
-    console.log(`>>> PLEASE run ${chalk.bold.yellow("'npm update'")}.`);
-    console.log('***************************************************************\n');
+    if (getHaveDependencyDifference()) {
+      console.log('\n***************************************************************');
+      console.log(chalk.bold.yellow('Dependencies have changed between versions, recommend updating.'));
+      console.log(`>>> PLEASE run ${chalk.bold.yellow("'npm update'")}.`);
+      console.log('***************************************************************\n');
+    }
+
   }
 
 
@@ -391,12 +637,41 @@ export const getZipFileList = async(filePath) => {
   }
 }
 
+function decodeBase64(encodedString) {
+  try {
+    const decodedString = atob(encodedString);
+    return decodedString;
+  } catch (error) {
+    console.error("Error decoding base64 string:", error);
+    return null;
+  }
+}
+
+export const writeZipBuffer = async(fileName, fileBuffer) => {
+  const currentDirectory = process.cwd();
+  const tempDirectory = join(currentDirectory, TEMP_PATH);
+
+  const storeDirectory = join (currentDirectory, ARCHIVES_PATH);
+  if (!fs.existsSync(storeDirectory)) {
+    fs.mkdirSync(storeDirectory);
+  }
+
+  if (!fs.existsSync (tempDirectory)) {
+    fs.mkdirSync(tempDirectory);
+  }
+
+  const filePath = join(tempDirectory, fileName);
+  fs.writeFileSync(filePath, fileBuffer, 'base64');
+
+}
+
 export default async options => {
   await showVersion();
   // await checkLibraryAndArchives();
 
   await checkPathAccess(pegaConfigJsonPath);
   const isLibraryBased = getLibraryBased();
+  const isLibraryBasedCL = getLibraryBasedCL();
   const useInputConfig = getUseInputConfig();
 
   if (!isLibraryBased) {
@@ -411,47 +686,208 @@ export default async options => {
   addDebugLog("importArchive", "", "+");
 
 
-  if (options.params.length >= 5) {
-    const filePath = options.params[3];
-    const fileName = options.params[4];
+  if (options.params.length >= 6) {
+    const localOrServer = options.params[3];
+    const filePath = options.params[4];
+    const fileName = options.params[5];
+
     await importArch( filePath, fileName, hasArch);
 
   }
   else {
 
-    let filePath;
-    let fileName;
-
     if (useInputConfig) {
       const inputConfig = await getInputConfigForCommand("importLibVersion");
-      filePath = inputConfig.fileLocation;
-      fileName = inputConfig.fileName;
+      const filePath = inputConfig.fileLocation;
+      const fileName = inputConfig.fileName;
+
+
+      console.log("");
+
+      const tasks = new Listr(
+        [
+          {
+            title: `Importing archive`,
+            task: async () => {
+              await importArch( filePath, fileName, hasArch);
+            }
+          }
+        ],
+        { concurrent: false, exitOnError: true }
+      );
+
+
+      await tasks.run().catch(err => {
+        console.log(chalk.bold.red(err.toString()));
+        process.exit(1);
+      });
+
+      console.log("");
+
+      // reapply to save if changed, because imported task.config may have overriden and we want
+      // to keep what was entered as the latest
+      await updateSavedFilePath(filePath);
 
     }
     else {
-      const filePathQuestions = await getFilePathQuestions();
-      const filePathAnswers = await inquirer.prompt(filePathQuestions);
-      ({ filePath } = filePathAnswers);
-      const zipFileList = await getZipFileList(filePath);
+      inquirer.registerPrompt('fuzzypath', inquirerFuzzyPath);
 
-      if (!zipFileList || zipFileList.length === 0) {
-        console.log(chalk.red.bold(`No zip files exist at path: ${filePath}`));
-        process.exit();
+      let importFrom = "Directory";
+
+      if (isLibraryBasedCL) {
+        const localOrServerQuestion = await getServerOrDirectoryQuestion();
+        const localOrServerAnswer = await inquirer.prompt(localOrServerQuestion);
+        ({importFrom} = localOrServerAnswer);
+      }
+      else {
+        importFrom = "Directory";
       }
 
-      await updateSavedFilePath(filePath);
+      if (importFrom === "Server") {
+        await checkAccessTokenExpiration();
+
+        let archiveVersions = [];
+        try {
+          archiveVersions = await getServerLibraryArchives();
+        }
+        catch (ex) {
+          console.log(chalk.redBright(ex));
+        }
+
+
+        if (archiveVersions && archiveVersions.pxResults.length > 0) {
+          // ALL option
+          const defaultPegaServerConfig = await getPegaServerConfig();
+
+          console.log(`\nRetrieved archives from server ${chalk.bold.green(`${defaultPegaServerConfig.server}`)}.`)
+
+          // to name value pairs
+          const archiveResults = archiveVersions["pxResults"].map( archive => ( { value: `${archive.pyApplicationName},${archive.pyFileName},${archive.pyFileType},${archive.pyRuleSet},${archive.pyRuleSetVersion}`, name: `${archive.pyLabel}, ${archive.pyRuleSet}:${archive.pyRuleSetVersion}` }) );
+
 
-      const fileNameQuestions = await getFileNameQuestions(zipFileList);
-      const fileNameAnswers = await inquirer.prompt(fileNameQuestions);
-      ({fileName} = fileNameAnswers);
+          const versionQuestions = await getLibraryArchiveQuestion(archiveResults);
+          const versionAnswers = await inquirer.prompt(versionQuestions);
 
+          const {archiveData} = versionAnswers;
+
+          if (archiveData != "") {
+
+            const arArchData = archiveData.split(",");
+            let fileName = `${arArchData[1]}.${arArchData[2]}`;
+            let fileData;
+
+            console.log("");
+
+            const tasks = new Listr(
+              [
+                {
+                  title: 'Fetching archive from server',
+                  task: async () => {
+                    // get archive
+                    fileData = await getServerLibraryArchive(arArchData[0],arArchData[1], arArchData[2], arArchData[3], arArchData[4]);
+                  }
+                },
+                {
+                  title: 'Saving archive in store',
+                  task: async () => {
+                    await writeZipBuffer(fileName, fileData.pyFileSource);
+
+                    // import archive
+                    const currentDirectory = process.cwd();
+                    const tempDirectory = join(currentDirectory, TEMP_PATH);
+
+                    await importArchServer( tempDirectory, fileName, hasArch);
+                  }
+                }
+              ],
+              { concurrent: false, exitOnError: true }
+            );
+
+            await tasks.run().catch(err => {
+              console.log(chalk.bold.red(err.toString()));
+              process.exit(1);
+            });
+
+          }
+
+        }
+        else {
+          // No library with that name
+          console.log(chalk.redBright(`No library archives exist on server.`));
+          process.exit(1);
+
+        }
+
+      }
+      else {
+        let filePathQuestions;
+        try {
+          filePathQuestions = await getFilePathQuestions();
+        }
+        catch (ex) {
+          process.exit(1);
+        }
+
+
+        let filePathAnswers;
+        try {
+          filePathAnswers = await inquirer.prompt(filePathQuestions);
+        }
+        catch(ex) {
+          process.exit(1);
+        }
+
+        const { filePath } = filePathAnswers;
+        const zipFileList = await getZipFileList(filePath);
+
+        if (!zipFileList || zipFileList.length === 0) {
+          console.log(chalk.red.bold(`No zip files exist at path: ${filePath}`));
+          process.exit();
+        }
+
+        await updateSavedFilePath(filePath);
+
+        const fileNameQuestions = await getFileNameQuestions(zipFileList);
+        const fileNameAnswers = await inquirer.prompt(fileNameQuestions);
+        const {fileName} = fileNameAnswers;
+
+
+
+        console.log("");
+
+        const tasks = new Listr(
+          [
+            {
+              title: `Importing archive`,
+              task: async () => {
+                await importArch( filePath, fileName, hasArch);
+              }
+            }
+          ],
+          { concurrent: false, exitOnError: true }
+        );
+
+
+        await tasks.run().catch(err => {
+          console.log(chalk.bold.red(err.toString()));
+          process.exit(1);
+        });
+
+        console.log("");
+
+
+        // reapply to save if changed, because imported task.config may have overriden and we want
+        // to keep what was entered as the latest
+        await updateSavedFilePath(filePath);
+      }
     }
 
-    await importArch( filePath, fileName, hasArch);
 
-    // reapply to save if changed, because imported task.config may have overriden and we want
-    // to keep what was entered as the latest
-    await updateSavedFilePath(filePath);
+
+
+
+
+
 
   }
 

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

@@ -1,5 +1,3 @@
-import chalk from 'chalk';
-import fs from 'fs';
 import path from 'path';
 import { join } from 'path';
 import { addDebugLog, getConfigDefaults, setConfigImportRelativePath, forceDefaultsUpdate } from '../../util.js';
@@ -20,16 +18,41 @@ addDebugLog("getFilePathQuestions", "", "");
   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
     }
   ];
 };