@pega/dx-component-builder-sdk 0.1.9 → 0.1.11

package/package.json

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

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/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/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/override/index.js

@@ -44,7 +44,14 @@ const getListAvailableComponents = async (type) => {
   const fullList = COMPONENT_SCHEMA.overrideComponent[type];
   let availList = [];
   for (var el in fullList) {
-    if (components.includes(fullList[el].value)) {
+
+    let listEl = fullList[el].value;
+    if (listEl.indexOf("/") >=0) {
+      const arKey = listEl.split("/");
+      listEl = arKey[arKey.length - 1];
+    }
+
+    if (components.includes(listEl)) {
       availList.push(new inquirer.Separator("** " + fullList[el].name));
     }
     else {

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)}`);