@pega/custom-dx-components 0.242.26 → 0.242.27

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

@@ -15,14 +15,15 @@ import { checkPathAccess, showVersion ,
   getComponentDirectoryPath,
   getPegaServerConfig,
   getComponents,
-  getComponentDefaults,
   sanitize,
   validateSemver,
   updateComponentDefaultLibrary,
   updateComponentDefaultVersion,
   copyFileToShared,
   getLibraryBased,
-  addDebugLog
+  addDebugLog,
+  checkLibraryAndArchives,
+  getConfigDefaults
 } from '../../util.js';
 
 import { COMPONENT_SCHEMA, COMPONENTS_DIRECTORY_PATH, TASKS_CONFIG_JSON_FILENAME, COMPONENTS_PATH, CATEGORY_CONSTELLATION, SHARED_FILE_NAMES } from '../../constants.js';
@@ -33,7 +34,7 @@ const pegaConfigJsonPath = path.join(path.resolve(), TASKS_CONFIG_JSON_FILENAME)
 
 const copy = promisify(ncp);
 
-let isLibraryBased = await getLibraryBased();
+const isLibraryBased =  getLibraryBased();
 
 const copyComponentTemplate = async (options) => {
   if (options.targetDirectory) {
@@ -174,7 +175,6 @@ export const validateCompile = async (
     sSubType = subtype.join('-');
   }
 
-  // await checkPathAccess(pegaConfigInternalJsonPath);
 
   framework = convertIntoPascalCase(CATEGORY_CONSTELLATION);
 
@@ -189,12 +189,22 @@ export const validateCompile = async (
   const originalFramework = framework;
 
   // check of library or version has changed from default, if so, update componentDefaults
-  const componentDefaults = await getComponentDefaults();
+  const componentDefaults = getConfigDefaults();
   if (componentDefaults.library == null || componentDefaults.library !== library) {
     await updateComponentDefaultLibrary(library);
   }
-  if (componentDefaults.version == null || componentDefaults.version !== version) {
-    await updateComponentDefaultVersion(version);
+
+  // library based, get version from defaults
+  if (isLibraryBased) {
+    version = componentDefaults.version;
+    if (defaultPegaServerConfig.devBuild) {
+      version = version.concat("-dev");
+    }
+  }
+  else {
+    if (componentDefaults.version == null || componentDefaults.version !== version) {
+      await updateComponentDefaultVersion(version);
+    }
   }
 
   if (isLaunchpad) {
@@ -216,12 +226,8 @@ export const validateCompile = async (
 
   }
 
-
-
   const componentKey = `${organization}_${library}_${componentName}`;
-
   const targetDirectory = await getComponentDirectoryPath(componentKey);
-
   const components = await getComponents(false);
 
   if (components.includes(componentKey)) {
@@ -254,8 +260,6 @@ export const validateCompile = async (
 
 export const validateCompileAll = async ({ prefix, library, version, allowedApplications, organization }, options) => {
 
-  isLibraryBased = await getLibraryBased();
-
   // eslint-disable-next-line no-restricted-syntax, guard-for-in
   for (const fieldIdx in COMPONENT_SCHEMA.subtype.field) {
     const type = 'Field';
@@ -355,6 +359,8 @@ export const validateCompileAll = async ({ prefix, library, version, allowedAppl
 export default async (options) => {
   await showVersion();
 
+  await checkLibraryAndArchives();
+
 addDebugLog("createAll", "", "+");
 
   await checkPathAccess(pegaConfigJsonPath);
@@ -373,7 +379,7 @@ addDebugLog("createAll", "", "+");
   ({ library } = componentData);
   let { organization } = JSON.parse(fs.readFileSync(path.resolve('package.json'), 'utf8'));
 
-  const componentDefaults = await getComponentDefaults();
+  const componentDefaults = getConfigDefaults();
   componentDefaults.library = library;
 
   if (options.params.length >= 8) {
@@ -410,7 +416,8 @@ addDebugLog("createAll", "", "+");
             return true;
           }
           return 'Please provide semver compatible version e.g 0.0.1';
-        }
+        },
+        when: () => !isLibraryBased
       },
       {
         name: 'library',
@@ -426,7 +433,8 @@ addDebugLog("createAll", "", "+");
             return true;
           }
           return 'Only alphanumeric values are allowed, starting with alphabets';
-        }
+        },
+        when: () => !isLibraryBased
       },
       {
         name: 'allowedApplications',
@@ -438,6 +446,13 @@ addDebugLog("createAll", "", "+");
 
     await inquirer.prompt(questions).then(async (answers) => {
       ({library} = answers);
+
+      if (isLibraryBased) {
+        // library comes from config
+        const orgLib = getConfigDefaults();
+        library = orgLib.library;
+      }
+
       const { version, allowedApplications } = answers;
       let { prefix } = answers;
       prefix = prefix.replace(/[^a-zA-Z0-9 ]/g, '');

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

@@ -0,0 +1,80 @@
+
+import chalk from 'chalk';
+
+import {
+  sanitize,
+  validateSemver,
+  getLibraryArchiveDirectories,
+  addDebugLog,
+  getConfigDefaults
+} from '../../util.js';
+
+export const getOkToProceedQuestion = async () => {
+addDebugLog("getCreateLibComponentQuestions", "", "");
+
+  return [
+    {
+      name: 'okToContinue',
+      type: 'confirm',
+      message: 'Ok to continue ?',
+      default: false
+    }
+  ];
+
+}
+
+export const getCreateLibComponentQuestions = async () => {
+addDebugLog("getCreateLibComponentQuestions", "", "");
+  const archDirectories = await getLibraryArchiveDirectories();
+  const orgLib = getConfigDefaults();
+
+
+  return [
+    {
+      name: 'libraryName',
+      message: 'Enter 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 = `${orgLib.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.';
+    }
+      }
+    },
+    {
+      name: 'version',
+      message: 'Enter version ',
+      default: '0.0.1',
+      validate: value => {
+        if (validateSemver(value)) {
+          return true;
+        }
+        return 'Please provide semver compatible version e.g 0.0.1';
+      }
+    },
+    {
+      name: 'permBuild',
+      type: 'confirm',
+      message: `Version to be ${chalk.bold.yellow('PERMENANT')} upon publish `,
+      default: false
+    }
+  ];
+};

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

@@ -0,0 +1,109 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+
+
+// eslint-disable-next-line import/order
+import {
+  showVersion,
+  updateComponentDefaultLibrary,
+  updateComponentDefaultVersion,
+  getLibraryBased,
+  addDebugLog,
+  zipVersionAndArchive,
+  hasArchives,
+  clearSrcComponentsDirectory,
+  hasLibraryAndVersion,
+  getConfigDefaults,
+  forceDefaultsUpdate
+} from '../../util.js';
+
+import { getCreateLibComponentQuestions, getOkToProceedQuestion } from './helper.js';
+import { showCurrentStatus } from '../show-status/index.js';
+
+
+const isLibraryBased =  getLibraryBased();
+
+export default async options => {
+  if (!isLibraryBased) {
+    console.log(`Command only supported for ${chalk.bold.green('library based')} components.`);
+    process.exit();
+  }
+
+  await showVersion();
+
+addDebugLog("createLibrary", "", "+");
+  let libraryName;
+  let version;
+  // permBuild is the opposite of devBuild
+  let permBuild;
+  const orgLib = getConfigDefaults();
+  const hasArch = await hasArchives();
+
+  if (hasArch) {
+    console.log(chalk.bold.yellow('\nBe sure to SAVE all changes before creating a new library, unsaved changes will be LOST.'))
+    console.log(chalk.bold.yellow('Current library/version will be archived and the newly created library/version will be your default.'))
+
+    const okQuestion = await getOkToProceedQuestion();
+    const okAnswers = await inquirer.prompt(okQuestion);
+    const { okToContinue } = okAnswers;
+
+    if (!okToContinue) {
+      return true;
+    }
+  }
+
+  if (options.params.length >= 6) {
+    libraryName = options.params[3];
+    version = options.params[4];
+    const dPerm = options.params[5];
+    permBuild = !!(dPerm === 'Y' || dPerm === 'y' || dPerm === true || dPerm === 'true');
+  } else {
+    const questions = await getCreateLibComponentQuestions();
+    const answers = await inquirer.prompt(questions);
+    ({ libraryName, version, permBuild } = answers);
+  }
+
+
+
+  // if have archives, then that means there is a current library, so
+  // archive it before clearing out /src/components
+
+  if (hasArch) {
+
+    const hasLib = await hasLibraryAndVersion(libraryName, version, !permBuild);
+    if (hasLib) {
+      console.log(`${chalk.bold.red(`Library ${orgLib.organization}_${libraryName} already exists.`)}`);
+      console.log("You can switch to that version by entering 'npm run switchVersion'.\n")
+      process.exit();
+    }
+
+    const currentOrgLib = orgLib.currentOrgLib;
+    const currentVersion = orgLib.buildVersion;
+    await zipVersionAndArchive(currentOrgLib, currentVersion);
+    await clearSrcComponentsDirectory();
+
+  }
+
+  const newOrgLib = `${orgLib.organization}_${libraryName}`;
+
+  if (orgLib.version == null || orgLib.version !== version) {
+    await updateComponentDefaultVersion(version);
+  }
+
+  if (!permBuild) {
+    version = version.concat("-dev");
+  }
+
+  // update library name in config and create a blank archive
+  await updateComponentDefaultLibrary(libraryName);
+  await zipVersionAndArchive(newOrgLib, version);
+
+  console.log(`${chalk.bold.green(`\nLibrary ${newOrgLib}/${version} has been created!\n`)}`);
+
+  await forceDefaultsUpdate();
+  await showCurrentStatus();
+
+addDebugLog("createLibrary", "END", "-");
+
+  return true;
+};

package/src/tasks/create-version/helper.js

@@ -0,0 +1,81 @@
+import chalk from 'chalk';
+
+import {
+  getComponents,
+  validateSemver,
+  updateConfigVersion,
+  addDebugLog,
+  getLibraryArchivesVersions,
+  getConfigDefaults
+} from '../../util.js';
+
+export const updateAllComponentsConfig = async( newVersion ) => {
+addDebugLog("updateAllComponentsConfig", `newVersion: ${newVersion}`, "");
+  const componentList = await getComponents();
+  const orgLib =  getConfigDefaults();
+  // const currentOrgLib = `${orgLib.organization}_${orgLib.library}`;
+  const currentOrgLib = orgLib.currentOrgLib;
+
+  for (const index in componentList) {
+    const componentKey = componentList[index];
+    await updateConfigVersion(componentKey, newVersion, currentOrgLib);
+
+  }
+};
+
+export const getNextVersion = async () => {
+addDebugLog("getNextVersion", "", "");
+  const orgLib =  getConfigDefaults();
+  const currentOrgLib = orgLib.currentOrgLib;
+  const archiveVersionList = await getLibraryArchivesVersions(currentOrgLib);
+
+  if (archiveVersionList && archiveVersionList.length > 0) {
+    let lastVersion = archiveVersionList[archiveVersionList.length - 1];
+    lastVersion = lastVersion.replaceAll("-dev", "");
+
+    const arVer = lastVersion.split(".");
+    arVer[2] = (parseInt(arVer[2]) + 1).toString();
+    const incrVersion = arVer.join(".");
+
+    return incrVersion;
+  }
+  else {
+    return "0.0.1";
+  }
+
+
+}
+
+export const getCreateVersionComponentQuestions = async () => {
+addDebugLog("getCreateVersionComponentQuestions", "", "");
+  const componentDefaults =  getConfigDefaults();
+
+  // increment the version
+  const incrVersion = await getNextVersion();
+
+  return [
+    {
+      name: 'version',
+      message: 'Enter version ',
+      default: incrVersion,
+      validate: value => {
+        if (validateSemver(value)) {
+          return true;
+        }
+        return 'Please provide semver compatible version e.g 0.0.1';
+      }
+    },
+    {
+      name: 'permBuild',
+      type: 'confirm',
+      message: `Version ${chalk.bold.yellow('PERMENANT')} upon publish ?`,
+      default: !componentDefaults.devBuild
+    },
+    {
+      name: 'copyExisting',
+      type: 'confirm',
+      message: 'Copy current components to new version ?',
+      default: true
+    },
+  ];
+};

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

@@ -0,0 +1,108 @@
+import { join } from 'path';
+import fs from 'fs';
+
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+
+
+// eslint-disable-next-line import/order
+import {
+  showVersion,
+  updateComponentDefaultVersion,
+  getLibraryBased,
+  addDebugLog,
+  zipVersionAndArchive,
+  setConfigDevBuild,
+  checkLibraryAndArchives,
+  getConfigDefaults
+} from '../../util.js';
+
+import { getCreateVersionComponentQuestions, updateAllComponentsConfig } from './helper.js';
+
+const isLibraryBased =  getLibraryBased();
+
+export default async options => {
+  if (!isLibraryBased) {
+    console.log(`Command only supported for ${chalk.bold.green('library based')} components.`);
+    process.exit();
+  }
+
+  await showVersion();
+  await checkLibraryAndArchives();
+
+addDebugLog("createVersion", "", "+");
+  let libraryName;
+  let version;
+  // permBuild is the opposite of devBuild
+  let permBuild;
+  let copyExisting;
+
+  const componentDefaults =  getConfigDefaults();
+  const currentDirectory = process.cwd();
+  const componentDirectory = join (currentDirectory, "src", "components");
+
+
+  if (options.params.length >= 6) {
+    version = options.params[3];
+    const dPerm = options.params[4];
+    const copyExist = options.params[5]
+    permBuild = !!(dPerm === 'Y' || dPerm === 'y' || dPerm === true || dPerm === 'true');
+    copyExisting = !!(copyExist === 'Y' || copyExist === 'y' || copyExist === true || copyExist === 'true');
+
+  } else {
+    const questions = await getCreateVersionComponentQuestions();
+    const answers = await inquirer.prompt(questions);
+    ({ version, permBuild, copyExisting } = answers);
+  }
+
+  const orgLib =  getConfigDefaults();
+  const savedNewVersion = version;
+  const existingOrgLib = orgLib.currentOrgLib;
+  let oldVersion = componentDefaults.version;
+  if (componentDefaults.devBuild) {
+    oldVersion = oldVersion.concat("-dev");
+  }
+
+  if (!permBuild) {
+    version = version.concat("-dev");
+  }
+
+  // archive existing
+  await zipVersionAndArchive(existingOrgLib, oldVersion);
+
+  if (copyExisting) {
+    // change all existing config to new version
+    await updateAllComponentsConfig(version);
+  }
+  else {
+    // wipe out /src/components
+    try {
+      fs.rmSync(componentDirectory, { recursive: true });
+addDebugLog("createVersion", `clear out: ${componentDirectory}`, "");
+    } catch (err) {
+      console.log(`No such directory: ${componentDirectory} `);
+      throw new Error(`No such file ${componentDirectory}`);
+    }
+
+    // create a blank directory
+addDebugLog("createVersion", `make new directory: ${componentDirectory}`, "");
+    fs.mkdirSync(componentDirectory, { recursive: true });
+  }
+
+  // update config with new version
+  await updateComponentDefaultVersion(savedNewVersion);
+  await setConfigDevBuild(!permBuild);
+
+  // create archive of new
+  await zipVersionAndArchive(existingOrgLib, version);
+
+
+
+  console.log(`${chalk.bold.green(`\nLibrary ${existingOrgLib}/${oldVersion} has been archived.`)}`);
+  console.log(`${chalk.bold.green(`Library ${existingOrgLib}/${version} has been created!\n`)}`);
+
+
+addDebugLog("createVersion", "END", "-");
+
+  return true;
+};

package/src/tasks/delete/index.js

@@ -1,10 +1,10 @@
 import inquirer from 'inquirer';
 
-import { showVersion, getLibraryBased, addDebugLog } from '../../util.js';
+import { showVersion, getLibraryBased, addDebugLog, checkLibraryAndArchives } from '../../util.js';
 
 import { deleteLocalComponents, SOURCE_OF_COMPONENT_TYPES, deleteServerComponents, getDeleteComponentsQuestions } from './helper.js';
 
-const isLibraryBased = await getLibraryBased();
+const isLibraryBased = getLibraryBased();
 
 const deleteComponentsFn = async (sourceOfComponents, answers, options) => {
 addDebugLog("deleteComponentsFn", `sourceOfComponents: ${sourceOfComponents}`, "");
@@ -26,6 +26,7 @@ addDebugLog("deleteComponentsFn", `sourceOfComponents: ${sourceOfComponents}`, "
 
 export default async (options) => {
   await showVersion();
+  await checkLibraryAndArchives();
 
 addDebugLog("delete", "", "+");
 
@@ -37,12 +38,14 @@ addDebugLog("delete", "", "+");
   else if (options.params[3] === SOURCE_OF_COMPONENT_TYPES.LOCAL) {
     sourceOfComponentsOption = options.params[3];
     await deleteComponentsFn(sourceOfComponentsOption, null, options);
-  } else if (options.params[3] === SOURCE_OF_COMPONENT_TYPES.SERVER) {
+  }
+  else if (options.params[3] === SOURCE_OF_COMPONENT_TYPES.SERVER) {
     sourceOfComponentsOption = options.params[3];
     const questions = await getDeleteComponentsQuestions(options, sourceOfComponentsOption);
     const answers = await inquirer.prompt(questions);
     await deleteComponentsFn(sourceOfComponentsOption, answers, options);
-  } else {
+  }
+  else {
     const questions = await getDeleteComponentsQuestions(options);
     const answers = await inquirer.prompt(questions);
     const { sourceOfComponents } = answers;

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

@@ -1,13 +1,18 @@
 import inquirer from 'inquirer';
 
-import { showVersion, getLibraryBased, addDebugLog } from '../../util.js';
+import { showVersion, getLibraryBased, addDebugLog, checkLibraryAndArchives } from '../../util.js';
 
-import { deleteLocalComponents, SOURCE_OF_COMPONENT_TYPES, deleteServerComponents, getDeleteComponentsQuestions } from './helper.js';
+import {
+  deleteLocalComponents,
+  SOURCE_OF_COMPONENT_TYPES,
+  deleteServerComponents,
+  getDeleteComponentsQuestions
+} from './helper.js';
 
-const isLibraryBased = await getLibraryBased();
+const isLibraryBased = getLibraryBased();
 
 const deleteComponentsFn = async (sourceOfComponents, answers, options) => {
-addDebugLog("deleteComponentsFn", `sourceOfComponents: ${sourceOfComponents}`, "");
+  addDebugLog('deleteComponentsFn', `sourceOfComponents: ${sourceOfComponents}`, '');
   switch (sourceOfComponents) {
     case SOURCE_OF_COMPONENT_TYPES.LOCAL: {
       await deleteLocalComponents(sourceOfComponents, options);
@@ -24,17 +29,17 @@ addDebugLog("deleteComponentsFn", `sourceOfComponents: ${sourceOfComponents}`, "
   }
 };
 
-export default async (options) => {
+export default async options => {
   await showVersion();
+  await checkLibraryAndArchives();
 
-addDebugLog("deleteAll", "", "+");
+  addDebugLog('deleteAll', '', '+');
 
   let sourceOfComponentsOption = SOURCE_OF_COMPONENT_TYPES.LOCAL;
   if (isLibraryBased) {
     sourceOfComponentsOption = SOURCE_OF_COMPONENT_TYPES.LOCAL;
     await deleteComponentsFn(sourceOfComponentsOption, null, options);
-  }
-  else if (options.params[3] === SOURCE_OF_COMPONENT_TYPES.LOCAL) {
+  } else if (options.params[3] === SOURCE_OF_COMPONENT_TYPES.LOCAL) {
     sourceOfComponentsOption = options.params[3];
     await deleteComponentsFn(sourceOfComponentsOption, null, options);
   } else if (options.params[3] === SOURCE_OF_COMPONENT_TYPES.SERVER) {
@@ -49,5 +54,5 @@ addDebugLog("deleteAll", "", "+");
     await deleteComponentsFn(sourceOfComponents, answers, options);
   }
 
-addDebugLog("deleteAll", "END", "-");
+  addDebugLog('deleteAll', 'END', '-');
 };

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

@@ -1,76 +1,49 @@
-import fs from 'fs';
 import path from 'path';
-
 import chalk from 'chalk';
 
-import { getPegaServerConfig, checkPathAccess, getComponentDefaults, addDebugLog } from '../../util.js';
-import {
-  TASKS_CONFIG_JSON_FILENAME,
-  COMPONENTS_DIRECTORY_PATH,
-  COMPONENTS_PATH
-} from '../../constants.js';
+import { addDebugLog, getConfigDefaults, getLibraryArchiveDirectories } from '../../util.js';
 
 export const SOURCE_OF_COMPONENT_TYPES = {
   SERVER: 'Server',
   LOCAL: 'Local'
 };
 
-const pegaConfigJsonPath = path.join(path.resolve(), TASKS_CONFIG_JSON_FILENAME);
-
-export const getOrgLib = async () => {
-addDebugLog("getOrgLib", "", "+");
-  const defaultPegaConfig = await getPegaServerConfig();
-
-  await checkPathAccess(pegaConfigJsonPath);
-
-  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);
-  }
-
-  const componentData = data[COMPONENTS_PATH];
-
-  let library;
-  ({ library } = componentData);
-  const { organization } = JSON.parse(fs.readFileSync(path.resolve('package.json'), 'utf8'));
-
-  const componentDefaults = await getComponentDefaults();
-  componentDefaults.library = library;
-  componentDefaults.organization = organization;
-
-addDebugLog("getOrgLib", `componentsDefaults: ${JSON.stringify(componentDefaults)}`, "");
-addDebugLog("getOrgLib", "END", "-");
-  return componentDefaults;
-};
 
 export const getDeleteLibraryQuestions = async () => {
 addDebugLog("getDeleteLibraryQuestions", "", "");
-  const defaultPegaConfig = await getPegaServerConfig();
+  const configDef = getConfigDefaults();
+  const archLibs = await getLibraryArchiveDirectories("");
 
   return [
     {
-      name: 'sourceOfLibrary',
+      name: 'libraryName',
       type: 'rawlist',
-      message: 'Delete library from Server or Local ?',
-      choices: Object.values(SOURCE_OF_COMPONENT_TYPES),
-      default: defaultPegaConfig.sourceOfComponents
+      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 (or ALL) to delete`,
+      message: `Select ${chalk.green.bold(`${libraryName}`)} library version ${orAll}to delete`,
       choices: libVersions
+    },
+    {
+      name: 'confirmDeletion',
+      type: 'confirm',
+      message: 'Confirm deletion ?',
+      default: false
     }
   ];
 };