@pega/custom-dx-components 0.24.17 → 0.25.1

package/src/tasks/delete-lib/helper.js

@@ -0,0 +1,54 @@
+import path from 'path';
+import chalk from 'chalk';
+
+import { addDebugLog, getConfigDefaults, getLibraryArchiveDirectories } from '../../util.js';
+
+export const SOURCE_OF_COMPONENT_TYPES = {
+  SERVER: 'Server',
+  LOCAL: 'Local'
+};
+
+
+export const getDeleteLibraryQuestions = async () => {
+addDebugLog("getDeleteLibraryQuestions", "", "");
+  const configDef = getConfigDefaults();
+  const archLibs = await getLibraryArchiveDirectories("");
+
+  if (archLibs.length === 0) {
+    console.log(chalk.red(`No libraries exist to delete.`));
+    process.exit();
+  }
+
+  return [
+    {
+      name: 'libraryName',
+      type: 'rawlist',
+      message: 'Select library',
+      choices: archLibs
+    }
+  ];
+};
+
+export const getLibraryVersionQuestion = async (libraryName, libVersions) => {
+addDebugLog("getLibraryVersionQuestion", `libraryName: ${libraryName}`, "");
+
+let orAll = "";
+if (libVersions.length > 1) {
+  orAll = "(or All) ";
+}
+
+  return [
+    {
+      name: 'version',
+      type: 'rawlist',
+      message: `Select ${chalk.green.bold(`${libraryName}`)} library version ${orAll}to delete`,
+      choices: libVersions
+    },
+    {
+      name: 'confirmDeletion',
+      type: 'confirm',
+      message: 'Confirm deletion ?',
+      default: false
+    }
+  ];
+};

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

