@pega/dx-component-builder-sdk 0.1.0

package/src/tasks/linter/index.js

@@ -0,0 +1,46 @@
+import { ESLint } from 'eslint';
+import chalk from 'chalk';
+
+export const lintComponent = async (dirToLint) => {
+  // console.log("in dx-component-builder-sdk: lintComponent - dirToLint: " + dirToLint);
+  console.log(chalk.green(` linting ${dirToLint}`));
+
+  // 1. Create an instance.
+  const eslint = new ESLint();
+
+  // 2. Lint files.
+  const results = await eslint.lintFiles([dirToLint]);
+
+  // 3. Format the results.
+  const formatter = await eslint.loadFormatter("stylish");
+  const resultText = formatter.format(results);
+
+  // 4. Output it.
+  // console.log(`lint resultText: ${resultText}`);
+  console.log(resultText);
+
+  // Indicate linting is complete
+  console.log(chalk.green(` linting complete...`));
+};
+
+// inpsired by https://eslint.org/docs/latest/developer-guide/nodejs-api
+
+// (async function main() {
+//   // 1. Create an instance.
+//   const eslint = new ESLint();
+
+//   // 2. Lint files.
+//   const results = await eslint.lintFiles(["lib/**/*.js"]);
+
+//   // 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);
+// });
+
+export default lintComponent;

package/src/tasks/list/helper.js

@@ -0,0 +1,118 @@
+import fs from 'fs';
+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 { constructCompleteUrl, getComponents, getPegaServerConfig } from '../../util.js';
+
+export const SOURCE_OF_COMPONENT_TYPES = {
+  SERVER: 'Server',
+  LOCAL: 'Local'
+};
+
+export const getListComponentsQuestions = async (options, sourceOfComponentsOption) => {
+  const defaultPegaServerConfig = await getPegaServerConfig();
+
+  return [
+    {
+      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];
+      }
+    }
+  ];
+};
+
+export const listLocalComponents = async sourceOfComponents => {
+  let localComponents = await getComponents();
+  localComponents = localComponents.map(name => ({ 'Rule name': name }));
+  if (localComponents.length > 0) {
+    console.log(chalk.bold.blueBright(`List of custom components in ${sourceOfComponents}`));
+    console.table(localComponents, ['Rule name']);
+  } else {
+    console.log(chalk.bold.redBright(`No custom components in ${sourceOfComponents}`));
+  }
+};
+
+export const getComponentsFromServer = async data => {
+  const defaultPegaServerConfig = await getPegaServerConfig();
+  const url = constructCompleteUrl(
+    defaultPegaServerConfig.server,
+    LIST_COMPONENT_SERVICE_REST_ENDPOINT
+  );
+  return new Promise((resolve, reject) => {
+    try {
+      fs.readFile(TOKEN_PATH, 'utf8', (err, data) => {
+        if (err) {
+          reject(
+            `\n${chalk.bold.red(
+              'Error occured in authentication. Please regenerate using authenticate'
+            )}`
+          );
+        }
+        if (data) {
+          const {
+            access_token: accessToken,
+            token_type: tokenType,
+            refresh_token: refreshToken
+          } = JSON.parse(data);
+          let status = 500;
+          fetch(url, {
+            method: 'GET',
+            agent: new https.Agent({ rejectUnauthorized: false }),
+            headers: {
+              Authorization: `${tokenType} ${accessToken}`
+            }
+          })
+            .then(response => {
+              status = response.status;
+              return response.text();
+            })
+            .then(resp => {
+              const respData = JSON.parse(resp);
+              if (status === 401) {
+                throw new Error(
+                  'Error occured in authentication. Please regenerate using authenticate'
+                );
+                // console.log(accessTokenUri, refreshToken);
+                /* TODO - Handle refresh_token */
+              } else if (status == 200) {
+                resolve(resp);
+              } else {
+                throw new Error(`${respData.message}`);
+              }
+            })
+            .catch(e => reject(`${chalk.bold.red(e)}`));
+        }
+      });
+    } catch (error) {
+      console.log(`\n${chalk.bold.red(error)}`);
+      reject(`${chalk.bold.red(error)}`);
+    }
+  });
+};
+
+export const displayServerComponents = async data => {
+  const defaultPegaServerConfig = await getPegaServerConfig();
+  const parsedData = JSON.parse(data);
+  const componentList = parsedData.pxResults?.map(({ label, pyRuleSet, pyRuleSetVersion }) => ({
+    'Rule name': label,
+    'Ruleset name': pyRuleSet,
+    'Ruleset version': pyRuleSetVersion
+  }));
+
+  if (componentList && componentList.length > 0) {
+    console.log(
+      chalk.bold.blueBright(`List of custom components in ${defaultPegaServerConfig.server}`)
+    );
+    console.table(componentList, ['Rule name', 'Ruleset name', 'Ruleset version']);
+  } else {
+    console.log(chalk.bold.redBright(`No custom components in ${defaultPegaServerConfig.server}`));
+  }
+};

