@pega/custom-dx-components 0.24.17 → 0.25.1

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

@@ -0,0 +1,389 @@
+import fs from 'fs';
+import { promisify } from 'util';
+import { join } from 'path';
+import path from 'path';
+
+import inquirer from 'inquirer';
+import ncp from 'ncp';
+import chalk from 'chalk';
+
+import {
+  checkPathAccess,
+  showVersion,
+  addDebugLog,
+  checkLibraryAndArchives,
+  getConfigDefaults,
+  getLibraryBased,
+  zipVersionAndArchive,
+  zipVersionAndArchiveCL,
+  cleanUpTemp
+ } from '../../util.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();
+const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
+
+
+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' });
+  }
+
+};
+
+
+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, fullArchive = "Full", currentOrArchive = "" ) => {
+addDebugLog("exportArch", `exportPath: ${exportPath}, orgLibName: ${orgLibName}, selectedVersion: ${selectedVersion}`, "");
+  const currentDirectory = process.cwd();
+  const archiveDirectory = join (currentDirectory, ARCHIVES_PATH, `${orgLibName}`, `${selectedVersion}`);
+  const fileName = `${orgLibName}_${selectedVersion}.zip`;
+  const archFileName = join(archiveDirectory, fileName);
+  const configDef = await getConfigDefaults();
+
+  const exportFile = join(exportPath, fileName);
+
+  let output;
+
+  let archiveBeforeStore = false;
+
+  if (fullArchive != "Full") {
+    await exportCLArch(exportPath, orgLibName, selectedVersion);
+    return;
+  }
+
+
+  if (orgLibName === configDef.currentOrgLib && selectedVersion === configDef.buildVersion) {
+
+    let currentOrStore = currentOrArchive;
+    if (currentOrArchive === "") {
+      console.log("\nYou've selected the current working library/version.");
+      console.log("Export store or the current.");
+      const archAnswers = await inquirer.prompt([
+        {
+          name: 'currentOrStore',
+          type: 'rawlist',
+          message: 'Select current or store',
+          default: "Current",
+          choices: ["Current", "Store"]
+        },
+      ]);
+
+      currentOrStore = archAnswers.currentOrStore;
+
+    }
+
+    if (currentOrStore === "Current") {
+      archiveBeforeStore = true;
+    }
+  }
+
+  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();
+    }
+  }
+
+
+
+  if (archiveBeforeStore) {
+    // archive it
+    output = await zipVersionAndArchive(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 {
+    fs.copyFileSync(archFileName, exportFile );
+
+    console.log(`\n${chalk.green(`${fileName}`)} has been exported to ${chalk.green(`${exportPath}`)}`);
+  }
+
+
+}
+
+
+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();
+  }
+
+  await cleanUpTemp();
+
+  addDebugLog("exportArchive", "", "+");
+
+
+  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];
+
+
+    const currentOrArchive = options.params[7];
+
+    await exportArch(filePath, libraryName, libraryVersion, fullArchive, currentOrArchive );
+
+  }
+  else {
+    let orgLibName = "";
+    let selectedVersion = "";
+    let fullArchive = "";
+
+    if (options.params.length >= 5) {
+      fullArchive = options.params[3];
+      orgLibName = options.params[4];
+      if (options.params.length >= 6) {
+        selectedVersion = options.params[5];
+      }
+    }
+
+    if (fullArchive === "" ) {
+      const fullArchiveQuestions = await getFullArchiveQuestions();
+      const fullArchiveAnswers = await inquirer.prompt(fullArchiveQuestions);
+      ({ fullArchive } = fullArchiveAnswers);
+    }
+
+    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);
+      }
+
+
+      filePathQuestions = await getFilePathQuestions();
+      filePathAnswers = await inquirer.prompt(filePathQuestions);
+      ({ filePath } = filePathAnswers);
+
+      await updateSavedExportFilePath(filePath);
+
+    }
+
+    // if (path.sep === "/") {
+    //   if (filePath.lastIndexOf(path.sep) != filePath.length - 1) {
+    //     filePath = filePath.concat(path.sep);
+    //   }
+    // }
+
+    await exportArch( filePath, orgLibName, selectedVersion, fullArchive);
+
+  }
+
+addDebugLog("exportArchive", "END", "-");
+
+};

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