@@ -0,0 +1,264 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+
+import {
+  showVersion,
+  getLibraryBased,
+  checkLibraryAndArchives,
+  addDebugLog,
+  getConfigDefaults,
+  getLibraryArchivesVersions,
+  deleteLocalArchiveLibrary,
+  deleteLocalArchiveLibraryVersion,
+  deleteLocalComponent,
+  getHaveDependencyDifference,
+  getComponents,
+  getLibraryArchiveDirectories,
+  deleteArchives,
+  forceDefaultsUpdate,
+  restoreFromArchive,
+  cleanUpTemp
+} from '../../util.js';
+
+import { getDeleteLibraryQuestions, getLibraryVersionQuestion } from './helper.js';
+import { showCurrentStatus } from '../show-status/index.js';
+
+
+
+export const deleteLibraryVersion = async (libraryName, version = "", okToDelete) => {
+addDebugLog("deleteLibraryVersion", "", "+");
+
+  const isLibraryBased = getLibraryBased();
+  const compDef = getConfigDefaults();
+  let libVersions = [];
+  let confirmDeletion;
+
+  if (!isLibraryBased) {
+    console.log(`Command only supported for ${chalk.bold.green('library mode')} components.`);
+    process.exit();
+  }
+
+  try {
+    libVersions = await getLibraryArchivesVersions(libraryName, "");
+  }
+  catch (ex) {}
+
+  if (version === "" || version === "ALL") {
+
+    if (libVersions.length > 0) {
+      // ALL option
+
+      if (version !== "ALL") {
+        if (libVersions.length > 1) {
+          libVersions.unshift('ALL');
+        }
+
+        const versionQuestions = await getLibraryVersionQuestion(libraryName, libVersions);
+        const versionAnswers = await inquirer.prompt(versionQuestions);
+
+        ({version, confirmDeletion} = versionAnswers);
+
+        if (!confirmDeletion) {
+          console.log(chalk.green(`Library not deleted.`));
+          process.exit();
+        }
+      }
+
+      if (okToDelete === undefined) {
+        if (libraryName === compDef.currentOrgLib && (version === "ALL" || version === compDef.buildVersion)) {
+          console.log(`\n${chalk.bold.yellow(`${compDef.displayLibVersion}`)} is your ${chalk.yellow('CURRENT')} library/version.`);
+          console.log(chalk.bold.yellow('Your current components will be DELETED!!!'))
+          const confirmAnswers = await inquirer.prompt([
+            {
+              name: 'confirmDeletion',
+              type: 'confirm',
+              message: 'Ok to delete?',
+              default: false
+            }
+          ]);
+
+          if (!confirmAnswers.confirmDeletion) {
+            console.log(chalk.green(`Library not deleted.`));
+            process.exit();
+          }
+
+        }
+      }
+      else if (!okToDelete) {
+        console.log(chalk.green(`Library not deleted.`));
+        process.exit();
+      }
+
+
+    }
+    else {
+        // No library with that name
+        console.log(chalk.redBright(`No local library named: ${libraryName} exists.`));
+addDebugLog("deleteLibraryVersion", "END", "-");
+        process.exit();
+
+    }
+
+  }
+  else {
+    if (okToDelete === undefined) {
+      if (libraryName === compDef.currentOrgLib && (version === "ALL" || version === compDef.buildVersion)) {
+        console.log(`\n${chalk.bold.yellow(`${compDef.displayLibVersion}`)} is your ${chalk.yellow('CURRENT')} library/version.`);
+        console.log(chalk.bold.yellow('Your current components will be DELETED!!!'))
+        const confirmAnswers = await inquirer.prompt([
+          {
+            name: 'confirmDeletion',
+            type: 'confirm',
+            message: 'Ok to delete?',
+            default: false
+          }
+        ]);
+
+        if (!confirmAnswers.confirmDeletion) {
+          console.log(chalk.green(`Library not deleted.`));
+          process.exit();
+        }
+
+      }
+    }
+    else if (!okToDelete) {
+      console.log(chalk.green(`Library not deleted.`));
+      process.exit();
+    }
+
+
+  }
+
+  // so if going to remove the only version, then remove ALL
+  if (version === 'ALL' || libVersions.length == 1) {
+    await deleteLocalArchiveLibrary(libraryName);
+  }
+  else {
+    await deleteLocalArchiveLibraryVersion(libraryName, version);
+  }
+
+  if (libraryName === compDef.currentOrgLib && (version === "ALL" || version === compDef.buildVersion)) {
+    // delete all components
+    const localComponents = await getComponents()
+    for (const component of localComponents) {
+      // console.log(chalk.bold.green("Deleting: " + componentToDelete));
+      // eslint-disable-next-line no-await-in-loop
+      await deleteLocalComponent(component);
+    }
+
+    // switch to another version, if no versions to switch to then delete /store so will be back to state of nothing
+    const archiveLibraries = await getLibraryArchiveDirectories("");
+    if (archiveLibraries && archiveLibraries.length > 0) {
+      if (archiveLibraries.includes(libraryName)) {
+        const archLibVersions = await getLibraryArchivesVersions(libraryName, "");
+        const lastVersion = archLibVersions[archLibVersions.length -1];
+        const switchToFileName = `${libraryName}_${lastVersion}.zip`;
+        await restoreFromArchive(switchToFileName, libraryName, lastVersion);
+
+        await forceDefaultsUpdate();
+        const configDef = getConfigDefaults();
+        console.log(`\nSwitched to ${chalk.green(`${configDef.displayLibVersion}`)}`);
+        await showCurrentStatus();
+
+      }
+      else {
+        // pick first
+        const newLib = archiveLibraries[0];
+        const archLibVersions = await getLibraryArchivesVersions(newLib, "");
+        const lastVersion = archLibVersions[archLibVersions.length -1];
+        const switchToFileName = `${newLib}_${lastVersion}.zip`;
+        await restoreFromArchive(switchToFileName, newLib, lastVersion);
+
+
+        await forceDefaultsUpdate();
+        const configDef = getConfigDefaults();
+        console.log(`\nSwitched to ${chalk.green(`${configDef.displayLibVersion}`)}`);
+        await showCurrentStatus();
+
+        if (getHaveDependencyDifference()) {
+
+          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');
+
+        }
+
+      }
+    }
+    else {
+      // no libraries, so remove "/store"
+      await deleteArchives();
+    }
+
+  }
+  else {
+    // switch to another version, if no versions to switch to then delete /store so will be back to state of nothing
+    const archiveLibraries = await getLibraryArchiveDirectories("");
+    if (!archiveLibraries || archiveLibraries.length === 0) {
+      // no libraries, so remove "/store"
+      await deleteArchives();
+    }
+
+  }
+
+
+addDebugLog("deleteLibraryVersion", "END", "-");
+
+}
+
+export default async (options) => {
+  const isLibraryBased = getLibraryBased();
+  if (!isLibraryBased) {
+    console.log(`Command only supported for ${chalk.bold.green('library based')} components.`)
+    process.exit();
+  }
+
+  await showVersion();
+  await checkLibraryAndArchives();
+  await cleanUpTemp();
+
+addDebugLog("deleteLibrary", "", "+");
+
+
+  let version = "";
+  let okToDelete;
+
+  const compDef = getConfigDefaults();
+  let libraryName;
+
+  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];
+      version = "ALL"
+    }
+    else {
+      const questions = await getDeleteLibraryQuestions();
+      const answers = await inquirer.prompt(questions);
+      ({ libraryName } = answers);
+    }
+
+
+
+  }
+
+  await deleteLibraryVersion(libraryName, version, okToDelete);
+
+
+
+addDebugLog("deleteLibrary", "END", "-");
+
+  return true;
+};

