@pega/custom-dx-components 0.24.17 → 0.25.1

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

@@ -0,0 +1,447 @@
+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 { Listr } from 'listr2';
+
+import {
+  sanitize,
+  checkPathAccess,
+  showVersion,
+  getDirectoryFiles,
+  addDebugLog,
+  checkLibraryAndArchives,
+  getConfigDefaults,
+  getLibraryBased,
+  unZipFromArchive,
+  zipVersionAndArchive,
+  getLibraryArchiveDirectories,
+  hasLibraryAndVersion,
+  cleanUpTemp,
+  hasArchives,
+  restoreFromArchive,
+  forceDefaultsUpdate
+ } from '../../util.js';
+import { TASKS_CONFIG_JSON_FILENAME, ARCHIVES_PATH, TEMP_PATH } from '../../constants.js';
+import { getFilePathQuestions, getFileNameQuestions, updateTempArchive, updateSavedFilePath  } from './helper.js';
+import { showCurrentStatus } from '../show-status/index.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,
+    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',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,
+    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);
+
+  // custom component
+  try {
+    fs.renameSync(currentDirectory, targetDirectory);
+  } 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 getPackgeOrg = async(packagePath) => {
+  const sPackData = fs.readFileSync(packagePath, { encoding: 'utf8' });
+  const packData = sPackData && JSON.parse(sPackData);
+
+  return packData.organization;
+}
+
+export const getLocalConfigData = async(tasksPath) => {
+  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;
+  configData.library = taskData["component"].library;
+  configData.version = taskData["component"].version;
+  configData.devBuild = devBuild;
+
+  configData.buildVersion = devBuild ? configData.version.concat("-dev") : configData.version;
+
+  return configData;
+}
+
+export const moveComp = async(componentKey, orgLibName, version, copyShared, 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);
+
+
+    await unZipFromArchive(archFileName);
+
+    // rename the component
+    const newComponentKey = await renameComponent(componentKey, orgLibName, version);
+    const currentCompPath = join(currentDirectory, "src", "components");
+    const tempCompPath = join(tempDirectory, "src", "components");
+
+    const currentComponentsPath = join(currentCompPath, `${newComponentKey}`);
+    const tempDirectoryComponents = join(tempCompPath, `${newComponentKey}`);
+
+    const currentSharedPath = join(currentCompPath, "shared");
+    const targetSharedPatah = join(tempCompPath, "shared");
+
+    // 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  });
+
+    // copy shared
+    if (copyShared) {
+      fs.cpSync(currentSharedPath, targetSharedPatah, { recursive: true, force: true  });
+    }
+
+    console.log(`\nCopied ${chalk.green(`${componentKey}`)} to ${chalk.green(`${orgLibName}/${version}`)} as ${chalk.green(`${newComponentKey}`)}\n`);
+
+    // rearchive temp directory
+    await zipVersionAndArchive(orgLibName, version, tempDirectory);
+
+    // delete temp directory
+    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 tempDirectory = join(currentDirectory, TEMP_PATH);
+  const zipFilePath = join(filePath, fileName);
+
+  await unZipFromArchive(zipFilePath);
+
+  // check to see if have a tasks.config.json file, if not, archive not good
+  const tempTasksConfig = join(tempDirectory, "tasks.config.json");
+  const tempPackage = join(tempDirectory, "package.json");
+
+  if (!fs.existsSync(tempTasksConfig) || !fs.existsSync(tempPackage)) {
+    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."));
+    process.exit(1);
+
+  }
+
+  // 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.\n`);
+  }
+  else {
+    const switchToFileName = `${orgLibName}_${version}.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();
+
+    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 getZipFileList = async(filePath) => {
+
+  if (fs.existsSync(filePath)) {
+    return fs
+      .readdirSync(filePath, { withFileTypes: true })
+      .filter(dirent => !dirent.isDirectory() && dirent.name.match(/.*\.(zip?)/ig))
+      .map(dirent => dirent.name);
+  }
+  else {
+    console.log(chalk.red.bold(`File path: ${filePath} does not exist or no permissions.`));
+    process.exit(1);
+  }
+}
+
+export default async options => {
+  await showVersion();
+  // await checkLibraryAndArchives();
+
+  await checkPathAccess(pegaConfigJsonPath);
+  const isLibraryBased = getLibraryBased();
+  if (!isLibraryBased) {
+    console.log(`Command only supported for ${chalk.bold.green('library mode')} components.`)
+    process.exit();
+  }
+
+  const hasArch = await hasArchives();
+
+  await cleanUpTemp();
+
+  addDebugLog("importArchive", "", "+");
+
+
+  if (options.params.length >= 5) {
+    const filePath = options.params[3];
+    const fileName = options.params[4];
+    await importArch( filePath, fileName, hasArch);
+
+  }
+  else {
+
+    const filePathQuestions = await getFilePathQuestions();
+    const filePathAnswers = await inquirer.prompt(filePathQuestions);
+    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;
+
+
+    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);
+
+
+
+  }
+
+addDebugLog("importArchive", "END", "-");
+
+};

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

@@ -0,0 +1,93 @@
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+import { join } from 'path';
+import { addDebugLog, getConfigDefaults, setConfigImportRelativePath, forceDefaultsUpdate } from '../../util.js';
+
+export const getFilePathQuestions = async () => {
+addDebugLog("getFilePathQuestions", "", "");
+
+  console.log("\nFile path examples:");
+  if (path.sep === "/") {
+    console.log("\tMac OS/Unix:\t/Users/name/...\n");
+  }
+  else {
+    console.log("\tWindows:\tC:\\Users\\name\\...\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);
+  if (path.sep === "/") {
+    defaultPath = "/".concat(defaultPath);
+  }
+
+
+  return [
+    {
+      name: 'filePath',
+      message: 'Enter full file path of zip file location:',
+      default: defaultPath
+    }
+  ];
+};
+
+export const getFileNameQuestions = async (zipFileList) => {
+addDebugLog("getFileNameQuestions", "", "");
+
+  return [
+    {
+      name: 'fileName',
+      type: 'rawlist',
+      message: `Select component`,
+      choices: zipFileList
+    },
+  ];
+};
+
+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]);
+
+  if (path.sep != "/") {
+    // windows
+    if (defaultPath.indexOf(path.sep) === 0) {
+      // if start with \\, then remove
+      defaultPath = defaultPath.substring(1);
+    }
+
+    if (filePath.indexOf(defaultPath) === 0) {
+
+      let relativePath = "";
+      if (filePath !== defaultPath) {
+        // same starting path, so we can save the relative
+        relativePath = filePath.replace(defaultPath.concat("/"), "");
+      }
+
+      await setConfigImportRelativePath(relativePath);
+      await forceDefaultsUpdate();
+
+    }
+  }
+  else {
+    // mac
+    if (filePath.indexOf(defaultPath) === 0) {
+
+      let relativePath = "";
+      if (filePath !== defaultPath) {
+        // same starting path, so we can save the relative
+        relativePath = filePath.replace(defaultPath.concat("/"), "");
+      }
+
+      await setConfigImportRelativePath(relativePath);
+      await forceDefaultsUpdate();
+
+    }
+  }
+
+}