@@ -0,0 +1,318 @@
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+import { join } from 'path';
+import { Listr } from 'listr2';
+import { addDebugLog, getConfigDefaults, convertIntoPascalCase, getComponents, getComponentDirectoryPath, getDirectoryFiles, setConfigImportRelativePath, forceDefaultsUpdate } from '../../util.js';
+import { TASKS_CONFIG_JSON_FILENAME, TEMP_PATH, PACKAGE_JSON_FILENAME } from '../../constants.js';
+
+
+export const SOURCE_OF_COMPONENT_TYPES = {
+  SERVER: 'Server',
+  LOCAL: 'Local'
+};
+
+export const setTasksConfig = async (libraryName, version, devBuild, currDir) => {
+addDebugLog("setTasksConfig", `libraryName: ${libraryName}, version: ${version}, devBuild: ${devBuild}`, "");
+  const pegaConfigJsonPath = join(currDir, TASKS_CONFIG_JSON_FILENAME);
+  const sPegaData = fs.readFileSync(pegaConfigJsonPath, { encoding: 'utf8' });
+  const configData = JSON.parse(sPegaData);
+  let serverConfig = configData['server-config'];
+  serverConfig.devBuild = devBuild;
+  let compConfig = configData['component'];
+  compConfig.library = libraryName;
+  compConfig.version = version;
+
+  // update file
+  // stringify "4", makes the json string look like JSON in the file, formated instead of a single line
+  fs.writeFileSync(pegaConfigJsonPath, JSON.stringify(configData, null, 4), { encoding: 'utf8',flag:'w' });
+}
+
+export const setPackageOrg = async (organization, currDir) => {
+addDebugLog("setPackageOrg", "", "");
+  const packageJsonPath = join(currDir, PACKAGE_JSON_FILENAME);
+  const sPackage = fs.readFileSync(packageJsonPath, { encoding: 'utf8'});
+  const packageData = JSON.parse(sPackage);
+
+  packageData.organization = organization;
+
+    // update file
+  // stringify "4", makes the json string look like JSON in the file, formated instead of a single line
+  fs.writeFileSync(packageJsonPath, JSON.stringify(packageData, null, 4), { encoding: 'utf8',flag:'w' });
+
+}
+
+export const updateConfig = async (
+  {
+    oldComponentKey,
+    newComponentKey,
+    organization,
+    library,
+    version,
+    currentDirectory,
+  }
+) => {
+
+addDebugLog("updateConfig", `oldComponentKey: ${oldComponentKey}, newComponentKey: ${newComponentKey}`, "");
+
+  let configData = fs.readFileSync(join(currentDirectory, "/config.json"), { encoding: 'utf8' });
+  configData = configData && JSON.parse(configData);
+
+  configData.name = newComponentKey;
+  if (configData.componentKey) configData.componentKey = newComponentKey;
+  configData.organization = organization;
+  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(currentDirectory, "/config.json"), JSON.stringify(configData, null, 4), { encoding: 'utf8',flag:'w' });
+
+};
+
+export const updateFile = async (
+    fileName,
+    oldComponentKeyPC,
+    newComponentKeyPC,
+    currentDirectory,
+) => {
+
+addDebugLog("updateFile", `fileName: ${fileName}, oldComponentKeyPC: ${oldComponentKeyPC}, newComponentKeyPC: ${newComponentKeyPC}, currentDirectory: ${currentDirectory}`, "");
+
+  let fileData = fs.readFileSync(join(currentDirectory, "/", fileName), { encoding: 'utf8' });
+
+  if (fileData.indexOf(oldComponentKeyPC) >= 0) {
+    fileData = fileData.replaceAll(oldComponentKeyPC, newComponentKeyPC);
+
+    fs.writeFileSync(join(currentDirectory, "/", fileName), fileData, { encoding: 'utf8',flag:'w' });
+  }
+
+};
+
+export const reanmeDirectory = async(currentDirectory, targetDirectory) => {
+  if (!fs.existsSync(targetDirectory)) {
+    fs.mkdirSync(targetDirectory, { recursive: true });
+  }
+
+  const targetFileList = await getDirectoryFiles(currentDirectory);
+  for (const targetFile of targetFileList) {
+    const currentFilePath = join(currentDirectory, targetFile);
+    const targetFilePath = join(targetDirectory, targetFile);
+    fs.copyFileSync(currentFilePath, targetFilePath)
+  }
+
+  // fs.rm(currentDirectory, { recursive: true }, err => {
+  //   if (err) {
+  //     throw err;
+  //   }
+  // });
+
+  fs.rmSync(currentDirectory, { recursive: true, force: true, maxRetries: 2  });
+
+
+}
+
+// rename the component
+export const renameComponent = async (
+  componentKey,
+  library,
+  version,
+  currDir
+) => {
+
+addDebugLog("renameComponent", `library: ${library}, componentKey: ${componentKey}`, "");
+
+
+const componentName = componentKey.split("_")[2];
+
+const configDef = getConfigDefaults();
+const orgLibName = `${configDef.organization}_${library}`;
+const organization = configDef.organization;
+
+const newComponentKey = `${orgLibName}_${componentName}`;
+
+const oldComponentKey = componentKey;
+const newComponentKeyPC = convertIntoPascalCase(newComponentKey);
+const oldComponentKeyPC = convertIntoPascalCase(oldComponentKey);
+
+const currentDirectory = await getComponentDirectoryPath(componentKey, currDir);
+const targetDirectory = await getComponentDirectoryPath(newComponentKey, currDir);
+
+const targetFileList = await getDirectoryFiles(currentDirectory);
+
+for (const fileIndex in targetFileList) {
+  const fileName = targetFileList[fileIndex];
+
+  if (fileName === "config.json") {
+    await updateConfig(
+      {
+        oldComponentKey,
+        newComponentKey,
+        componentName,
+        organization,
+        library,
+        version,
+        currentDirectory,
+      }
+    );
+  }
+  else {
+    await updateFile(
+        fileName,
+        oldComponentKeyPC,
+        newComponentKeyPC,
+        currentDirectory );
+
+  }
+
+} // for
+
+
+
+// rename the directory
+await reanmeDirectory(currentDirectory, targetDirectory);
+
+
+return newComponentKey;
+
+};
+
+export const renameComponents = async(compList, libraryName, version, compDir) => {
+  for (const componentKey of compList) {
+    await renameComponent(componentKey, libraryName, version, compDir);
+  }
+}
+
+export const updateTempArchive = async(libraryName, version, devBuild) => {
+  const currentDirectory = process.cwd();
+  const tempStoreDirectory = join(currentDirectory, TEMP_PATH);
+  const configDef = getConfigDefaults();
+
+  // remove -dev if exists
+  const justVersion = version.replace("-dev", "");
+
+
+  const tasks = new Listr(
+    [
+      {
+        title: 'Update tasks.config',
+        task: async () => {
+          await setTasksConfig(libraryName, justVersion, devBuild, tempStoreDirectory);
+        }
+      },
+      {
+        title: 'Update package.json',
+        task: async () => {
+          await setPackageOrg(configDef.organization, tempStoreDirectory);
+        }
+      },
+      {
+        title: `Renaming components`,
+        task: async () => {
+          const compDir = join(tempStoreDirectory, "src", "components");
+          const compList = await getComponents(compDir);
+
+          await renameComponents(compList, libraryName, version, compDir);
+        }
+      }
+    ],
+    {
+      exitOnError: true
+    }
+  );
+
+  await tasks.run().catch(err => {
+    console.log(chalk.bold.red(err.toString()));
+    process.exit(1);
+  });
+
+
+}
+
+
+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 zip file`,
+      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();
+
+    }
+  }
+
+}