@pega/dx-component-builder-sdk 0.1.26 → 0.1.27

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

@@ -0,0 +1,456 @@
+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 } from '../../util.js';
+import { CATEGORY_CONSTELLATION, 
+  SDK_CONFIG_JSON_FILENAME,
+  DXCB_CONFIG, 
+  DXCB_COMPONENT_DEFAULTS,
+  CUSTOM_TEMPLATES,
+  CUSTOM_TEMPLATE_PATH } from '../../constants.js';
+
+
+
+export const DXCB_CONFIG_INTERNAL_JSON_FILENAME = 'src/dxcb.config.json';
+
+const pegaConfigJsonPath = path.join(path.resolve(), SDK_CONFIG_JSON_FILENAME);
+const pegaConfigInternalJsonPath = path.join(path.resolve(), DXCB_CONFIG_INTERNAL_JSON_FILENAME);
+
+import {
+  convertIntoPascalCase,
+  compileMustacheTemplate,
+  getComponentDirectoryPath,
+  getPegaConfig,
+  getComponents,
+  getComponentDefaults,
+  sanitize,
+  validateSemver
+} from '../../util.js';
+import { COMPONENT_SCHEMA } from '../../constants.js';
+
+const copy = promisify(ncp);
+
+const copyComponentTemplate = async options => {
+  if (options.targetDirectory) {
+    return copy(options.templateDirectory, options.targetDirectory, {
+      clobber: false
+    });
+  }
+  else {
+    return copy(options.templateDirectoryConstellation, options.targetDirectoryConstellation, {
+      clobber: false,
+      filter: (fileName) => { 
+        // filter out the file config.json or config.json.mustache
+        if (fileName.indexOf("config.json") >= 0) return false;
+        else return true;
+      }
+    });
+  }
+
+};
+
+export const compileMustacheTemplates = async (
+  componentDirectory,
+  {
+    componentKey,
+    componentName,
+    componentLabel,
+    library,
+    version,
+    type,
+    subtype,
+    description,
+    organization,
+    allowedApplications
+  }
+) => {
+  const files = fs.readdirSync(componentDirectory);
+  const componentClassName = convertIntoPascalCase(componentKey);
+
+  const isTemplate = type === 'Template';
+  const isPicklist = subtype === 'Picklist';
+  const isBool = subtype === 'Boolean';
+  const isPhone = subtype === 'Phone';
+
+  if (Array.isArray(subtype) && subtype.length === 1) {
+    subtype = subtype.toString();
+  }
+
+  let mustacheSubType = subtype;
+
+  // overrides
+  if (typeof(mustacheSubType) == "string") {
+    switch (mustacheSubType) {
+      case "FORM-region" :
+        mustacheSubType = "FORM";
+        break;
+      case "DETAILS-region" :
+        mustacheSubType = "DETAILS";
+        break;
+      case "Text-Input" :
+        mustacheSubType = "Text";
+        break;
+    }
+
+  }
+
+  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());
+  files.forEach(file => {
+    const filePath = path.join(componentDirectory, file);
+
+    const output = compileMustacheTemplate(filePath, {
+      COMPONENT_KEY: componentKey,
+      COMPONENT_NAME: componentName,
+      COMPONENT_LABEL: componentLabel,
+      COMPONENT_CLASS_NAME: componentClassName,
+      ORGANIZATION: organization,
+      VERSION: version,
+      LIBRARY: library,
+      ALLOWEDAPPS: JSON.stringify(allowedApplications),
+      TYPE: type,
+      SUB_TYPE: JSON.stringify(mustacheSubType),
+      DESCRIPTION: description || componentLabel,
+      IS_TEMPLATE: isTemplate,
+      IS_PICKLIST: isPicklist,
+      IS_BOOLEAN: isBool,
+      IS_PHONE: isPhone
+    });
+    fs.writeFileSync(filePath, output);
+    fs.renameSync(filePath, filePath.replace('.mustache', ''));
+  });
+};
+
+
+export const validateCompileAll = async (
+  {
+    prefix,
+    library,
+    version,
+    allowedApplications,
+    organization
+  },
+  options,
+  onlyCompanion = false
+
+) => {
+
+
+  for (let fieldIdx in COMPONENT_SCHEMA.subtype.field) {
+    const type = "Field";
+    const subtype = COMPONENT_SCHEMA.subtype.field[fieldIdx].value;
+    const prefixNoSpace = prefix.replace(/\s+/g, '');
+    const componentName = "".concat(prefixNoSpace).concat(COMPONENT_SCHEMA.subtype.field[fieldIdx].name);
+    const componentLabel = "".concat(prefix).concat(" ").concat(COMPONENT_SCHEMA.subtype.field[fieldIdx].name);
+    const description = componentLabel;
+
+    await validateCompile(
+      {
+        library,
+        organization,
+        componentName,
+        componentLabel,
+        version,
+        type,
+        subtype,
+        description,
+        allowedApplications
+      },
+      options
+    )
+  }
+
+  for (let templateIdx in COMPONENT_SCHEMA.subtype.template) {
+    const type = "Template";
+    const subtype = COMPONENT_SCHEMA.subtype.template[templateIdx].value;
+    const prefixNoSpace = prefix.replace(/\s+/g, '');
+    let templateName =  convertIntoPascalCase(COMPONENT_SCHEMA.subtype.template[templateIdx].name);
+    let templateLabel = convertIntoPascalCase(COMPONENT_SCHEMA.subtype.template[templateIdx].name);
+    if (templateName.indexOf("region") >= 0) {
+      templateName = templateName.replace(" region", "");
+      templateName = "TwoColumn".concat(templateName);
+      templateLabel = "Two Column".concat(templateName);
+    }
+    const componentName = "".concat(prefixNoSpace).concat(templateName);
+    const componentLabel = "".concat(prefix).concat(" ").concat(templateLabel);
+    const description = componentLabel;
+
+    await validateCompile(
+      {
+        library,
+        organization,
+        componentName,
+        componentLabel,
+        version,
+        type,
+        subtype,
+        description,
+        allowedApplications
+      },
+      options
+    )
+  }
+
+
+  for (let widgetIdx in COMPONENT_SCHEMA.subtype.widget) {
+    const type = "Widget";
+    const subtype = COMPONENT_SCHEMA.subtype.widget[widgetIdx].value;
+    const prefixNoSpace = prefix.replace(/\s+/g, '');
+    let widgetName = convertIntoPascalCase(COMPONENT_SCHEMA.subtype.widget[widgetIdx].name).concat("Widget");
+    let widgetLabel = convertIntoPascalCase(COMPONENT_SCHEMA.subtype.widget[widgetIdx].name).concat(" Widget");
+    if (widgetName.indexOf("&") >= 0) {
+      widgetName = widgetName.replace(" & ", "");
+    }
+    const componentName = "".concat(prefixNoSpace).concat(widgetName);
+    const componentLabel = "".concat(prefix).concat(" ").concat(widgetLabel);
+    const description = componentLabel;
+
+    await validateCompile(
+      {
+        library,
+        organization,
+        componentName,
+        componentLabel,
+        version,
+        type,
+        subtype,
+        description,
+        allowedApplications
+      },
+      options
+    )
+  }
+
+  
+}
+
+
+export const validateCompile = async (
+  {
+    library,
+    organization,
+    componentName,
+    componentLabel,
+    version,
+    framework,
+    type,
+    subtype,
+    description,
+    allowedApplications
+  },
+  options,
+  onlyCompanion = false
+) => {
+
+  let sSubType = subtype;
+  if (Array.isArray(subtype)) {
+    sSubType = subtype.join("-");
+  }
+
+  const typeLC = type.toLowerCase();
+
+  await checkPathAccess(pegaConfigInternalJsonPath);
+
+  let internalData = fs.readFileSync(pegaConfigInternalJsonPath, { encoding: 'utf8' });
+  internalData = internalData && JSON.parse(internalData);
+
+  framework = internalData.sdkType;
+
+  let pegaConfig = await getPegaConfig();
+  let templateParentDir = `./templates/${framework}`;
+  if (pegaConfig[DXCB_CONFIG] &&
+      pegaConfig[DXCB_CONFIG][CUSTOM_TEMPLATES] &&
+      pegaConfig[DXCB_CONFIG][CUSTOM_TEMPLATES][CUSTOM_TEMPLATE_PATH] && 
+      pegaConfig[DXCB_CONFIG][CUSTOM_TEMPLATES][CUSTOM_TEMPLATE_PATH] != "") {
+    templateParentDir = pegaConfig[DXCB_CONFIG][CUSTOM_TEMPLATES][CUSTOM_TEMPLATE_PATH];
+  }
+
+  const templateDir = `${templateParentDir}/${typeLC}/${sSubType}`;
+  let templateDirectory = fileURLToPath(new URL(templateDir, import.meta.url));
+  templateDirectory = templateDirectory.replace("/create-all", "/create");
+
+  const templateDirConstellation = `./templates/Constellation/${typeLC}/${sSubType}`;
+  let templateDirectoryConstellation = fileURLToPath(new URL(templateDirConstellation, import.meta.url));
+  templateDirectoryConstellation = templateDirectoryConstellation.replace("/create-all", "/create");
+
+  const componentKey = `${organization}_${library}_${componentName}`;
+
+ 
+  const targetDirectory = await getComponentDirectoryPath(join(typeLC, "/",componentKey));
+  const targetDirectoryConstellation = await getComponentDirectoryPath(join(typeLC, "/",componentKey), CATEGORY_CONSTELLATION);
+
+  const components = await getComponents(false);
+
+  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;
+    }
+  }
+  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;
+    }
+  }
+
+
+  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({
+    ...options,
+    targetDirectoryConstellation,
+    templateDirectoryConstellation
+  });
+  await compileMustacheTemplates(targetDirectoryConstellation, {
+    componentKey,
+    componentName,
+    componentLabel,
+    library,
+    version,
+    type,
+    subtype,
+    description,
+    organization,
+    allowedApplications
+  });
+
+  if (!onlyCompanion) {
+    console.log(chalk.green(`created ${componentKey} component in ${targetDirectory}`));
+  }
+
+  console.log(chalk.green(`created ${componentKey} companion component in ${targetDirectoryConstellation}`));
+
+};
+
+export default async options => {
+  showVersion();
+
+  await checkPathAccess(pegaConfigJsonPath);
+
+  let data = fs.readFileSync(pegaConfigJsonPath, { encoding: 'utf8' });
+  data = data && JSON.parse(data);
+
+  if (!data[DXCB_CONFIG] || !data[DXCB_CONFIG][DXCB_COMPONENT_DEFAULTS]) {
+    console.error(
+      `${chalk.red.bold('ERROR')} Could not able find component defaults in config.json`
+    );
+    process.exit(1);
+  }
+
+  const componentData = data[DXCB_CONFIG][DXCB_COMPONENT_DEFAULTS];
+
+  const { organization, library} = componentData;
+
+  let componentDefaults = await getComponentDefaults();
+  componentDefaults.library = library;
+
+
+  const questions = [
+    {
+      name: 'prefix',
+      message: 'Enter prefix label'
+    },
+    {
+      name: 'version',
+      message: 'Enter 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 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'
+    }
+  ];
+
+  await inquirer.prompt(questions).then(async answers => {
+    const {
+      prefix,
+      library,
+      version,
+      allowedApplications
+    } = answers;
+    await validateCompileAll(
+      {
+        prefix,
+        library,
+        version,
+        allowedApplications,
+        organization
+      },
+      options
+    );
+  });
+  
+};

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