package/src/tasks/delete-pub/helper.js

@@ -0,0 +1,35 @@
+import chalk from 'chalk';
+import { getPegaServerConfig, addDebugLog } from '../../util.js';
+
+export const SOURCE_OF_COMPONENT_TYPES = {
+  SERVER: 'Server',
+  LOCAL: 'Local'
+};
+
+
+export const getDeleteLibraryQuestions = async () => {
+addDebugLog("getDeleteLibraryQuestions", "", "");
+  const defaultPegaConfig = await getPegaServerConfig();
+
+  return [
+    {
+      name: 'sourceOfLibrary',
+      type: 'rawlist',
+      message: 'Delete library from Server or Local ?',
+      choices: Object.values(SOURCE_OF_COMPONENT_TYPES),
+      default: defaultPegaConfig.sourceOfComponents
+    }
+  ];
+};
+
+export const getLibraryVersionQuestion = async (libraryName, libVersions) => {
+addDebugLog("getLibraryVersionQuestion", `libraryName: ${libraryName}`, "");
+  return [
+    {
+      name: 'version',
+      type: 'rawlist',
+      message: `Select ${chalk.green.bold(`${libraryName}`)} library version (or ALL) to delete`,
+      choices: libVersions
+    }
+  ];
+};

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

@@ -0,0 +1,106 @@
+import inquirer from 'inquirer';
+
+import chalk from 'chalk';
+
+import { showVersion, getC11NB2STokenAndStaticServer, getLocalLibraryVersions, getLibraryBased, deleteLocalLibrary, deleteLocalLibraryVersion, addDebugLog, getConfigDefaults } from '../../util.js';
+import { deleteLib } from '@pega/constellation-dx-components-build-utils/index.js';
+
+import { getDeleteLibraryQuestions, getLibraryVersionQuestion, SOURCE_OF_COMPONENT_TYPES } from './helper.js';
+
+
+
+export default async (options) => {
+  const isLibraryBased = getLibraryBased();
+  if (!isLibraryBased) {
+    console.log(`Command only supported for ${chalk.bold.green('library mode')} components.`)
+    process.exit();
+  }
+
+  await showVersion();
+
+addDebugLog("deletePublished", "", "+");
+
+  let sourceOfLibrary;
+  let organization;
+  let library;
+  let version;
+
+  const compDef = getConfigDefaults();
+  organization = compDef.organization;
+  library = compDef.library;
+  const libraryName = compDef.currentOrgLib;
+
+  if (options.params.length >= 5) {
+    sourceOfLibrary = options.params[3];
+    version = options.params[4];
+
+  }
+  else {
+
+    const questions = await getDeleteLibraryQuestions();
+    const answers = await inquirer.prompt(questions);
+    ({ sourceOfLibrary } = answers);
+
+    if (sourceOfLibrary === SOURCE_OF_COMPONENT_TYPES.LOCAL ) {
+      // local
+
+      let libVersions = [];
+      try {
+        libVersions = await getLocalLibraryVersions(libraryName);
+      }
+      catch (ex) {}
+
+
+      if (libVersions.length > 0) {
+        // ALL option
+        libVersions.unshift('ALL');
+
+        const versionQuestions = await getLibraryVersionQuestion(libraryName, libVersions);
+        const versionAnswers = await inquirer.prompt(versionQuestions);
+
+        ({version} = versionAnswers);
+
+      }
+      else {
+        // No library with that name
+        console.log(chalk.redBright(`No local library named: ${libraryName} exists.`));
+addDebugLog("deletePublished", "END", "-");
+        process.exit(1);
+
+      }
+
+    }
+
+  }
+
+
+  if (sourceOfLibrary === SOURCE_OF_COMPONENT_TYPES.LOCAL ) {
+    if (version === 'ALL') {
+      await deleteLocalLibrary(libraryName);
+    }
+    else {
+      await deleteLocalLibraryVersion(libraryName, version);
+    }
+
+  }
+  else {
+    // server
+    const tokenAndStaticServer = await getC11NB2STokenAndStaticServer();
+
+    if (tokenAndStaticServer.C11NB2S === undefined) {
+      console.log(chalk.redBright("Need to authenticate, missing services token.\nDeleting a library requires authentication to acquire a token to delete."));
+addDebugLog("deletePublished", "END", "-");
+      process.exit(1);
+    }
+
+addDebugLog("deleteLib", "services call", "");
+    await deleteLib(tokenAndStaticServer.C11NB2S, tokenAndStaticServer.appStaticContentServer);
+addDebugLog("deleteLib", "services end", "");
+  }
+
+
+
+addDebugLog("deletePublished", "END", "-");
+
+  return true;
+};

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

