@pega/dx-component-builder-sdk 0.1.23 → 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;
+      }
     });
   }