@pega/custom-dx-components 0.0.1 → 0.23.1

package/src/tasks/validator/index.js

@@ -5,8 +5,13 @@ import chalk from 'chalk';
 import inquirer from 'inquirer';
 import Ajv from 'ajv';
 
-import { COMPONENT_SCHEMA } from '../../constants.js';
-import { getComponentDirectoryPath, getComponents, getOOTBComponents } from '../../util.js';
+import {
+  COMPONENT_SCHEMA } from '../../constants.js';
+
+import {
+  getComponentDirectoryPath,
+  getComponents,
+  getOOTBComponents } from '../../util.js';
 
 const ajv = new Ajv({ allErrors: true });
 
@@ -15,12 +20,20 @@ const combinationTypes = ['PAGE', 'CASE'];
 const allowedSubtypes = [
   ...new Set([
     ...COMPONENT_SCHEMA.subtype.field.map(({ value }) => value),
-    ...COMPONENT_SCHEMA.subtype.template,
-    ...COMPONENT_SCHEMA.subtype.widget,
-    combinationTypes
+    ...COMPONENT_SCHEMA.subtype.template.map(({ value }) => value),
+    ...COMPONENT_SCHEMA.subtype.widget.map(({ value }) => value)
   ])
 ];
 
+// additional subtypes are manually added below
+const allowedOverrideSubtypes = [
+  ...new Set([
+    ...COMPONENT_SCHEMA.subtype.field.map(({ value }) => value),
+    ...COMPONENT_SCHEMA.subtype.template.map(({ value }) => value),
+    ...COMPONENT_SCHEMA.subtype.widget.map(({ value }) => value)
+  ]), "ACTION", "DATA_CAPTURE", "SUMMARY", "CASEVIEW", "DATAVIEW", "LIST"
+];
+
 const schema = {
   type: 'object',
   properties: {
@@ -32,7 +45,7 @@ const schema = {
     organization: { type: 'string' },
     version: { type: 'string' },
     library: { type: 'string' },
-    allowedApplications : { type: 'array' },
+    allowedApplications: { type: 'array' },
     type: { type: 'string', enum: COMPONENT_SCHEMA.type.map(({ value }) => value) },
     subtype: {
       anyOf: [{ type: 'string' }, { type: 'array' }],
@@ -44,24 +57,263 @@ const schema = {
       type: 'array',
       uniqueItems: true,
       items: {
-        type: 'object',
-        properties: {
-          name: { type: 'string' },
-          label: { type: 'string' },
-          format: { type: 'string' }
-        },
-        required: ['name', 'label', 'format']
+        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: false
+  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: allowedOverrideSubtypes
+    },
+    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: ['name', 'type', 'subtype', 'properties', 'componentKey'],
+  additionalProperties: true
 };
 
 const validateSchema = ajv.compile(schema);
+const validateOverideSchema = ajv.compile(overrideSchema);
+
+
 
-export default async option => {
+export default async (option) => {
   let componentToValidate = null;
   if (option.params && option.params[3]) {
     componentToValidate = option.params[3];
@@ -75,26 +327,47 @@ export default async option => {
     });
 
     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'));
+  let configFileName = "config.json";
+
+  const configFile = path.join(componentDirectory, configFileName);
+  let configData;
+  try {
+    configData = fs.readFileSync(path.resolve(configFile), 'utf8');
+  }
+  catch (err) {
+
+    // 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) {
+
     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}`);
+        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)}`);

package/src/util.js

@@ -7,6 +7,10 @@ import chalk from 'chalk';
 import mustache from 'mustache';
 import pascalCase from 'pascalcase';
 import fetch from 'node-fetch';
+import { createRequire } from 'module';
+
+import _ from 'lodash';
+
 
 import {
   COMPONENTS_DIRECTORY_PATH,
@@ -15,11 +19,15 @@ import {
   OOTB_COMPONENT_SERVICE_REST_ENDPOINT,
   DELETE_COMPONENT_SERVICE_REST_ENDPOINT,
   OOTB_COMPONENTS,
-  TOKEN_URL_V1
+  SERVICES_AI_REST_ENDPOINT,
+  BOOTSTRAP_SERVICE_REST_ENDPOINT,
+  SERVICE_TOKEN_PATH
 } from './constants.js';
 
 const access = promisify(fs.access);
 
+let servicesToken = "";
+
 export const checkPathAccess = async (path, options = {}) => {
   const { errorMessage } = options;
 
@@ -51,7 +59,7 @@ export const deleteLocalComponent = async componentKey => {
 
   const directory = join(currentDirectory, data[COMPONENTS_DIRECTORY_PATH], componentKey);
 
-  fs.rmdir(directory, { recursive: true }, err => {
+  fs.rm(directory, { recursive: true }, err => {
     if (err) {
       throw err;
     }
@@ -74,7 +82,9 @@ export const deleteServerComponent = async componentKey => {
         token_type: tokenType,
         refresh_token: refreshToken
       } = JSON.parse(OauthData);
-      fetch(deleteUrl, {
+
+
+      await fetch(deleteUrl, {
         method: 'DELETE',
         agent: new https.Agent({ rejectUnauthorized: false }),
         headers: {
@@ -83,12 +93,23 @@ export const deleteServerComponent = async componentKey => {
       })
         .then(response => response.text())
         .then(resp => {
-          const respData = JSON.parse(resp);
+          let respData;
+          try {
+            respData = JSON.parse(resp);
+
+          }
+          catch (e) {
+            console.log(chalk.bold.redBright(`Failure : ${resp}`));
+            process.exit(1);
+          }
+
           if (respData.status == 200) {
             console.log(chalk.bold.green(`Success : ${respData.message}`));
           } else {
             throw new Error(`${respData.message}`);
           }
+
+
         })
         .catch(e => Promise.reject(`${chalk.bold.red(e)}`));
     }
@@ -97,6 +118,7 @@ export const deleteServerComponent = async componentKey => {
   }
 };
 
+
 export const getComponents = async () => {
   const currentDirectory = process.cwd();
   const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
@@ -120,6 +142,51 @@ export const getComponents = async () => {
     .map(dirent => dirent.name);
 };
 
+
+
+
+export const getSubComponents = async (directory, type) => {
+
+  const subDirectory = join(directory, type);
+  return fs
+  .readdirSync(subDirectory, { withFileTypes: true })
+  .filter(dirent => dirent.isDirectory())
+  .map(dirent => dirent.name);
+}
+
+
+export const getDirectoryFiles = async (directory) => {
+  return fs
+  .readdirSync(directory, { withFileTypes: true })
+  .filter(dirent => !dirent.isDirectory())
+  .map(dirent => dirent.name);
+}
+
+
+export const getComponentsObj = async () => {
+
+  let compList = new Array();
+
+  //const componentList = await getDirectoryFiles(directory);
+  const componentList = await getComponents();
+
+
+  if (componentList.length > 0) {
+
+    compList.push(...componentList.map(
+      name => {
+        const container = {};
+        container.name = name;
+        container.value = name;
+
+        return container;
+      }
+    ));
+  }
+
+  return compList;
+}
+
 export const getPegaConfig = async () => {
   const currentDirectory = process.cwd();
   const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
@@ -132,11 +199,32 @@ export const getPegaConfig = async () => {
   return data;
 };
 
+export const getAIPromptData = async (aiPromptPath) => {
+  await checkPathAccess(aiPromptPath);
+
+  let data = fs.readFileSync(aiPromptPath, { encoding: 'utf8' });
+
+  return data;
+}
+
+export const getComponentConfigJson = async (componentDirectory) => {
+
+  const filePath = join(componentDirectory, "config.json");
+  await checkPathAccess(filePath);
+
+  let data = fs.readFileSync(filePath, { encoding: 'utf8' });
+
+  data = _.unescape(data);
+
+  return data;
+}
+
 export const getPegaServerConfig = async () => {
   const config = await getPegaConfig();
   return config['server-config'];
 };
 
+
 export const getComponentDefaults = async () => {
   const config = await getPegaConfig();
   return config.component;
@@ -218,6 +306,25 @@ export const validateRulesetVersion = str => {
   return regex.test(str);
 };
 
+export const showVersion = () => {
+  // get package version, so can display at start
+  const require = createRequire(import.meta.url);
+  const pData = require("@pega/custom-dx-components/package.json");
+
+  console.log(chalk.green("DX Component Builder v" + pData.version));
+
+  // do a check of node version, it should be 18 or greater
+  const arNodeVersion  = process.versions.node.split(".");
+
+  const nodeMajorVersion = parseInt(arNodeVersion[0]);
+  const nodeMinorVersion = parseInt(arNodeVersion[1]);
+
+  if (nodeMajorVersion < 18) {
+    console.log(chalk.redBright("DX Component Builder - SDK requires node v18 or greater, current version: " + process.version));
+    process.exit(1);
+  }
+};
+
 export const getOOTBComponents = async () => {
   return new Promise((resolve, reject) => {
     fs.readFile(OOTB_COMPONENTS, 'utf-8', async (err, data) => {
@@ -272,6 +379,140 @@ export const getOOTBComponents = async () => {
   });
 };
 
-export const getTokenUrl = async (server) => {
-  return server.endsWith('/') ? `${server}${TOKEN_URL_V1}` : `${server}/${TOKEN_URL_V1}`;
+
+
+export const storeServicesToken = async () => {
+  const { server } = await getPegaServerConfig();
+  const url = constructCompleteUrl(server, BOOTSTRAP_SERVICE_REST_ENDPOINT);
+
+  let returnToken = "";
+
+  try {
+    const OauthData = fs.readFileSync(TOKEN_PATH, 'utf8');
+    if (OauthData) {
+      let {
+        access_token: accessToken,
+        token_type: tokenType,
+        refresh_token: refreshToken
+      } = JSON.parse(OauthData);
+
+      await fetch(url, {
+        method: 'GET',
+        agent: new https.Agent({ rejectUnauthorized: false }),
+        headers: {
+          Authorization: `${tokenType} ${accessToken}`
+        },
+      })
+        .then(response => response.text())
+        .then(data => {
+
+          try {
+            const returnData = JSON.parse(data);
+
+            if (returnData != null && returnData.pyConfigJSON) {
+              const returnJSON = JSON.parse(returnData.pyConfigJSON);
+              const strToken = JSON.stringify(returnJSON.tokens, null, 2);
+
+
+              fs.writeFileSync(SERVICE_TOKEN_PATH, strToken, err => {
+                if (err) {
+                  Promise.reject(`${chalk.bold.red(err)}`);
+                }
+              });
+              //returnToken = returnJSON.tokens.C11NB2S;
+            }
+            else {
+              //returnToken = "";
+            }
+          }
+          catch {
+            Promise.reject(`${chalk.bold.red(data)}`);
+          }
+
+
+        })
+        .catch(e => Promise.reject(`${chalk.bold.red(e)}`));
+    }
+  }
+  catch (error) {
+    throw new Error('Error occurred in validation', error);
+  }
+
+  //return returnToken;
+
+}
+
+export const getAIComponent = async (prompt) => {
+
+
+  const { servicesServer } = await getPegaServerConfig();
+  if (servicesServer === undefined) {
+    Promise.reject(`${chalk.bold.red("ERROR: servicesServer not defined in tasks.config.json" )}`);
+  }
+
+  const serviceUrl = constructCompleteUrl(servicesServer, SERVICES_AI_REST_ENDPOINT);
+
+  const jsonBody = { "prompt" : prompt };
+
+  let returnCode = "";
+
+  try {
+    const OauthData = fs.readFileSync(TOKEN_PATH, 'utf8');
+    const ServicesData = fs.readFileSync(SERVICE_TOKEN_PATH, 'utf8');
+    if (OauthData && ServicesData) {
+      let {
+        access_token: accessToken,
+        token_type: tokenType,
+        refresh_token: refreshToken
+      } = JSON.parse(OauthData);
+
+      const { C11NB2S } = JSON.parse(ServicesData);
+
+      // services needs Bearer with a big "B"
+      tokenType = convertIntoPascalCase(tokenType);
+
+      await fetch(serviceUrl, {
+        method: 'POST',
+        agent: new https.Agent({ rejectUnauthorized: false }),
+        headers: {
+          Authorization: `${tokenType} ${C11NB2S}`,
+          'Accept': 'application/json',
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(jsonBody),
+      })
+        .then(response => response.text())
+        .then(data => {
+
+          try {
+            const returnData = JSON.parse(data);
+
+            if (returnData != null && returnData.code) {
+              returnCode = returnData.code;
+            }
+            else {
+              returnCode = "";
+            }
+          }
+          catch {
+            Promise.reject(`Error in AI generation: \n ${chalk.bold.red(data)}`);
+            //throw new Error('Error occurred in validation', data);
+          }
+
+
+        })
+        .catch(e => Promise.reject(`Error in AI generation: \n ${chalk.bold.red(e)}`));
+    }
+  }
+  catch (error) {
+    if (error.code === 'ENOENT') {
+      Promise.reject(`${chalk.bold.red("ERROR: Need to authenticate or reauthenticate.")}`);
+    }
+    else {
+      throw new Error('Error occurred in validation', error);
+    }
+
+  }
+
+  return returnCode;
 };