package/src/tasks/list/index.js

@@ -0,0 +1,51 @@
+import inquirer from 'inquirer';
+import ora from 'ora';
+import chalk from 'chalk';
+
+import {
+  listLocalComponents,
+  SOURCE_OF_COMPONENT_TYPES,
+  getComponentsFromServer,
+  displayServerComponents,
+  getListComponentsQuestions
+} from './helper.js';
+
+const getList = async (sourceOfComponents, answers) => {
+  switch (sourceOfComponents) {
+    case SOURCE_OF_COMPONENT_TYPES.LOCAL: {
+      await listLocalComponents(sourceOfComponents);
+      break;
+    }
+    case SOURCE_OF_COMPONENT_TYPES.SERVER: {
+      const spinner = ora('Fetching components from server\n').start();
+      const data = await getComponentsFromServer(answers);
+      spinner.stop();
+      await displayServerComponents(data, answers);
+
+      break;
+    }
+    default: {
+      console.log('Source of components needs to be either Local or Server');
+      break;
+    }
+  }
+};
+
+export default async options => {
+  let sourceOfComponentsOption = SOURCE_OF_COMPONENT_TYPES.LOCAL;
+
+  if (options.params[3] === SOURCE_OF_COMPONENT_TYPES.LOCAL) {
+    sourceOfComponentsOption = options.params[3];
+    await getList(sourceOfComponentsOption);
+  } else if (options.params[3] === 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;
+    await getList(sourceOfComponents, answers);
+  }
+};

package/src/tasks/map/map.js

