@pega/dx-component-builder-sdk 0.1.47 → 0.1.49

package/src/tasks/validator/index.js

@@ -9,12 +9,14 @@ import {
   COMPONENT_SCHEMA,
   CATEGORY_CUSTOM,
   CATEGORY_OVERRIDE } from '../../constants.js';
-  
+
 import {
   getComponentDirectoryPath,
   getComponents,
   getOOTBComponents,
-  removeComponentPrefix } from '../../util.js';
+  removeComponentPrefix,
+  getFramework, 
+  getLocalComponentKeyFromConfig} from '../../util.js';
 
 const ajv = new Ajv({ allErrors: true });
 
@@ -34,7 +36,7 @@ const allowedOverrideSubtypes = [
     ...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"
+  ]), "ACTION", "DATA_CAPTURE", "SUMMARY", "CASEVIEW", "DATAVIEW", "LIST", "TAB"
 ];
 
 const schema = {
@@ -312,12 +314,14 @@ const overrideSchema = {
 };
 
 const validateSchema = ajv.compile(schema);
-const validateOverideSchema = ajv.compile(overrideSchema);
+const validateOverrideSchema = ajv.compile(overrideSchema);
 
 
 
 export default async (option, category = CATEGORY_CUSTOM) => {
   let componentToValidate = null;
+  const framework = await getFramework();
+
   if (option.params && option.params[3]) {
     componentToValidate = option.params[3];
   } else if (option && option.task === 'validateSchema') {
@@ -352,7 +356,7 @@ export default async (option, category = CATEGORY_CUSTOM) => {
     }
     else if (category === CATEGORY_OVERRIDE) {
       // for now, if now file just end
-      console.log(`${chalk.bold.yellow('Config file not availabe for: ' + componentToValidate)}`);
+      console.log(`${chalk.bold.yellow('Config file not available for: ' + componentToValidate)}`);
       return;
     }
   }
@@ -360,15 +364,29 @@ export default async (option, category = CATEGORY_CUSTOM) => {
   //const data = JSON.parse(fs.readFileSync(path.resolve(configFile), 'utf8'));
   const data = JSON.parse(configData);
 
-  const valid = (category === CATEGORY_OVERRIDE) ? validateOverideSchema(data) : validateSchema(data);
+  const valid = (category === CATEGORY_OVERRIDE) ? validateOverrideSchema(data) : validateSchema(data);
 
   if (valid) {
 
     // need to remove path
+    const originalComponentToValidate = componentToValidate;
     componentToValidate = removeComponentPrefix(componentToValidate);
 
     // don't check for out the box if override
     if (category != CATEGORY_OVERRIDE) {
+
+      // we are validating the component name, not the actual component
+      // so need to get the component name (or key) from config.json
+      switch(framework) {
+        case "SDK-Angular":
+          componentToValidate = await getLocalComponentKeyFromConfig(originalComponentToValidate);
+          break;
+        case "SDK-React":
+          break;
+        case "SDK-WebComponents":
+          break;
+      }
+
       if (
         componentToValidate &&
         !/^[A-Za-z0-9]+_[A-Za-z0-9]+_[A-Za-z0-9]+$/.test(componentToValidate)
@@ -383,6 +401,12 @@ export default async (option, category = CATEGORY_CUSTOM) => {
 
     console.log(`${chalk.bold.green(componentToValidate)} schema is valid`);
   } else {
-    throw new Error(`Invalid: ${ajv.errorsText(validateSchema.errors)}`);
+    if (category === CATEGORY_OVERRIDE) {
+      throw new Error(`Invalid: ${ajv.errorsText(validateOverrideSchema.errors)}`);
+    }
+    else {
+      throw new Error(`Invalid: ${ajv.errorsText(validateSchema.errors)}`);
+    }
+
   }
 };

package/src/util.js

@@ -4,15 +4,18 @@ import { join } from 'path';
 import { promisify } from 'util';
 import https from 'https';
 import inquirer from 'inquirer';
+import crypto from 'node:crypto';
 import { createRequire } from "module";
 
 import chalk from 'chalk';
 import mustache from 'mustache';
 import pascalCase from 'pascalcase';
 import fetch from 'node-fetch';
+import kebabcase from 'kebab-case';
 
 import {
-  COMPONENTS_DIRECTORY_PATH,
+  REACT_COMPONENTS_DIRECTORY_PATH,
+  ANGULAR_COMPONENTS_DIRECTORY_PATH,
   SDK_CONFIG_JSON_FILENAME,
   DXCB_CONFIG,
   DXCB_PUBLISH_ACCESS,
@@ -42,11 +45,16 @@ import {
 
 export const DXCB_CONFIG_INTERNAL_JSON_FILENAME = 'src/dxcb.config.json';
 
+let componentsDirectoryPath = "";
+let framework = "";
+
 const access = promisify(fs.access);
 
 export const checkPathAccess = async (path, options = {}) => {
   const { errorMessage } = options;
 
+  await updateComponentsDirectoryPath();
+
   try {
     await access(path, fs.constants.R_OK);
   } catch (err) {
@@ -57,6 +65,27 @@ export const checkPathAccess = async (path, options = {}) => {
   }
 };
 
+export const updateComponentsDirectoryPath = async () => {
+
+  if (framework === "") {
+    framework = await getFramework();
+
+    switch (framework) {
+      case "SDK-Angular":
+        componentsDirectoryPath = ANGULAR_COMPONENTS_DIRECTORY_PATH;
+        break;
+      case "SDK-React":
+        componentsDirectoryPath = REACT_COMPONENTS_DIRECTORY_PATH;
+        break;
+      case "SDK-WebComponents":
+        break;
+    }
+  }
+
+
+
+}
+
 export const visualLCCategory = (category) => {
 
   switch (category) {
@@ -70,13 +99,68 @@ export const visualLCCategory = (category) => {
   return category.toLowerCase();
 }
 
+let componentFramework = "";
+
 export const getFramework = async () => {
-  const pegaConfigInternalJsonPath = path.join(path.resolve(), DXCB_CONFIG_INTERNAL_JSON_FILENAME);
 
-  let internalData = fs.readFileSync(pegaConfigInternalJsonPath, { encoding: 'utf8' });
-  internalData = internalData && JSON.parse(internalData);
+  if ( componentFramework === "") {
+    const pegaConfigInternalJsonPath = path.join(path.resolve(), DXCB_CONFIG_INTERNAL_JSON_FILENAME);
+
+    let internalData = fs.readFileSync(pegaConfigInternalJsonPath, { encoding: 'utf8' });
+    internalData = internalData && JSON.parse(internalData);
+    componentFramework = internalData.sdkType;
+
+  }
+
+  return componentFramework
+}
+
+export const getLocalComponentConfig = async (componentKey, category = CATEGORY_CUSTOM) => {
+
+  if (category != "custom") {
+    return "";
+  }
+
+  let configJSON = null;
+  const currentDirectory = process.cwd();
+  const pegaConfigJsonPath = join(currentDirectory, SDK_CONFIG_JSON_FILENAME);
+  const categoryDirectory = (category === CATEGORY_CONSTELLATION) ? join("/", COMPONENT_DIRECTORY_PREFIX_CUSTOM + category.toLowerCase()) : join("/", category.toLowerCase() + COMPONENT_DIRECTORY_SUFFIX_SDK);
+
+  await checkPathAccess(pegaConfigJsonPath);
+
+  let data = fs.readFileSync(pegaConfigJsonPath, { encoding: 'utf8' });
+  data = JSON.parse(data);
+
+
+  const directory = join(currentDirectory, componentsDirectoryPath, categoryDirectory, componentKey);
+
+  // test for the directory
+  if (fs.existsSync(directory)) {
+
+    // get config.json if exists
+    const configJsonPath = join(directory, "config.json");
+
+    if (fs.existsSync(configJsonPath)) {
+      let data = fs.readFileSync(configJsonPath, { encoding: 'utf8'});
+      configJSON = JSON.parse(data);
+    }
+
+  }
 
-  return (internalData.sdkType);
+  return configJSON;
+}
+
+export const getLocalComponentKeyFromConfig = async (folderName, category) => {
+
+  const configJSON = await getLocalComponentConfig(folderName, category);
+  if (typeof(configJSON) == 'object') {
+    return configJSON.componentKey;
+  }
+  else {
+    return "";
+  }
+
+  
 }
 
 export const deleteLocalComponent = async (componentKey, category = CATEGORY_CUSTOM) => {
@@ -90,7 +174,7 @@ export const deleteLocalComponent = async (componentKey, category = CATEGORY_CUS
   data = JSON.parse(data);
 
 
-  const directory = join(currentDirectory, COMPONENTS_DIRECTORY_PATH, categoryDirectory, componentKey);
+  const directory = join(currentDirectory, componentsDirectoryPath, categoryDirectory, componentKey);
 
   // test for the directory
   if (fs.existsSync(directory)) {
@@ -112,14 +196,25 @@ export const deleteLocalComponent = async (componentKey, category = CATEGORY_CUS
   }
 };
 
+export const getHttpsAgent = (serverConfig) => {
+  const agentOptions = { rejectUnauthorized: false };
+  if (serverConfig.legacyTLS) {
+    agentOptions.secureOptions = crypto.constants.SSL_OP_LEGACY_SERVER_CONNECT;
+  }
+  return new https.Agent(agentOptions);
+};
+
 export const deleteServerComponent = async componentKey => {
-  const { server, user, password } = await getPegaServerConfig();
+  const serverConfig = await getPegaServerConfig();
+  const { server, user, password } = serverConfig;
   const url = constructCompleteUrl(server, DELETE_COMPONENT_SERVICE_REST_ENDPOINT);
   const [componentName, rulesetName, rulesetVersion] = componentKey.split('~|~');
   const deleteUrl = `${url}/${componentName}/rulesetname/${rulesetName}/rulesetversion/${rulesetVersion}`;
   try {
     const OauthData = fs.readFileSync(TOKEN_PATH, 'utf8');
 
+    let status = 500;
+
     if (OauthData) {
       const {
         access_token: accessToken,
@@ -128,12 +223,15 @@ export const deleteServerComponent = async componentKey => {
       } = JSON.parse(OauthData);
       fetch(deleteUrl, {
         method: 'DELETE',
-        agent: new https.Agent({ rejectUnauthorized: false }),
+        agent: getHttpsAgent(serverConfig),
         headers: {
           Authorization: `${tokenType} ${accessToken}`
         }
       })
-        .then(response => response.text())
+        .then(response => {
+          status = response.status;
+          return response.text();
+        })
         .then(resp => {
           const respData = JSON.parse(resp);
           if (respData.status == 200) {
@@ -142,7 +240,21 @@ export const deleteServerComponent = async componentKey => {
             throw new Error(`${respData.message}`);
           }
         })
-        .catch(e => Promise.reject(`${chalk.bold.red(e)}`));
+        .catch(e => {
+          if (status === 403) {
+            // eslint-disable-next-line prefer-promise-reject-errors
+            Promise.reject(
+              `${chalk.bold.red(
+                'Error forbidden: User does not have privileges to Delete.'
+              )}`
+            );
+          }
+          else {
+            // eslint-disable-next-line prefer-promise-reject-errors
+            Promise.reject(`${chalk.bold.red(e)}`)
+          }
+
+        });
     }
   } catch (error) {
     console.log(`\n${chalk.bold.red(error)}`);
@@ -187,7 +299,7 @@ export const getOptionsSource = (options) => {
   return sourceType;
 }
 
-export const getComponents = async (showSeparator = false, category = CATEGORY_CUSTOM) => {
+export const getComponents = async (showSeparator = false, category = CATEGORY_CUSTOM, isName = true) => {
   const currentDirectory = process.cwd();
   const pegaConfigJsonPath = join(currentDirectory, SDK_CONFIG_JSON_FILENAME);
   const categoryDirectory = (category === CATEGORY_CONSTELLATION) ? join("/", COMPONENT_DIRECTORY_PREFIX_CUSTOM + category.toLowerCase()) : join("/", category.toLowerCase() + COMPONENT_DIRECTORY_SUFFIX_SDK);
@@ -197,16 +309,29 @@ export const getComponents = async (showSeparator = false, category = CATEGORY_C
   let data = fs.readFileSync(pegaConfigJsonPath, { encoding: 'utf8' });
   data = JSON.parse(data);
 
-  const directory = join(currentDirectory, COMPONENTS_DIRECTORY_PATH, categoryDirectory);
+  const directory = join(currentDirectory, componentsDirectoryPath, categoryDirectory);
   let compList = new Array();
 
   switch (category) {
     case CATEGORY_CUSTOM:
     case CATEGORY_CONSTELLATION:
-      const fieldComps = await getSubComponents(directory, FIELD_PATH);
-      const templateComps = await getSubComponents(directory, TEMPLATE_PATH);
-      const widgetComps = await getSubComponents(directory, WIDGET_PATH);
-
+      let fieldComps;
+      let templateComps;
+      let widgetComps
+
+      if (isName) {
+        // this is new (better) way, where we ALWAYS have the Pascal case, even when the file is in another case, like Kabab
+        // keeping all in Pascal case makes display same for different SDKs and is the case that the customer typed in
+        fieldComps = await getSubComponentsName(directory, FIELD_PATH);
+        templateComps = await getSubComponentsName(directory, TEMPLATE_PATH);
+        widgetComps = await getSubComponentsName(directory, WIDGET_PATH);
+      }
+      else {
+        // this is the old way, were we get the actual name from the file (for Angular this is Kabab case)
+        fieldComps = await getSubComponents(directory, FIELD_PATH);
+        templateComps = await getSubComponents(directory, TEMPLATE_PATH);
+        widgetComps = await getSubComponents(directory, WIDGET_PATH);
+      }
 
 
       if (fieldComps.length > 0) {
@@ -275,6 +400,24 @@ export const getSubComponents = async (directory, type) => {
   .map(dirent => dirent.name);
 }
 
+export const getSubComponentsName = async (directory, type) => {
+
+  const subDirectory = join(directory, type);
+  const directoryList = fs.readdirSync(subDirectory, { withFileTypes: true })
+  .filter(dirent => dirent.isDirectory());
+
+  let componentList = new Array();
+
+  for ( let i =0; i < directoryList.length; i++) {
+    const directoryObj = directoryList[i];
+    const configJSON = await getLocalComponentConfig(join(type, directoryObj.name));
+    componentList.push(configJSON['componentKey']);
+  }
+
+  return componentList;
+
+}
+
 
 export const getDirectoryFiles = async (directory) => {
   return fs
@@ -294,14 +437,14 @@ export const getComponentsObj = async (showSeparator = false, category = CATEGOR
   let data = fs.readFileSync(pegaConfigJsonPath, { encoding: 'utf8' });
   data = JSON.parse(data);
 
-  const directory = join(currentDirectory, COMPONENTS_DIRECTORY_PATH, categoryDirectory);
+  const directory = join(currentDirectory, componentsDirectoryPath, categoryDirectory);
   let compList = new Array();
 
   switch (category) {
     case CATEGORY_CUSTOM:
-      const fieldComps = await getSubComponents(directory, FIELD_PATH);
-      const templateComps = await getSubComponents(directory, TEMPLATE_PATH);
-      const widgetComps = await getSubComponents(directory, WIDGET_PATH);
+      const fieldComps = await getSubComponentsName(directory, FIELD_PATH);
+      const templateComps = await getSubComponentsName(directory, TEMPLATE_PATH);
+      const widgetComps = await getSubComponentsName(directory, WIDGET_PATH);
 
       if (fieldComps.length > 0) {
         if (showSeparator) compList.push(new inquirer.Separator("---- fields ----"));
@@ -447,7 +590,7 @@ export const getComponentsAndSubDirectory = async (category = CATEGORY_CUSTOM) =
   let data = fs.readFileSync(pegaConfigJsonPath, { encoding: 'utf8' });
   data = JSON.parse(data);
 
-  const directory = join(currentDirectory, COMPONENTS_DIRECTORY_PATH, categoryDirectory);
+  const directory = join(currentDirectory, componentsDirectoryPath, categoryDirectory);
 
   const fieldComps = await getSubComponentsAndDir(directory, FIELD_PATH);
   const templateComps = await getSubComponentsAndDir(directory, TEMPLATE_PATH);
@@ -516,7 +659,7 @@ export const getComponentDirectoryPath = async (componentKey, category = CATEGOR
   let data = fs.readFileSync(pegaConfigJsonPath, { encoding: 'utf8' });
   data = JSON.parse(data);
 
-  return join(currentDirectory, COMPONENTS_DIRECTORY_PATH, categoryDirectory, componentKey);
+  return join(currentDirectory, componentsDirectoryPath, categoryDirectory, componentKey);
 };
 
 
@@ -533,24 +676,28 @@ export const convertIntoPascalCase = string => {
   return pascalCase(string);
 };
 
-export const constructCompleteUrl = (baseServer, endPoint) => {
-  return baseServer.endsWith('/') ? `${baseServer}${endPoint}` : `${baseServer}/${endPoint}`;
-};
+export const convertIntoKebabCase = string => {
+  let kCase = kebabcase(string);
+  if (kCase.length > 0 && string.length > 0) {
+    if (kCase[0] == '-' && string[0] != '-') {
+      kCase = kCase.substring(1);
+    }
+  }
 
-export const nodeFetch = (url, config) => {
-  const { method, user, password, headers, ...restConfig } = config;
 
-  if (url.startsWith('https')) restConfig.agent = new https.Agent({ rejectUnauthorized: false });
+  return kCase;
+}
 
-  return fetch(url, {
-    method,
-    ...restConfig,
-    headers: {
-      'Content-Type': 'application/json;charset=utf-8',
-      Authorization: `Basic ${Buffer.from(`${user}:${password}`).toString('base64')}`,
-      ...headers
-    }
-  });
+export const reverseKebabCase = string => {
+  if (string[0] != '-') {
+    string = "-".concat(string);
+  }
+
+  return kebabcase.reverse(string);
+}
+
+export const constructCompleteUrl = (baseServer, endPoint) => {
+  return baseServer.endsWith('/') ? `${baseServer}${endPoint}` : `${baseServer}/${endPoint}`;
 };
 
 export const sanitize = str => {
@@ -601,7 +748,8 @@ export const getOOTBComponents = async () => {
     fs.readFile(OOTB_COMPONENTS, 'utf-8', async (err, data) => {
       if (err) {
         try {
-          const { server } = await getPegaServerConfig();
+          const serverConfig = await getPegaServerConfig();
+          const { server } = serverConfig;
           const url = constructCompleteUrl(server, OOTB_COMPONENT_SERVICE_REST_ENDPOINT);
           const OauthData = fs.readFileSync(TOKEN_PATH, 'utf8');
           if (OauthData) {
@@ -612,7 +760,7 @@ export const getOOTBComponents = async () => {
             } = JSON.parse(OauthData);
             fetch(url, {
               method: 'GET',
-              agent: new https.Agent({ rejectUnauthorized: false }),
+              agent: getHttpsAgent(serverConfig),
               headers: {
                 Authorization: `${tokenType} ${accessToken}`
               }

package/src/tasks/create/templates/Constellation/field/TimeofDay/styles.js.mustache

@@ -1,7 +0,0 @@
-import styled, { css } from 'styled-components';
-
-export default styled.div(() => {
-  return css`
-    margin: 0px 0px;
-  `;
-});