@pega/dx-component-builder-sdk 0.1.10 → 0.1.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pega/dx-component-builder-sdk",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "Utility for building custom UI components",
   "bin": "./bin/index.js",
   "scripts": {

package/src/cli.js

@@ -7,6 +7,7 @@ import {
   createComponent,
   deleteComponent,
   deleteAllComponents,
+  generateMissingCompanions,
   listComponents,
   overrideComponent,
   publishComponent,
@@ -28,7 +29,8 @@ const TASKS = {
   DELETE: 'delete',
   DELETE_ALL: "deleteAll",
   AUTHENTICATE: 'authenticate',
-  UPGRADE: 'upgrade'
+  UPGRADE: 'upgrade',
+  GENERATE_MISSING_COMPANIONS: 'generateMissingCompanions'
 };
 
 const parseArgumentsIntoOptions = rawArgs => {
@@ -102,6 +104,10 @@ export default async (args = []) => {
       upgrade(options);
       break;
     }
+    case TASKS.GENERATE_MISSING_COMPANIONS: {
+      generateMissingCompanions(options);
+      break;
+    }
     default: {
       console.log(chalk.red(`No task matched with ${task}`));
       break;

package/src/constants.js

@@ -517,7 +517,7 @@ export const COMPONENT_SCHEMA = {
       },
       {
         name: 'Action Buttons For File Utility',
-        value: 'FileUtility/ActionButtonsForFileUtility'
+        value: 'FileUtility/ActionButtonsForFileUtil'
       },
       {
         name: 'Followers',

package/src/tasks/create/index.js

@@ -130,7 +130,7 @@ export const compileMustacheTemplates = async (
 
 
 
-const validateCompile = async (
+export const validateCompile = async (
   {
     library,
     organization,
@@ -143,7 +143,8 @@ const validateCompile = async (
     description,
     allowedApplications
   },
-  options
+  options,
+  onlyCompanion = false
 ) => {
 
   let sSubType = subtype;
@@ -177,41 +178,55 @@ const validateCompile = async (
   const targetDirectoryConstellation = await getComponentDirectoryPath(join(typeLC, "/",componentKey), CATEGORY_CONSTELLATION);
 
   const components = await getComponents(false);
-  if (components.includes(componentKey)) {
-    console.log(chalk.red(`${componentKey} component already exists in ${targetDirectory}`));
 
-    let componentsConstellation = await getComponents(false, CATEGORY_CONSTELLATION);
+  if (!onlyCompanion) {
     if (components.includes(componentKey)) {
+      console.log(chalk.red(`${componentKey} component already exists in ${targetDirectory}`));
+
+      let componentsConstellation = await getComponents(false, CATEGORY_CONSTELLATION);
+      if (components.includes(componentKey)) {
+        console.log(chalk.red(`${componentKey} companion component already exists in ${targetDirectoryConstellation}`));
+      }
+
+      return;
+    }
+    // test for constellation
+    const componentsConstellation = await getComponents(false, CATEGORY_CONSTELLATION);
+    if (componentsConstellation.includes(componentKey)) {
       console.log(chalk.red(`${componentKey} companion component already exists in ${targetDirectoryConstellation}`));
+      return;
     }
-
-    return;
   }
-  // test for constellation
-  const componentsConstellation = await getComponents(false, CATEGORY_CONSTELLATION);
-  if (components.includes(componentKey)) {
-    console.log(chalk.red(`${componentKey} companion component already exists in ${targetDirectoryConstellation}`));
-    return;
+  else {
+    // test for constellation
+    const componentsConstellation = await getComponents(false, CATEGORY_CONSTELLATION);
+    if (componentsConstellation.includes(componentKey)) {
+      console.log(chalk.red(`${componentKey} companion component already exists in ${targetDirectoryConstellation}`));
+      return;
+    }
   }
 
-  // component
-  await copyComponentTemplate({
-    ...options,
-    targetDirectory,
-    templateDirectory
-  });
-  await compileMustacheTemplates(targetDirectory, {
-    componentKey,
-    componentName,
-    componentLabel,
-    library,
-    version,
-    type,
-    subtype,
-    description,
-    organization,
-    allowedApplications
-  });
+
+  if (!onlyCompanion) {
+    // component
+    await copyComponentTemplate({
+      ...options,
+      targetDirectory,
+      templateDirectory
+    });
+    await compileMustacheTemplates(targetDirectory, {
+      componentKey,
+      componentName,
+      componentLabel,
+      library,
+      version,
+      type,
+      subtype,
+      description,
+      organization,
+      allowedApplications
+    });
+  }
 
   // matching constellation
   await copyComponentTemplate({
@@ -232,7 +247,10 @@ const validateCompile = async (
     allowedApplications
   });
 
-  console.log(chalk.green(`created ${componentKey} component in ${targetDirectory}`));
+  if (!onlyCompanion) {
+    console.log(chalk.green(`created ${componentKey} component in ${targetDirectory}`));
+  }
+
   console.log(chalk.green(`created ${componentKey} companion component in ${targetDirectoryConstellation}`));
 
 };

package/src/tasks/delete/helper.js

@@ -28,25 +28,24 @@ export const getDeleteComponentsQuestions = async (options, sourceOfComponentsOp
   const categoryType = getOptionsCategory(options);
 
   return [
-    {
-      name: 'category',
-      type: 'rawlist',
-      message: 'Category of components ?',
-      choices: COMPONENT_SCHEMA.category,
-      when() {
-        return !options.params[4] && categoryType == null;
-      }
-    },
     {
       name: 'sourceOfComponents',
       type: 'rawlist',
       message: 'Delete components from Server or Local ?',
       choices: Object.values(SOURCE_OF_COMPONENT_TYPES),
       default: defaultPegaServerConfig.sourceOfComponents,
+
+    },
+    {
+      name: 'category',
+      type: 'rawlist',
+      message: 'Category of components ?',
+      choices: COMPONENT_SCHEMA.category,
       when(answers) {
-        return !options.params[4] && answers.category != CATEGORY_OVERRIDE && categoryType != CATEGORY_OVERRIDE;
+        return answers.sourceOfComponents != "Server"
       }
     }
+
   ];
 };
 
@@ -81,7 +80,7 @@ export const deleteLocalComponents = async (sourceOfComponents, category = CATEG
           await deleteFromComponentMap(answers.componentKey, category);
         }
         else {
-          console.log(chalk.bold.redBright(`No component in map: ` + componnetName));
+          console.log(chalk.bold.redBright(`No component in map: ` + componentName));
         }
 
       }
@@ -115,7 +114,7 @@ export const deleteServerComponents = async (sourceOfComponents, answers) => {
     const answers = await inquirer.prompt({
       name: 'componentToDelete',
       type: 'rawlist',
-      pageSize: 10,
+      pageSize: 15,
       message: `Select component to delete \n  ${standardizeStr('Rule name', 48)} ${standardizeStr(
         'Ruleset name',
         30
@@ -128,11 +127,23 @@ export const deleteServerComponents = async (sourceOfComponents, answers) => {
     const componentName = answers.componentToDelete.split("~")[0];
     const componentKey = componentObj.find( theObj => theObj.name === componentName);
 
+    // check to see if component is an override component
+    if (componentKey === undefined) {
+      const overrideObj = await getComponentsObj(false, CATEGORY_OVERRIDE);
+      if (overrideObj) {
+        const overrideKey = overrideObj.find( theObj => theObj.name === componentName);
+        if (overrideKey != undefined) {
+          // override component, don't remove from map, just end
+          return;
+        }
+      }
+    }
+
     if (componentKey != undefined) {
       await deleteFromComponentMap(componentKey.value);
     }
     else {
-      console.log(chalk.bold.redBright(`No component in map: ` + componnetName));
+      console.log(chalk.bold.redBright(`No component in map: ` + componentName));
     }
 
   } else {

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

@@ -29,24 +29,21 @@ export const getDeleteComponentsQuestions = async (options, sourceOfComponentsOp
   const categoryType = getOptionsCategory(options);
 
   return [
-    {
-      name: 'category',
-      type: 'rawlist',
-      message: 'Category of components ?',
-      choices: COMPONENT_SCHEMA.category,
-      when() {
-        return !options.params[4] && categoryType == null;
-      }
-    },
     {
       name: 'sourceOfComponents',
       type: 'rawlist',
       message: 'Delete components from Server or Local ?',
       choices: Object.values(SOURCE_OF_COMPONENT_TYPES),
       default: defaultPegaServerConfig.sourceOfComponents,
-      when(answers) {
-        return !options.params[4] && answers.category != CATEGORY_OVERRIDE && categoryType != CATEGORY_OVERRIDE;
 
+    },
+    {
+      name: 'category',
+      type: 'rawlist',
+      message: 'Category of components ?',
+      choices: COMPONENT_SCHEMA.category,
+      when(answers) {
+        return answers.sourceOfComponents != "Server"
       }
     }
   ];
@@ -180,6 +177,18 @@ export const deleteServerComponents = async (sourceOfComponents, answers) => {
           const componentName = componentToDelete.split("~")[0];
           const componentKey = componentObj.find( theObj => theObj.name === componentName);
 
+          // check to see if component is an override component
+          if (componentKey === undefined) {
+            const overrideObj = await getComponentsObj(false, CATEGORY_OVERRIDE);
+            if (overrideObj) {
+              const overrideKey = overrideObj.find( theObj => theObj.name === componentName);
+              if (overrideKey != undefined) {
+                // override component, don't remove from map, just end
+                continue;
+              }
+            }
+          }
+
           if (componentKey != undefined) {
             await deleteFromComponentMap(componentKey.value);
           }

package/src/tasks/generate-missing-companions/index.js

@@ -0,0 +1,77 @@
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+
+import { validateCompile } from '../create/index.js';
+import {
+  showVersion,
+  getComponents,
+  getComponentsObj,
+  getComponentDirectoryPath,
+  getComponentsAndSubDirectory
+} from '../../util.js';
+import {CATEGORY_CONSTELLATION, CATEGORY_CUSTOM, CATEGORY_OVERRIDE } from '../..//constants.js';
+import { or } from 'ajv/dist/compile/codegen/index.js';
+
+export const DXCB_CONFIG_INTERNAL_JSON_FILENAME = 'src/dxcb.config.json';
+const pegaConfigInternalJsonPath = path.join(path.resolve(), DXCB_CONFIG_INTERNAL_JSON_FILENAME);
+
+
+const getMissingList = async () => {
+  const customList = await getComponentsAndSubDirectory(CATEGORY_CUSTOM);
+  const constellationList = await getComponentsAndSubDirectory(CATEGORY_CONSTELLATION);
+  let missingList = [];
+
+  for (var el in customList) {
+    const found = constellationList.find(element => element === customList[el]);
+    if (found === undefined) {
+      missingList.push(customList[el]);
+    }
+  }
+
+  return missingList;
+}
+
+const generateMissingCompanion = async (componentKey) => {
+  const srcDirectory = await getComponentDirectoryPath(componentKey, CATEGORY_CUSTOM);
+  const configJson = `${srcDirectory}/config.json`;
+
+  if (fs.existsSync(configJson)) {
+    let data = fs.readFileSync(configJson, { encoding: 'utf8' });
+    data = JSON.parse(data);
+
+    const { name, label, description, organization, version, library, componentKey, type, subtype} = data;
+    let { allowedApplications } = data;
+
+    const componentName = componentKey.split("_")[2];
+
+    // look up the framework
+    let internalData = fs.readFileSync(pegaConfigInternalJsonPath, { encoding: 'utf8' });
+    internalData = internalData && JSON.parse(internalData);
+
+    const framework = internalData.sdkType;
+    allowedApplications = allowedApplications.toString();
+
+
+    validateCompile({library, organization, componentName, label, version, framework, type, subtype, description, allowedApplications}, null, true);
+  }
+
+}
+
+export default async options => {
+
+  showVersion();
+
+  const missingList = await getMissingList();
+
+  if (missingList.length === 0) {
+    console.log(chalk.bold.green("No missing companion components!"));
+    return;
+  }
+
+  for (var el in missingList) {
+    await generateMissingCompanion(missingList[el]);
+  }
+
+
+}

package/src/tasks/index.js

@@ -10,3 +10,4 @@ export { default as validate } from './validator/index.js';
 export { default as authenticate } from './authenticate/index.js';
 export { default as upgrade } from './upgrade/index.js';
 export { default as buildComponent } from './build/index.js';
+export { default as generateMissingCompanions } from './generate-missing-companions/index.js';

package/src/tasks/list/helper.js

@@ -20,25 +20,23 @@ export const getListComponentsQuestions = async (options, sourceOfComponentsOpti
   const categoryType = getOptionsCategory(options);
 
   return [
-    {
-      name: 'category',
-      type: 'rawlist',
-      message: 'Category of components ?',
-      choices: COMPONENT_SCHEMA.category,
-      when() {
-        return !options.params[4] && categoryType == null;
-      }
-    },
+
     {
       name: 'sourceOfComponents',
       type: 'rawlist',
       message: 'List components from Server or Local ?',
       choices: Object.values(SOURCE_OF_COMPONENT_TYPES),
       default: defaultPegaServerConfig.sourceOfComponents,
+    },
+    {
+      name: 'category',
+      type: 'rawlist',
+      message: 'Category of components ?',
+      choices: COMPONENT_SCHEMA.category,
       when(answers) {
-        return !options.params[4] && answers.category != 'override' && categoryType != 'override';
+        return answers.sourceOfComponents != "Server"
       }
-    }
+    },
   ];
 };
 

package/src/tasks/publish/helper.js

@@ -53,7 +53,8 @@ export const getPublishComponentQuestions = async (category) => {
       name: 'componentKey',
       type: 'rawlist',
       message: 'Select component to publish',
-      choices: components
+      choices: components,
+      pageSize: 15,
     },
     {
       name: 'rulesetName',
@@ -107,8 +108,9 @@ export const zipComponent = async (componentKey, category = CATEGORY_CUSTOM) =>
 
   const zip = new AdmZip();
 
-  zip.addLocalFolder(srcDirectory, 'src/');
+
   if (category === CATEGORY_CUSTOM || category == CATEGORY_CONSTELLATION) {
+    zip.addLocalFolder(srcDirectory, 'src/');
     zip.addLocalFile(configJson);
   }
   else {
@@ -119,7 +121,9 @@ export const zipComponent = async (componentKey, category = CATEGORY_CUSTOM) =>
 
   }
 
-  zip.addLocalFolder(buildDirectory);
+  if (category === CATEGORY_CUSTOM || category === CATEGORY_CONSTELLATION) {
+    zip.addLocalFolder(buildDirectory);
+  }
   const zipContent = zip.toBuffer().toString('base64');
 
   let configContent = "{ }";
@@ -165,10 +169,17 @@ export const publishComponentToServer = async data => {
     componentKey = arKey[arKey.length - 1];
   }
 
+  const configContentObj = JSON.parse(configContent);
+
+  if (configContentObj.type == null || configContentObj.subtype == null) {
+    console.log(chalk.bold.yellow(`No config-ext to publish for ${componentKey}`));
+    return;
+  }
+
   const apiBody = {
     configContent,
     zipContent,
-    componentKey: JSON.parse(configContent).componentKey,
+    componentKey: configContentObj.componentKey,
     publishFor: 'constellation',
     rulesetName,
     rulesetVersion,

package/src/tasks/publish/index.js

@@ -132,14 +132,13 @@ export default async options => {
           content = { ...content, ...output };
         }
       },
-      /*
       {
         title: 'Publish component',
         task: async () => {
           await publishComponentToServer(content);
         }
       }
-      */
+
     ],
     {
       exitOnError: true

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

@@ -100,8 +100,9 @@ export const zipComponent = async (componentKey, category = CATEGORY_CUSTOM) =>
 
   const zip = new AdmZip();
 
-  zip.addLocalFolder(srcDirectory, 'src/');
+
   if (category === CATEGORY_CUSTOM || category == CATEGORY_CONSTELLATION) {
+    zip.addLocalFolder(srcDirectory, 'src/');
     zip.addLocalFile(configJson);
   }
   else {
@@ -112,7 +113,9 @@ export const zipComponent = async (componentKey, category = CATEGORY_CUSTOM) =>
 
   }
 
-  zip.addLocalFolder(buildDirectory);
+  if (category === CATEGORY_CUSTOM || category === CATEGORY_CONSTELLATION) {
+    zip.addLocalFolder(buildDirectory);
+  }
   const zipContent = zip.toBuffer().toString('base64');
 
   let configContent = "{ }";
@@ -149,12 +152,26 @@ export const zipComponent = async (componentKey, category = CATEGORY_CUSTOM) =>
 };
 
 export const publishComponentToServer = async data => {
-  const { configContent, zipContent, componentKey, rulesetName, rulesetVersion } = data;
+  const { configContent, zipContent, rulesetName, rulesetVersion } = data;
+  let { componentKey } = data;
+
+
+  if (componentKey.indexOf("/") >=0) {
+    const arKey = componentKey.split("/");
+    componentKey = arKey[arKey.length - 1];
+  }
+
+  const configContentObj = JSON.parse(configContent);
+
+  if (configContentObj.type == null || configContentObj.subtype == null) {
+    console.log(chalk.bold.yellow(`No config-ext to publish for ${componentKey}`));
+    return;
+  }
 
   const apiBody = {
     configContent,
     zipContent,
-    componentKey: JSON.parse(configContent).componentKey,
+    componentKey: configContentObj.componentKey,
     publishFor: 'constellation',
     rulesetName,
     rulesetVersion,

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

@@ -128,17 +128,15 @@ export default async options => {
         title: 'Zip Component',
         task: async () => {
           const output = await zipComponent(componentKey, category);
-          content = { ...content, ...output };
+          content = { ...content, ...output, componentKey };
         }
-      }
-      /*
+      },
       {
         title: 'Publish component',
         task: async () => {
           await publishComponentToServer(content);
         }
       }
-      */
     ],
     {
       exitOnError: true

package/src/tasks/validator/index.js

@@ -167,7 +167,145 @@ 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: allowedSubtypes
+    },
+    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: ['componentKey', 'name', 'description', 'type', 'subtype', 'properties'],
+  additionalProperties: true
+};
+
 const validateSchema = ajv.compile(schema);
+const validateOverideSchema = ajv.compile(overrideSchema);
 
 
 
@@ -192,7 +330,11 @@ export default async (option, category = CATEGORY_CUSTOM) => {
   }
 
   const componentDirectory = await getComponentDirectoryPath(componentToValidate, category);
-  const configFile = path.join(componentDirectory, 'config.json');
+  let configFileName = "config.json";
+  if (category === CATEGORY_OVERRIDE) {
+    configFileName = "config-ext.json";
+  }
+  const configFile = path.join(componentDirectory, configFileName);
   let configData;
   try {
     configData = fs.readFileSync(path.resolve(configFile), 'utf8');
@@ -211,23 +353,27 @@ export default async (option, category = CATEGORY_CUSTOM) => {
   //const data = JSON.parse(fs.readFileSync(path.resolve(configFile), 'utf8'));
   const data = JSON.parse(configData);
 
-  const valid = validateSchema(data);
+  const valid = (category === CATEGORY_OVERRIDE) ? validateOverideSchema(data) : validateSchema(data);
 
   if (valid) {
 
     // need to remove path
     componentToValidate = removeComponentPrefix(componentToValidate);
 
-    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 occurred in validating ${componentToValidate}`);
+    // don't check for out the box if override
+    if (category != CATEGORY_OVERRIDE) {
+      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 occurred in validating ${componentToValidate}`);
+        }
       }
     }
 
+
     console.log(`${chalk.bold.green(componentToValidate)} schema is valid`);
   } else {
     throw new Error(`Invalid: ${ajv.errorsText(validateSchema.errors)}`);

package/src/util.js

@@ -36,7 +36,8 @@ import {
   COMPONENT_PREFIX_DSE_PATH,
   COMPONENT_PREFIX_INFRA_PATH,
   CATEGORY_CUSTOM,
-  CATEGORY_OVERRIDE
+  CATEGORY_OVERRIDE,
+  CATEGORY_CONSTELLATION
 } from './constants.js';
 
 
@@ -172,6 +173,7 @@ export const getComponents = async (showSeparator = false, category = CATEGORY_C
 
   switch (category) {
     case CATEGORY_CUSTOM:
+    case CATEGORY_CONSTELLATION:
       const fieldComps = await getSubComponents(directory, FIELD_PATH);
       const templateComps = await getSubComponents(directory, TEMPLATE_PATH);
       const widgetComps = await getSubComponents(directory, WIDGET_PATH);