@pega/custom-dx-components 0.242.28 → 0.242.29

package/src/tasks/list/index.js

@@ -13,7 +13,6 @@ import {
   getListComponentsQuestions
 } from './helper.js';
 
-const isLibraryBased = getLibraryBased();
 
 const getList = async (sourceOfComponents, answers) => {
 addDebugLog("getList", `sourceOfComponents: ${sourceOfComponents}`, "");
@@ -69,6 +68,7 @@ addDebugLog("getList", `sourceOfComponents: ${sourceOfComponents}`, "");
 export default async (options) => {
   await showVersion();
   await checkLibraryAndArchives();
+  const isLibraryBased = getLibraryBased();
 
 
 addDebugLog("list", "", "+");

package/src/tasks/list-lib/index.js

@@ -4,13 +4,11 @@ import chalk from 'chalk';
 import {showVersion, getLibraryBased, addDebugLog, checkLibraryAndArchives, getLibraryArchivesVersions, getConfigDefaults, getLocalArchivedLibrraryVersionData, getComponentsConfigs } from '../../util.js';
 import { getArchiveLibraryQuestions } from './helper.js';
 
-const isLibraryBased =  getLibraryBased();
-
-
 export default async (options) => {
+  const isLibraryBased =  getLibraryBased();
 
   if (!isLibraryBased) {
-    console.log(`Command only supported for ${chalk.bold.green('library based')} components.`)
+    console.log(`Command only supported for ${chalk.bold.green('library mode')} components.`)
     process.exit();
   }
 
@@ -71,20 +69,20 @@ addDebugLog("listLibrary", "", "+");
       if (libraryName === compDef.currentOrgLib && selectedVersion === compDef.buildVersion) {
 
         console.log("\nYou've selected the current working library/version.");
-        console.log("You can list current components or the last archive of this library/version.");
+        console.log("You can list current components or the last store of this library/version.");
         const archAnswers = await inquirer.prompt([
           {
-            name: 'currentOrArchive',
+            name: 'currentOrStore',
             type: 'rawlist',
-            message: 'Select current or archive',
+            message: 'Select current or store',
             default: "Current",
-            choices: ["Current", "Archive"]
+            choices: ["Current", "Store"]
           },
         ]);
 
-        const currentOrArchive = archAnswers.currentOrArchive;
+        const currentOrStore = archAnswers.currentOrStore;
 
-        if (currentOrArchive === "Current") {
+        if (currentOrStore === "Current") {
           data = await getComponentsConfigs();
           builtOn = "(no date - current)";
         }

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

@@ -7,7 +7,7 @@ import { listLibJSONResponse } from '@pega/constellation-dx-components-build-uti
 
 import { getListLibraryQuestions, SOURCE_OF_COMPONENT_TYPES } from './helper.js';
 
-const isLibraryBased =  getLibraryBased();
+
 
 export const getServerLibraryVersions = async(libraryName) => {
 addDebugLog("getServerLibraryVersions", `libraryName: ${libraryName}`, "");
@@ -34,9 +34,9 @@ addDebugLog("listLibJSONResponse", "services end", "");
 }
 
 export default async (options) => {
-
+  const isLibraryBased =  getLibraryBased();
   if (!isLibraryBased) {
-    console.log(`Command only supported for ${chalk.bold.green('library based')} components.`)
+    console.log(`Command only supported for ${chalk.bold.green('library mode')} components.`)
     process.exit();
   }
 

package/src/tasks/move/helper.js

@@ -0,0 +1,56 @@
+import chalk from 'chalk';
+
+import { addDebugLog, getConfigDefaults } from '../../util.js';
+
+
+export const getComponentKeyQuestion = async(localComponents, copyMoveLC, paramComponentKey = null) => {
+  const orAll = localComponents.length > 1 ? "or ALL" : "";
+
+  return [
+
+    {
+      name: 'componentKey',
+      type: 'rawlist',
+      pageSize: 15,
+      message: `Select component to ${copyMoveLC} ${orAll}`,
+      choices: localComponents,
+      when: () => !paramComponentKey
+    }
+  ];
+}
+
+
+
+export const getLibraryQuestions = async (archLibs) => {
+addDebugLog("getLibraryQuestions", "", "");
+  const configDef = getConfigDefaults();
+
+
+  return [
+    {
+      name: 'libraryName',
+      type: 'rawlist',
+      message: 'Select library to move to',
+      choices: archLibs
+    }
+  ];
+};
+
+export const getLibraryVersionQuestion = async (libraryName, libVersions) => {
+addDebugLog("getLibraryVersionQuestion", `libraryName: ${libraryName}`, "");
+
+  return [
+    {
+      name: 'version',
+      type: 'rawlist',
+      message: `Select ${chalk.green.bold(`${libraryName}`)} library version to move to`,
+      choices: libVersions
+    },
+    {
+      name: 'copyShared',
+      type: 'confirm',
+      message: `Copy ${chalk.yellow.bold("/shared")} directory (same named files will be overridden) ?`,
+      default: true
+    },
+  ];
+};

package/src/tasks/move/index.js

@@ -0,0 +1,441 @@
+import fs from 'fs';
+import { promisify } from 'util';
+import { join } from 'path';
+
+import inquirer from 'inquirer';
+import ncp from 'ncp';
+import chalk from 'chalk';
+
+import {
+  checkPathAccess,
+  showVersion,
+  getComponentsObj,
+  getDirectoryFiles,
+  addDebugLog,
+  checkLibraryAndArchives,
+  getConfigDefaults,
+  getLibraryBased,
+  unZipFromArchive,
+  zipVersionAndArchive,
+  getLibraryArchivesVersions,
+  getLibraryArchiveDirectories
+ } from '../../util.js';
+import { TASKS_CONFIG_JSON_FILENAME, COMPONENTS_DIRECTORY_PATH, COMPONENTS_PATH, ARCHIVES_PATH, TEMP_PATH } from '../../constants.js';
+import { getComponentKeyQuestion, getLibraryQuestions, getLibraryVersionQuestion } from './helper.js';
+
+export const DXCB_CONFIG_INTERNAL_JSON_FILENAME = 'src/dxcb.config.json';
+const currentDirectory = process.cwd();
+const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
+
+
+import {
+  convertIntoPascalCase,
+  getComponentDirectoryPath
+} from '../../util.js';
+import { or } from 'ajv/dist/compile/codegen/index.js';
+
+
+const copy = promisify(ncp);
+
+
+export const updateConfig = async (
+  {
+    oldComponentKey,
+    newComponentKey,
+    library,
+    version,
+    targetDirectory,
+  },
+  options,
+  onlyCompanion = false
+) => {
+
+addDebugLog("updateConfig", `oldComponentKey: ${oldComponentKey}, newComponentKey: ${newComponentKey}`, "");
+
+  let configData = fs.readFileSync(join(targetDirectory, "/config.json"), { encoding: 'utf8' });
+  configData = configData && JSON.parse(configData);
+
+  configData.name = newComponentKey;
+  if (configData.componentKey) configData.componentKey = newComponentKey;
+  configData.library = library;
+  configData.version = version;
+
+  // stringify "4", makes the json string look like JSON in the file, formated instead of a single line
+  fs.writeFileSync(join(targetDirectory, "/config.json"), JSON.stringify(configData, null, 4), { encoding: 'utf8' });
+
+};
+
+export const updateFile = async (
+    fileName,
+    oldComponentKeyPC,
+    newComponentKeyPC,
+    targetDirectory,
+) => {
+
+addDebugLog("updateFile", `fileName: ${fileName}, oldComponentKeyPC: ${oldComponentKeyPC}, newComponentKeyPC: ${newComponentKeyPC}, targetDirectory: ${targetDirectory}`, "");
+
+  let fileData = fs.readFileSync(join(targetDirectory, "/", fileName), { encoding: 'utf8' });
+
+  if (fileData.indexOf(oldComponentKeyPC) >= 0) {
+    fileData = fileData.replaceAll(oldComponentKeyPC, newComponentKeyPC);
+
+    fs.writeFileSync(join(targetDirectory, "/", fileName), fileData, { encoding: 'utf8' });
+  }
+
+};
+
+
+// rename the component
+export const renameComponent = async (
+    componentKey,
+    library,
+    version,
+    copyMove,
+    options
+) => {
+
+addDebugLog("renameComponent", `library: ${library}, componentKey: ${componentKey}`, "");
+
+
+  const componentName = componentKey.split("_")[2];
+
+  const configDef = getConfigDefaults();
+
+  const newComponentKey = `${library}_${componentName}`;
+
+  const oldComponentKey = componentKey;
+  const newComponentKeyPC = convertIntoPascalCase(newComponentKey);
+  const oldComponentKeyPC = convertIntoPascalCase(oldComponentKey);
+
+  const currentDirectory = await getComponentDirectoryPath(componentKey);
+  const targetDirectory = await getComponentDirectoryPath(newComponentKey);
+
+
+
+  if (copyMove === "Move") {
+    // custom component
+    try {
+      fs.renameSync(currentDirectory, targetDirectory);
+    } catch(err) {
+      console.log(err)
+    }
+  }
+  else {
+    // copy
+    // custom component
+    try {
+      fs.cpSync(currentDirectory, targetDirectory, { recursive: true});
+    } catch(err) {
+      console.log(err)
+    }
+  }
+
+
+
+
+  const targetFileList = await getDirectoryFiles(targetDirectory);
+
+  for (var fileIndex in targetFileList) {
+    const fileName = targetFileList[fileIndex];
+
+    if (fileName === "config.json") {
+      await updateConfig(
+        {
+          oldComponentKey,
+          newComponentKey,
+          componentName,
+          library,
+          version,
+          targetDirectory,
+        },
+        options
+      );
+    }
+    else {
+      await updateFile(
+          fileName,
+          oldComponentKeyPC,
+          newComponentKeyPC,
+          targetDirectory );
+
+    }
+
+  } // for
+
+
+  return newComponentKey;
+
+};
+
+
+export const moveComp = async(componentKey, copyMove, orgLibName, version, copyShared, localComponents, options) => {
+    // put lib/version into temp directory
+    const currentDirectory = process.cwd();
+    const tempDirectory = join(currentDirectory, TEMP_PATH);
+    const archiveDirectory = join (currentDirectory, ARCHIVES_PATH, `${orgLibName}`, `${version}`);
+    const fileName = `${orgLibName}_${version}.zip`;
+    const archFileName = join(archiveDirectory, fileName);
+    const currentCompPath = join(currentDirectory, "src", "components");
+    const tempCompPath = join(tempDirectory, "src", "components");
+
+    await unZipFromArchive(archFileName);
+
+    const copiedOrMoved = copyMove === "Copy" ? "Copied" : "Moved";
+
+    let newComponentKey;
+
+    if (componentKey === 'ALL') {
+      for (let index in localComponents) {
+        // skip first ALL
+        if (index > 1) {
+          const localComponentKey = localComponents[index];
+          newComponentKey = await localMoveCopyComp(localComponentKey.value, orgLibName, version, copyMove, currentDirectory, tempDirectory);
+          if (newComponentKey) {
+            console.log(`${copiedOrMoved} ${chalk.green(`${localComponentKey.value}`)} to ${chalk.green(`${orgLibName}/${version}`)} as ${chalk.green(`${newComponentKey}`)}`);
+          }
+          else {
+            console.log(chalk.yellow(`Not ${copiedOrMoved}`));
+          }
+
+        }
+      }
+
+      const currentSharedPath = join(currentCompPath, "shared");
+      const targetSharedPatah = join(tempCompPath, "shared");
+
+      // copy shared
+      if (copyShared) {
+        fs.cpSync(currentSharedPath, targetSharedPatah, { recursive: true, force: true  });
+      }
+
+      // rearchive temp directory
+      await zipVersionAndArchive(orgLibName, version, tempDirectory);
+
+      // delete temp directory
+      fs.rmSync(tempDirectory, { recursive: true, force: true, maxRetries: 5  });
+
+
+
+    }
+    else {
+
+      // if (copyMove === "Move") {
+      //    await localMoveComp(componentKey, orgLibName, version, currentDirectory, tempDirectory);
+      // }
+      // else {
+      //   await localCopyComp(componentKey, orgLibName, version, currentDirectory, tempDirectory);
+      // }
+
+      const newComponentKey = await localMoveCopyComp(componentKey, orgLibName, version, copyMove, currentDirectory, tempDirectory);
+
+      if (newComponentKey) {
+        const currentSharedPath = join(currentCompPath, "shared");
+        const targetSharedPatah = join(tempCompPath, "shared");
+
+        // copy shared
+        if (copyShared) {
+          fs.cpSync(currentSharedPath, targetSharedPatah, { recursive: true, force: true  });
+        }
+
+
+        console.log(`\n${copiedOrMoved} ${chalk.green(`${componentKey}`)} to ${chalk.green(`${orgLibName}/${version}`)} as ${chalk.green(`${newComponentKey}`)}\n`);
+
+        // rearchive temp directory
+        await zipVersionAndArchive(orgLibName, version, tempDirectory);
+      }
+      else {
+        console.log(chalk.yellow(`No components were ${copiedOrMoved}`));
+      }
+
+
+      // delete temp directory
+      fs.rmSync(tempDirectory, { recursive: true, force: true, maxRetries: 5  });
+    }
+
+
+
+}
+
+export const localMoveCopyComp = async(componentKey, orgLibName, version, copyMove, currentDirectory, tempDirectory ) => {
+    const currentCompPath = join(currentDirectory, "src", "components");
+    const tempCompPath = join(tempDirectory, "src", "components");
+
+    const tempCompName = componentKey.split("_")[2];
+    const newTempComponentKey = `${orgLibName}_${tempCompName}`;
+    const tempDirComp = join(tempCompPath, `${newTempComponentKey}`);
+
+    if (fs.existsSync(tempDirComp)) {
+      const answers = await inquirer.prompt([
+        {
+          name: 'confirmOverride',
+          type: 'confirm',
+          message: `Component ${chalk.yellow(`${tempCompName}`)} currently exists in ${chalk.yellow(`${orgLibName}/${version}`)}, override?`,
+          default: false
+        }
+      ]);
+      if (!answers.confirmOverride) {
+        return null;
+      }
+    }
+
+
+    // rename the component
+    const newComponentKey = await renameComponent(componentKey, orgLibName, version, copyMove);
+
+
+
+
+    const currentComponentsPath = join(currentCompPath, `${newComponentKey}`);
+    const tempDirectoryComponents = join(tempCompPath, `${newComponentKey}`);
+
+    // copy component into temp directory
+    fs.cpSync(currentComponentsPath, tempDirectoryComponents, { recursive: true, force: true  });
+
+    // remove from components
+    fs.rmSync(currentComponentsPath, { recursive: true, force: true, maxRetries: 2  });
+
+    return newComponentKey;
+}
+
+
+
+export default async options => {
+  await showVersion();
+  await checkLibraryAndArchives();
+
+addDebugLog("move", "", "+");
+
+  await checkPathAccess(pegaConfigJsonPath);
+  const isLibraryBased = getLibraryBased();
+  if (!isLibraryBased) {
+    console.log(`Command only supported for ${chalk.bold.green('library mode')} components.`)
+    process.exit();
+  }
+
+  let data = fs.readFileSync(pegaConfigJsonPath, { encoding: 'utf8' });
+  data = data && JSON.parse(data);
+
+  if (!data[COMPONENTS_DIRECTORY_PATH]) {
+    console.error(
+      `${chalk.red.bold('ERROR')} Could not able find components directory path in config.json`
+    );
+    process.exit(1);
+  }
+
+  let copyMove;
+  let copyMoveLC;
+  let componentKey;
+  let orgLibName;
+  let version;
+  let copyShared;
+
+  let localComponents = await getComponentsObj();
+
+  if (!localComponents || localComponents.length === 0 ) {
+    console.log(chalk.red.bold("No components to move/copy."));
+    process.exit();
+  }
+
+  if (options.params.length >= 8) {
+    componentKey = options.params[3];
+    copyMove = options.param[4];
+    orgLibName = options.params[5];
+    version = options.params[6];
+    copyShared = options.params[7];
+
+    await moveComp(
+      componentKey,
+      copyMove,
+      orgLibName,
+      version,
+      copyShared,
+      localComponents,
+      options
+    );
+
+  }
+  else {
+
+    // VS Code pluggin would send in the component
+    let paramComponentKey;
+    if (options.params.length == 4) {
+      paramComponentKey = options.params[3];
+    }
+
+    const configDef = getConfigDefaults();
+    console.log(`Current library: ${chalk.green(`${configDef.displayLibVersion}`)}`);
+
+    // test to see if currnet library has more than one version
+    // if no available versions can not move/copy to it, so send in current lib
+    // as library to be removed from the list
+    let removeOrgLib = "";
+    let libVersions;
+    try {
+      libVersions = await getLibraryArchivesVersions(configDef.currentOrgLib, configDef.buildVersion);
+    }
+    catch (ex) {}
+    if (!libVersions || libVersions.length === 0) {
+      removeOrgLib = configDef.currentOrgLib;
+    }
+
+    const archLibs = await getLibraryArchiveDirectories(removeOrgLib);
+
+    if (!archLibs || archLibs.length === 0) {
+      console.log(chalk.red.bold("No available libraries to move/copy to."));
+      process.exit();
+    }
+
+    const copyMoveQuestion = [
+      {
+        name: 'copyMove',
+        type: 'rawlist',
+        message: "Copy or Move",
+        choices: ["Copy", "Move"],
+        default: "Copy"
+      }
+    ];
+
+    const copyMoveAnswer = await inquirer.prompt(copyMoveQuestion);
+    ({copyMove} = copyMoveAnswer);
+    copyMoveLC = copyMove.toLowerCase();
+
+    if (localComponents && localComponents.length > 1) {
+      localComponents.unshift({name: 'ALL', value: 'ALL'});
+    }
+
+    const keyQuestions = await getComponentKeyQuestion(localComponents, copyMoveLC, paramComponentKey);
+
+    const answers = await inquirer.prompt(keyQuestions);
+    ({ componentKey = paramComponentKey} = answers);
+
+
+
+    const libQuestions = await getLibraryQuestions(archLibs);
+    const libAnswers = await inquirer.prompt(libQuestions);
+    orgLibName = libAnswers.libraryName;
+    const buildVersion = configDef.currentOrgLib === orgLibName ? configDef.buildVersion : "";
+
+    try {
+      libVersions = await getLibraryArchivesVersions(orgLibName, buildVersion);
+    }
+    catch (ex) {}
+
+    const versionQuestions = await getLibraryVersionQuestion(orgLibName, libVersions);
+    const versionAnswers = await inquirer.prompt(versionQuestions);
+    ({version, copyShared} = versionAnswers);
+
+
+    await moveComp(
+      componentKey,
+      copyMove,
+      orgLibName,
+      version,
+      copyShared,
+      localComponents,
+      options
+    );
+  }
+
+addDebugLog("rename", "END", "-");
+
+};

package/src/tasks/promote-webpack/index.js

@@ -21,8 +21,6 @@ import {
   BUILDER_DIR_FILE_PATH
 } from '../../constants.js';
 
-const isLibraryBased = getLibraryBased();
-
 
 export const copyWebPack = async () => {
 addDebugLog("copyWebPack","", "");
@@ -94,8 +92,9 @@ addDebugLog("copyWebPack","", "");
 
 
 export default async options => {
+  const isLibraryBased = getLibraryBased();
   if (isLibraryBased) {
-    console.log(`Command only supported for ${chalk.bold.green('non library based')} components.`)
+    console.log(`Command only supported for ${chalk.bold.green('non library mode')} components.`)
     process.exit();
   }
 

package/src/tasks/publish/index.js

@@ -11,12 +11,11 @@ import { getPublishComponentQuestions, publishComponentToServer, zipComponent }
 import { default as buildLibrary } from '../build-lib/index.js';
 import { default as publishLibrary } from '../publish-lib/index.js';
 
-const isLibraryBased = getLibraryBased();
-
 export default async options => {
 
   await showVersion();
   await checkLibraryAndArchives();
+  const isLibraryBased = getLibraryBased();
 
   if (isLibraryBased) {
 

package/src/tasks/publish-all/index.js

@@ -14,7 +14,6 @@ import {
   cleanUp
 } from './helper.js';
 
-const isLibraryBased = getLibraryBased();
 
 export function getCustomTasks(componentKey, sourceMap, devBuild, content, options) {
 addDebugLog("getCustomTasks", `componentKey: ${componentKey}, sourceMap: ${sourceMap}, devBuild: ${devBuild}`, "");
@@ -64,8 +63,9 @@ addDebugLog("getCustomTasks", `componentKey: ${componentKey}, sourceMap: ${sourc
 }
 
 export default async options => {
+  const isLibraryBased = getLibraryBased();
   if (isLibraryBased) {
-    console.log(`Command only supported for ${chalk.bold.green('non library based')} components.`)
+    console.log(`Command only supported for ${chalk.bold.green('non library mode')} components.`)
     process.exit();
   }
 

package/src/tasks/publish-lib/index.js

@@ -11,8 +11,6 @@ import { publishLib, listLibJSONResponse, deleteLibVersion } from '@pega/constel
 import { getLibraryVersionQuestion } from './helper.js';
 
 
-const isLibraryBased =  getLibraryBased();
-
 export function getCustomTasks(componentKey, sourceMap, devBuild, options) {
 addDebugLog("getCustomTasks", `componentKey: ${componentKey}, sourceMap: ${sourceMap}, devBuild: ${devBuild}`, "");
 
@@ -63,11 +61,16 @@ addDebugLog("publishNewLibraryAsync", `libraryName: ${libraryName}, version: ${v
 
   if (checkDeleted ) {
     console.log(chalk.yellow(`Verifying library has been deleted..`));
-    let libExists = await doesLibraryExist(libraryName, version);
+    let libExists = true;
     let count = 0;
     while (libExists) {
+
+      // sleep a second and try again
+      await new Promise(r => setTimeout(r, 1000));
+
       // keep checking until no longer exists
       libExists = await doesLibraryExist(libraryName, version);
+
       count ++;
 
       if (count > 100) {
@@ -88,8 +91,9 @@ addDebugLog("deleteLib", "services end", "");
 
 
 export default async (options) => {
+  const isLibraryBased =  getLibraryBased();
   if (!isLibraryBased) {
-    console.log(`Command only supported for ${chalk.bold.green('library based')} components.`)
+    console.log(`Command only supported for ${chalk.bold.green('library mode')} components.`)
     process.exit();
   }
 

package/src/tasks/rename-lib/index.js

@@ -34,8 +34,6 @@ export const DXCB_CONFIG_INTERNAL_JSON_FILENAME = 'src/dxcb.config.json';
 const currentDirectory = process.cwd();
 const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
 
-const isLibraryBased =  getLibraryBased();
-
 import {
   convertIntoPascalCase,
   getComponentDirectoryPath,
@@ -243,8 +241,9 @@ addDebugLog("renameComponent", `library: ${library}, organization: ${organizatio
 };
 
 export default async options => {
+  const isLibraryBased =  getLibraryBased();
   if (!isLibraryBased) {
-    console.log(`Command only supported for ${chalk.bold.green('library based')} components.`);
+    console.log(`Command only supported for ${chalk.bold.green('library mode')} components.`);
     process.exit();
   }