@@ -0,0 +1,118 @@
+
+import fs from 'fs';
+import path from 'path';
+import { join } from 'path';
+
+import {
+  convertIntoPascalCase,
+  removeComponentPrefix
+} from '../../util.js';
+
+import {
+  COMPONENTS_DIRECTORY_PATH,
+  DXCB_CONFIG_JSON_FILENAME
+} from '../../constants.js';
+
+export const SDK_LOCAL_COMPONENT_MAP_FILENAME = "sdk-local-component-map.js";
+export const COMPONENT_PATH = "./src/components";
+export const IMPORT_END_TAG = "/*import end";
+export const MAP_END_TAG = "/*map end";
+
+export const updateComponentMap = async (componentKey, category = "custom") => {
+
+  const pegaConfigJsonPath = path.join(path.resolve(), DXCB_CONFIG_JSON_FILENAME);
+  const pegaLocalComponentMapPath = path.join(path.resolve(), SDK_LOCAL_COMPONENT_MAP_FILENAME);
+  const categoryDirectory = join("/", category.toLowerCase());
+
+  const componentNameNoPrefix = removeComponentPrefix(componentKey);
+  const componentName = convertIntoPascalCase(componentNameNoPrefix);
+
+  let mapData = fs.readFileSync(pegaLocalComponentMapPath, { encoding: 'utf8' });
+
+  let data = fs.readFileSync(pegaConfigJsonPath, { encoding: 'utf8' });
+  data = JSON.parse(data);
+
+  if (!data[COMPONENTS_DIRECTORY_PATH]) {
+    console.error(
+      `${chalk.red.bold('ERROR')} Could not able find components directory path in config.json`
+    );
+    process.exit(1);
+  }
+
+  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(",");
+
+  if (mapData.indexOf(importComponent) < 0) {
+    // not present so we can add
+
+    // add import
+    let endImportIndex = mapData.indexOf(IMPORT_END_TAG);
+    let mapDataStart = mapData.substring(0, endImportIndex);
+    let mapDataEnd = mapData.substring(endImportIndex);
+
+    mapData = mapDataStart.concat(importFull).concat("\n").concat(mapDataEnd);
+
+
+
+    // add map
+    let endMapIndex = mapData.indexOf(MAP_END_TAG);
+    mapDataStart = mapData.substring(0, endMapIndex);
+    mapDataEnd = mapData.substring(endMapIndex);
+
+    mapData = mapDataStart.concat("  ").concat(mapFull).concat("\n").concat(mapDataEnd);
+
+
+    //console.log(mapData);
+
+    //console.log("update");
+
+    fs.writeFileSync(pegaLocalComponentMapPath, mapData, { encoding: 'utf8' });
+
+
+  }
+
+
+};
+
+export const deleteFromComponentMap = async (componentKey, category = "custom") =>  {
+  const pegaLocalComponentMapPath = path.join(path.resolve(), SDK_LOCAL_COMPONENT_MAP_FILENAME);
+  const categoryDirectory = join("/", category.toLowerCase());
+
+  const componentNameNoPrefix = removeComponentPrefix(componentKey);
+  const componentName = convertIntoPascalCase(componentNameNoPrefix);
+
+  let mapData = fs.readFileSync(pegaLocalComponentMapPath, { encoding: 'utf8' });
+
+  let data = fs.readFileSync(pegaConfigJsonPath, { encoding: 'utf8' });
+  data = JSON.parse(data);
+
+  if (!data[COMPONENTS_DIRECTORY_PATH]) {
+    console.error(
+      `${chalk.red.bold('ERROR')} Could not able find components directory path in config.json`
+    );
+    process.exit(1);
+  }
+
+  let importComponent = join("./", data[COMPONENTS_DIRECTORY_PATH], categoryDirectory, componentKey);
+
+  let importFull = "import ".concat(componentName).concat(" from '").concat(importComponent).concat("/';");
+  let mapFull = "\"".concat(componentNameNoPrefix).concat("\" : " ).concat(componentName).concat(",");
+
+
+  if (mapData.indexOf(importFull) >= 0) {
+
+    let removeImport = importFull.concat("\n");
+    let removeMap = "  ".concat(mapFull).concat("\n");
+
+    mapData = mapData.replace(removeImport, "");
+    mapData = mapData.replace(removeMap, "");
+
+    fs.writeFileSync(pegaLocalComponentMapPath, mapData, { encoding: 'utf8' });
+
+  }
+
+
+};

package/src/tasks/publish/helper.js

