@pega/custom-dx-components 8.8.10 → 8.8.11

package/src/constants.js

@@ -2,7 +2,7 @@
 export const TASKS_CONFIG_JSON_FILENAME = 'tasks.config.json';
 export const BUILD_CONFIG_JSON_FILENAME = 'build.config.json';
 export const COMPONENTS_DIRECTORY_PATH = 'components-directory-path';
-export const COMPONENTS_PATH = 'component'
+export const COMPONENTS_PATH = 'component';
 export const TOKEN_PATH = 'node_modules/@pega/custom-dx-components/.access_token';
 export const OOTB_COMPONENTS = 'node_modules/@pega/custom-dx-components/.ootb_components';
 
@@ -15,18 +15,29 @@ export const INF_TOKEN_URL_V1 = 'PRRestService/oauth2/v1/token';
 export const INF_AUTHORIZE_URL_V1 = 'PRRestService/oauth2/v1/authorize';
 export const LP_TOKEN_URL = 'uas/oauth/token';
 export const LP_AUTHORIZE_URL = 'uas/oauth/authorize';
-export const LP_LIST_COMPONENT_SERVICE_REST_ENDPOINT = 'pegalaunchpad/c11n/v103/app/appstudiox/componentslist';
-
+export const LP_LIST_COMPONENT_SERVICE_REST_ENDPOINT =
+  'pegalaunchpad/c11n/v103/app/appstudiox/componentslist';
+export const LP_PUBLISH_COMPONENT_SERVICE_REST_ENDPOINT =
+  'pegalaunchpad/c11n/isolations/{isolationId}/v102/assetsUpdate';
 
 export const FIELD_PATH = '/field';
 export const TEMPLATE_PATH = '/template';
 export const WIDGET_PATH = '/widget';
 
-export const COMPONENT_PREFIX_FIELD_PATH = "field/";
-export const COMPONENT_PREFIX_TEMPLATE_PATH = "template/";
-export const COMPONENT_PREFIX_WIDGET_PATH = "widget/";
+export const COMPONENT_PREFIX_FIELD_PATH = 'field/';
+export const COMPONENT_PREFIX_TEMPLATE_PATH = 'template/';
+export const COMPONENT_PREFIX_WIDGET_PATH = 'widget/';
+
+export const CATEGORY_CONSTELLATION = 'constellation';
 
