@pega/custom-dx-components 0.0.1 → 0.8.1

package/src/util.js

@@ -2,20 +2,24 @@ import fs from 'fs';
 import { join } from 'path';
 import { promisify } from 'util';
 import https from 'https';
+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 checkGit from 'check-git';
 
+import * as currentPath from './currentPath.cjs';
 import {
   COMPONENTS_DIRECTORY_PATH,
   TASKS_CONFIG_JSON_FILENAME,
   TOKEN_PATH,
   OOTB_COMPONENT_SERVICE_REST_ENDPOINT,
   DELETE_COMPONENT_SERVICE_REST_ENDPOINT,
-  OOTB_COMPONENTS,
-  TOKEN_URL_V1
+  LP_DELETE_COMPONENT_SERVICE_REST_ENDPOINT,
+  OOTB_COMPONENTS
 } from './constants.js';
 
 const access = promisify(fs.access);
@@ -26,14 +30,13 @@ export const checkPathAccess = async (path, options = {}) => {
   try {
     await access(path, fs.constants.R_OK);
   } catch (err) {
-    const message =
-      errorMessage || `${chalk.red.bold('ERROR')} Could not able to access path - ${path}`;
+    const message = errorMessage || `${chalk.red.bold('ERROR')} Could not able to access path - ${path}`;
     console.error(message);
     process.exit(1);
   }
 };
 