@@ -0,0 +1,147 @@
+import fs from 'fs';
+import path from 'path';
+import https from 'https';
+
+import fetch from 'node-fetch';
+import AdmZip from 'adm-zip';
+import chalk from 'chalk';
+
+import {
+  constructCompleteUrl,
+  getComponentDirectoryPath,
+  getComponents,
+  getComponentsObj,
+  getComponentsAndSubDirectory,
+  getPegaServerConfig,
+  validateRulesetVersion
+} from '../../util.js';
+import { PUBLISH_COMPONENT_SERVICE_REST_ENDPOINT, TOKEN_PATH } from '../../constants.js';
+
+export const getPublishComponentQuestions = async () => {
+  const components = await getComponentsObj(true);
+  const defaultPegaConfig = await getPegaServerConfig();
+
+  return [
+    {
+      name: 'componentKey',
+      type: 'rawlist',
+      message: 'Select component to publish',
+      choices: components
+    },
+    {
+      name: 'rulesetName',
+      message: 'Enter ruleset name',
+      default: defaultPegaConfig.rulesetName,
+      validate: value => {
+        if (value.trim()) {
+          return true;
+        }
+        return 'Ruleset name cannot be empty';
+      }
+    },
+    {
+      name: 'rulesetVersion',
+      message: 'Enter ruleset version',
+      default: defaultPegaConfig.rulesetVersion,
+      validate: value => {
+        if (validateRulesetVersion(value)) {
+          return true;
+        }
+        return 'Please provide compatible version e.g 01-01-01';
+      }
+    },
+    {
+      name: 'sourceMap',
+      message: 'Generate source map ?',
+      default: defaultPegaConfig.sourceMap,
+      when: () => false && !process.env.SOURCE_MAP
+    },
+    {
+      name: 'devBuild',
+      message: 'Generate development build ?',
+      default: defaultPegaConfig.devBuild
+    }
+  ];
+};
+
+export const zipComponent = async componentKey => {
+  const srcDirectory = await getComponentDirectoryPath(componentKey);
+  const buildDirectory = await path.join(path.resolve(), 'dist/components', componentKey);
+  const configJson = `${srcDirectory}/config.json`;
+
+  const zip = new AdmZip();
+
+  zip.addLocalFolder(srcDirectory, 'src/');
+  zip.addLocalFile(configJson);
+  zip.addLocalFolder(buildDirectory);
+  const zipContent = zip.toBuffer().toString('base64');
+
+  const configContent = Buffer.from(fs.readFileSync(`${srcDirectory}/config.json`)).toString();
+  fs.rmdir('dist', { recursive: true }, err => {
+    if (err) {
+      throw err;
+    }
+  });
+  return { zipContent, configContent };
+};
+
+export const publishComponentToServer = async data => {
+  const { configContent, zipContent, componentKey, rulesetName, rulesetVersion } = data;
+
+  const apiBody = {
+    configContent,
+    zipContent,
+    componentKey: JSON.parse(configContent).componentKey,
+    publishFor: 'constellation',
+    rulesetName,
+    rulesetVersion,
+    category: ''
+  };
+  const defaultPegaConfig = await getPegaServerConfig();
+  const url = constructCompleteUrl(
+    defaultPegaConfig.server,
+    PUBLISH_COMPONENT_SERVICE_REST_ENDPOINT
+  );
+  try {
+    const OauthData = fs.readFileSync(TOKEN_PATH, 'utf8');
+    if (OauthData) {
+      const {
+        access_token: accessToken,
+        token_type: tokenType,
+        refresh_token: refreshToken
+      } = JSON.parse(OauthData);
+      let status = 500;
+      fetch(url, {
+        method: 'POST',
+        agent: new https.Agent({ rejectUnauthorized: false }),
+        headers: {
+          Authorization: `${tokenType} ${accessToken}`
+        },
+        body: JSON.stringify(apiBody)
+      })
+        .then(response => {
+          status = response.status;
+          return response.text();
+        })
+        .then(resp => {
+          const respData = JSON.parse(resp);
+          if (status === 401) {
+            throw new Error(
+              'Error occured in authentication. Please regenerate using authenticate'
+            );
+            // console.log(accessTokenUri, refreshToken);
+            /* TODO - Handle refresh_token */
+          } else if (status == 200) {
+            console.log(chalk.bold.green(`Success : ${respData.message}`));
+          } else {
+            throw new Error(`${respData.message}`);
+          }
+        })
+        .catch(e => Promise.reject(`${chalk.bold.red(e)}`));
+    } else {
+      throw new Error(`Error occured in authentication. Please regenerate using authenticate`);
+    }
+  } catch (err) {
+    throw new Error(`Error occured in authentication. Please regenerate using authenticate`);
+  }
+};

package/src/tasks/publish/index.js

@@ -0,0 +1,72 @@
+import inquirer from 'inquirer';
+import Listr from 'listr';
+import chalk from 'chalk';
+
+import validate from '../validator/index.js';
+import { getComponentDirectoryPath } from '../../util.js';
+import bundleComponent from '../bundle/index.js';
+import { updateComponentMap  } from '../map/map.js';
+import { lintComponent } from '../linter/index.js';
+
+import { getPublishComponentQuestions, publishComponentToServer, zipComponent } from './helper.js';
+
+export default async options => {
+  const questions = await getPublishComponentQuestions();
+  const answers = await inquirer.prompt(questions);
+  const { componentKey, sourceMap, devBuild } = answers;
+
+  let content = {
+    ...answers
+  };
+
+  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
+    }
+  );
+
+  await tasks.run().catch(err => {
+    console.log(chalk.bold.red(err.toString()));
+  });
+  return true;
+};

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

