@pega/custom-dx-components 2.0.24 → 8.5.1

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

@@ -8,28 +8,17 @@ import bundleComponent from '../bundle/index.js';
 import { lintComponent } from '../linter/index.js';
 
 
-import { getPublishComponentQuestions, publishComponentToServer, zipComponent } from './helper.js';
+import { getPublishComponentQuestions, publishComponentToServer, zipComponent, cleanUp } from './helper.js';
 import {
   getComponents,
   getComponentDirectoryPath,
   showVersion
 } from '../../util.js';
 
-export default async options => {
-  showVersion();
-
-  const components = await getComponents();
-  const questions = await getPublishComponentQuestions();
-  const answers = await inquirer.prompt(questions);
-  const {sourceMap, devBuild } = answers;
-
-  let content = {
-    ...answers
-  };
 
-  var componentKey;
 
-  const tasks = new Listr(
+export function getCustomTasks(componentKey, sourceMap, devBuild, content, options) {
+  const customTasks = new Listr(
     [
       {
         title: 'Validate config schema',
@@ -69,16 +58,38 @@ export default async options => {
     }
   );
 
+  return customTasks;
+}
+
+export default async options => {
+  showVersion();
+
+  const components = await getComponents();
+  const questions = await getPublishComponentQuestions();
+  const answers = await inquirer.prompt(questions);
+  const {sourceMap, devBuild } = answers;
+
+  let content = {
+    ...answers
+  };
+
+  var componentKey;
+
+
   for (var index in components) {
     componentKey = components[index];
     console.log(chalk.bold.green("Publishing: " + componentKey));
-    await tasks.run().catch(err => {
+
+    let myCustomTasks = getCustomTasks(componentKey, sourceMap, devBuild, content, options);
+
+    await myCustomTasks.run().catch(err => {
        console.log(chalk.bold.red(err.toString()));
     });
   }
 
- // await tasks.run().catch(err => {
- //   console.log(chalk.bold.red(err.toString()));
-//  });
+   // once done, remove leftover directories
+   cleanUp();
+
+
   return true;
 };

package/src/tasks/rename/index.js

@@ -0,0 +1,315 @@
+import path from 'path';
+import { URL, fileURLToPath } from 'url';
+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 { checkPathAccess, showVersion, getComponentsObj, getDirectoryFiles } from '../../util.js';
+import { TASKS_CONFIG_JSON_FILENAME, COMPONENTS_DIRECTORY_PATH, COMPONENTS_PATH } from '../../constants.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,
+  getPegaConfig,
+  getComponentDefaults,
+  sanitize,
+  validateSemver
+} from '../../util.js';
+import { COMPONENT_SCHEMA } from '../../constants.js';
+
+const copy = promisify(ncp);
+
+
+export const updateConfig = async (
+  {
+    oldComponentKey,
+    newComponentKey,
+    library,
+    organization,
+    componentName,
+    componentLabel,
+    version,
+    description,
+    allowedApplications,
+    targetDirectory,
+  },
+  options,
+  onlyCompanion = false
+) => {
+
+  let configData = fs.readFileSync(join(targetDirectory, "/config.json"), { encoding: 'utf8' });
+  configData = configData && JSON.parse(configData);
+
+  configData.name = newComponentKey;
+  configData.label = componentLabel;
+  configData.organization = organization;
+  if (configData.componentKey) configData.componentKey = newComponentKey;
+  configData.library = library;
+  configData.version = version;
+  configData.description = (description != '') ? description : componentLabel;
+
+  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());
+
+  configData.allowedApplications = allowedApplications;
+
+  // 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' });
+
+};
+
+export const updateFile = async (
+    fileName,
+    oldComponentKeyPC,
+    newComponentKeyPC,
+    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' });
+  }
+
+};
+
+
+export const renameComponent = async (
+  {
+    library,
+    organization,
+    componentKey,
+    componentName,
+    componentLabel,
+    version,
+    description,
+    allowedApplications
+  },
+  options,
+  onlyCompanion = false
+) => {
+
+
+  let pegaConfig = await getPegaConfig();
+
+  const newComponentKey = `${organization}_${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,
+          componentLabel,
+          library,
+          version,
+          description,
+          allowedApplications,
+          organization,
+          targetDirectory,
+        },
+        options
+      );
+    }
+    else {
+      await updateFile(
+          fileName,
+          oldComponentKeyPC,
+          newComponentKeyPC,
+          targetDirectory );
+
+    }
+
+  } // for
+
+
+  console.log(chalk.green(`Component ${oldComponentKey} renamed to ${newComponentKey}`));
+
+};
+
+
+
+
+
+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];
+
+  const { library } = componentData;
+  const { organization } = JSON.parse(fs.readFileSync(path.resolve('package.json'), 'utf8'));
+
+  let componentDefaults = await getComponentDefaults();
+  componentDefaults.library = library;
+
+  const localComponents = await getComponentsObj();
+
+  const questions = [
+    {
+      name: 'componentKey',
+      type: 'rawlist',
+      pageSize: 15,
+      message: 'Select component to rename',
+      choices: localComponents
+    },
+    {
+      name: 'componentName',
+      message: 'Enter new component name (required, no spaces)',
+      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: 'componentLabel',
+      message: 'Enter new component label for display (required)',
+      validate: value => {
+        if (value) {
+          return true;
+        }
+        return 'Please provide value for label';
+      }
+    },
+    {
+      name: 'organization',
+      message: 'Enter new component organization',
+      default: organization,
+      validate: value => {
+        if (value) {
+          return true;
+        }
+        return 'Please provide value for organization';
+      }
+    },
+    {
+      name: 'version',
+      message: 'Enter new 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 new 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'
+    },
+    {
+      name: 'description',
+      message: 'Enter new description for the component (defaults to new label)',
+      default: componentDefaults.description,
+      /* if left blank and no defaults, mustache will use componentLabel, because description is used in app studio and
+      shouldn't be blank */
+    }
+  ];
+
+  await inquirer.prompt(questions).then(async answers => {
+    const {
+      componentKey,
+      componentName,
+      componentLabel,
+      organization,
+      library,
+      version,
+      description,
+      allowedApplications
+    } = answers;
+
+    await renameComponent(
+      {
+        componentKey,
+        componentName,
+        componentLabel,
+        library,
+        version,
+        description,
+        allowedApplications,
+        organization
+      },
+      options
+    );
+
+  });
+
+};

package/src/tasks/validator/index.js

@@ -5,8 +5,13 @@ import chalk from 'chalk';
 import inquirer from 'inquirer';
 import Ajv from 'ajv';
 
-import { COMPONENT_SCHEMA } from '../../constants.js';
-import { getComponentDirectoryPath, getComponents, getOOTBComponents } from '../../util.js';
+import {
+  COMPONENT_SCHEMA } from '../../constants.js';
+
+import {
+  getComponentDirectoryPath,
+  getComponents,
+  getOOTBComponents } from '../../util.js';
 
 const ajv = new Ajv({ allErrors: true });
 
@@ -15,11 +20,20 @@ const combinationTypes = ['PAGE', 'CASE'];
 const allowedSubtypes = [
   ...new Set([
     ...COMPONENT_SCHEMA.subtype.field.map(({ value }) => value),
-    ...COMPONENT_SCHEMA.subtype.template,
+    ...COMPONENT_SCHEMA.subtype.template.map(({ value }) => value),
     ...COMPONENT_SCHEMA.subtype.widget.map(({ value }) => value)
   ])
 ];
 
+// additional subtypes are manually added below
+const allowedOverrideSubtypes = [
+  ...new Set([
+    ...COMPONENT_SCHEMA.subtype.field.map(({ value }) => value),
+    ...COMPONENT_SCHEMA.subtype.template.map(({ value }) => value),
+    ...COMPONENT_SCHEMA.subtype.widget.map(({ value }) => value)
+  ]), "ACTION", "DATA_CAPTURE", "SUMMARY", "CASEVIEW", "DATAVIEW", "LIST"
+];
+
 const schema = {
   type: 'object',
   properties: {
@@ -157,9 +171,149 @@ const schema = {
   additionalProperties: true
 };
 
+const overrideSchema = {
+  type: 'object',
+  properties: {
+    baseComponentName: { type: 'string' },
+    componentKey: { type: 'string', pattern: '^[A-Za-z0-9]+$' },
+    name: { type: 'string', pattern: '^[A-Za-z0-9]+$' },
+    label: { type: 'string' },
+    description: { type: 'string' },
+    organization: { type: 'string' },
+    version: { type: 'string' },
+    library: { type: 'string' },
+    allowedApplications: { type: 'array' },
+    type: { type: 'string', enum: COMPONENT_SCHEMA.type.map(({ value }) => value) },
+    subtype: {
+      anyOf: [{ type: 'string' }, { type: 'array' }],
+
+      enum: allowedOverrideSubtypes
+    },
+    icon: { type: 'string' },
+    properties: {
+      type: 'array',
+      uniqueItems: true,
+      items: {
+        anyOf: [
+          {
+            type: 'object',
+            properties: {
+              name: { type: 'string' },
+              label: { type: 'string' },
+              format: { type: 'string' }
+            },
+            required: ['name', 'label', 'format']
+          },
+          {
+            type: 'object',
+            properties: {
+              format: { type: 'string' },
+              source: {
+                type: 'object',
+                properties: {
+                  name: { type: 'string' },
+                  label: { type: 'string' },
+                  format: { type: 'string' }
+                },
+                required: ['name', 'label', 'format']
+              },
+              cascadeElements: {
+                type: 'array',
+                uniqueItems: true,
+                items: {
+                  anyOf: [
+                    {
+                      type: 'object',
+                      properties: {
+                        key: { type: 'string'},
+                        name: { type: 'string' },
+                        label: { type: 'string' },
+                        format: { type: 'string' }
+                      },
+                      required: ['key','name', 'label', 'format']
+                    }
+                  ]
+                }
+              },
+            },
+            required: ['format']
+          },
+          {
+            type: 'object',
+            properties: {
+              label: { type: 'string' },
+              format: { type: 'string' },
+              properties: {
+                type: 'array',
+                uniqueItems: true,
+                items: {
+                  anyOf: [
+                    {
+                      type: 'object',
+                      properties: {
+                        name: { type: 'string' },
+                        label: { type: 'string' },
+                        format: { type: 'string' }
+                      },
+                      required: ['name', 'label', 'format']
+                    },
+                    {
+                      type: 'object',
+                      properties: {
+                        variant: { type: 'string' },
+                        label: { type: 'string' },
+                        format: { type: 'string' }
+                      },
+                      required: ['variant', 'label', 'format']
+                    },
+                    {
+                      type: 'object',
+                      properties: {
+                        format: { type: 'string' },
+                        elements: {
+                          type: 'array',
+                          uniqueItems: true,
+                          items: {
+                            anyOf: [
+                              {
+                                type: 'object',
+                                properties: {
+                                  key: { type: 'string' },
+                                  name: { type: 'string' },
+                                  label: { type: 'string' },
+                                  format: { type: 'string' },
+                                  variant: { type: 'string' }
+                                },
+                                required: ['key', 'format', 'label']
+                              }
+                            ]
+                          }
+                        }
+                      },
+                      required: ['format', 'elements']
+                    },
+                  ]
+                }
+              }
+
+            },
+            required: ['label', 'format'],
+          }
+        ]
+      }
+    },
+    defaultConfig: { type: 'object' }
+  },
+  required: ['name', 'type', 'subtype', 'properties', 'componentKey'],
+  additionalProperties: true
+};
+
 const validateSchema = ajv.compile(schema);
+const validateOverideSchema = ajv.compile(overrideSchema);
+
 
-export default async option => {
+
+export default async (option) => {
   let componentToValidate = null;
   if (option.params && option.params[3]) {
     componentToValidate = option.params[3];
@@ -173,26 +327,47 @@ export default async option => {
     });
 
     componentToValidate = answer.component;
+  } else if (option.name) {
+    componentToValidate = option.value;
   } else {
     componentToValidate = option;
   }
 
   const componentDirectory = await getComponentDirectoryPath(componentToValidate);
-  const configFile = path.join(componentDirectory, 'config.json');
-  const data = JSON.parse(fs.readFileSync(path.resolve(configFile), 'utf8'));
+  let configFileName = "config.json";
+
+  const configFile = path.join(componentDirectory, configFileName);
+  let configData;
+  try {
+    configData = fs.readFileSync(path.resolve(configFile), 'utf8');
+  }
+  catch (err) {
+
+    // for now, if now file just end
+    console.log(`${chalk.bold.yellow('Config file not availabe for: ' + componentToValidate)}`);
+    return;
+
+  }
+
+  //const data = JSON.parse(fs.readFileSync(path.resolve(configFile), 'utf8'));
+  const data = JSON.parse(configData);
+
   const valid = validateSchema(data);
 
   if (valid) {
+
     if (
       componentToValidate &&
       !/^[A-Za-z0-9]+_[A-Za-z0-9]+_[A-Za-z0-9]+$/.test(componentToValidate)
     ) {
       const ootbComponents = await getOOTBComponents();
       if (ootbComponents.includes(componentToValidate)) {
-        throw new Error(`Invalid: Error occured in validating ${componentToValidate}`);
+        throw new Error(`Invalid: Error occurred in validating ${componentToValidate}`);
       }
     }
 
+
+
     console.log(`${chalk.bold.green(componentToValidate)} schema is valid`);
   } else {
     throw new Error(`Invalid: ${ajv.errorsText(validateSchema.errors)}`);