@pega/custom-dx-components 0.0.1 → 0.1.10

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);
@@ -51,17 +55,26 @@ export const deleteLocalComponent = async componentKey => {
 
   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 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}`;
@@ -76,14 +89,21 @@ 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(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 {
@@ -104,11 +124,12 @@ 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`
+      `${chalk.red.bold('ERROR')} Could not find components directory path in config.json`
     );
     process.exit(1);
   }
@@ -120,6 +141,42 @@ 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 () => {
+  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 () => {
   const currentDirectory = process.cwd();
   const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
@@ -178,22 +235,6 @@ 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 => {
   /* Allow only numbers and case insensitive alphabets */
   str = str.replace(/[^a-zA-Z0-9 ]/g, '');
@@ -218,23 +259,56 @@ 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}`
               }
@@ -260,18 +334,138 @@ export const getOOTBComponents = async () => {
                   }
                 }
               })
+              // 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 || 'undefined')
+  );
+  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,60 @@
+/* eslint-disable react/jsx-no-useless-fragment */
+import { useState } from 'react';
+import { withKnobs } from '@storybook/addon-knobs';
+
+import { stateProps, configProps } from './mock';
+import PegaDxilMyTestText from './index.jsx';
+
+export default {
+  title: 'PegaDxilMyTestText',
+  decorators: [withKnobs],
+  component: PegaDxilMyTestText
+};
+
+export const BasePegaDxilMyTestText = () => {
+  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,61 @@
+import PropTypes from 'prop-types';
+import { Input } 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, hideLabel, 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>
+      <Input
+        type='text'
+        value={value}
+        label={label}
+        labelHidden={hideLabel}
+        placeholder={placeholder}
+        disabled={disabled}
+        readOnly={readOnly}
+        required={required}
+        onChange={handleOnChange}
+        testId={testId}
+      />
+    </StyledPegaDxilMyTestTextWrapper>
+  );
+};
+
+PegaDxilMyTestText.defaultProps = {
+  value: '',
+  placeholder: '',
+  disabled: false,
+  readOnly: false,
+  required: false,
+  testId: ''
+};
+
+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.js

@@ -0,0 +1,15 @@
+/* eslint-disable storybook/default-exports */
+/* eslint-disable storybook/prefer-pascal-case */
+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,15 @@
+
+// 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;
+//  `;
+// });

package/tests/assets/components/createAll/Constellation/Pega_DXIL_MyAutocomplete/component-constants.js

@@ -0,0 +1,5 @@
+export default {
+  PROPERTY_REFERENCE: 'propertyRef',
+  WORK_BASKET: 'workbasket',
+  WORK_QUEUE: 'workqueue'
+};