-export const deleteLocalComponent = async componentKey => {
+export const deleteLocalComponent = async (componentKey) => {
   const currentDirectory = process.cwd();
   const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
 
@@ -43,25 +46,32 @@ export const deleteLocalComponent = async componentKey => {
   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`
-    );
+    console.error(`${chalk.red.bold('ERROR')} Could not able find components directory path in config.json`);
     process.exit(1);
   }
 
   const directory = join(currentDirectory, data[COMPONENTS_DIRECTORY_PATH], componentKey);
 
-  fs.rmdir(directory, { recursive: true }, err => {
-    if (err) {
-      throw err;
-    }
-
+  try {
+    fs.rmSync(directory, { recursive: true });
     console.log(`${chalk.red.bold(componentKey)} is deleted from Local`);
-  });
+  } catch (err) {
+    console.log('no file');
+    throw new Error(`No such file ${componentKey}`);
+  }
 };
 
-export const deleteServerComponent = async componentKey => {
-  const { server, user, password } = await getPegaServerConfig();
+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 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}`;
@@ -69,28 +79,31 @@ export const deleteServerComponent = async componentKey => {
     const OauthData = fs.readFileSync(TOKEN_PATH, 'utf8');
 
     if (OauthData) {
-      const {
-        access_token: accessToken,
-        token_type: tokenType,
-        refresh_token: refreshToken
-      } = JSON.parse(OauthData);
+      const { access_token: accessToken, token_type: tokenType, refresh_token: refreshToken } = 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(resp => {
-          const respData = JSON.parse(resp);
+        .then((response) => response.text())
+        .then((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)}`));
+        .catch((e) => Promise.reject(`${chalk.bold.red(e)}`));
     }
   } catch (error) {
     console.log(`\n${chalk.bold.red(error)}`);
@@ -104,20 +117,55 @@ export const getComponents = async () => {
   await checkPathAccess(pegaConfigJsonPath);
 
   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`
-    );
+    console.error(`${chalk.red.bold('ERROR')} Could not find components directory path in config.json`);
     process.exit(1);
   }
 
   const directory = join(currentDirectory, data[COMPONENTS_DIRECTORY_PATH]);
   return fs
     .readdirSync(directory, { withFileTypes: true })
-    .filter(dirent => dirent.isDirectory())
-    .map(dirent => dirent.name);
+    .filter((dirent) => dirent.isDirectory())
+    .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 () => {
+  const compList = [];
+
+  // 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 () => {
@@ -142,7 +190,7 @@ export const getComponentDefaults = async () => {
   return config.component;
 };
 
-export const getComponentDirectoryPath = async componentKey => {
+export const getComponentDirectoryPath = async (componentKey) => {
   const currentDirectory = process.cwd();
   const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
 
@@ -152,9 +200,7 @@ export const getComponentDirectoryPath = async componentKey => {
   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`
-    );
+    console.error(`${chalk.red.bold('ERROR')} Could not able find components directory path in config.json`);
     process.exit(1);
   }
 
@@ -166,11 +212,11 @@ export const compileMustacheTemplate = (file, data) => {
   return mustache.render(content, data);
 };
 
-export const isPascalCase = string => {
+export const isPascalCase = (string) => {
   return string === pascalCase(string);
 };
 
-export const convertIntoPascalCase = string => {
+export const convertIntoPascalCase = (string) => {
   return pascalCase(string);
 };
 
@@ -178,23 +224,7 @@ export const constructCompleteUrl = (baseServer, endPoint) => {
   return baseServer.endsWith('/') ? `${baseServer}${endPoint}` : `${baseServer}/${endPoint}`;
 };
 
-export const nodeFetch = (url, config) => {
-  const { method, user, password, headers, ...restConfig } = config;
-
-  if (url.startsWith('https')) restConfig.agent = new https.Agent({ rejectUnauthorized: false });
-
-  return fetch(url, {
-    method,
-    ...restConfig,
-    headers: {
-      'Content-Type': 'application/json;charset=utf-8',
-      Authorization: `Basic ${Buffer.from(`${user}:${password}`).toString('base64')}`,
-      ...headers
-    }
-  });
-};
-
-export const sanitize = str => {
+export const sanitize = (str) => {
   /* Allow only numbers and case insensitive alphabets */
   str = str.replace(/[^a-zA-Z0-9 ]/g, '');
   /* spaces will be replaced by - */
@@ -202,13 +232,13 @@ export const sanitize = str => {
   return str;
 };
 
-export const validateSemver = str => {
+export const validateSemver = (str) => {
   /* basic semver version validation - 0.0.1-dev */
   const regex = /^[0-9]\d*\.\d+\.\d+(?:-[a-zA-Z0-9]+)?$/g;
   return regex.test(str);
 };
 
-export const validateRulesetVersion = str => {
+export const validateRulesetVersion = (str) => {
   /* Ruleset version range - 01-99 */
   if (str.indexOf('00') !== -1) {
     return false;
@@ -218,33 +248,62 @@ export const validateRulesetVersion = str => {
   return regex.test(str);
 };
 
+export const standardizeStr = (str, length) => {
+  return str.padEnd(length);
+};
+
+export const showVersion = () => {
+  // get package version, so can display at start
+  // const require = createRequire(import.meta.url);
+  const require = createRequire(currentPath.default);
+
+  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);
+  }
+
+  const hasGit = checkGit(process.cwd());
+
+  if (!hasGit) {
+    console.log(chalk.redBright('DX Component Builder - SDK git to be installed.'));
+    process.exit(1);
+  }
+};
+
 export const getOOTBComponents = async () => {
-  return new Promise((resolve, reject) => {
-    fs.readFile(OOTB_COMPONENTS, 'utf-8', async (err, data) => {
-      if (err) {
+  return new Promise((resolve) => {
+    fs.readFile(OOTB_COMPONENTS, 'utf-8', async (error, ootbComponentsData) => {
+      if (error) {
         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) {
-            const {
-              access_token: accessToken,
-              token_type: tokenType,
-              refresh_token: refreshToken
-            } = JSON.parse(OauthData);
+            const { access_token: accessToken, token_type: tokenType } = JSON.parse(OauthData);
             fetch(url, {
               method: 'GET',
-              agent: new https.Agent({ rejectUnauthorized: false }),
+              agent: getHttpsAgent(serverConfig),
               headers: {
                 Authorization: `${tokenType} ${accessToken}`
               }
             })
-              .then(response => response.text())
-              .then(data => {
+              .then((response) => response.text())
+              .then((data) => {
                 if (data.charAt() === '[') {
                   data = data.slice(1, -1);
                   data = data.replace(/\s/g, '');
-                  fs.writeFile(OOTB_COMPONENTS, data, err => {
+                  fs.writeFile(OOTB_COMPONENTS, data, (err) => {
                     if (err) {
                       console.error(err);
                     }
@@ -254,24 +313,135 @@ export const getOOTBComponents = async () => {
                   data = JSON.parse(data);
                   if (data && data.errors) {
                     const errMessages = data.errors;
-                    errMessages.forEach(msgArr => {
+                    errMessages.forEach((msgArr) => {
                       throw new Error(`Failed with error - ${JSON.stringify(msgArr.message)}`);
                     });
                   }
                 }
               })
-              .catch(e => Promise.reject(`${chalk.bold.red(e)}`));
+              // eslint-disable-next-line prefer-promise-reject-errors
+              .catch((e) => Promise.reject(`${chalk.bold.red(e)}`));
           }
-        } catch (error) {
-          throw new Error('Error occurred in validation', error);
+        } catch (e) {
+          throw new Error('Error occurred in validation', e);
         }
       } else {
-        resolve(data.split(','));
+        resolve(ootbComponentsData.split(','));
       }
     });
   });
 };
 
-export const getTokenUrl = async (server) => {
-  return server.endsWith('/') ? `${server}${TOKEN_URL_V1}` : `${server}/${TOKEN_URL_V1}`;
+export const deleteInfinityServerComponent = async (componentKey) => {
+  const serverConfig = await getPegaServerConfig();
+  const { server } = 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, token_type: tokenType } = JSON.parse(OauthData);
+      fetch(deleteUrl, {
+        method: 'DELETE',
+        agent: getHttpsAgent(serverConfig),
+        headers: {
+          Authorization: `${tokenType} ${accessToken}`
+        }
+      })
+        .then((response) => {
+          status = response.status;
+          return response.text();
+        })
+        .then((resp) => {
+          let respData;
+          try {
+            respData = JSON.parse(resp);
+          } catch (e) {
+            console.log(chalk.bold.redBright(`Failure : ${resp}`));
+            process.exit(1);
+          }
+
+          if (status === 200) {
+            console.log(chalk.bold.green(`Success : ${respData.message}`));
+          } else {
+            throw new Error(`${respData.message}`);
+          }
+        })
+        .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)}`);
+  }
+};
+
+export const deleteLaunchpadServerComponent = async (componentKey) => {
+  const { server, isolationId } = await getPegaServerConfig();
+  const deleteUrl = constructCompleteUrl(server, LP_DELETE_COMPONENT_SERVICE_REST_ENDPOINT.replace('{isolationId}', isolationId));
+  const [componentName] = componentKey.split('~|~');
+
+  try {
+    const OauthData = fs.readFileSync(TOKEN_PATH, 'utf8');
+
+    let status = 500;
+
+    if (OauthData) {
+      const { access_token: accessToken, token_type: tokenType } = JSON.parse(OauthData);
+
+      const headers = {
+        Authorization: `${tokenType} ${accessToken}`,
+        cookie: `Pega-AAT=${accessToken}`,
+        'Content-Type': 'application/json'
+      };
+
+      const apiBody = {
+        type: 'CustomComponent',
+        componentName
+      };
+
+      fetch(deleteUrl, {
+        method: 'DELETE',
+        agent: new https.Agent({ rejectUnauthorized: false }),
+        headers,
+        body: JSON.stringify(apiBody)
+      })
+        .then((response) => {
+          status = response.status;
+          return response.text();
+        })
+        .then((response) => {
+          if (status === 401) {
+            throw new Error('Error occurred in authentication. Please regenerate using authenticate');
+            // console.log(accessTokenUri, refreshToken);
+            /* TODO - Handle refresh_token */
+          } else if (status === 200 || status === 201) {
+            console.log(chalk.bold.green(`Success : ${response}`));
+          } else {
+            throw new Error(`${response.message}`);
+          }
+        })
+        .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)}`);
+  }
 };

package/tests/assets/components/create/Pega_DXIL_MyTestText/config.json

@@ -0,0 +1,55 @@
+{
+  "name": "Pega_DXIL_MyTestText",
+  "label": "My Test Text",
+  "description": "My Test Text Description",
+  "organization": "Pega",
+  "version": "0.0.1",
+  "library": "DXIL",
+  "allowedApplications": [],
+  "componentKey": "Pega_DXIL_MyTestText",
+  "type": "Field",
+  "subtype": "Text",
+  "properties": [
+    {
+      "name": "label",
+      "label": "Label value",
+      "format": "TEXT"
+    },
+    {
+      "name": "placeholder",
+      "label": "Placeholder",
+      "format": "TEXT"
+    },
+    {
+      "name": "visibility",
+      "label": "Visible",
+      "format": "VISIBILITY"
+    },
+    {
+      "name": "disabled",
+      "label": "Disabled",
+      "format": "DISABLED"
+    },
+    {
+      "name": "required",
+      "label": "Required",
+      "format": "REQUIRED"
+    },
+    {
+      "label": "Advanced",
+      "format": "GROUP",
+      "collapsible": true,
+      "properties": [
+        {
+          "name": "testId",
+          "label": "Test ID",
+          "format": "TEXT",
+          "ignorePattern": "[^-_\\p{N}\\p{L}]",
+          "includeAnnotations": false
+        }
+      ]
+    }
+  ],
+  "defaultConfig": {
+  }
+}

package/tests/assets/components/create/Pega_DXIL_MyTestText/demo.stories.jsx

@@ -0,0 +1,51 @@
+import { useState } from 'react';
+import { withKnobs } from '@storybook/addon-knobs';
+
+import { stateProps, configProps } from './mock.stories';
+
+import PegaDxilMyTestText from './index.jsx';
+
+export default {
+  title: 'PegaDxilMyTestText',
+  decorators: [withKnobs],
+  component: PegaDxilMyTestText
+};
+
+export const basePegaDxilMyTestText = () => {
+  // eslint-disable-next-line react-hooks/rules-of-hooks
+  const [value, setValue] = useState(configProps.value);
+
+  const props = {
+    value,
+    placeholder: configProps.placeholder,
+    label: configProps.label,
+    testId: configProps.testId,
+    hasSuggestions: configProps.hasSuggestions,
+
+    getPConnect: () => {
+      return {
+        getStateProps: () => {
+          return stateProps;
+        },
+        getActionsApi: () => {
+          return {
+            updateFieldValue: (propName, theValue) => {
+              setValue(theValue);
+            },
+            triggerFieldChange: () => {/* nothing */}
+          };
+        },
+        ignoreSuggestion: () => {/* nothing */},
+        acceptSuggestion: () => {/* nothing */},
+        setInheritedProps: () => {/* nothing */},
+        resolveConfigProps: () => {/* nothing */}
+      };
+    }
+  };
+
+  return (
+    <>
+      <PegaDxilMyTestText {...props} />
+    </>
+  );
+};

package/tests/assets/components/create/Pega_DXIL_MyTestText/index.jsx

@@ -0,0 +1,60 @@
+import PropTypes from 'prop-types';
+import { Input, Label } from '@pega/cosmos-react-core';
+
+import StyledPegaDxilMyTestTextWrapper from './styles';
+
+
+// Duplicated runtime code from Constellation Design System Component
+
+// props passed in combination of props from property panel (config.json) and run time props from Constellation
+// any default values in config.pros should be set in defaultProps at bottom of this file
+const PegaDxilMyTestText = props => {
+  const { getPConnect, value, placeholder, disabled, readOnly, required, label, testId } = props;
+
+  const pConn = getPConnect();
+  const actions = pConn.getActionsApi();
+  const propName = pConn?.getStateProps()?.value;
+
+  const handleOnChange = event => {
+    const { value: updatedValue } = event.target;
+    actions.updateFieldValue(propName, updatedValue);
+  };
+
+  return (
+    <StyledPegaDxilMyTestTextWrapper>
+      <Label>{label}</Label>
+      <Input
+        type='text'
+        value={value}
+        placeholder={placeholder}
+        disabled={disabled}
+        readOnly={readOnly}
+        required={required}
+        onChange={handleOnChange}
+        testId={testId}
+      />
+    </StyledPegaDxilMyTestTextWrapper>
+  );
+};
+
+PegaDxilMyTestText.defaultProps = {
+  value: '',
+  placeholder: '',
+  disabled: false,
+  readOnly: false,
+  required: false,
+  testId: null
+};
+
+PegaDxilMyTestText.propTypes = {
+  label: PropTypes.string,
+  value: PropTypes.string,
+  placeholder: PropTypes.string,
+  getPConnect: PropTypes.func.isRequired,
+  disabled: PropTypes.oneOfType([PropTypes.bool, PropTypes.string]),
+  readOnly: PropTypes.oneOfType([PropTypes.bool, PropTypes.string]),
+  required: PropTypes.oneOfType([PropTypes.bool, PropTypes.string]),
+  testId: PropTypes.string
+};
+
+export default PegaDxilMyTestText;

package/tests/assets/components/create/Pega_DXIL_MyTestText/mock.stories.js

@@ -0,0 +1,13 @@
+export const configProps = {
+  value: '',
+  label: 'Text Sample',
+  placeholder: 'Text Placeholder',
+  helperText: 'Text Helper Text',
+  testId: 'Text-12345678',
+  hasSuggestions: false
+};
+
+export const stateProps = {
+  value: '.TextSample',
+  hasSuggestions: false
+};

package/tests/assets/components/create/Pega_DXIL_MyTestText/styles.js

@@ -0,0 +1,14 @@
+// utilizing theming, comment out, if want individual style
+import styled from 'styled-components';
+import { Configuration } from '@pega/cosmos-react-core';
+
+export default styled(Configuration)``;
+
+// individual style, comment out above, and uncomment here and add styles
+// import styled, { css } from 'styled-components';
+//
+// export default styled.div(() => {
+//  return css`
+//    margin: 0px 0;
+//  `;
+// });