@pega/custom-dx-components 0.24.17 → 0.25.2

package/src/tasks/move/index.js

@@ -0,0 +1,477 @@
+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 {
+  sanitize,
+  checkPathAccess,
+  showVersion,
+  getComponentsObj,
+  getDirectoryFiles,
+  addDebugLog,
+  checkLibraryAndArchives,
+  getConfigDefaults,
+  getLibraryBased,
+  unZipFromArchive,
+  zipVersionAndArchive,
+  getLibraryArchivesVersions,
+  getLibraryArchiveDirectories,
+  cleanUpTemp
+ } from '../../util.js';
+import { TASKS_CONFIG_JSON_FILENAME, COMPONENTS_DIRECTORY_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';
+
+
+const copy = promisify(ncp);
+
+
+export const updateConfig = async (
+  {
+    oldComponentKey,
+    newComponentKey,
+    compName,
+    library,
+    version,
+    compLabel,
+    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;
+
+  if (compLabel != "") {
+    configData.label = compLabel;
+    configData.description = compLabel;
+  }
+
+  // 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', flag:'w' });
+
+};
+
+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',flag:'w' });
+  }
+
+};
+
+
+// rename the component
+export const renameComponent = async (
+    componentKey,
+    library,
+    version,
+    copyMove,
+    compName = "",
+    compLabel = "",
+    options
+) => {
+
+addDebugLog("renameComponent", `library: ${library}, componentKey: ${componentKey}`, "");
+
+  // const componentName = componentKey.split("_")[2];
+  const newComponentKey = `${library}_${compName}`;
+  const oldComponentKey = componentKey;
+  const newComponentKeyPC = convertIntoPascalCase(newComponentKey);
+  const oldComponentKeyPC = convertIntoPascalCase(oldComponentKey);
+
+  const currentDirectory = process.cwd();
+  const tempDirectory = join(currentDirectory, TEMP_PATH, "src", "components");
+  const existingDirectory = await getComponentDirectoryPath(componentKey);
+  const targetDirectory = await getComponentDirectoryPath(newComponentKey, tempDirectory);
+
+  if (copyMove === "Move") {
+    // custom component
+    try {
+      fs.renameSync(existingDirectory, targetDirectory);
+    } catch(err) {
+      console.log(err)
+    }
+  }
+  else {
+    // copy
+    // custom component
+    try {
+      fs.cpSync(existingDirectory, 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,
+          compName,
+          library,
+          version,
+          compLabel,
+          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");
+    const configDef = getConfigDefaults();
+
+    await unZipFromArchive(archFileName);
+
+    const copiedOrMoved = copyMove === "Copy" ? "Copied" : "Moved";
+
+    let newComponentKey;
+
+    if (componentKey === 'ALL') {
+      for (let index in localComponents) {
+        // skip first ALL
+        if (index > 0) {
+          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 {
+
+      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);
+
+        // update current /src/components because we copied to it (as well as the archive)
+        if (orgLibName === configDef.currentOrgLib && version === configDef.buildVersion && copyMove === "Copy") {
+          fs.cpSync(join(tempCompPath, newComponentKey), join(currentCompPath, newComponentKey),  { recursive: true, force: true  });
+        }
+
+      }
+      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 configDef = getConfigDefaults();
+
+    const tempCompName = componentKey.split("_")[2];
+    let newTempComponentKey = `${orgLibName}_${tempCompName}`;
+    const tempDirComp = join(tempCompPath, `${newTempComponentKey}`);
+
+    let compLabel = "";
+    let compName = tempCompName;
+
+    if (fs.existsSync(join(tempCompPath, componentKey)) && version === configDef.buildVersion && copyMove === "Copy") {
+      // need to rename
+      console.log(`\n${chalk.yellow(`${tempCompName}`)} exists, select new name and label for copied component.`);
+      const nameAnswers = await inquirer.prompt([
+        {
+          name: 'componentName',
+          message: 'Enter component name (required)',
+          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.';
+          }
+        },
+        {
+          name: 'componentLabel',
+          message: 'Enter component label for display (required)',
+          validate: value => {
+            if (value) {
+              return true;
+            }
+            return 'Please provide value for label';
+          }
+        }
+      ]);
+
+      //
+      compName = nameAnswers.componentName;
+      compLabel = nameAnswers.componentLabel;
+
+    }
+    else 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;
+      }
+      else {
+        // delete the one in the temp directory, so can move/copy latest
+        fs.rmSync(tempDirComp,  { recursive: true, force: true, maxRetries: 2  });
+      }
+    }
+
+    // rename the component
+    const newComponentKey = await renameComponent(componentKey, orgLibName, version, copyMove, compName, compLabel);
+
+    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();
+  }
+
+  await cleanUpTemp();
+
+  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();
+
+  const configDef = getConfigDefaults();
+
+  if (!localComponents || localComponents.length === 0 ) {
+    console.log(chalk.red.bold("No components to move/copy."));
+    process.exit();
+  }
+
+  if (options.params.length >= 8) {
+    copyMove = options.params[3];
+    componentKey = options.params[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);
+      libVersions = await getLibraryArchivesVersions(configDef.currentOrgLib, "0.0.0");
+    }
+    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 ? (copyMove === "Move" ? configDef.buildVersion : "" ) : "";
+
+    try {
+      libVersions = await getLibraryArchivesVersions(orgLibName, buildVersion);
+    }
+    catch (ex) {}
+
+    if (libVersions.length == 0) {
+      console.log(`Current library: ${chalk.green(`${orgLibName}`)} has NO available versions to move to.`);
+      process.exit();
+    }
+
+    const versionQuestions = await getLibraryVersionQuestion(orgLibName, libVersions, copyMoveLC);
+    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

@@ -7,23 +7,23 @@ import chalk from 'chalk';
 import inquirer from 'inquirer';
 
 import {
-  convertIntoPascalCase,
   checkPathAccess,
   showVersion,
-  updateUseWebPackPromotion
+  updateUseWebPackPromotion,
+  getLibraryBased,
+  addDebugLog
 } from '../../util.js';
 
 import {
   WEBPACK_CONFIG_JS_FILENAME,
   WEBPACK_PATHS_JS_FILENAME,
   PACKAGE_JSON_FILENAME,
-  BUILDER_INDEX_FILE_PATH,
   BUILDER_DIR_FILE_PATH
 } from '../../constants.js';
 
 
-
 export const copyWebPack = async () => {
+addDebugLog("copyWebPack","", "");
 
    // first check to see if already have the file
   const newWebPackConfigDir = path.resolve(WEBPACK_CONFIG_JS_FILENAME);
@@ -92,9 +92,18 @@ export const copyWebPack = async () => {
 
 
 export default async options => {
-  showVersion();
+  const isLibraryBased = getLibraryBased();
+  if (isLibraryBased) {
+    console.log(`Command only supported for ${chalk.bold.green('non library mode')} components.`)
+    process.exit();
+  }
+
+  await showVersion();
+addDebugLog("promoteWebPack","", "+");
 
   await copyWebPack();
   await updateUseWebPackPromotion(true);
 
+addDebugLog("promoteWebPack","END", "-");
+
 };

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

@@ -395,7 +395,9 @@ module.exports = (
       /* isEnvProduction && new CompressionPlugin(compressionGZConfObj) */
     ].filter(Boolean),
     performance: {
-      hints: 'warning'
+      hints: false,
+      maxEntrypointSize: 512000,
+      maxAssetSize: 512000
     },
     externals
   };

package/src/tasks/publish/helper.js

@@ -2,7 +2,7 @@ import fs from 'fs';
 import path from 'path';
 
 import fetch from 'node-fetch';
-import AdmZip from 'adm-zip';
+import archiver from 'archiver';
 import chalk from 'chalk';
 
 import {
@@ -11,7 +11,8 @@ import {
   getComponents,
   getPegaServerConfig,
   validateRulesetVersion,
-  getHttpsAgent
+  getHttpsAgent,
+  addDebugLog
 } from '../../util.js';
 import {
   PUBLISH_COMPONENT_SERVICE_REST_ENDPOINT,
@@ -20,6 +21,7 @@ import {
 } from '../../constants.js';
 
 export const getPublishComponentQuestions = async componentKey => {
+addDebugLog("getPublishComponentQuestions", `componentKey: ${componentKey}`, "");
   const components = await getComponents();
 
   if (components.length === 0) {
@@ -83,35 +85,54 @@ export const getPublishComponentQuestions = async componentKey => {
 };
 
 export const zipComponent = async componentKey => {
+addDebugLog("zipComponent", `componentKey: ${componentKey}`, "");
   const srcDirectory = await getComponentDirectoryPath(componentKey);
   const buildDirectory = await path.join(path.resolve(), 'dist/components', componentKey);
   const configJson = `${srcDirectory}/config.json`;
   const localizationJson = `${srcDirectory}/localizations.json`;
 
-  const zip = new AdmZip();
+  const archive = archiver('zip', { zlib: { level: 9 } });
+  const zipChunks = [];
+  archive.on('data', chunk => zipChunks.push(chunk));
 
-  zip.addLocalFolder(srcDirectory, 'src/');
-  zip.addLocalFile(configJson);
+  // Add src directory
+  archive.directory(srcDirectory, 'src');
 
+  // Add config.json file
+  if (fs.existsSync(configJson)) {
+    archive.file(configJson, { name: path.basename(configJson) });
+  }
+
+  // Add localizations.json file if it exists
   if (fs.existsSync(localizationJson)) {
-    zip.addLocalFile(localizationJson);
+    archive.file(localizationJson, { name: path.basename(localizationJson) });
   }
 
-  zip.addLocalFolder(buildDirectory);
-  const zipContent = zip.toBuffer().toString('base64');
+  // Add build directory
+  archive.directory(buildDirectory, false);
 
-  const configContent = Buffer.from(fs.readFileSync(`${srcDirectory}/config.json`)).toString();
+  await archive.finalize();
+
+  const zipBuffer = Buffer.concat(zipChunks);
+  console.log(chalk.green(`component zipped with size: ${Math.ceil(zipBuffer.length / 1024)} KB`));
+  const zipContent = zipBuffer.toString('base64');
+
+  const configContent = Buffer.from(fs.readFileSync(configJson)).toString();
+
+  if (fs.existsSync('dist')) {
+    fs.rm('dist', { recursive: true }, err => {
+      if (err) {
+        throw err;
+      }
+    });
+  }
 
-  fs.rm('dist', { recursive: true }, err => {
-    if (err) {
-      throw err;
-    }
-  });
 
   return { zipContent, configContent };
 };
 
 export const publishComponentToServer = async (data, doFetch) => {
+addDebugLog("publishComponentToServer", `data: ${data}`, "");
   const { configContent, zipContent, rulesetName, rulesetVersion } = data;
 
   const defaultPegaServerConfig = await getPegaServerConfig();
@@ -159,7 +180,7 @@ export const publishComponentToServer = async (data, doFetch) => {
           // refresh_token: refreshToken
         } = JSON.parse(OauthData);
         let status = 500;
-        const headers = {};
+        let headers = {};
 
         if (isLaunchpad) {
           headers.cookie = `Pega-AAT=${accessToken}`;
@@ -215,7 +236,8 @@ export const publishComponentToServer = async (data, doFetch) => {
         throw new Error(`Error occurred in authentication. Please regenerate using authenticate`);
       }
     } catch (err) {
-      throw new Error(`Error occurred in authentication. Please regenerate using authenticate`);
+      // throw new Error(`Error occurred in authentication. Please regenerate using authenticate`);
+      throw new Error(err);
     }
   }
 };