@@ -0,0 +1,56 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+
+import {
+  showVersion,
+  getLibraryBased,
+  checkLibraryAndArchives,
+  getConfigDefaults,
+  addDebugLog,
+  cleanUpTemp
+} from '../../util.js';
+
+import { deleteLibraryVersion } from '../delete-lib/index.js';
+
+
+export default async (options) => {
+  const isLibraryBased = getLibraryBased();
+  if (!isLibraryBased) {
+    console.log(`Command only supported for ${chalk.bold.green('library mode')} components.`)
+    process.exit();
+  }
+
+  await showVersion();
+  await checkLibraryAndArchives();
+  await cleanUpTemp();
+
+addDebugLog("deleteVersion", "", "+");
+
+
+  let version = "";
+  let okToDelete;
+
+  const configDef = getConfigDefaults();
+  let libraryName = configDef.currentOrgLib;
+
+  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);
+
+
+
+addDebugLog("deleteVersion", "END", "-");
+
+  return true;
+};

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

@@ -0,0 +1,146 @@
+import chalk from 'chalk';
+import path from 'path';
+import { join } from 'path';
+import { addDebugLog, getConfigDefaults, getLibraryArchiveDirectories, getLibraryArchivesVersions, setConfigExportRelativePath, forceDefaultsUpdate } from '../../util.js';
+
+export const SOURCE_OF_COMPONENT_TYPES = {
+  SERVER: 'Server',
+  LOCAL: 'Local'
+};
+
+
+export const getFilePathQuestions = async () => {
+addDebugLog("getFilePathQuestions", "", "");
+
+  console.log("\nFile path examples:");
+  if (path.sep === "/") {
+    console.log("\tMac OS/Unix:\t/Users/name/...");
+  }
+  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.exportRelativePath);
+  if (path.sep === "/") {
+    defaultPath = "/".concat(defaultPath);
+  }
+
+
+  return [
+    {
+      name: 'filePath',
+      message: 'Enter full file path of directory to export zip file:',
+      default: defaultPath
+    }
+  ];
+};
+
+export const getFileNameQuestions = async (zipFileList) => {
+addDebugLog("getFileNameQuestions", "", "");
+
+  return [
+    {
+      name: 'fileName',
+      type: 'rawlist',
+      message: `Select zip file`,
+      choices: zipFileList
+    },
+  ];
+};
+
+export const getLibraryQuestion = async () => {
+addDebugLog("getLibraryQuestion", "", "");
+  const componentDefaults = getConfigDefaults();
+  const orgLib = getConfigDefaults();
+  const currentOrgLib = `${orgLib.organization}_${orgLib.library}`;
+
+  const archVersionList = await getLibraryArchiveDirectories("");
+
+
+  return [
+    {
+      name: 'orgLibName',
+      type: 'rawlist',
+      message: `Select a library (current library is ${chalk.bold.green(`${currentOrgLib}`)}) `,
+      choices: archVersionList
+    }
+  ];
+};
+
+export const getLibraryVersionQuestion = async (newOrgLib) => {
+addDebugLog("getLibraryVersionQuestion", "", "");
+
+  const archVersionList = await getLibraryArchivesVersions(newOrgLib, "0.0.0");
+
+  return [
+    {
+      name: 'selectedVersion',
+      type: 'rawlist',
+      message: `Select a version  `,
+      choices: archVersionList
+    }
+  ];
+};
+
+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);
+  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 setConfigExportRelativePath(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 setConfigExportRelativePath(relativePath);
+      await forceDefaultsUpdate();
+
+    }
+  }
+
+}