@@ -76,20 +76,18 @@ export const deleteLocalComponents = async (sourceOfComponents, category = CATEG
         if (localComponents[index].type == undefined) {
           var componentToDelete = localComponents[index].value;
           await deleteLocalComponent(componentToDelete, category);
-          if (category  === "custom") {
+          if (category  === CATEGORY_CUSTOM) {
             await deleteLocalComponent(componentToDelete, CATEGORY_CONSTELLATION);
           }
 
-          if (category === 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));
-            }
-
+          // 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/index.js

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

package/src/tasks/linter/index.js

@@ -1,46 +1,71 @@
 import { ESLint } from 'eslint';
 import chalk from 'chalk';
+import { getPegaConfig } from '../../util.js'
+import { DXCB_CONFIG, DXCB_COMPONENT_DEFAULTS, LINT_SETTING_KEY, LINT_OFF, LINT_SHOW, LINT_BLOCK, LINT_DEFAULT } from '../../constants.js';
+
+//  lintSettings immported from constants.js: a set of the expected values of lint setting from sdk-config.json
+//  LINT_OFF: don't run lint
+//  LINT_SHOW: run lint, show results, but don't block processing from continuing if there are lint errors/warnings
+//  LINT_BLOCK: run lint, show results, block processing from continuing if there are lint errors/warnings
+
+const lintSettings = new Set([LINT_OFF, LINT_SHOW, LINT_BLOCK]);
 
 export const lintComponent = async (dirToLint) => {
-  // console.log("in dx-component-builder-sdk: lintComponent - dirToLint: " + dirToLint);
-  //console.log(chalk.green(` linting ${dirToLint}`));
+  // get setting from sdk-config. If not found or unexpected value, default to LINT_DEFAULT
+  const pegaConfig = await getPegaConfig();
+  let lintSetting = pegaConfig[DXCB_CONFIG][DXCB_COMPONENT_DEFAULTS][LINT_SETTING_KEY];
 
-  // 1. Create an instance.
-  const eslint = new ESLint();
+  // Check to see if lintSetting is an expected value. Show error if unexpected value encountered
+  if (!lintSettings?.has(lintSetting)) {
+    console.log(chalk.red(`Invalid or missing ${LINT_SETTING_KEY}: ${lintSetting}. Using \"${LINT_BLOCK}\".`));
+    lintSetting = LINT_DEFAULT;
+  }
 
-  // 2. Lint files.
-  const results = await eslint.lintFiles([dirToLint]);
+  // console.log("in dx-component-builder-sdk: lintComponent - dirToLint: " + dirToLint);
+  // console.log(chalk.green(` linting ${dirToLint} - setting: ${lintSetting}`));
 
-  // 3. Format the results.
-  const formatter = await eslint.loadFormatter("stylish");
-  const resultText = formatter.format(results);
+  let resultText = undefined;
 
-  // 4. Output it.
-  // console.log(`lint resultText: ${resultText}`);
-  console.log(resultText);
+  if (lintSetting !== LINT_OFF) {
+    // 1. Create an instance.
+    const eslint = new ESLint();
 
-  // Indicate linting is complete
-  //console.log(chalk.green(` linting complete...`));
-};
+    // 2. Lint file(s) .
+    const results = await eslint.lintFiles([dirToLint]);
 
-// inpsired by https://eslint.org/docs/latest/developer-guide/nodejs-api
+    // 3. Format results.
+    const formatter = await eslint.loadFormatter("stylish");
+    resultText = formatter.format(results);
 
-// (async function main() {
-//   // 1. Create an instance.
-//   const eslint = new ESLint();
+    // 4. Output results.
+    // console.log("lint results[");
+    // results.forEach(function (result) { console.log(JSON.stringify(result)) });
+    // console.log("]");
+    // console.log("lint resultText[" + resultText + "]");
 
-//   // 2. Lint files.
-//   const results = await eslint.lintFiles(["lib/**/*.js"]);
+    if (resultText.length > 0) {
+      if (lintSetting === LINT_SHOW) {
+        // Config setting says to allow processing to continue. So, show lint output but continue
+        console.log(chalk.yellow(`  Lint: `));
+        console.log(`${resultText}`);
+        console.log(chalk.yellow(`  Continuing...`));
+      } else {
+        // Config setting (at this point, assumed to be "block") says to NOT allow processing to continue.
+        //  So, throw error!
+        console.log(chalk.red(`  Lint errors/warnings. Processing blocked.`));
+        throw new Error( "Lint:\n" + resultText );
+      }
+    }
+  } else {
+    console.log(chalk.green(`  Lint is off.`));
+  }
+  // Indicate linting is complete
+  if ((lintSetting !== LINT_OFF) && resultText) {
+    console.log(chalk.green(` linting complete...`));
+  }
 
-//   // 3. Format the results.
-//   const formatter = await eslint.loadFormatter("stylish");
-//   const resultText = formatter.format(results);
+};
 
-//   // 4. Output it.
-//   console.log(resultText);
-// })().catch((error) => {
-//   process.exitCode = 1;
-//   console.error(error);
-// });
+// inspired by https://eslint.org/docs/latest/developer-guide/nodejs-api
 
 export default lintComponent;