@pega/custom-dx-components 0.242.66 → 0.242.68

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

@@ -7,7 +7,10 @@ import {
   checkLibraryAndArchives,
   getConfigDefaults,
   addDebugLog,
-  cleanUpTemp
+  cleanUpTemp,
+  getUseInputConfig,
+  getInputConfigForCommand,
+  convertYNToBoolean
 } from '../../util.js';
 
 import { deleteLibraryVersion } from '../delete-lib/index.js';
@@ -15,6 +18,8 @@ import { deleteLibraryVersion } from '../delete-lib/index.js';
 
 export default async (options) => {
   const isLibraryBased = getLibraryBased();
+  const useInputConfig = getUseInputConfig();
+
   if (!isLibraryBased) {
     console.log(`Command only supported for ${chalk.bold.green('library mode')} components.`)
     process.exit();
@@ -33,19 +38,35 @@ addDebugLog("deleteVersion", "", "+");
   const configDef = getConfigDefaults();
   let libraryName = configDef.currentOrgLib;
 
-  if (options.params.length >= 5) {
-    libraryName = options.params[3]
-    version = options.params[4];
+  if (useInputConfig) {
+    const inputConfig = await getInputConfigForCommand("deleteLibVersion");
+    version = inputConfig.libraryVersion;
+    const isPermanent = inputConfig.isPermanent;
+    const permBuild = convertYNToBoolean(isPermanent);
 
-    if (options.params.length >=6 ) {
-      const okToDel = options.params[5];
-      okToDelete = !!(okToDel === 'Y' || okToDel === 'y' || okToDel === true || okToDel === 'true');
+    if (!permBuild && version != "ALL") {
+      version = version.concat("-dev");
     }
+
+    okToDelete = convertYNToBoolean(inputConfig.confirmDelete);
   }
-  else if (options.params.length >= 4) {
-    libraryName = options.params[3];
+  else {
+    if (options.params.length >= 5) {
+      libraryName = options.params[3]
+      version = options.params[4];
+
+      if (options.params.length >=6 ) {
+        const okToDel = options.params[5];
+        okToDelete = !!(okToDel === 'Y' || okToDel === 'y' || okToDel === true || okToDel === 'true');
+      }
+    }
+    else if (options.params.length >= 4) {
+      libraryName = options.params[3];
+    }
   }
 
+
+
   await deleteLibraryVersion(libraryName, version, okToDelete);
 
 

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

@@ -86,6 +86,20 @@ addDebugLog("getLibraryVersionQuestion", "", "");
   ];
 };
 
+export const getFullArchiveQuestions = async () => {
+
+  return [
+    {
+      name: 'fullArchive',
+      type: 'rawlist',
+      message: 'Type of export',
+      choices: [{name: 'Full Archive (code)', value: 'Full'}, {name: 'CL Binary (runtime only)', value: 'Binary'}],
+      default: 'Full'
+    }
+
+  ];
+}
+
 export const updateSavedExportFilePath = async(filePath) => {
   const currentDirectory = process.cwd();
   const arPathParts = currentDirectory.split(path.sep);

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

@@ -15,11 +15,12 @@ import {
   getConfigDefaults,
   getLibraryBased,
   zipVersionAndArchive,
+  zipVersionAndArchiveCL,
   cleanUpTemp
  } from '../../util.js';
-import { TASKS_CONFIG_JSON_FILENAME, ARCHIVES_PATH } from '../../constants.js';
-import { getFilePathQuestions, getLibraryQuestion, getLibraryVersionQuestion, updateSavedExportFilePath  } from './helper.js';
-import { or } from 'ajv/dist/compile/codegen/index.js';
+import { TASKS_CONFIG_JSON_FILENAME, ARCHIVES_PATH, BIN_ARCHIVES_PATH } from '../../constants.js';
+import { getFilePathQuestions, getLibraryQuestion, getLibraryVersionQuestion, updateSavedExportFilePath, getFullArchiveQuestions  } from './helper.js';
+import { localBuildLibrary } from '../build-lib/index.js';
 
 export const DXCB_CONFIG_INTERNAL_JSON_FILENAME = 'src/dxcb.config.json';
 const currentDirectory = process.cwd();
@@ -75,9 +76,95 @@ addDebugLog("updateFile", `fileName: ${fileName}, oldComponentKeyPC: ${oldCompon
 };
 
 
+export const exportCLArch = async(exportPath, orgLibName, selectedVersion) => {
+addDebugLog("exportCLArch", `exportPath: ${exportPath}, orgLibName: ${orgLibName}, selectedVersion: ${selectedVersion}`, "");
+  const currentDirectory = process.cwd();
+  const archiveDirectory = join (currentDirectory, BIN_ARCHIVES_PATH);
+  const fileName = `${orgLibName}_${selectedVersion}.zip`;
+  const archFileName = join(archiveDirectory, fileName);
+  const configDef = await getConfigDefaults();
+
+  const exportFile = join(exportPath, fileName);
+  let output;
+
+    // need to build the libary
+    console.log(chalk.green(`\nBuilding binaries...\n`));
+    const arOrgLib = orgLibName.split("_")
+    const arVersion = selectedVersion.split("-");
+    const devBuild = arVersion.length > 1 ? true : false;
+
+    await localBuildLibrary(arOrgLib[0], arOrgLib[1], arVersion[0], devBuild);
+
+    const libraryDir = join(currentDirectory, orgLibName, selectedVersion );
+    if (fs.existsSync(libraryDir)) {
+      console.log(chalk.green(`\nExporting binaries...\n`));
+
+      if (!fs.existsSync(exportPath)) {
+        console.log(`\Path: ${chalk.yellow(`${exportPath}`)} doesn't exist.`);
+        const newPathAnswer = await inquirer.prompt([
+          {
+            name: 'createNewPath',
+            type: 'confirm',
+            message: 'Create path',
+            default: true
+          },
+        ]);
+        const createNewPath = newPathAnswer.createNewPath;
+        if (createNewPath) {
+          fs.mkdirSync(exportPath, { recursive: true });
+
+          await updateSavedExportFilePath(exportPath);
+        }
+        else {
+          console.log(chalk.green("Store not exported."));
+          process.exit();
+        }
+      }
+
+      if (fs.existsSync(exportFile)) {
+        console.log(`\nFile: ${chalk.yellow(`${fileName}`)} already exists in ${chalk.yellow(`${exportPath}`)}.`);
+        const overwriteQuestion = await inquirer.prompt([
+          {
+            name: 'overWriteFile',
+            type: 'confirm',
+            message: 'Overrwrite',
+            default: true
+          },
+        ]);
+
+        if (!overwriteQuestion.overWriteFile) {
+          console.log(chalk.green("Store not exported."));
+          process.exit();
+        }
+      }
+
+
+
+      // archive it
+      output = await zipVersionAndArchiveCL(configDef.currentOrgLib, configDef.buildVersion);
+
+      // if archiving, need to wait before copying
+      output.on('close', function() {
+        fs.copyFileSync(archFileName, exportFile );
+
+        console.log(`\n${chalk.green(`${fileName}`)} has been exported to ${chalk.green(`${exportPath}`)}`);
+
+      });
+
+    }
+    else {
+      console.log.chalk.green(`\nBinary does not exist.`);
+    }
+
 
 
-export const exportArch = async(exportPath, orgLibName, selectedVersion, currentOrArchive = "") => {
+
+
+
+}
+
+
+export const exportArch = async(exportPath, orgLibName, selectedVersion, fullArchive = "Full", currentOrArchive = "" ) => {
 addDebugLog("exportArch", `exportPath: ${exportPath}, orgLibName: ${orgLibName}, selectedVersion: ${selectedVersion}`, "");
   const currentDirectory = process.cwd();
   const archiveDirectory = join (currentDirectory, ARCHIVES_PATH, `${orgLibName}`, `${selectedVersion}`);
@@ -91,6 +178,11 @@ addDebugLog("exportArch", `exportPath: ${exportPath}, orgLibName: ${orgLibName},
 
   let archiveBeforeStore = false;
 
+  if (fullArchive != "Full") {
+    await exportCLArch(exportPath, orgLibName, selectedVersion);
+    return;
+  }
+
 
   if (orgLibName === configDef.currentOrgLib && selectedVersion === configDef.buildVersion) {
 
@@ -210,46 +302,77 @@ export default async options => {
   addDebugLog("exportArchive", "", "+");
 
 
-  if (options.params.length >= 7) {
-    const libraryName = options.params[3];
-    const libraryVersion = options.params[4];
-    const filePath = options.params[5];
-    const currentOrArchive = options.params[6];
+  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];
+
 
-    await exportArch(filePath, libraryName, libraryVersion, currentOrArchive );
+    const currentOrArchive = options.params[7];
+
+    await exportArch(filePath, libraryName, libraryVersion, fullArchive, currentOrArchive );
 
   }
   else {
     let orgLibName = "";
     let selectedVersion = "";
+    let fullArchive = "";
 
-    if (options.params.length >= 4) {
-      orgLibName = options.params[3];
-      if (options.params.length >= 5) {
-        selectedVersion = options.params[4];
+    if (options.params.length >= 5) {
+      fullArchive = options.params[3];
+      orgLibName = options.params[4];
+      if (options.params.length >= 6) {
+        selectedVersion = options.params[5];
       }
     }
 
-
-    if (orgLibName === "") {
-      const libraryQuestion = await getLibraryQuestion();
-      const libraryAnswers = await inquirer.prompt(libraryQuestion);
-      ({ orgLibName } = libraryAnswers);
+    if (fullArchive === "" ) {
+      const fullArchiveQuestions = await getFullArchiveQuestions();
+      const fullArchiveAnswers = await inquirer.prompt(fullArchiveQuestions);
+      ({ fullArchive } = fullArchiveAnswers);
     }
 
-    if (selectedVersion === "") {
-      const libraryVersionQuestion = await getLibraryVersionQuestion(orgLibName);
-      const libraryVersionAnswer = await inquirer.prompt(libraryVersionQuestion);
-      ({ selectedVersion } = libraryVersionAnswer);
+    let filePathQuestions;
+    let filePathAnswers;
+    let filePath;
+
+    // if Binary, then we need to just build the current library, get the results and
+    // and export an archive as zip
+    if (fullArchive === "Binary") {
+      filePathQuestions = await getFilePathQuestions();
+      filePathAnswers = await inquirer.prompt(filePathQuestions);
+      ({ filePath } = filePathAnswers);
+
+      await updateSavedExportFilePath(filePath);
+
+      const configDef = getConfigDefaults();
+      orgLibName = configDef.currentOrgLib;
+      selectedVersion = configDef.buildVersion;
+
+
     }
+    else {
+      if (orgLibName === "") {
+        const libraryQuestion = await getLibraryQuestion();
+        const libraryAnswers = await inquirer.prompt(libraryQuestion);
+        ({ orgLibName } = libraryAnswers);
+      }
 
+      if (selectedVersion === "") {
+        const libraryVersionQuestion = await getLibraryVersionQuestion(orgLibName);
+        const libraryVersionAnswer = await inquirer.prompt(libraryVersionQuestion);
+        ({ selectedVersion } = libraryVersionAnswer);
+      }
 
-    const filePathQuestions = await getFilePathQuestions();
-    const filePathAnswers = await inquirer.prompt(filePathQuestions);
-    let { filePath } = filePathAnswers;
 
-    await updateSavedExportFilePath(filePath);
+      filePathQuestions = await getFilePathQuestions();
+      filePathAnswers = await inquirer.prompt(filePathQuestions);
+      ({ filePath } = filePathAnswers);
 
+      await updateSavedExportFilePath(filePath);
+
+    }
 
     // if (path.sep === "/") {
     //   if (filePath.lastIndexOf(path.sep) != filePath.length - 1) {
@@ -257,7 +380,7 @@ export default async options => {
     //   }
     // }
 
-    await exportArch( filePath, orgLibName, selectedVersion);
+    await exportArch( filePath, orgLibName, selectedVersion, fullArchive);
 
   }
 

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

@@ -23,7 +23,9 @@ import {
   cleanUpTemp,
   hasArchives,
   restoreFromArchive,
-  forceDefaultsUpdate
+  forceDefaultsUpdate,
+  getUseInputConfig,
+  getInputConfigForCommand
  } from '../../util.js';
 import { TASKS_CONFIG_JSON_FILENAME, ARCHIVES_PATH, TEMP_PATH } from '../../constants.js';
 import { getFilePathQuestions, getFileNameQuestions, updateTempArchive, updateSavedFilePath  } from './helper.js';
@@ -395,6 +397,8 @@ export default async options => {
 
   await checkPathAccess(pegaConfigJsonPath);
   const isLibraryBased = getLibraryBased();
+  const useInputConfig = getUseInputConfig();
+
   if (!isLibraryBased) {
     console.log(`Command only supported for ${chalk.bold.green('library mode')} components.`)
     process.exit();
@@ -415,22 +419,33 @@ export default async options => {
   }
   else {
 
-    const filePathQuestions = await getFilePathQuestions();
-    const filePathAnswers = await inquirer.prompt(filePathQuestions);
-    const { filePath } = filePathAnswers;
-    const zipFileList = await getZipFileList(filePath);
+    let filePath;
+    let fileName;
+
+    if (useInputConfig) {
+      const inputConfig = await getInputConfigForCommand("importLibVersion");
+      filePath = inputConfig.fileLocation;
+      fileName = inputConfig.fileName;
 
-    if (!zipFileList || zipFileList.length === 0) {
-      console.log(chalk.red.bold(`No zip files exist at path: ${filePath}`));
-      process.exit();
     }
+    else {
+      const filePathQuestions = await getFilePathQuestions();
+      const filePathAnswers = await inquirer.prompt(filePathQuestions);
+      ({ 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);
+      await updateSavedFilePath(filePath);
 
-    const fileNameQuestions = await getFileNameQuestions(zipFileList);
-    const fileNameAnswers = await inquirer.prompt(fileNameQuestions);
-    const {fileName} = fileNameAnswers;
+      const fileNameQuestions = await getFileNameQuestions(zipFileList);
+      const fileNameAnswers = await inquirer.prompt(fileNameQuestions);
+      ({fileName} = fileNameAnswers);
 
+    }
 
     await importArch( filePath, fileName, hasArch);
 
@@ -438,8 +453,6 @@ export default async options => {
     // to keep what was entered as the latest
     await updateSavedFilePath(filePath);
 
-
-
   }
 
 addDebugLog("importArchive", "END", "-");

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

@@ -14,7 +14,10 @@ import {
   addDebugLog,
   checkLibraryAndArchives,
   getConfigDefaults,
-  getComponents
+  getComponents,
+  getUseInputConfig,
+  getInputConfigForCommand,
+  convertYNToBoolean
  } from '../../util.js';
 import { TASKS_CONFIG_JSON_FILENAME } from '../../constants.js';
 import { getFilePathQuestions, getFileNameQuestions, updateSavedFilePath  } from './helper.js';
@@ -156,6 +159,8 @@ addDebugLog("renameComponent", `library: ${library}, componentKey: ${componentKe
 export const importComp = async(filePath, fileName, askValidate) => {
 addDebugLog("importComp", `filePath: ${filePath}, fileName: ${fileName}`, "");
 
+  const useInputConfig = getUseInputConfig();
+
   const currentDirectory = process.cwd();
   // const compDirectory = join(currentDirectory, "src", "components");
 
@@ -166,6 +171,8 @@ addDebugLog("importComp", `filePath: ${filePath}, fileName: ${fileName}`, "");
   let configData;
   let newName = "";
   let newLabel = "";
+  let proceedAs;
+
 
   if (fs.existsSync(copyDir)) {
     configData = fs.readFileSync(join(copyDir, "/config.json"), { encoding: 'utf8' });
@@ -178,66 +185,96 @@ addDebugLog("importComp", `filePath: ${filePath}, fileName: ${fileName}`, "");
 
     if (currentCompList && currentCompList.includes(potentialCompKey)) {
       console.log(`\nComponent ${chalk.yellow(`${potentialCompKey}`)} already exists.`);
-      const proceedAnswers = await inquirer.prompt([
 
-        {
-          name: 'proceedAs',
-          type: 'rawlist',
-          message: `Proceed as ?`,
-          default: 'No import',
-          choices: ['No import', 'Overwrite', 'New name']
-        },
-        {
-          name: 'componentName',
-          message: 'Enter component name (required)',
-          when(answers) {
-            return answers.proceedAs === 'New name';
+
+
+      if (useInputConfig) {
+        const inputConfig = await getInputConfigForCommand("importComponent");
+        proceedAs = inputConfig.proceedIfExists;
+
+        newName = inputConfig?.newComponentName;
+        newLabel = inputConfig?.newComponentLabel;
+
+
+        switch (proceedAs) {
+          case 'No import':
+            // removed copied
+            // fs.rmSync(copyDir, { recursive: true, force: true, maxRetries: 2 });
+            process.exit();
+            break;
+          case 'Overwrite':
+            // remove existing
+            const existingComp = await getComponentDirectoryPath(potentialCompKey);
+            fs.rmSync(existingComp, { recursive: true, force: true, maxRetries: 2 });
+            break;
+        }
+
+      }
+      else {
+        const proceedAnswers = await inquirer.prompt([
+
+          {
+            name: 'proceedAs',
+            type: 'rawlist',
+            message: `Proceed as ?`,
+            default: 'No import',
+            choices: ['No import', 'Overwrite', 'New 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)) {
-              return true;
+          {
+            name: 'componentName',
+            message: 'Enter component name (required)',
+            when(answers) {
+              return answers.proceedAs === 'New 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)) {
+                return true;
+              }
+              return 'Only alphanumeric values are allowed, starting with alphabets, no spaces.';
             }
-            return 'Only alphanumeric values are allowed, starting with alphabets, no spaces.';
-          }
-        },
-        {
-          name: 'componentLabel',
-          message: 'Enter component label for display (required)',
-          when(answers) {
-            return answers.proceedAs === 'New name';
           },
-          validate: value => {
-            if (value) {
-              return true;
+          {
+            name: 'componentLabel',
+            message: 'Enter component label for display (required)',
+            when(answers) {
+              return answers.proceedAs === 'New name';
+            },
+            validate: value => {
+              if (value) {
+                return true;
+              }
+              return 'Please provide value for label';
             }
-            return 'Please provide value for label';
           }
+        ]);
+
+        proceedAs = proceedAnswers.proceedAs;
+
+        switch (proceedAs) {
+          case 'No import':
+            // removed copied
+            // fs.rmSync(copyDir, { recursive: true, force: true, maxRetries: 2 });
+            process.exit();
+            break;
+          case 'Overwrite':
+            // remove existing
+            const existingComp = await getComponentDirectoryPath(potentialCompKey);
+            fs.rmSync(existingComp, { recursive: true, force: true, maxRetries: 2 });
+            break;
+          case 'New name':
+            newName = proceedAnswers.componentName;
+            newLabel = proceedAnswers.componentLabel;
+            break;
         }
-      ]);
-
-
-      switch (proceedAnswers.proceedAs) {
-        case 'No import':
-          // removed copied
-          // fs.rmSync(copyDir, { recursive: true, force: true, maxRetries: 2 });
-          process.exit();
-          break;
-        case 'Overwrite':
-          // remove existing
-          const existingComp = await getComponentDirectoryPath(potentialCompKey);
-          fs.rmSync(existingComp, { recursive: true, force: true, maxRetries: 2 });
-          break;
-        case 'New name':
-          newName = proceedAnswers.componentName;
-          newLabel = proceedAnswers.componentLabel;
-          break;
       }
 
+
+
     }
   }
 
@@ -251,30 +288,39 @@ addDebugLog("importComp", `filePath: ${filePath}, fileName: ${fileName}`, "");
     console.log(`\n${chalk.green(`${fileName}`)} has been imported as ${chalk.green(`${newCompKey}`)}\n`);
 
     if (askValidate) {
-      const validateAnswers = await inquirer.prompt([
-        {
-          name: 'doValidate',
-          type: 'confirm',
-          message: `Validate ${chalk.yellow(`${newCompKey}`)}`,
-          default: true
-        }]);
-
-      if (validateAnswers.doValidate) {
-        const args  = [ '','', '', `${newCompKey}`];
-        let myOptions = {};
-        myOptions["params"] = args;
-
-        await buildComponent(myOptions);
-      }
-    }
-
-
 
+      if (useInputConfig) {
+        const inputConfig = await getInputConfigForCommand("importComponent");
+        if (convertYNToBoolean(inputConfig.doValidation)) {
+          const args  = [ '','', '', `${newCompKey}`];
+          let myOptions = {};
+          myOptions["params"] = args;
 
-  }
+          await buildComponent(myOptions);
+        }
 
+      }
+      else {
+        const validateAnswers = await inquirer.prompt([
+          {
+            name: 'doValidate',
+            type: 'confirm',
+            message: `Validate ${chalk.yellow(`${newCompKey}`)}`,
+            default: true
+          }]);
+
+        if (validateAnswers.doValidate) {
+          const args  = [ '','', '', `${newCompKey}`];
+          let myOptions = {};
+          myOptions["params"] = args;
+
+          await buildComponent(myOptions);
+        }
+      }
 
+    }
 
+  }
 
 }
 
@@ -321,6 +367,8 @@ export default async options => {
   await checkLibraryAndArchives();
   await checkPathAccess(pegaConfigJsonPath);
 
+  const useInputConfig = getUseInputConfig();
+
 addDebugLog("importComponent", "", "+");
 
   if (options.params.length >= 5) {
@@ -340,22 +388,36 @@ addDebugLog("importComponent", "", "+");
   }
   else {
 
-    const filePathQuestions = await getFilePathQuestions();
-    const filePathAnswers = await inquirer.prompt(filePathQuestions);
-    const { filePath } = filePathAnswers;
+    let filePath;
+    let fileName;
+
+    if (useInputConfig) {
+      const inputConfig = await getInputConfigForCommand("importComponent");
+      filePath = inputConfig.fileLocation;
+      fileName = inputConfig.fileName;
+
+    }
+    else {
+      const filePathQuestions = await getFilePathQuestions();
+      const filePathAnswers = await inquirer.prompt(filePathQuestions);
+      ({ filePath } = filePathAnswers);
+
+      const compFileList = await getComponentList(filePath);
+
+      if (!compFileList || compFileList.length === 0) {
+        console.log(chalk.red.bold(`No component files exist at path: ${filePath}`));
+        process.exit();
+      }
+
+      await updateSavedFilePath(filePath);
 
-    const compFileList = await getComponentList(filePath);
+      const fileNameQuestions = await getFileNameQuestions(compFileList);
+      const fileNameAnswers = await inquirer.prompt(fileNameQuestions);
+      ({fileName} = fileNameAnswers);
 
-    if (!compFileList || compFileList.length === 0) {
-      console.log(chalk.red.bold(`No component files exist at path: ${filePath}`));
-      process.exit();
     }
 
-    await updateSavedFilePath(filePath);
 
-    const fileNameQuestions = await getFileNameQuestions(compFileList);
-    const fileNameAnswers = await inquirer.prompt(fileNameQuestions);
-    const {fileName} = fileNameAnswers;
 
     await importComp( filePath, fileName, true);