-export const CATEGORY_CONSTELLATION = "constellation";
+export const AUTHENTICATE_DEFAULTS = {
+  serverType: 'infinity',
+  server: 'https://localhost:1080/prweb',
+  clientId: '10095186356008396159',
+  grantType: 'authCode',
+  authService: 'pega',
+  redirectUri: 'https://localhost:4010/'
+};
 
 export const AUTHENTICATE_SCHEMA = {
   serverType: [

package/src/tasks/authenticate/helper.js

@@ -1,30 +1,47 @@
 /* eslint-disable import/prefer-default-export */
 import { getPegaServerConfig } from '../../util.js';
 
-import { AUTHENTICATE_SCHEMA } from '../../constants.js';
+import { AUTHENTICATE_SCHEMA, AUTHENTICATE_DEFAULTS } from '../../constants.js';
 
 export const getAuthQuestions = async (dxcbConfig) => {
   const defaultPegaConfig = dxcbConfig;
-  const aMustAsk = dxcbConfig['questions_askAlways'] ? dxcbConfig['questions_askAlways'].split(',') : [];
+  const aAlwaysAsk = dxcbConfig['questions_askAlways'] ? dxcbConfig['questions_askAlways'].split(',') : [];
   const aNeverAsk = dxcbConfig['questions_askNever'] ? dxcbConfig['questions_askNever'].split(',') : [];
+  const aAskOnce = dxcbConfig['questions_askOnce'] ? dxcbConfig['questions_askOnce'].split(',') : [];
+  const aAskedOnce = dxcbConfig['questions_askedOnce'] ? dxcbConfig['questions_askedOnce'].split(',') : [];
+
+  // Ask if various must, never, once criteria are met
+  const askThisTime = (prop) => {
+    const bAsk = aAlwaysAsk.includes(prop) ||
+      (!aNeverAsk.includes(prop) && (aAskOnce.includes(prop) && !aAskedOnce.includes(prop)));
+    return bAsk;
+  };
+
+  const initAnswer = (prop, answers, defValue) => {
+    return askThisTime(prop, answers) ? undefined : (defaultPegaConfig[prop] ? defaultPegaConfig[prop] : defValue);
+  };
 
   const initAnswers = (answers) => {
     // Setup default answers (if they are present and non-empty)
-    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;
+    answers.serverType = initAnswer('serverType', answers, AUTHENTICATE_DEFAULTS.serverType);
+    answers.server = initAnswer('server', answers, AUTHENTICATE_DEFAULTS.server);
+    answers.isolationId = initAnswer('isolationId', answers);
+    answers.clientId = initAnswer('clientId', answers, AUTHENTICATE_DEFAULTS.clientId);
+    answers.grantType = initAnswer('grantType', answers, AUTHENTICATE_DEFAULTS.grantType);
+    answers.authService = initAnswer('authService', answers, AUTHENTICATE_DEFAULTS.authService);
+    answers.redirectUri = initAnswer('redirectUri', AUTHENTICATE_DEFAULTS.redirectUri);
+    answers.clientSecret = initAnswer('clientSecret', answers);
+    answers.user = initAnswer('user', answers);
+    answers.password = initAnswer('password', answers);
+    answers.aAsked = [];
   };
 
   const fnStandardWhen = (prop, answers) => {
-    if (aNeverAsk.includes(prop)) {
-      return false;
+    const ask = askThisTime(prop) || !answers[prop];
+    if (ask) {
+      answers.aAsked.push(prop);
     }
-    return aMustAsk.includes(prop) || !answers[prop];
+    return ask;
   };
 
   return [
@@ -49,16 +66,30 @@ export const getAuthQuestions = async (dxcbConfig) => {
     },
     {
       name: 'server',
+      type: 'input',
       message: 'Enter pega server url',
       default: defaultPegaConfig.server,
+      validate: value => {
+        if (value.trim()) {
+          return true;
+        }
+        return 'Pega server cannot be empty';
+      },
       when: answers => {
         return fnStandardWhen('server', answers);
       }
     },
     {
       name: 'isolationId',
+      tpye: 'input',
       message: 'Enter isolation id',
       default: defaultPegaConfig.isolationId,
+      validate: value => {
+        if (value.trim()) {
+          return true;
+        }
+        return 'Launchpad isolationId cannot be empty';
+      },
       when: answers => {
         return answers.serverType === "launchpad" && fnStandardWhen('isolationId', answers);
       }
@@ -81,8 +112,39 @@ export const getAuthQuestions = async (dxcbConfig) => {
         return fnStandardWhen('grantType', answers);
       }
     },
+    {
+      name: 'authService',
+      type: 'input',
+      message: 'Enter authentication service alias',
+      default: defaultPegaConfig.authService,
+      validate: value => {
+        if (value.trim()) {
+          return true;
+        }
+        return 'Authentication service alias cannot be empty';
+      },
+      when: answers => {
+        return answers.serverType === "infinity" && answers.grantType === "authCode" && fnStandardWhen('authService', answers);
+      }
+    },
+    {
+      name: 'redirectUri',
+      type: 'input',
+      message: 'Enter valid redirect Uri within OAuth 2.0 client reg reccord',
+      default: defaultPegaConfig.redirectUri,
+      validate: value => {
+        if (value.trim()) {
+          return true;
+        }
+        return 'Redirect URI cannot be empty';
+      },
+      when: answers => {
+        return answers.serverType === "infinity" && answers.grantType === "authCode" && fnStandardWhen('redirectUri', answers);
+      }
+    },
     {
       name: 'user',
+      type: 'input',
       message: 'Enter user id',
       default: defaultPegaConfig.user,
       validate: (value, answers) => {
@@ -112,6 +174,7 @@ export const getAuthQuestions = async (dxcbConfig) => {
     },
     {
       name: 'clientId',
+      type: 'input',
       message: 'Enter clientId',
       default: defaultPegaConfig.clientId,
       validate: value => {

package/src/tasks/authenticate/index.js

@@ -144,8 +144,9 @@ export default async options => {
   const questions = await getAuthQuestions(serverConfig);
   // console.log(`questions: ${JSON.stringify(questions)}`);
   const answers = await inquirer.prompt(questions);
-  const aProps = ['serverType', 'server', 'isolationId', 'clientId', 'grantType', 'clientSecret', 'user', 'password'];
-  serverConfig.authService = serverConfig.authService || 'pega';
+  const aAsked = answers.aAsked;
+  delete answers.aAsked;
+  const aProps = ['serverType', 'server', 'isolationId', 'clientId', 'grantType', 'authService', 'redirectUri', 'clientSecret', 'user', 'password'];
   const isLaunchPad = answers.serverType === "launchpad";
   let bWriteUpdate = false;
   for (let i = 0; i < aProps.length; i += 1) {
@@ -161,6 +162,23 @@ export default async options => {
       }
     }
   }
+  // Update the askedOnce array based on askOnce criteria
+  const aAskOnce = serverConfig['questions_askOnce'] ? serverConfig['questions_askOnce'].split(',') : [];
+  const aAskedOnce = serverConfig['questions_askedOnce'] ? serverConfig['questions_askedOnce'].split(',') : [];
+  let bAskedOnceUpdated = false;
+  for (let j = 0; j < aAsked.length; j += 1) {
+    const prop = aAsked[j];
+    if (aAskOnce.includes(prop) && !aAskedOnce.includes(prop)) {
+      // Add entries we want to only ask once to the asked list if appropriate
+      aAskedOnce.push(prop);
+      bAskedOnceUpdated = true;
+    }
+  }
+  // If askedOnce array was updated we need to update value in config
+  if (bAskedOnceUpdated) {
+    serverConfig['questions_askedOnce'] = aAskedOnce.join(',');
+    bWriteUpdate = true;
+  }
 
   try {
     // console.log(`serverConfig: ${JSON.stringify(serverConfig)}`);

package/src/tasks/init/template/package.json.mustache

@@ -56,7 +56,7 @@
   },
   "devDependencies": {
     "@pega/configs": "^0.5.3",
-    "@pega/custom-dx-components": "^8.8.10",
+    "@pega/custom-dx-components": "^8.8.11",
     "@pega/eslint-config": "^0.3.2",
     "@storybook/addon-actions": "^6.5.12",
     "@storybook/addon-essentials": "^6.5.12",

package/src/tasks/init/template/tasks.config.json

@@ -12,6 +12,8 @@
     "clientSecret": "",
     "grantType": "authCode",
     "redirectUri": "https://localhost:4010/",
+    "authService_comment": "Infinity authentication service alias (when grantType is set to 'authCode')",
+    "authService": "pega",
     "cert_and_key_comment": "Path to SSL certificate file and SSL key file to use when starting local HTTPS server",
     "cert_and_key_comment2": "Needed only when using 'authCode' grantType and redirectUri begins with 'https://localhost'",
     "cert": "./keys/dxcb.crt",
@@ -19,9 +21,11 @@
     "user_and_password_comment": "useful primarily when grantType is set to 'passwordCreds'",
     "user": "",
     "password": "",
-    "questions_comment": "useful for designating certain questions should always or never be asked during npm run authenticate",
+    "questions_comment": "useful for designating how frequently questions should be asked during npm run authenticate",
     "questions_askAlways": "",
-    "questions_askNever": ""
+    "questions_askNever": "",
+    "questions_askOnce": "server,authService",
+    "questions_askedOnce": ""
   },
   "component": {
     "library": "Extensions",

package/src/tasks/publish/helper.js

@@ -13,7 +13,11 @@ import {
   getPegaServerConfig,
   validateRulesetVersion
 } from '../../util.js';
-import { PUBLISH_COMPONENT_SERVICE_REST_ENDPOINT, TOKEN_PATH } from '../../constants.js';
+import {
+  PUBLISH_COMPONENT_SERVICE_REST_ENDPOINT,
+  LP_PUBLISH_COMPONENT_SERVICE_REST_ENDPOINT,
+  TOKEN_PATH
+} from '../../constants.js';
 
 export const getPublishComponentQuestions = async () => {
   const components = await getComponents();
@@ -35,6 +39,9 @@ export const getPublishComponentQuestions = async () => {
           return true;
         }
         return 'Ruleset name cannot be empty';
+      },
+      when: answers => {
+        return answers.serverType === 'infinity';
       }
     },
     {
@@ -46,12 +53,16 @@ export const getPublishComponentQuestions = async () => {
           return true;
         }
         return 'Please provide compatible version e.g 01-01-01';
+      },
+      when: answers => {
+        return answers.serverType === 'infinity';
       }
     },
     {
       name: 'sourceMap',
       message: 'Generate source map ?',
       default: defaultPegaConfig.sourceMap,
+      // eslint-disable-next-line sonarjs/no-redundant-boolean
       when: () => false && !process.env.SOURCE_MAP
     },
     {
@@ -86,37 +97,65 @@ export const zipComponent = async componentKey => {
 };
 
 export const publishComponentToServer = async data => {
-  const { configContent, zipContent, componentKey, rulesetName, rulesetVersion } = data;
-
-  const apiBody = {
-    configContent,
-    zipContent,
-    componentKey: JSON.parse(configContent).componentKey,
-    publishFor: 'constellation',
-    rulesetName,
-    rulesetVersion,
-    category: ''
-  };
+  const { configContent, zipContent, rulesetName, rulesetVersion } = data;
+
+  const defaultPegaServerConfig = await getPegaServerConfig();
+  const { serverType, isolationId } = defaultPegaServerConfig;
+  const isLaunchpad = serverType === 'launchpad';
+  const launchpadRestEndpoint = LP_PUBLISH_COMPONENT_SERVICE_REST_ENDPOINT.replace(
+    '{isolationId}',
+    isolationId
+  );
+  let apiBody;
+
+  if (isLaunchpad) {
+    apiBody = {
+      type: 'CustomComponent',
+      zipContent,
+      componentName: JSON.parse(configContent).componentKey,
+      pxUpdateDateTime: '',
+      environmentID: defaultPegaServerConfig.isolationId
+    };
+  } else {
+    apiBody = {
+      configContent,
+      zipContent,
+      componentKey: JSON.parse(configContent).componentKey,
+      publishFor: 'constellation',
+      rulesetName,
+      rulesetVersion,
+      category: ''
+    };
+  }
+
   const defaultPegaConfig = await getPegaServerConfig();
   const url = constructCompleteUrl(
     defaultPegaConfig.server,
-    PUBLISH_COMPONENT_SERVICE_REST_ENDPOINT
+    isLaunchpad ? launchpadRestEndpoint : PUBLISH_COMPONENT_SERVICE_REST_ENDPOINT
   );
+
   try {
     const OauthData = fs.readFileSync(TOKEN_PATH, 'utf8');
     if (OauthData) {
       const {
         access_token: accessToken,
-        token_type: tokenType,
-        refresh_token: refreshToken
+        token_type: tokenType
+        // refresh_token: refreshToken
       } = JSON.parse(OauthData);
       let status = 500;
+      const headers = {};
+
+      if (isLaunchpad) {
+        headers.cookie = `Pega-AAT=${accessToken}`;
+        headers['Content-Type'] = 'application/json';
+      } else {
+        headers.Authorization = `${tokenType} ${accessToken}`;
+      }
+
       fetch(url, {
         method: 'POST',
         agent: new https.Agent({ rejectUnauthorized: false }),
-        headers: {
-          Authorization: `${tokenType} ${accessToken}`
-        },
+        headers,
         body: JSON.stringify(apiBody)
       })
         .then(response => {
@@ -124,27 +163,32 @@ export const publishComponentToServer = async data => {
           return response.text();
         })
         .then(resp => {
-          const respData = JSON.parse(resp);
+          const respData = isLaunchpad ? resp : JSON.parse(resp);
           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) {
-            console.log(chalk.bold.green(`Success : ${respData.message}`));
+          } else if (status === 200 || status === 201) {
+            console.log(chalk.bold.green(`Success : ${isLaunchpad ? respData : respData.message}`));
           } else {
             throw new Error(`${respData.message}`);
           }
         })
-        .catch( e => {
-          if (e.code == 'ECONNREFUSED') {
-            Promise.reject(`${chalk.bold.red('Error occurred in authentication. Please regenerate using authenticate')}`);
-          }
-          else {
+        .catch(e => {
+          if (e.code === 'ECONNREFUSED') {
+            // eslint-disable-next-line prefer-promise-reject-errors
+            Promise.reject(
+              `${chalk.bold.red(
+                'Error occurred in authentication. Please regenerate using authenticate'
+              )}`
+            );
+          } else {
+            // eslint-disable-next-line prefer-promise-reject-errors
             Promise.reject(`${chalk.bold.red(e)}`);
           }
-        })
+        });
     } else {
       throw new Error(`Error occurred in authentication. Please regenerate using authenticate`);
     }