@pega/custom-dx-components 0.0.1 → 0.1.10

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

@@ -0,0 +1,398 @@
+import path from 'path';
+import { URL, fileURLToPath } from 'url';
+import fs from 'fs';
+import { promisify } from 'util';
+
+
+import inquirer from 'inquirer';
+import ncp from 'ncp';
+import chalk from 'chalk';
+
+// eslint-disable-next-line import/order
+import { checkPathAccess, showVersion ,
+  convertIntoPascalCase,
+  compileMustacheTemplate,
+  getComponentDirectoryPath,
+  getPegaServerConfig,
+  getComponents,
+  getComponentDefaults,
+  sanitize,
+  validateSemver
+} from '../../util.js';
+
+import { COMPONENT_SCHEMA, COMPONENTS_DIRECTORY_PATH, TASKS_CONFIG_JSON_FILENAME, COMPONENTS_PATH, CATEGORY_CONSTELLATION } from '../../constants.js';
+
+export const DXCB_CONFIG_INTERNAL_JSON_FILENAME = 'src/dxcb.config.json';
+
+const pegaConfigJsonPath = path.join(path.resolve(), TASKS_CONFIG_JSON_FILENAME);
+
+const copy = promisify(ncp);
+
+const copyComponentTemplate = async (options) => {
+  if (options.targetDirectory) {
+    return copy(options.templateDirectory, options.targetDirectory, {
+      clobber: false
+    });
+  } else {
+    return copy(options.templateDirectoryConstellation, options.targetDirectoryConstellation, {
+      clobber: false,
+      filter: (fileName) => {
+        // filter out the file config.json or config.json.mustache
+        if (fileName.indexOf('config.json') >= 0) return false;
+        else return true;
+      }
+    });
+  }
+};
+
+export const compileMustacheTemplates = async (
+  componentDirectory,
+  { componentKey, componentName, componentLabel, library, version, type, subtype, description, organization, allowedApplications }
+) => {
+  const files = fs.readdirSync(componentDirectory);
+  const componentClassName = convertIntoPascalCase(componentKey);
+
+  const isTemplate = type === 'Template';
+
+  const isBool = subtype === 'Boolean';
+  const isPhone = subtype === 'Phone';
+
+  if (Array.isArray(subtype) && subtype.length === 1) {
+    subtype = subtype.toString();
+  }
+
+  let mustacheSubType = subtype;
+
+  // overrides
+  if (typeof mustacheSubType === 'string') {
+    // eslint-disable-next-line default-case
+    switch (mustacheSubType) {
+      case 'FORM-region':
+        mustacheSubType = 'FORM';
+        break;
+      case 'DETAILS-region':
+        mustacheSubType = 'DETAILS';
+        break;
+      case 'Text-Input':
+        mustacheSubType = 'Text';
+        break;
+      case 'Picklist-Autocomplete':
+        mustacheSubType = 'Picklist';
+        break;
+      case 'Picklist-RadioButtons':
+        mustacheSubType = 'Picklist';
+        break;
+    }
+  }
+
+  const isPicklist = subtype === 'Picklist';
+
+  if (allowedApplications.trim() === '') {
+    allowedApplications = [];
+  } else {
+    if (allowedApplications.indexOf(',') !== -1) {
+      allowedApplications = allowedApplications.split(',');
+    }
+    allowedApplications = [].concat(allowedApplications);
+  }
+
+  allowedApplications = allowedApplications.filter((el) => !!el.trim()).map((el) => el.trim());
+  files.forEach((file) => {
+    const filePath = path.join(componentDirectory, file);
+
+    const output = compileMustacheTemplate(filePath, {
+      COMPONENT_KEY: componentKey,
+      COMPONENT_NAME: componentName,
+      COMPONENT_LABEL: componentLabel,
+      COMPONENT_CLASS_NAME: componentClassName,
+      ORGANIZATION: organization,
+      VERSION: version,
+      LIBRARY: library,
+      ALLOWEDAPPS: JSON.stringify(allowedApplications),
+      TYPE: type,
+      SUB_TYPE: JSON.stringify(mustacheSubType),
+      DESCRIPTION: description || componentLabel,
+      IS_TEMPLATE: isTemplate,
+      IS_PICKLIST: isPicklist,
+      IS_BOOLEAN: isBool,
+      IS_PHONE: isPhone
+    });
+    fs.writeFileSync(filePath, output);
+    fs.renameSync(filePath, filePath.replace('.mustache', ''));
+  });
+};
+
+export const validateCompile = async (
+  { library, organization, componentName, componentLabel, version, framework, type, subtype, description, allowedApplications },
+  options
+) => {
+  let sSubType = subtype;
+  if (Array.isArray(subtype)) {
+    sSubType = subtype.join('-');
+  }
+
+  // await checkPathAccess(pegaConfigInternalJsonPath);
+
+  framework = convertIntoPascalCase(CATEGORY_CONSTELLATION);
+
+  const templateParentDir = `./templates/${framework}`;
+
+  let templateDir = `${templateParentDir}/${type}/${sSubType}`;
+  let templateDirectory = fileURLToPath(new URL(templateDir, import.meta.url));
+  templateDirectory = templateDirectory.replace(`${path.sep  }create-all`, `${path.sep  }create`);
+
+  const defaultPegaServerConfig = await getPegaServerConfig();
+  const isLaunchpad = defaultPegaServerConfig.serverType === 'launchpad';
+  const originalFramework = framework;
+
+  if (isLaunchpad) {
+    framework = "Launchpad";
+
+    templateDir = `./templates/${framework}/${type}/${sSubType}`;
+    templateDirectory = fileURLToPath(new URL(templateDir, import.meta.url));
+    templateDirectory = templateDirectory.replace(`${path.sep  }create-all`, `${path.sep  }create`);
+
+    // if doesn't exist, revert
+    if (!fs.existsSync(templateDirectory)) {
+      framework = originalFramework;
+
+      templateDir = `./templates/${framework}/${type}/${sSubType}`;
+      templateDirectory = fileURLToPath(new URL(templateDir, import.meta.url));
+      templateDirectory = templateDirectory.replace(`${path.sep  }create-all`, `${path.sep  }create`);
+
+    }
+
+  }
+
+
+
+  const componentKey = `${organization}_${library}_${componentName}`;
+
+  const targetDirectory = await getComponentDirectoryPath(componentKey);
+
+  const components = await getComponents(false);
+
+  if (components.includes(componentKey)) {
+    console.log(chalk.red(`${componentKey} component already exists in ${targetDirectory}`));
+
+    return;
+  }
+
+  // component
+  await copyComponentTemplate({
+    ...options,
+    targetDirectory,
+    templateDirectory
+  });
+  await compileMustacheTemplates(targetDirectory, {
+    componentKey,
+    componentName,
+    componentLabel,
+    library,
+    version,
+    type,
+    subtype,
+    description,
+    organization,
+    allowedApplications
+  });
+
+  console.log(chalk.green(`created ${componentKey} component in ${targetDirectory}`));
+};
+
+export const validateCompileAll = async ({ prefix, library, version, allowedApplications, organization }, options) => {
+  // eslint-disable-next-line no-restricted-syntax, guard-for-in
+  for (const fieldIdx in COMPONENT_SCHEMA.subtype.field) {
+    const type = 'Field';
+    const subtype = COMPONENT_SCHEMA.subtype.field[fieldIdx].value;
+    const prefixNoSpace = prefix.replace(/\s+/g, '');
+    const componentNameNoSpace = COMPONENT_SCHEMA.subtype.field[fieldIdx].name.replace(/\s+/g, '');
+    const componentName = ''.concat(prefixNoSpace).concat(componentNameNoSpace);
+    const componentLabel = ''.concat(prefix).concat(' ').concat(COMPONENT_SCHEMA.subtype.field[fieldIdx].name);
+    const description = componentLabel;
+
+    // eslint-disable-next-line no-await-in-loop
+    await validateCompile(
+      {
+        library,
+        organization,
+        componentName,
+        componentLabel,
+        version,
+        type,
+        subtype,
+        description,
+        allowedApplications
+      },
+      options
+    );
+  }
+
+  // eslint-disable-next-line no-restricted-syntax, guard-for-in
+  for (const templateIdx in COMPONENT_SCHEMA.subtype.template) {
+    const type = 'Template';
+    const subtype = COMPONENT_SCHEMA.subtype.template[templateIdx].value;
+    const prefixNoSpace = prefix.replace(/\s+/g, '');
+    const templateNameOriginal = COMPONENT_SCHEMA.subtype.template[templateIdx].name;
+    let templateName = convertIntoPascalCase(COMPONENT_SCHEMA.subtype.template[templateIdx].name);
+    let templateLabel = convertIntoPascalCase(COMPONENT_SCHEMA.subtype.template[templateIdx].name);
+    if (templateNameOriginal.indexOf('region') >= 0) {
+      const templateNameBase = convertIntoPascalCase(templateNameOriginal.replace(' region', ''));
+      templateName = 'TwoColumn'.concat(templateNameBase);
+      templateLabel = 'Two Column '.concat(templateNameBase);
+    }
+    const componentName = ''.concat(prefixNoSpace).concat(templateName);
+    const componentLabel = ''.concat(prefix).concat(' ').concat(templateLabel);
+    const description = componentLabel;
+
+    // eslint-disable-next-line no-await-in-loop
+    await validateCompile(
+      {
+        library,
+        organization,
+        componentName,
+        componentLabel,
+        version,
+        type,
+        subtype,
+        description,
+        allowedApplications
+      },
+      options
+    );
+  }
+
+  // eslint-disable-next-line no-restricted-syntax, guard-for-in
+  for (const widgetIdx in COMPONENT_SCHEMA.subtype.widget) {
+    const type = 'Widget';
+    const subtype = COMPONENT_SCHEMA.subtype.widget[widgetIdx].value;
+    const prefixNoSpace = prefix.replace(/\s+/g, '');
+    const widgetNameOriginal = COMPONENT_SCHEMA.subtype.widget[widgetIdx].name;
+    let widgetName = convertIntoPascalCase(COMPONENT_SCHEMA.subtype.widget[widgetIdx].name).concat('Widget');
+    const widgetLabel = convertIntoPascalCase(COMPONENT_SCHEMA.subtype.widget[widgetIdx].name).concat(' Widget');
+    if (widgetName.indexOf('&') >= 0) {
+      widgetName = convertIntoPascalCase(widgetNameOriginal.replace(' & ', ''));
+    }
+    const componentName = ''.concat(prefixNoSpace).concat(widgetName);
+    const componentLabel = ''.concat(prefix).concat(' ').concat(widgetLabel);
+    const description = componentLabel;
+
+    // eslint-disable-next-line no-await-in-loop
+    await validateCompile(
+      {
+        library,
+        organization,
+        componentName,
+        componentLabel,
+        version,
+        type,
+        subtype,
+        description,
+        allowedApplications
+      },
+      options
+    );
+  }
+};
+
+
+
+export default async (options) => {
+  showVersion();
+
+  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);
+  let { organization } = JSON.parse(fs.readFileSync(path.resolve('package.json'), 'utf8'));
+
+  const componentDefaults = await getComponentDefaults();
+  componentDefaults.library = library;
+
+  if (options.params.length >= 8) {
+    const prefix = options.params[3];
+    const version = options.params[4];
+    library = options.params[5];
+    const allowedApplications = options.params[6];
+
+    // overwrite
+    organization = options.params[7];
+
+    await validateCompileAll(
+      {
+        prefix,
+        library,
+        version,
+        allowedApplications,
+        organization
+      },
+      options
+    );
+  } else {
+    const questions = [
+      {
+        name: 'prefix',
+        message: 'Enter prefix label'
+      },
+      {
+        name: 'version',
+        message: 'Enter component version',
+        default: componentDefaults.version,
+        validate: (value) => {
+          if (validateSemver(value)) {
+            return true;
+          }
+          return 'Please provide semver compatible version e.g 0.0.1';
+        }
+      },
+      {
+        name: 'library',
+        message: 'Enter library name (required)',
+        default: componentDefaults.library,
+        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';
+        }
+      },
+      {
+        name: 'allowedApplications',
+        message: 'Please enter the application names to be supported (comma-separated). ',
+        suffix: 'Keep empty for all applications'
+      }
+    ];
+
+    await inquirer.prompt(questions).then(async (answers) => {
+      ({library} = answers);
+      const { version, allowedApplications } = answers;
+      let { prefix } = answers;
+      prefix = prefix.replace(/[^a-zA-Z0-9 ]/g, '');
+      await validateCompileAll(
+        {
+          prefix,
+          library,
+          version,
+          allowedApplications,
+          organization
+        },
+        options
+      );
+    });
+  }
+};

