@pega/dx-component-builder-sdk 0.1.0 → 0.1.1

package/src/tasks/delete/index.js

@@ -6,13 +6,16 @@ import {
   deleteLocalComponents,
   SOURCE_OF_COMPONENT_TYPES,
   deleteServerComponents,
-  getDeleteComponentsQuestions
+  getDeleteComponentsQuestions,
+  getOptionsCategory
 } from './helper.js';
 
+
+
 const deleteComponentsFn = async (sourceOfComponents, answers) => {
   switch (sourceOfComponents) {
     case SOURCE_OF_COMPONENT_TYPES.LOCAL: {
-      await deleteLocalComponents(sourceOfComponents);
+      await deleteLocalComponents(sourceOfComponents, answers.category);
       break;
     }
     case SOURCE_OF_COMPONENT_TYPES.SERVER: {
@@ -28,18 +31,25 @@ const deleteComponentsFn = async (sourceOfComponents, answers) => {
 
 export default async options => {
   let sourceOfComponentsOption = SOURCE_OF_COMPONENT_TYPES.LOCAL;
-  if (options.params[3] === SOURCE_OF_COMPONENT_TYPES.LOCAL) {
+  if (options.params[4] === SOURCE_OF_COMPONENT_TYPES.LOCAL) {
     sourceOfComponentsOption = options.params[3];
     await deleteComponentsFn(sourceOfComponentsOption);
-  } else if (options.params[3] === SOURCE_OF_COMPONENT_TYPES.SERVER) {
+  } else if (options.params[4] === 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);
   } else {
     const questions = await getDeleteComponentsQuestions(options);
-    const answers = await inquirer.prompt(questions);
-    const { sourceOfComponents } = answers;
+    let answers = await inquirer.prompt(questions);
+    const categoryType = getOptionsCategory(options);
+    let { sourceOfComponents, category } = answers;
+    if (!sourceOfComponents) {
+      sourceOfComponents = SOURCE_OF_COMPONENT_TYPES.LOCAL
+    }
+    if (categoryType != null) {
+      answers.category = categoryType;
+    }
     await deleteComponentsFn(sourceOfComponents, answers);
   }
 };

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

@@ -2,7 +2,7 @@ import chalk from 'chalk';
 import inquirer from 'inquirer';
 import ora from 'ora';
 
-import { LIST_COMPONENT_SERVICE_REST_ENDPOINT } from '../..//constants.js';
+import { LIST_COMPONENT_SERVICE_REST_ENDPOINT, COMPONENT_SCHEMA } from '../..//constants.js';
 import {
   constructCompleteUrl,
   deleteLocalComponent,
@@ -22,19 +22,48 @@ export const SOURCE_OF_COMPONENT_TYPES = {
   LOCAL: 'Local'
 };
 
+export const getOptionsCategory = (options) => {
+  let categoryType = null;
+  if (options.params[3]) {
+    let catType = options.params[3];
+
+    switch (catType.toLowerCase()) {
+      case "override" :
+      case "o" :
+        categoryType = "override";
+        break;
+      case "custom" :
+      case "c" :
+        categoryType = "custom";
+        break;
+      }
+  }
+  return categoryType;
+}
+
 export const getDeleteComponentsQuestions = async (options, sourceOfComponentsOption) => {
   const defaultPegaServerConfig = await getPegaServerConfig();
-
+  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() {
-        return !options.params[3];
+      when(answers) {
+        return !options.params[4] && answers.category != 'override' && categoryType != 'override';
+
       }
     }
   ];
@@ -42,8 +71,8 @@ export const getDeleteComponentsQuestions = async (options, sourceOfComponentsOp
 
 
 
-export const deleteLocalComponents = async sourceOfComponents => {
-  const localComponents = await getComponentsObj(true);
+export const deleteLocalComponents = async (sourceOfComponents, category = "custom") => {
+  const localComponents = await getComponentsObj(true, category);
 
   for (var index in localComponents) {
     if (localComponents[index].type != undefined && localComponents[index].type === "separator") {
@@ -69,7 +98,18 @@ export const deleteLocalComponents = async sourceOfComponents => {
       for (var index in localComponents) {
         if (localComponents[index].type == undefined) {
           var componentToDelete = localComponents[index].value;
-          await deleteLocalComponent(componentToDelete);
+          await deleteLocalComponent(componentToDelete, category);
+
+          if (category === "override") {
+            // need to remove the map as well
+            if (componentToDelete != undefined) {
+              await deleteFromComponentMap(componentToDelete, category);
+            }
+            else {
+              console.log(chalk.bold.redBright(`No component in map: ` + componentToDelete));
+            }
+
+          }
         }
 
       }

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

@@ -6,13 +6,14 @@ import {
   deleteLocalComponents,
   SOURCE_OF_COMPONENT_TYPES,
   deleteServerComponents,
-  getDeleteComponentsQuestions
+  getDeleteComponentsQuestions,
+  getOptionsCategory
 } from './helper.js';
 
 const deleteComponentsFn = async (sourceOfComponents, answers) => {
   switch (sourceOfComponents) {
     case SOURCE_OF_COMPONENT_TYPES.LOCAL: {
-      await deleteLocalComponents(sourceOfComponents);
+      await deleteLocalComponents(sourceOfComponents, answers.category);
       break;
     }
     case SOURCE_OF_COMPONENT_TYPES.SERVER: {
@@ -38,8 +39,15 @@ export default async options => {
     await deleteComponentsFn(sourceOfComponentsOption, answers);
   } else {
     const questions = await getDeleteComponentsQuestions(options);
-    const answers = await inquirer.prompt(questions);
-    const { sourceOfComponents } = answers;
+    let answers = await inquirer.prompt(questions);
+    const categoryType = getOptionsCategory(options);
+    let { sourceOfComponents, category } = answers;
+    if (!sourceOfComponents) {
+      sourceOfComponents = SOURCE_OF_COMPONENT_TYPES.LOCAL
+    }
+    if (categoryType != null) {
+      answers.category = categoryType;
+    }
     await deleteComponentsFn(sourceOfComponents, answers);
   }
 };

package/src/tasks/index.js

@@ -1,4 +1,5 @@
 export { default as createComponent } from './create/index.js';
+export { default as overrideComponent } from './override/index.js';
 export { default as deleteComponent } from './delete/index.js';
 export { default as deleteAllComponents } from './delete-all/index.js';
 export { default as publishComponent } from './publish/index.js';

package/src/tasks/list/helper.js

@@ -4,33 +4,64 @@ import https from 'https';
 import chalk from 'chalk';
 import fetch from 'node-fetch';
 
-import { LIST_COMPONENT_SERVICE_REST_ENDPOINT, TOKEN_PATH } from '../../constants.js';
+import { LIST_COMPONENT_SERVICE_REST_ENDPOINT, TOKEN_PATH, COMPONENT_SCHEMA } from '../../constants.js';
 import { constructCompleteUrl, getComponents, getPegaServerConfig } from '../../util.js';
 
+
 export const SOURCE_OF_COMPONENT_TYPES = {
   SERVER: 'Server',
   LOCAL: 'Local'
 };
 
+export const getOptionsCategory = (options) => {
+  let categoryType = null;
+  if (options.params[3]) {
+    let catType = options.params[3];
+
+    switch (catType.toLowerCase()) {
+      case "override" :
+      case "o" :
+        categoryType = "override";
+        break;
+      case "custom" :
+        case "c" :
+          categoryType = "custom";
+          break;
+      }
+  }
+  return categoryType;
+}
+
 export const getListComponentsQuestions = async (options, sourceOfComponentsOption) => {
   const defaultPegaServerConfig = await getPegaServerConfig();
 
+  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,
-      when() {
-        return !options.params[3];
+      when(answers) {
+        return !options.params[4] && answers.category != 'override' && categoryType != 'override';
       }
     }
   ];
 };
 
-export const listLocalComponents = async sourceOfComponents => {
-  let localComponents = await getComponents();
+export const listLocalComponents = async (sourceOfComponents, category = "custom") => {
+  let localComponents = await getComponents(false, category);
   localComponents = localComponents.map(name => ({ 'Rule name': name }));
   if (localComponents.length > 0) {
     console.log(chalk.bold.blueBright(`List of custom components in ${sourceOfComponents}`));

package/src/tasks/list/index.js

@@ -7,13 +7,15 @@ import {
   SOURCE_OF_COMPONENT_TYPES,
   getComponentsFromServer,
   displayServerComponents,
-  getListComponentsQuestions
+  getListComponentsQuestions,
+  getOptionsCategory
 } from './helper.js';
 
+
 const getList = async (sourceOfComponents, answers) => {
   switch (sourceOfComponents) {
     case SOURCE_OF_COMPONENT_TYPES.LOCAL: {
-      await listLocalComponents(sourceOfComponents);
+      await listLocalComponents(sourceOfComponents, answers.category);
       break;
     }
     case SOURCE_OF_COMPONENT_TYPES.SERVER: {
@@ -32,20 +34,28 @@ const getList = async (sourceOfComponents, answers) => {
 };
 
 export default async options => {
+
   let sourceOfComponentsOption = SOURCE_OF_COMPONENT_TYPES.LOCAL;
 
-  if (options.params[3] === SOURCE_OF_COMPONENT_TYPES.LOCAL) {
+  if (options.params[4] === SOURCE_OF_COMPONENT_TYPES.LOCAL) {
     sourceOfComponentsOption = options.params[3];
     await getList(sourceOfComponentsOption);
-  } else if (options.params[3] === SOURCE_OF_COMPONENT_TYPES.SERVER) {
+  } else if (options.params[4] === SOURCE_OF_COMPONENT_TYPES.SERVER) {
     sourceOfComponentsOption = options.params[3];
     const questions = await getListComponentsQuestions(options, sourceOfComponentsOption);
     const answers = await inquirer.prompt(questions);
     await getList(sourceOfComponentsOption, answers);
   } else {
     const questions = await getListComponentsQuestions(options);
-    const answers = await inquirer.prompt(questions);
-    const { sourceOfComponents } = answers;
+    let answers = await inquirer.prompt(questions);
+    const categoryType = getOptionsCategory(options);
+    let { sourceOfComponents, category } = answers;
+    if (!sourceOfComponents) {
+      sourceOfComponents = SOURCE_OF_COMPONENT_TYPES.LOCAL
+    }
+    if (categoryType != null) {
+      answers.category = categoryType;
+    }
     await getList(sourceOfComponents, answers);
   }
 };

package/src/tasks/map/map.js

@@ -80,6 +80,7 @@ export const updateComponentMap = async (componentKey, category = "custom") => {
 export const deleteFromComponentMap = async (componentKey, category = "custom") =>  {
   const pegaLocalComponentMapPath = path.join(path.resolve(), SDK_LOCAL_COMPONENT_MAP_FILENAME);
   const categoryDirectory = join("/", category.toLowerCase());
+  const pegaConfigJsonPath = path.join(path.resolve(), DXCB_CONFIG_JSON_FILENAME);
 
   const componentNameNoPrefix = removeComponentPrefix(componentKey);
   const componentName = convertIntoPascalCase(componentNameNoPrefix);
@@ -96,7 +97,8 @@ export const deleteFromComponentMap = async (componentKey, category = "custom")
     process.exit(1);
   }
 
-  let importComponent = join("./", data[COMPONENTS_DIRECTORY_PATH], categoryDirectory, componentKey);
+  let importComponent = join(data[COMPONENTS_DIRECTORY_PATH], categoryDirectory, componentKey);
+  importComponent = "./".concat(importComponent);
 
   let importFull = "import ".concat(componentName).concat(" from '").concat(importComponent).concat("/';");
   let mapFull = "\"".concat(componentNameNoPrefix).concat("\" : " ).concat(componentName).concat(",");

package/src/tasks/override/index.js

@@ -0,0 +1,212 @@
+import path from 'path';
+import { URL, fileURLToPath } from 'url';
+import fs from 'fs';
+import { promisify } from 'util';
+import { createRequire } from "module";
+import { join } from 'path';
+
+import inquirer from 'inquirer';
+import ncp from 'ncp';
+import chalk from 'chalk';
+import { updateComponentMap  } from '../map/map.js';
+
+import { checkPathAccess, getTokenUrl } from '../../util.js';
+
+
+export const DXCB_CONFIG_JSON_FILENAME = 'dxcb.config.json';
+export const DXCB_CONFIG_INTERNAL_JSON_FILENAME = 'src/dxcb.config.json';
+
+const pegaConfigJsonPath = path.join(path.resolve(), DXCB_CONFIG_JSON_FILENAME);
+const pegaConfigInternalJsonPath = path.join(path.resolve(), DXCB_CONFIG_INTERNAL_JSON_FILENAME);
+
+import {
+  convertIntoPascalCase,
+  compileMustacheTemplate,
+  getComponentDirectoryPath,
+  getComponents,
+  getComponentDefaults,
+  sanitize,
+  validateSemver
+} from '@pega/dx-component-builder-sdk/src/util.js';
+import { COMPONENT_SCHEMA } from '../../constants.js';
+
+const copy = promisify(ncp);
+
+const copyComponentTemplate = async options => {
+  return copy(options.overrideDirectory, options.targetDirectory, {
+    clobber: false
+  });
+};
+
+
+
+
+
+
+
+const validateCompile = async (
+  {
+    componentName,
+    type
+  },
+  options
+) => {
+
+  // componentName has sub directory if components are in a sub directory of main "type"
+  const overrideDirectory = `node_modules/@pega/react-sdk-overrides/lib/${type}/${componentName}`;
+
+  await checkPathAccess(overrideDirectory);
+
+  let componentKey = componentName;
+  if (componentKey.indexOf("/") >= 0) {
+    componentKey = componentKey.split("/")[1];
+  }
+  const typeLC = type.toLowerCase();
+  const targetDirectory = await getComponentDirectoryPath(join(typeLC, "/",componentKey), "override");
+
+  const components = await getComponents(false, "override");
+  if (components.includes(componentKey)) {
+    console.log(chalk.red(`${componentKey} component already exists in ${targetDirectory}`));
+    return;
+  }
+
+  await copyComponentTemplate({
+    ...options,
+    targetDirectory,
+    overrideDirectory
+  });
+
+
+  console.log(chalk.green(`> Created ${componentKey} component in ${targetDirectory}`));
+
+  const componentKeyWithType = join(type, componentKey);
+  await updateComponentMap(componentKeyWithType, "override");
+
+  console.log(chalk.green(`> Added ${componentKeyWithType} to map`));
+
+};
+
+export default async options => {
+
+  let promptType = null;
+  if (options.params[3]) {
+    let inputType = options.params[3];
+
+    switch (inputType.toLowerCase()) {
+      case "forms" :
+      case "f" :
+        promptType = "forms";
+        break;
+      case "templates" :
+      case "t" :
+        promptType = "templates";
+        break;
+      case "widgets" :
+      case "w" :
+        promptType = "widgets";
+        break;
+      case "designsystemextensions" :
+      case "des" :
+      case "d" :
+        promptType = "designSystemExtensions";
+        break;
+      case "infra" :
+      case "i" :
+        promptType = "infra";
+        break;
+      }
+  }
+
+  await checkPathAccess(pegaConfigJsonPath);
+
+  let data = fs.readFileSync(pegaConfigJsonPath, { encoding: 'utf8' });
+  data = data && JSON.parse(data);
+
+  const componentData = data['component'];
+
+  const { organization, library} = componentData;
+
+  let componentDefaults = await getComponentDefaults();
+  componentDefaults.library = library;
+
+
+  const questions = [
+    {
+      name: 'type',
+      type: 'rawlist',
+      message: 'Enter type of component',
+      choices: COMPONENT_SCHEMA.overrideType,
+      when (propmtType) {
+        return promptType === null;
+      }
+    },
+    {
+      name: 'componentName',
+      type: 'rawlist',
+      message: 'Enter component to be overridden',
+      choices: COMPONENT_SCHEMA.overrideComponent.forms,
+      when(answers) {
+        return answers.type === 'forms' || promptType === 'forms';
+      }
+    },
+    {
+      name: 'componentName',
+      type: 'rawlist',
+      message: 'Enter component to be overridden',
+      choices: COMPONENT_SCHEMA.overrideComponent.designSystemExtensions,
+      when(answers) {
+        return answers.type === 'designSystemExtensions' || promptType === 'designSystemExtensions';
+      }
+    },
+    {
+      name: 'componentName',
+      type: 'rawlist',
+      message: 'Enter component to be overridden',
+      choices: COMPONENT_SCHEMA.overrideComponent.infra,
+      when(answers) {
+        return answers.type === 'infra'  || promptType === 'infra';
+      }
+    },
+    {
+      name: 'componentName',
+      type: 'rawlist',
+      message: 'Enter component to be overridden',
+      choices: COMPONENT_SCHEMA.overrideComponent.templates,
+      when(answers) {
+        return answers.type === 'templates' || promptType === 'templates';
+      }
+    },
+    {
+      name: 'componentName',
+      type: 'rawlist',
+      message: 'Enter component to be overridden',
+      choices: COMPONENT_SCHEMA.overrideComponent.widgets,
+      when(answers) {
+        return answers.type === 'widgets'  || promptType === 'widgets';
+      }
+    },
+
+  ];
+
+  // get package version, so can display at create
+  const require = createRequire(import.meta.url);
+  const pData = require("@pega/dx-component-builder-sdk/package.json");
+
+  console.log(chalk.green("DX Component Builder - SDK vt" + pData.version));
+  await inquirer.prompt(questions).then(async answers => {
+    let {
+      componentName,
+      type
+    } = answers;
+    if (promptType) type = promptType;
+
+    await validateCompile(
+      {
+        componentName,
+        type
+      },
+      options
+    );
+  });
+
+};

package/src/tasks/validator/index.js

@@ -169,7 +169,7 @@ const validateSchema = ajv.compile(schema);
 
 
 
-export default async option => {
+export default async (option, category = "custom") => {
   let componentToValidate = null;
   if (option.params && option.params[3]) {
     componentToValidate = option.params[3];
@@ -189,9 +189,26 @@ export default async option => {
     componentToValidate = option;
   }
 
-  const componentDirectory = await getComponentDirectoryPath(componentToValidate);
+  const componentDirectory = await getComponentDirectoryPath(componentToValidate, category);
   const configFile = path.join(componentDirectory, 'config.json');
-  const data = JSON.parse(fs.readFileSync(path.resolve(configFile), 'utf8'));
+  let configData;
+  try {
+    configData = fs.readFileSync(path.resolve(configFile), 'utf8');
+  }
+  catch (err) {
+    if (category == "custom") {
+      throw new Error(`Missing config file for: ${componentToValidate}`);
+    }
+    else if (category == "override") {
+      // 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) {