@@ -0,0 +1,139 @@
+import fs from 'fs';
+import path from 'path';
+import https from 'https';
+
+import fetch from 'node-fetch';
+import AdmZip from 'adm-zip';
+import chalk from 'chalk';
+
+import {
+  constructCompleteUrl,
+  getComponentDirectoryPath,
+  getComponentsObj,
+  getPegaServerConfig,
+  validateRulesetVersion
+} from '../../util.js';
+import { PUBLISH_COMPONENT_SERVICE_REST_ENDPOINT, TOKEN_PATH } from '../../constants.js';
+
+export const getPublishComponentQuestions = async () => {
+  const components = await getComponentsObj();
+  const defaultPegaConfig = await getPegaServerConfig();
+
+  return [
+    {
+      name: 'rulesetName',
+      message: 'Enter ruleset name',
+      default: defaultPegaConfig.rulesetName,
+      validate: value => {
+        if (value.trim()) {
+          return true;
+        }
+        return 'Ruleset name cannot be empty';
+      }
+    },
+    {
+      name: 'rulesetVersion',
+      message: 'Enter ruleset version',
+      default: defaultPegaConfig.rulesetVersion,
+      validate: value => {
+        if (validateRulesetVersion(value)) {
+          return true;
+        }
+        return 'Please provide compatible version e.g 01-01-01';
+      }
+    },
+    {
+      name: 'sourceMap',
+      message: 'Generate source map ?',
+      default: defaultPegaConfig.sourceMap,
+      when: () => false && !process.env.SOURCE_MAP
+    },
+    {
+      name: 'devBuild',
+      message: 'Generate development build ?',
+      default: defaultPegaConfig.devBuild
+    }
+  ];
+};
+
+export const zipComponent = async componentKey => {
+  const srcDirectory = await getComponentDirectoryPath(componentKey);
+  const buildDirectory = await path.join(path.resolve(), 'dist/components', componentKey);
+  const configJson = `${srcDirectory}/config.json`;
+
+  const zip = new AdmZip();
+
+  zip.addLocalFolder(srcDirectory, 'src/');
+  zip.addLocalFile(configJson);
+  zip.addLocalFolder(buildDirectory);
+  const zipContent = zip.toBuffer().toString('base64');
+
+  const configContent = Buffer.from(fs.readFileSync(`${srcDirectory}/config.json`)).toString();
+  fs.rmdir('dist', { recursive: true }, err => {
+    if (err) {
+      throw err;
+    }
+  });
+  return { zipContent, configContent };
+};
+
+export const publishComponentToServer = async data => {
+  const { configContent, zipContent, componentKey, rulesetName, rulesetVersion } = data;
+
+  const apiBody = {
+    configContent,
+    zipContent,
+    componentKey: JSON.parse(configContent).componentKey,
+    publishFor: 'constellation',
+    rulesetName,
+    rulesetVersion,
+    category: ''
+  };
+  const defaultPegaConfig = await getPegaServerConfig();
+  const url = constructCompleteUrl(
+    defaultPegaConfig.server,
+    PUBLISH_COMPONENT_SERVICE_REST_ENDPOINT
+  );
+  try {
+    const OauthData = fs.readFileSync(TOKEN_PATH, 'utf8');
+    if (OauthData) {
+      const {
+        access_token: accessToken,
+        token_type: tokenType,
+        refresh_token: refreshToken
+      } = JSON.parse(OauthData);
+      let status = 500;
+      fetch(url, {
+        method: 'POST',
+        agent: new https.Agent({ rejectUnauthorized: false }),
+        headers: {
+          Authorization: `${tokenType} ${accessToken}`
+        },
+        body: JSON.stringify(apiBody)
+      })
+        .then(response => {
+          status = response.status;
+          return response.text();
+        })
+        .then(resp => {
+          const respData = JSON.parse(resp);
+          if (status === 401) {
+            throw new Error(
+              'Error occured in authentication. Please regenerate using authenticate'
+            );
+            // console.log(accessTokenUri, refreshToken);
+            /* TODO - Handle refresh_token */
+          } else if (status == 200) {
+            console.log(chalk.bold.green(`Success : ${respData.message}`));
+          } else {
+            throw new Error(`${respData.message}`);
+          }
+        })
+        .catch(e => Promise.reject(`${chalk.bold.red(e)}`));
+    } else {
+      throw new Error(`Error occured in authentication. Please regenerate using authenticate`);
+    }
+  } catch (err) {
+    throw new Error(`Error occured in authentication. Please regenerate using authenticate`);
+  }
+};