package/src/tasks/delete/helper.js

@@ -1,24 +1,34 @@
+import fs from 'fs';
 import chalk from 'chalk';
 import inquirer from 'inquirer';
 import ora from 'ora';
 
-import { LIST_COMPONENT_SERVICE_REST_ENDPOINT } from '../../constants.js';
+import path from 'path';
+import { join } from 'path';
+
 import {
-  constructCompleteUrl,
   deleteLocalComponent,
-  deleteServerComponent,
+  deleteInfinityServerComponent,
+  deleteLaunchpadServerComponent,
   getComponents,
   getPegaServerConfig,
-  nodeFetch
+  standardizeStr,
+  sanitize
 } from '../../util.js';
 import { getComponentsFromServer } from '../list/helper.js';
 
+import { TASKS_CONFIG_JSON_FILENAME, COMPONENTS_DIRECTORY_PATH, COMPONENTS_PATH } from '../../constants.js';
+
 export const SOURCE_OF_COMPONENT_TYPES = {
   SERVER: 'Server',
   LOCAL: 'Local'
 };
 
-export const getDeleteComponentsQuestions = async (options, sourceOfComponentsOption) => {
+let library;
+let organization;
+
+
+export const getDeleteComponentsQuestions = async (options) => {
   const defaultPegaServerConfig = await getPegaServerConfig();
 
   return [
@@ -35,26 +45,82 @@ export const getDeleteComponentsQuestions = async (options, sourceOfComponentsOp
   ];
 };
 
-export const deleteLocalComponents = async sourceOfComponents => {
+export const getLaunchPadFilterQuestions = async () => {
+  const defaultPegaServerConfig = await getPegaServerConfig();
+
+  const currentDirectory = process.cwd();
+  const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
+
+  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];
+
+   ({ library } = componentData);
+   ({ organization } = JSON.parse(fs.readFileSync(path.resolve('package.json'), 'utf8')));
+
+  return [
+  {
+    name: 'organization',
+    message: 'Enter component organization (required)',
+    default: organization,
+    validate: value => {
+      if (value) {
+        return true;
+      }
+      return 'Please provide value for organization';
+    }
+  },
+  {
+    name: 'library',
+    message: 'Enter library name (required)',
+    default: library,
+    validate: value => {
+      if (value) {
+        return true;
+      }
+      return 'Please provide value for library';
+    }
+  }
+  ];
+}
+
+export const deleteLocalComponents = async (sourceOfComponents, options) => {
   const localComponents = await getComponents();
 
   if (localComponents.length > 0) {
-    const answers = await inquirer.prompt([
-      {
-        name: 'componentKey',
-        type: 'rawlist',
-        message: 'Select component to delete',
-        choices: localComponents
-      },
-      {
-        name: 'confirmDeletion',
-        type: 'confirm',
-        message: 'Are you sure ?',
-        default: false
+    if (options.params.length >= 6) {
+      const componentKey = options.params[4];
+      const sDeletion = options.params[5];
+      const confirmDeletion = sDeletion === 'Y' || sDeletion === 'y' || sDeletion === true || sDeletion === 'true';
+      if (confirmDeletion) {
+        await deleteLocalComponent(componentKey);
+      }
+    } else {
+      const answers = await inquirer.prompt([
+        {
+          name: 'componentKey',
+          type: 'rawlist',
+          message: 'Select component to delete',
+          choices: localComponents
+        },
+        {
+          name: 'confirmDeletion',
+          type: 'confirm',
+          message: 'Are you sure ?',
+          default: false
+        }
+      ]);
+      if (answers.confirmDeletion) {
+        await deleteLocalComponent(answers.componentKey);
       }
-    ]);
-    if (answers.confirmDeletion) {
-      await deleteLocalComponent(answers.componentKey);
     }
   } else {
     console.log(chalk.bold.redBright(`No custom components in ${sourceOfComponents}`));
@@ -62,44 +128,85 @@ export const deleteLocalComponents = async sourceOfComponents => {
 };
 
 export const deleteServerComponents = async (sourceOfComponents, answers) => {
-  const spinner = ora('Fetching components from server').start();
-  const data = await getComponentsFromServer(answers);
 
-  const serverComponents = JSON.parse(data);
+  const defaultPegaServerConfig = await getPegaServerConfig();
+  const isLaunchpad = defaultPegaServerConfig.serverType === 'launchpad';
+
+
+  if (isLaunchpad) {
+    const questions = await getLaunchPadFilterQuestions();
+    const lpAnswers = await inquirer.prompt(questions);
+
+    ({library, organization} = lpAnswers);
+  }
+
+  const spinner = ora('Fetching components from server').start();
+  const data = await getComponentsFromServer(library, organization);
   spinner.stop();
-  if (serverComponents && serverComponents.pxResults?.length > 0) {
-    const choicesArr = serverComponents.pxResults.map(({ label, pyRuleSet, pyRuleSetVersion }) => {
-      const name = `${standardizeStr(label, 45)} ${standardizeStr(pyRuleSet, 30)} ${standardizeStr(
-        pyRuleSetVersion,
-        20
-      )}`;
-
-      const value = `${label}~|~${pyRuleSet}~|~${pyRuleSetVersion}`;
-      const short = `Selected component : ${chalk.redBright(
-        `${label} ${pyRuleSet} : ${pyRuleSetVersion}`
-      )}`;
-
-      return { name, value, short };
-    });
-    const answers = await inquirer.prompt({
-      name: 'componentToDelete',
-      type: 'rawlist',
-      pageSize: 10,
-      message: `Select component to delete \n  ${standardizeStr('Rule name', 48)} ${standardizeStr(
-        'Ruleset name',
-        30
-      )} ${standardizeStr('Ruleset version', 22)}`,
-      choices: choicesArr
-    });
-    await deleteServerComponent(answers.componentToDelete);
+
+
+  let serverComponents;
+  if (isLaunchpad) {
+    serverComponents = data;
+
   } else {
-    console.log(chalk.bold.redBright(`No custom components in ${sourceOfComponents}`));
+    try {
+      if (typeof data === 'object') {
+        serverComponents = data.pxResults;
+      } else {
+        serverComponents = JSON.parse(data).pxResults;
+      }
+    } catch (ex) {
+      /* empty */
+    }
   }
-};
 
-export const standardizeStr = (str, leng) => {
-  for (let i = str.length; i <= leng; i++) {
-    str += ' ';
+
+  if (serverComponents && serverComponents?.length > 0) {
+    if (isLaunchpad) {
+      const choicesArr = serverComponents.map(({ name: componentName, type, version }) => {
+        const name = `${standardizeStr(componentName, 45)} ${standardizeStr(type, 20)} ${standardizeStr(version, 20)}`;
+
+        const value = `${componentName}~|~${type}~|~${version}`;
+        const short = `\n Selected component : ${chalk.redBright(`${componentName} ${type} : ${version}`)}`;
+
+        return { name, value, short };
+      });
+
+      const launchpadAnswers = await inquirer.prompt({
+        name: 'componentToDelete',
+        type: 'rawlist',
+        pageSize: 10,
+        message: `Select component to delete \n  ${standardizeStr('Component Name', 48)} ${standardizeStr('Type', 20)} ${standardizeStr(
+          'Version',
+          22
+        )}`,
+        choices: choicesArr
+      });
+      await deleteLaunchpadServerComponent(launchpadAnswers.componentToDelete);
+    } else {
+      // logic for Infinity
+      const choicesArr = serverComponents.map(({ label, pyRuleSet, pyRuleSetVersion }) => {
+        const name = `${standardizeStr(label, 45)} ${standardizeStr(pyRuleSet, 30)} ${standardizeStr(pyRuleSetVersion, 20)}`;
+
+        const value = `${label}~|~${pyRuleSet}~|~${pyRuleSetVersion}`;
+        const short = `\n Selected component : ${chalk.redBright(`${label} ${pyRuleSet} : ${pyRuleSetVersion}`)}`;
+
+        return { name, value, short };
+      });
+      const infinityAnswers = await inquirer.prompt({
+        name: 'componentToDelete',
+        type: 'rawlist',
+        pageSize: 10,
+        message: `Select component to delete \n  ${standardizeStr('Rule name', 48)} ${standardizeStr('Ruleset name', 30)} ${standardizeStr(
+          'Ruleset version',
+          22
+        )}`,
+        choices: choicesArr
+      });
+      await deleteInfinityServerComponent(infinityAnswers.componentToDelete);
+    }
+  } else {
+    console.log(chalk.bold.redBright(`No custom components in ${sourceOfComponents}`));
   }
-  return str;
 };

package/src/tasks/delete/index.js

@@ -1,18 +1,13 @@
 import inquirer from 'inquirer';
-import ora from 'ora';
-import chalk from 'chalk';
 
-import {
-  deleteLocalComponents,
-  SOURCE_OF_COMPONENT_TYPES,
-  deleteServerComponents,
-  getDeleteComponentsQuestions
-} from './helper.js';
+import { showVersion } from '../../util.js';
 
-const deleteComponentsFn = async (sourceOfComponents, answers) => {
+import { deleteLocalComponents, SOURCE_OF_COMPONENT_TYPES, deleteServerComponents, getDeleteComponentsQuestions } from './helper.js';
+
+const deleteComponentsFn = async (sourceOfComponents, answers, options) => {
   switch (sourceOfComponents) {
     case SOURCE_OF_COMPONENT_TYPES.LOCAL: {
-      await deleteLocalComponents(sourceOfComponents);
+      await deleteLocalComponents(sourceOfComponents, options);
       break;
     }
     case SOURCE_OF_COMPONENT_TYPES.SERVER: {
@@ -26,20 +21,22 @@ const deleteComponentsFn = async (sourceOfComponents, answers) => {
   }
 };
 
-export default async options => {
+export default async (options) => {
+  showVersion();
+
   let sourceOfComponentsOption = SOURCE_OF_COMPONENT_TYPES.LOCAL;
   if (options.params[3] === SOURCE_OF_COMPONENT_TYPES.LOCAL) {
     sourceOfComponentsOption = options.params[3];
-    await deleteComponentsFn(sourceOfComponentsOption);
+    await deleteComponentsFn(sourceOfComponentsOption, null, options);
   } 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);
+    await deleteComponentsFn(sourceOfComponentsOption, answers, options);
   } else {
     const questions = await getDeleteComponentsQuestions(options);
     const answers = await inquirer.prompt(questions);
     const { sourceOfComponents } = answers;
-    await deleteComponentsFn(sourceOfComponents, answers);
+    await deleteComponentsFn(sourceOfComponents, answers, options);
   }
 };