@pega/dx-component-builder-sdk 0.1.24 → 0.1.25

package/src/tasks/authenticate/helper.js

@@ -1,24 +1,98 @@
 /* eslint-disable import/prefer-default-export */
 import { getPegaServerConfig } from '../../util.js';
 
-export const getAuthQuestions = async () => {
-  const defaultPegaConfig = await getPegaServerConfig();
+import { AUTHENTICATE_SCHEMA } from '../../constants.js';
+
+export const getAuthQuestions = async (dxcbConfig) => {
+  const defaultPegaConfig = dxcbConfig;
+  const aMustAsk = dxcbConfig['questions_askAlways'] ? dxcbConfig['questions_askAlways'].split(',') : [];
+  const aNeverAsk = dxcbConfig['questions_askNever'] ? dxcbConfig['questions_askNever'].split(',') : [];
+
+  const initAnswers = (answers) => {
+    // Setup default answers
+    answers.serverType = defaultPegaConfig.serverType || "infinity";
+    answers.server = defaultPegaConfig.server || undefined;
+    answers.isolationId = defaultPegaConfig.isolationId || undefined;
+    answers.clientId = defaultPegaConfig.clientId || undefined;
+    answers.grantType = defaultPegaConfig.grantType || "authCode";
+    answers.clientSecret = defaultPegaConfig.clientSecret || undefined;
+    answers.user = defaultPegaConfig.user || undefined;
+    answers.password = defaultPegaConfig.password || undefined;
+  }
+
+  const fnStandardWhen = (prop, answers) => {
+    if (aNeverAsk.includes(prop)) {
+      return false;
+    }
+    return aMustAsk.includes(prop) || !answers[prop];
+  };
 
   return [
+    {
+      name: 'serverType',
+      type: 'rawlist',
+      message: 'Enter Pega server type',
+      default: answers => {
+        return defaultPegaConfig.serverType;
+      },
+      choices: AUTHENTICATE_SCHEMA.serverType,
+      validate: value => {
+        if (value.trim()) {
+          return true;
+        }
+        return 'Pega server type cannot be empty';
+      },
+      when: answers => {
+        initAnswers(answers);
+        return fnStandardWhen('serverType', answers);
+      }
+    },
     {
       name: 'server',
       message: 'Enter pega server url',
-      default: defaultPegaConfig.server
+      default: defaultPegaConfig.server,
+      when: answers =>{
+        return fnStandardWhen('server', answers);
+      }
+    },
+    {
+      name: 'isolationId',
+      message: 'Enter isolation id',
+      default: defaultPegaConfig.isolationId,
+      when: answers => {
+        return answers.serverType === "launchpad" && fnStandardWhen('isolationId', answers);
+      }
+    },
+    {
+      name: 'grantType',
+      type: 'rawlist',
+      message: 'Enter OAuth 2.0 grant type',
+      default: defaultPegaConfig.grantType,
+      choices: answers => {
+        return AUTHENTICATE_SCHEMA.grantType.filter(gt => !(answers.serverType === "launchpad" && gt.value === "passwordCreds"));
+      },
+      validate: value => {
+        if (value.trim()) {
+          return true;
+        }
+        return 'Grant type cannot be empty';
+      },
+      when: answers => {
+        return fnStandardWhen('grantType', answers);
+      }
     },
     {
       name: 'user',
       message: 'Enter user id',
       default: defaultPegaConfig.user,
-      validate: value => {
-        if (value.trim()) {
+      validate: (value, answers) => {
+        if (value.trim() || answers.grantType === "authCode") {
           return true;
         }
         return 'Username cannot be empty';
+      },
+      when: answers => {
+        return (answers.serverType === "infinity" && answers.grantType === "passwordCreds") && fnStandardWhen('user', answers);
       }
     },
     {
@@ -26,11 +100,14 @@ export const getAuthQuestions = async () => {
       type: 'password',
       message: 'Enter password',
       default: defaultPegaConfig.password,
-      validate: value => {
-        if (value.trim()) {
+      validate: (value, answers) => {
+        if (value.trim() || answers.grantType === "authCode") {
           return true;
         }
         return 'Password cannot be empty';
+      },
+      when: answers => {
+        return (answers.user && (answers.serverType === "infinity" && answers.grantType === "passwordCreds") && fnStandardWhen('password', answers));
       }
     },
     {
@@ -42,6 +119,9 @@ export const getAuthQuestions = async () => {
           return true;
         }
         return 'clientId cannot be empty';
+      },
+      when: answers => {
+        return fnStandardWhen('clientId', answers);
       }
     },
     {
@@ -49,11 +129,14 @@ export const getAuthQuestions = async () => {
       type: 'password',
       message: 'Enter clientSecret',
       default: defaultPegaConfig.clientSecret,
-      validate: value => {
+      validate: (value, answers) => {
         if (value.trim()) {
           return true;
         }
         return 'clientSecret cannot be empty';
+      },
+      when: answers => {
+        return (answers.grantType !== "authCode" && fnStandardWhen('clientSecret', answers));
       }
     }
   ];

package/src/tasks/authenticate/index.js

@@ -1,90 +1,166 @@
 import path from 'path';
-import fs from 'fs';
-import https from 'https';
+import fs from 'node:fs';
 
 import chalk from 'chalk';
 import inquirer from 'inquirer';
-import fetch from 'node-fetch';
 
-import { checkPathAccess, getPegaServerConfig, getTokenUrl, showVersion } from '../../util.js';
-import { TOKEN_PATH, SDK_CONFIG_JSON_FILENAME, SERVER_CONFIG, SERVER_REST_URL } from '../../constants.js';
+import { checkPathAccess, showVersion } from '../../util.js';
+import { TOKEN_PATH, TOKEN_URL_V1, AUTHORIZE_URL_V1, LP_TOKEN_URL, LP_AUTHORIZE_URL, SDK_CONFIG_JSON_FILENAME,
+  SERVER_CONFIG, DXCB_CONFIG, DXCB_PUBLISH_ACCESS, SERVER_TYPE, SERVER_REST_URL, LP_SERVER_REST_URL } from '../../constants.js';
 
 import { getAuthQuestions } from './helper.js';
-
+import PegaAuth from '../../auth.js';
 
 const pegaConfigJsonPath = path.join(path.resolve(), SDK_CONFIG_JSON_FILENAME);
+let server = null;
 
 const generateAccessToken = async config => {
-  const formData = new URLSearchParams();
-  formData.append('client_id', config.clientId);
-  formData.append('client_secret', config.clientSecret);
-  formData.append('username', config.user);
-  formData.append('password', config.password);
-  formData.append('grant_type', 'password');
-
-  const accessTokenUri = await getTokenUrl(config.server);
-  fetch(accessTokenUri, {
-    agent: new https.Agent({ rejectUnauthorized: false }),
-    method: 'POST',
-    headers: { 'content-type': 'application/x-www-form-urlencoded' },
-    body: formData.toString()
-  })
-    .then(response => {
-      if (response.ok && response.status === 200) {
-        return response.json();
-      } else {
-        throw new Error(`Failed with status: ${response.status}`);
-      }
-    })
-    .then(data => {
-      if (data && data.errors) {
-        const errMessages = data.errors;
-        errMessages.forEach(msgArr => {
-          throw new Error(`Failed with error - ${JSON.stringify(msgArr.message)}`);
-        });
-      }
-      if (data.token_type) {
-        fs.writeFile(TOKEN_PATH, JSON.stringify(data), err => {
-          if (err) {
-            console.error(err);
-          }
-          console.log(`${chalk.bold.green('Authenticated successfully !!')}`);
-        });
+
+  let authSuccess = false;
+  const { serverType, isolationId, grantType, clientId, clientSecret, user, password } = config;
+  // Try to gracefully deal with missing trailing slashes for server (and later conditionally for redirectUri)
+  const server = config.server.endsWith('/') ? config.server : `${config.server}/`;
+
+  return new Promise((resolve, reject) => {
+    const sTokenUri = `${server}${serverType === 'infinity' ? TOKEN_URL_V1 : LP_TOKEN_URL}`;
+    const sAuthorizeUri = `${server}${serverType === 'infinity' ? AUTHORIZE_URL_V1 : LP_AUTHORIZE_URL}`;
+    // console.log(`grantType: ${config.grantType}`);
+
+    const authCodeConfig = grantType === 'authCode' ? {
+      authorizeUri: sAuthorizeUri,
+      redirectUri: config.redirectUri.endsWith('/') ? config.redirectUri : `${config.redirectUri}/`,
+      cert: config.cert,
+      key: config.key,
+      winTitle: 'DX Component Dev',
+      winBodyHtml: `Authentication is complete.  This browser window may be closed.`
+    } : {};
+
+    // Build auth config structure
+    const authConfig = {
+      serverType: serverType,
+      grantType: grantType,
+      tokenUri: sTokenUri,
+      clientId: clientId,
+      clientSecret: clientSecret,
+      ignoreInvalidCerts: true,
+      ...authCodeConfig
+    };
+    if (serverType === 'infinity') {
+      authConfig.authService = 'pega';
+      if (grantType !== 'clientCreds' && user && password) {
+        authConfig.userIdentifier = user;
+        authConfig.password = Buffer.from(password).toString('base64');
       }
-    })
-    .catch(e => console.log(`${chalk.bold.red(e)}`));
+    }
+    if (serverType === 'launchpad') {
+      authConfig.isolationId = isolationId;
+      // authConfig.noPKCE = true;
+    }
+    const auth = new PegaAuth(authConfig);
+    // console.log(`...about to invoke auth.login\n${JSON.stringify(authConfig)}`);
+
+    auth.login()
+      .then((token) => {
+        if (token?.token_type) {
+          fs.writeFile(TOKEN_PATH, JSON.stringify(token), err => {
+            if (err) {
+              console.error(err);
+              return reject(authSuccess);
+            }
+            console.log(`${chalk.bold.green('Authenticated successfully !!')}`);
+            authSuccess = true;
+            return resolve(authSuccess);
+          });
+        } else {
+          console.log(`${chalk.bold.red('Authentication failed:' + JSON.stringify(token.errors ? token.errors : token))}`);
+          return reject(authSuccess);
+        }
+      })
+      .catch((e) => {
+        console.log(`${chalk.bold.red(e)}`);
+        return reject(authSuccess);
+      });
+  });
 };
 
 export default async options => {
+
+  let authOK = false;
+
   showVersion();
 
   await checkPathAccess(pegaConfigJsonPath);
 
-  let data = fs.readFileSync(pegaConfigJsonPath, { encoding: 'utf8' });
-  data = data && JSON.parse(data);
+  let cfgData = fs.readFileSync(pegaConfigJsonPath, { encoding: 'utf8' });
+  let data = null;
+  if (cfgData) {
+    try {
+      data = JSON.parse(cfgData);
+    } catch (e) {
+      const msg = `Invalid JSON within ${SDK_CONFIG_JSON_FILENAME}`;
+      console.log(`${chalk.red(msg)}`);
+      process.exit(1);
+    }
+  }
 
   if (!data[SERVER_CONFIG] || !data[SERVER_CONFIG][SERVER_REST_URL]) {
     console.error(
-      `${chalk.red.bold('ERROR')} Could not able find publish access path in config.json`
+      `${chalk.red.bold('ERROR')} ${SERVER_CONFIG}.${SERVER_REST_URL} property not found within ${SDK_CONFIG_JSON_FILENAME}`
     );
     process.exit(1);
   }
 
-  //const serverConfig = data[SERVER_CONFIG][SERVER_REST_URL];
-  const serverConfig = await getPegaServerConfig();
-  const params = options.params;
+ // Note: serverConfig below is actually dxcbConfig.
+  const serverConfig = data[DXCB_CONFIG][DXCB_PUBLISH_ACCESS];
+  serverConfig.serverType = data[SERVER_CONFIG][SERVER_TYPE] || "infinity";
+  serverConfig.server = data[SERVER_CONFIG][serverConfig.serverType === "infinity" ? SERVER_REST_URL : LP_SERVER_REST_URL];
+  const isPwdNonEmpty = serverConfig['password'] ? true : false;
 
-  const questions = await getAuthQuestions(params);
+  const questions = await getAuthQuestions(serverConfig);
   const answers = await inquirer.prompt(questions);
-  serverConfig.server = answers.server;
-  serverConfig.user = answers.user;
-  serverConfig.password = answers.password;
-  serverConfig.clientId = answers.clientId;
-  serverConfig.clientSecret = answers.clientSecret;
-  await generateAccessToken(serverConfig);
-
-  data = JSON.stringify(data, null, 2);
-  fs.writeFile(pegaConfigJsonPath, data, err => {
-    if (err) throw err;
-  });
+  const aProps = ['serverType','server','isolationId','clientId','grantType','clientSecret','user','password'];
+  const isLaunchPad = answers.serverType === "launchpad";
+  let bWriteUpdate = false;
+  for (let i = 0; i < aProps.length; i += 1) {
+    const prop = aProps[i];
+    if (serverConfig[prop] !== answers[prop]) {
+      // console.log(`property ${prop} changed from ${serverConfig[prop]} to ${answers[prop]}`);
+      serverConfig[prop] = answers[prop];
+      if (prop !== 'password' || isPwdNonEmpty) {
+        bWriteUpdate = true;
+      }
+      if (prop === 'server') {
+        data[SERVER_CONFIG][isLaunchPad ? LP_SERVER_REST_URL : SERVER_REST_URL] = answers.server;
+      }
+    }
+  }
+
+  try {
+    authOK = await generateAccessToken(serverConfig);
+  } catch (e) {
+  }
+
+  delete serverConfig.serverType;
+  delete serverConfig.server;
+
+  if (authOK & bWriteUpdate) {
+    // Don't write password value (unless it already had a value)
+    if (!isPwdNonEmpty) {
+      serverConfig['password'] = '';
+    }
+    console.log(`${chalk.green('Writing updated config...')}`);
+    let updCfg = null;
+    try {
+      updCfg = JSON.stringify(data, null, 2);
+      // console.log(`updated config: ${updCfg}`);
+      fs.writeFileSync(pegaConfigJsonPath, updCfg, err => {
+        if (err) throw err;
+      });
+    } catch (e) {
+
+    }
+  }
+
+  process.exit(1);
+
 };

package/src/tasks/create/index.js

@@ -45,7 +45,12 @@ const copyComponentTemplate = async options => {
   }
   else {
     return copy(options.templateDirectoryConstellation, options.targetDirectoryConstellation, {
-      clobber: false
+      clobber: false,
+      filter: (fileName) => { 
+        // filter out the file config.json or config.json.mustache
+        if (fileName.indexOf("config.json") >= 0) return false;
+        else return true;
+      }
     });
   }
 

package/src/tasks/create/templates/SDK-React/template/FORM-region/demo.stories.jsx.mustache

@@ -0,0 +1,183 @@
+import { useState } from 'react';
+import {{COMPONENT_CLASS_NAME}} from './index.tsx';
+import { pyReviewRaw } from './mock.stories';
+import { TextField } from '@material-ui/core';
+import MuiPhoneNumber from 'material-ui-phone-number';
+import { KeyboardDatePicker, MuiPickersUtilsProvider } from '@material-ui/pickers';
+import DayjsUtils from '@date-io/dayjs';
+
+export default {
+  title: '{{COMPONENT_CLASS_NAME}}',
+  component: {{COMPONENT_CLASS_NAME}}
+};
+
+const renderField = resolvedProps => {
+  const { displayMode, value = '', label = '', onChange} = resolvedProps;
+
+  const variant = displayMode === 'LABELS_LEFT' ? 'inline' : 'stacked';
+  let val = '';
+  if (label === 'Service Date')
+    val = <MuiPickersUtilsProvider utils={DayjsUtils}><KeyboardDatePicker
+      variant='inline'
+      inputVariant='outlined'
+      placeholder='mm/dd/yyyy'
+      fullWidth
+      format='MM/DD/YYYY'
+      mask='__/__/____'
+      size='small'
+      label={label}
+      value={value || null}
+      onChange={onChange}
+    />
+    </MuiPickersUtilsProvider>
+
+{{! pick new delimiteres for mustache }}
+{{=<% %>=}}
+
+  if (label === 'Email')
+    val = <TextField type='email' value={value} size='small' variant='outlined' style={{ fontSize: '14px' }} label={label} onChange={onChange}></TextField>;
+
+  if (label === 'First Name' || label === 'Last Name' || label === 'Middle Name')
+    val = <TextField value={value} size='small' variant='outlined' style={{ fontSize: '14px' }} label={label} onChange={onChange}></TextField>;
+
+  if (label === 'Phone Number')
+    val = <MuiPhoneNumber value={value} variant='outlined' size='small' style={{ fontSize: '14px' }} defaultCountry='us' label={label} onChange={onChange}></MuiPhoneNumber>;
+
+<%={{ }}=%>     {{! revert delimiteres for mustache }}
+
+  if (variant === 'inline') {
+    val = value || <span aria-hidden='true'>&ndash;&ndash;</span>;
+  }
+
+  return val;
+};
+
+export const Base{{COMPONENT_CLASS_NAME}} = () => {
+  const [firstName, setFirstName] = useState('John');
+  const [middleName, setMiddleName] = useState('');
+  const [lastName, setLastName] = useState('Joe');
+  const [phone, setPhone] = useState('+16397975093');
+  const [serviceDate, setServiceDate] = useState('2023-01-25');
+  const [email, setEmail] = useState('john@doe.com');
+  const regionChildrenResolved = [
+    {
+      readOnly: undefined,
+      value: firstName,
+      label: 'First Name',
+      hasSuggestions: false,
+      onChange: val => {
+        setFirstName(val.target.value);
+      }
+    },
+    {
+      readOnly: undefined,
+      value: middleName,
+      label: 'Middle Name',
+      hasSuggestions: false,
+      onChange: val => {
+        setMiddleName(val.target.value);
+      }
+    },
+    {
+      readOnly: undefined,
+      value: lastName,
+      label: 'Last Name',
+      hasSuggestions: false,
+      onChange: val => {
+        setLastName(val.target.value);
+      }
+    },
+    {
+      readOnly: undefined,
+      value: email,
+      label: 'Email',
+      hasSuggestions: false,
+      onChange: val => {
+        setEmail(val.target.value);
+      }
+    },
+    {
+      readOnly: undefined,
+      value: phone,
+      label: 'Phone Number',
+      datasource: {
+        fields: {
+          value: undefined
+        },
+        source: [
+          {
+            value: '+1'
+          },
+          {
+            value: '+91'
+          },
+          {
+            value: '+48'
+          },
+          {
+            value: '+44'
+          }
+        ]
+      },
+      hasSuggestions: false,
+      onChange: val => {
+        setPhone(val);
+      }
+    },
+    {
+      readOnly: undefined,
+      value: serviceDate,
+      label: 'Service Date',
+      hasSuggestions: false,
+      onChange: date => {
+        const changeValue = date && date.isValid() ? date.toISOString() : null;
+        setServiceDate(changeValue);
+      }
+
+    }
+  ];
+  const props = {
+    template: 'DefaultForm',
+    getPConnect: () => {
+      return {
+        getChildren: () => {
+          return pyReviewRaw.children;
+        },
+        createComponent: config => {
+          switch (config.config.value) {
+            case '@P .FirstName':
+              return renderField(regionChildrenResolved[0]);
+            case '@P .MiddleName':
+              return renderField(regionChildrenResolved[1]);
+            case '@P .LastName':
+              return renderField(regionChildrenResolved[2]);
+            case '@P .Email':
+              return renderField(regionChildrenResolved[3]);
+            case '@P .PhoneNumber':
+              return renderField(regionChildrenResolved[4]);
+            case '@P .ServiceDate':
+              return renderField(regionChildrenResolved[5]);
+            default:
+              break;
+          }
+        }
+      };
+    }
+  };
+
+  const regionAChildren = pyReviewRaw.children[0].children.map(child => {
+    return props.getPConnect().createComponent(child);
+  });
+  const regionBChildren = pyReviewRaw.children[1].children.map(child => {
+    return props.getPConnect().createComponent(child);
+  });
+
+  return (
+    <>
+      <{{COMPONENT_CLASS_NAME}} {...props}>
+        {regionAChildren}
+        {regionBChildren}
+      </{{COMPONENT_CLASS_NAME}}>
+    </>
+  );
+};