@pega/dx-component-builder-sdk 0.1.0

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

@@ -0,0 +1,84 @@
+import inquirer from 'inquirer';
+import Listr from 'listr';
+import chalk from 'chalk';
+
+import validate from '../validator/index.js';
+
+import bundleComponent from '../bundle/index.js';
+import { updateComponentMap } from '../map/map.js';
+
+import { getPublishComponentQuestions, publishComponentToServer, zipComponent } from './helper.js';
+import {
+  getComponentsObj, 
+  getComponentDirectoryPath
+} from '../../util.js';
+import { lintComponent } from '../linter/index.js';
+
+export default async options => {
+  const components = await getComponentsObj();
+  const questions = await getPublishComponentQuestions();
+  const answers = await inquirer.prompt(questions);
+  const {sourceMap, devBuild } = answers;
+
+  let content = {
+    ...answers
+  };
+
+  var componentKey;
+
+  const tasks = new Listr(
+    [
+      {
+        title: 'Validate config schema',
+        task: async () => {
+          await validate(componentKey);
+        }
+      },
+      {
+        title: 'Lint component',
+        task: async () => {
+          const targetDirectory = await getComponentDirectoryPath(componentKey);
+          // console.log(`in buildComponent Lint component task: componentKey: ${componentKey} targetDirectory: ${targetDirectory}`);
+          await lintComponent(targetDirectory);
+        }
+      },
+      {
+        title: 'Bundle Component',
+        task: async () => await bundleComponent(componentKey, sourceMap, devBuild),
+        skip: () => (options.skipBundle ? 'Skipped bundling component' : undefined)
+      },
+      {
+        title: 'Update Component Map',
+        task: async () => {
+            await updateComponentMap(componentKey);
+        }
+      },
+      {
+        title: 'Zip Component',
+        task: async () => {
+          const output = await zipComponent(componentKey);
+          content = { ...content, ...output };
+        }
+      },
+      {
+        title: 'Publish Component',
+        task: async () => {
+          await publishComponentToServer(content);
+        }
+      }
+    ],
+    {
+      exitOnError: true
+    }
+  );
+
+  for (var index in components) {
+    componentKey = components[index].value;
+    console.log(chalk.bold.green("Publishing: " + components[index].name));
+    await tasks.run().catch(err => {
+       console.log(chalk.bold.red(err.toString()));
+    });
+  }
+
+  return true;
+};

package/src/tasks/update/index.js

@@ -0,0 +1,5 @@
+import publishComponent from '../publish/index.js';
+
+export default options => {
+  return publishComponent(options);
+};

package/src/tasks/upgrade/index.js

@@ -0,0 +1,31 @@
+import { promisify } from 'util';
+import { exec } from 'child_process';
+
+import Listr from 'listr';
+
+const execPromise = promisify(exec);
+
+export default async options => {
+  const installDependenciesText = `Upgrading package to latest version.`;
+
+  const tasks = new Listr(
+    [
+      {
+        title: installDependenciesText,
+        task: async () => {
+          await execPromise('npm uninstall --save-dev @pega/dx-component-builder-sdk', {
+            cwd: options.targetDirectory
+          });
+          await execPromise('npm install --save-dev @pega/dx-component-builder-sdk', {
+            cwd: options.targetDirectory
+          });
+        }
+      }
+    ],
+    {
+      exitOnError: false
+    }
+  );
+
+  await tasks.run();
+};

package/src/tasks/validator/index.js

@@ -0,0 +1,216 @@
+import path from 'path';
+import fs from 'fs';
+
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import Ajv from 'ajv';
+
+import {
+  COMPONENT_SCHEMA,
+  COMPONENT_PREFIX_FIELD_PATH,
+  COMPONENT_PREFIX_TEMPLATE_PATH,
+  COMPONENT_PREFIX_WIDGET_PATH } from '../../constants.js';
+import {
+  getComponentDirectoryPath,
+  getComponents,
+  getOOTBComponents,
+  removeComponentPrefix } from '../../util.js';
+
+const ajv = new Ajv({ allErrors: true });
+
+const combinationTypes = ['PAGE', 'CASE'];
+
+const allowedSubtypes = [
+  ...new Set([
+    ...COMPONENT_SCHEMA.subtype.field.map(({ value }) => value),
+    ...COMPONENT_SCHEMA.subtype.template,
+    ...COMPONENT_SCHEMA.subtype.widget.map(({ value }) => value)
+  ])
+];
+
+const schema = {
+  type: 'object',
+  properties: {
+    baseComponentName: { type: 'string' },
+    componentKey: { type: 'string', pattern: '^[A-Za-z0-9]+_[A-Za-z0-9]+_[A-Za-z0-9]+$' },
+    name: { type: 'string', pattern: '^[A-Za-z0-9]+_[A-Za-z0-9]+_[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);
+
+
+
+export default async option => {
+  let componentToValidate = null;
+  if (option.params && option.params[3]) {
+    componentToValidate = option.params[3];
+  } else if (option && option.task === 'validateSchema') {
+    const localComponents = await getComponents();
+    const answer = await inquirer.prompt({
+      name: 'component',
+      type: 'rawlist',
+      message: 'Select component to validate',
+      choices: localComponents
+    });
+
+    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'));
+  const valid = 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 occured in validating ${componentToValidate}`);
+      }
+    }
+
+    console.log(`${chalk.bold.green(componentToValidate)} schema is valid`);
+  } else {
+    throw new Error(`Invalid: ${ajv.errorsText(validateSchema.errors)}`);
+  }
+};