@pega/custom-dx-components 24.1.12 → 24.2.10

package/src/tasks/publish/index.js

@@ -1,23 +1,106 @@
 import inquirer from 'inquirer';
 import { Listr } from 'listr2';
 import chalk from 'chalk';
+import fs from 'fs';
 
 import validate from '../validator/index.js';
 import bundleComponent from '../bundle/index.js';
 import { lintComponent } from '../linter/index.js';
-import { getComponentDirectoryPath, showVersion } from '../../util.js';
+import { getComponentDirectoryPath, showVersion, getLibraryBased, addDebugLog, getPegaServerConfig, updateServerConfigRuleSetAndVersion, checkLibraryAndArchives, getConfigDevBuild, checkJWTExpiration, getConfigDefaults } from '../../util.js';
 
 import { getPublishComponentQuestions, publishComponentToServer, zipComponent } from './helper.js';
+import { default as buildLibrary } from '../build-lib/index.js';
+import { default as publishLibrary } from '../publish-lib/index.js';
+
+import {
+  TOKEN_PATH
+} from '../../constants.js';
 
 export default async options => {
-  showVersion();
 
+  await showVersion();
+  await checkLibraryAndArchives();
+  const isLibraryBased = getLibraryBased();
+
+addDebugLog("publish", "", "+");
+
+  if (isLibraryBased) {
+
+    await checkJWTExpiration();
+
+    const devBuild = await getConfigDevBuild();
+    let okToPublish = false;
+
+    const orgLib =  getConfigDefaults();
+    const currentOrgLib = orgLib.currentOrgLib;
+    // const currentVersion = devBuild ? `${orgLib.version}-dev`: orgLib.version;
+    const currentVersion = orgLib.buildVersion;
+
+
+
+    const publishThisVersion = await inquirer.prompt([
+      {
+        name: 'confirmPublish',
+        type: 'confirm',
+        message: `Publish ${chalk.bold.green(`${orgLib.displayLibVersion}`)}, proceed ?`,
+        default: true
+      }
+    ]);
+
+    if (publishThisVersion.confirmPublish) {
+      okToPublish = true;
+    }
+
+    if (okToPublish && !devBuild) {
+      okToPublish = false;
+      console.log("");
+      const publishAnswers = await inquirer.prompt([
+        {
+          name: 'confirmPublish',
+          type: 'confirm',
+          message: `You are about to publish a ${chalk.bold.yellow('PRODUCTION')} version which can ${chalk.bold.yellow('NOT')} be deleted, proceed ?`,
+          default: false
+        }
+      ]);
+      if (publishAnswers.confirmPublish) {
+        okToPublish = true;
+      }
+    }
+
+    if (okToPublish) {
+      // marking as internal, so no questions will be ask
+      options.params.push("internal");
+
+      await buildLibrary(options);
+      await publishLibrary(options);
+    }
+
+    return true;
+  }
+
+
+  let OauthData;
+  try {
+    OauthData = fs.readFileSync(TOKEN_PATH, 'utf8');
+  }
+  catch (ex) {
+
+  }
+
+  if (!OauthData) {
+    console.log(chalk.redBright("Need to authenticate, missing services token."));
+    process.exit(1);
+  }
+
+  // non library based publish
   let componentKey;
   let sourceMap;
   let devBuild;
   let content;
 
   let doFetch = true;
+  // const defaultPegaConfig = await getPegaServerConfig();
+  const componentDefaults = getConfigDefaults();
 
   if (options.params.length >= 7) {
     componentKey = options.params[3];
@@ -46,6 +129,11 @@ export default async options => {
     };
   }
 
+  // update ruleset and version config for future
+  if (componentDefaults.serverType === "infinity") {
+    updateServerConfigRuleSetAndVersion(content.rulesetName, content.rulesetVersion);
+  }
+
   const sDevBuild = devBuild ? '(dev build)' : '';
   const tasks = new Listr(
     [
@@ -90,5 +178,10 @@ export default async options => {
   await tasks.run().catch(err => {
     console.log(chalk.bold.red(err.toString()));
   });
+
+
+addDebugLog("publish", "END", "-");
+
+
   return true;
 };

package/src/tasks/publish-all/helper.js

@@ -2,7 +2,7 @@ import fs from 'fs';
 import path from 'path';
 
 import fetch from 'node-fetch';
-import AdmZip from 'adm-zip';
+import archiver from 'archiver';
 import chalk from 'chalk';
 
 import {
@@ -10,7 +10,8 @@ import {
   getComponentDirectoryPath,
   getPegaServerConfig,
   validateRulesetVersion,
-  getHttpsAgent
+  getHttpsAgent,
+  addDebugLog
 } from '../../util.js';
 import {
   PUBLISH_COMPONENT_SERVICE_REST_ENDPOINT,
@@ -19,6 +20,8 @@ import {
 } from '../../constants.js';
 
 export const getPublishComponentQuestions = async () => {
+addDebugLog("getPublishComponentQuestions", "", "");
+
   const defaultPegaConfig = await getPegaServerConfig();
 
   return [
@@ -67,48 +70,67 @@ export const getPublishComponentQuestions = async () => {
 };
 
 export const zipComponent = async componentKey => {
+addDebugLog("zipComponent", `componentKey: ${componentKey}`, "");
   const srcDirectory = await getComponentDirectoryPath(componentKey);
   const buildDirectory = await path.join(path.resolve(), 'dist/components', componentKey);
   const configJson = `${srcDirectory}/config.json`;
   const localizationJson = `${srcDirectory}/localizations.json`;
 
-  const zip = new AdmZip();
+  const archive = archiver('zip', { zlib: { level: 9 } });
+  const zipChunks = [];
+  archive.on('data', chunk => zipChunks.push(chunk));
+
+  // Add src directory
+  archive.directory(srcDirectory, 'src');
 
-  zip.addLocalFolder(srcDirectory, 'src/');
-  zip.addLocalFile(configJson);
+  // Add config.json file
+  if (fs.existsSync(configJson)) {
+    archive.file(configJson, { name: path.basename(configJson) });
+  }
 
+  // Add localizations.json file if it exists
   if (fs.existsSync(localizationJson)) {
-    zip.addLocalFile(localizationJson);
+    archive.file(localizationJson, { name: path.basename(localizationJson) });
   }
 
-  zip.addLocalFolder(buildDirectory);
-  const zipContent = zip.toBuffer().toString('base64');
+  // Add build directory
+  archive.directory(buildDirectory, false);
+
+  await archive.finalize();
+
+  const zipBuffer = Buffer.concat(zipChunks);
+  console.log(chalk.green(`component zipped with size: ${Math.ceil(zipBuffer.length / 1024)} KB`));
+  const zipContent = zipBuffer.toString('base64');
+
+  const configContent = Buffer.from(fs.readFileSync(configJson)).toString();
 
-  const configContent = Buffer.from(fs.readFileSync(`${srcDirectory}/config.json`)).toString();
-  // clean up now happens in function cleanUp
-  // fs.rmdir('dist', { recursive: true }, err => {
-  //  if (err) {
-  //    throw err;
-  //  }
-  // });
   return { zipContent, configContent };
 };
 
 export const cleanUp = async () => {
-  fs.rm('dist/components', { recursive: true }, err => {
-    if (err) {
-      throw err;
-    }
-  });
+addDebugLog("cleanUp", "", "");
+
+  if (fs.existsSync('dist/components')) {
+    fs.rm('dist/components', { recursive: true }, err => {
+      if (err) {
+        throw err;
+      }
+    });
+  }
+
+  if (fs.existsSync('lib')) {
+    fs.rm('lib', { recursive: true }, err => {
+      if (err) {
+        throw err;
+      }
+    });
+  }
 
-  fs.rm('lib', { recursive: true }, err => {
-    if (err) {
-      throw err;
-    }
-  });
 };
 
 export const publishComponentToServer = async (data, doFetch) => {
+addDebugLog("publishComponentToServer", "", "");
+
   const { configContent, zipContent, rulesetName, rulesetVersion } = data;
 
   const defaultPegaServerConfig = await getPegaServerConfig();
@@ -165,11 +187,10 @@ export const publishComponentToServer = async (data, doFetch) => {
           headers.Authorization = `${tokenType} ${accessToken}`;
         }
 
-
         const response = await fetch(url, {
           method: 'POST',
           agent: getHttpsAgent(defaultPegaConfig),
-          headers: headers,
+          headers,
           body: JSON.stringify(apiBody)
         });
 
@@ -181,45 +202,34 @@ export const publishComponentToServer = async (data, doFetch) => {
             );
             // console.log(accessTokenUri, refreshToken);
             /* TODO - Handle refresh_token */
-          }
-          else if (status === 404){
+          } else if (status === 404) {
             throw new Error('404: Server resource not found');
-          }
-          else if (status === 405){
+          } else if (status === 405) {
             throw new Error('405: Server method not allowed');
-          }
-          else if (status === 408){
+          } else if (status === 408) {
             throw new Error('408: Server timed out');
-          }
-          else if (response.status === 403) {
-            throw new Error(
-              'Error forbidden: User does not have privileges to Publish.'
-            );
+          } else if (response.status === 403) {
+            throw new Error('Error forbidden: User does not have privileges to Publish.');
           }
         }
 
         try {
           const respData = isLaunchpad ? await response.text() : await response.json();
-          console.log(
-                chalk.bold.green(`Success : ${isLaunchpad ? respData : respData.message}`)
-          );
+          console.log(chalk.bold.green(`Success : ${isLaunchpad ? respData : respData.message}`));
 
           if (status === 500) {
             status = 999;
             throw new Error(respData.message);
           }
-        }
-        catch (err) {
+        } catch (err) {
           if (status === 500) {
-              throw new Error(
-               `Error occurred in authentication. Please regenerate using authenticate`
-              );
-          }
-          else if (status === 999) {
-            throw new Error (err);
+            throw new Error(
+              `Error occurred in authentication. Please regenerate using authenticate`
+            );
+          } else if (status === 999) {
+            throw new Error(err);
           }
         }
-
       } else {
         throw new Error(`Error occurred in authentication. Please regenerate using authenticate`);
       }

package/src/tasks/publish-all/index.js

@@ -5,7 +5,7 @@ import chalk from 'chalk';
 import validate from '../validator/index.js';
 import bundleComponent from '../bundle/index.js';
 import { lintComponent } from '../linter/index.js';
-import { getComponents, getComponentDirectoryPath, showVersion } from '../../util.js';
+import { getComponents, getComponentDirectoryPath, showVersion, getLibraryBased, addDebugLog, getPegaServerConfig, updateServerConfigRuleSetAndVersion, checkLibraryAndArchives } from '../../util.js';
 
 import {
   getPublishComponentQuestions,
@@ -14,7 +14,10 @@ import {
   cleanUp
 } from './helper.js';
 
+
 export function getCustomTasks(componentKey, sourceMap, devBuild, content, options) {
+addDebugLog("getCustomTasks", `componentKey: ${componentKey}, sourceMap: ${sourceMap}, devBuild: ${devBuild}`, "");
+
   const sDevBuild = devBuild ? '(dev build)' : '';
   // eslint-disable no-unneeded-ternary,no-nested-ternary
   const doFetch = options.params.length >= 7 ? (options.params[6] === 'noFetch' ? false : true) : true;
@@ -60,9 +63,19 @@ export function getCustomTasks(componentKey, sourceMap, devBuild, content, optio
 }
 
 export default async options => {
-  showVersion();
+  const isLibraryBased = getLibraryBased();
+  if (isLibraryBased) {
+    console.log(`Command only supported for ${chalk.bold.green('non library mode')} components.`)
+    process.exit();
+  }
+
+  await showVersion();
+  await checkLibraryAndArchives();
+
+addDebugLog("publishAll", "", "+");
 
   const components = await getComponents();
+  const defaultPegaConfig = await getPegaServerConfig();
 
   if (components.length === 0) {
     console.log(chalk.redBright('No components to publish'));
@@ -91,6 +104,11 @@ export default async options => {
     };
   }
 
+  // update ruleset and version config for future
+  if (defaultPegaConfig.serverType === "infinity") {
+    updateServerConfigRuleSetAndVersion(content.rulesetName, content.rulesetVersion);
+  }
+
   // eslint-disable-next-line no-shadow
   for await (const componentKey of components) {
     console.log(chalk.bold.green(`Publishing: ${componentKey}`));
@@ -108,5 +126,8 @@ export default async options => {
   // once done, remove leftover directories
   await cleanUp();
 
+
+addDebugLog("publishAll", "END", "-");
+
   return true;
 };

package/src/tasks/publish-lib/helper.js

@@ -0,0 +1,17 @@
+import {
+  addDebugLog
+} from '../../util.js';
+
+
+export const getLibraryVersionQuestion = async(libVersions) => {
+addDebugLog("getLibraryVersionQuestion", `libVersions: ${libVersions}`, "");
+    return [
+      {
+        name: 'version',
+        type: 'rawlist',
+        message: 'Select library version to publish',
+        choices: libVersions
+      }
+    ];
+
+}

package/src/tasks/publish-lib/index.js

@@ -0,0 +1,270 @@
+import inquirer from 'inquirer';
+import { Listr } from 'listr2';
+import chalk from 'chalk';
+
+import validate from '../validator/index.js';
+import { lintComponent } from '../linter/index.js';
+import { getComponentDirectoryPath, showVersion, getC11NB2STokenAndStaticServer, getLocalLibraryVersions, getLibraryBased, deletePublishExtras, addDebugLog, checkLibraryAndArchives, checkJWTExpiration, getConfigDefaults } from '../../util.js';
+
+import { publishLib, listLibJSONResponse, deleteLibVersion } from '@pega/constellation-dx-components-build-utils/index.js';
+
+import { getLibraryVersionQuestion } from './helper.js';
+
+
+export function getCustomTasks(componentKey, sourceMap, devBuild, options) {
+addDebugLog("getCustomTasks", `componentKey: ${componentKey}, sourceMap: ${sourceMap}, devBuild: ${devBuild}`, "");
+
+  const sDevBuild = devBuild ? '(dev build)' : '';
+  return new Listr(
+    [
+      {
+        title: 'Validate config schema',
+        task: async () => {
+          await validate(componentKey);
+        }
+      },
+      {
+        title: 'Lint component',
+        task: async () => {
+          const targetDirectory = await getComponentDirectoryPath(componentKey);
+          // console.log(`in buildComponent Lint component task: componentKey: ${componentKey} targetDirectory: ${targetDirectory}`);
+          await lintComponent(targetDirectory);
+        }
+      }
+
+    ],
+    { concurrent: false, exitOnError: true }
+  );
+
+
+}
+
+export const doesLibraryExist = async (libraryName, libraryVersion) => {
+addDebugLog("doesLibraryExist", `libraryName: ${libraryName}, libraryVersion: ${libraryVersion}`, "");
+
+  const tokenAndStaticServer = await getC11NB2STokenAndStaticServer();
+  const libList = await listLibJSONResponse(tokenAndStaticServer.C11NB2S, tokenAndStaticServer.appStaticContentServer);
+
+  let libVersionExists = false;
+  if (libList && libList[libraryName] && libList[libraryName][libraryVersion]) {
+      libVersionExists = true;
+  }
+
+  return libVersionExists;
+}
+
+
+export const publishNewLibraryAsync = async (libraryName, version, checkDeleted = false) => {
+addDebugLog("publishNewLibraryAsync", `libraryName: ${libraryName}, version: ${version}, checkDeleted: ${checkDeleted} `, "");
+
+  const tokenAndStaticServer = await getC11NB2STokenAndStaticServer();
+
+  if (checkDeleted ) {
+    console.log(chalk.yellow(`Verifying library has been deleted..`));
+    let libExists = true;
+    let count = 0;
+    while (libExists) {
+
+      // sleep a second and try again
+      await new Promise(r => setTimeout(r, 1000));
+
+      // keep checking until no longer exists
+      libExists = await doesLibraryExist(libraryName, version);
+
+      count ++;
+
+      if (count > 100) {
+        console.log(chalk.red.bold(`Library hasn't been deleted, can't proceed.`));
+        process.exit(1);
+      }
+    }
+
+    console.log(chalk.green(`Deleted..`));
+  }
+
+  console.log("\nPublishing Library " + chalk.bold.green(`${libraryName}/${version}`) + " to " + chalk.bold.green(`${tokenAndStaticServer.appStaticContentServer}`));
+addDebugLog("publishLib", "services call", "");
+  await publishLib(libraryName, version, tokenAndStaticServer.C11NB2S, tokenAndStaticServer.appStaticContentServer);
+addDebugLog("deleteLib", "services end", "");
+
+}
+
+
+export default async (options) => {
+  const isLibraryBased =  getLibraryBased();
+  if (!isLibraryBased) {
+    console.log(`Command only supported for ${chalk.bold.green('library mode')} components.`)
+    process.exit();
+  }
+
+  if (options.params.length != 4) {
+    // internal so already called
+    await showVersion();
+    await checkLibraryAndArchives();
+    await checkJWTExpiration();
+  }
+
+addDebugLog("publishLibrary", "", "+");
+
+  let organization;
+  let library;
+  let version;
+  let devBuild;
+  let internalPublish = false;
+
+  let libraryName;
+  let noRealPublish = false;
+
+
+  if (options.params.length === 5) {
+    libraryName = options.params[3];
+    version = options.params[4];
+  }
+  else if (options.params.length === 6) {
+    libraryName = options.params[3];
+    version = options.params[4];
+    noRealPublish = true;
+  }
+  else if (options.params.length === 4) {
+    // internal call from publish
+    internalPublish = true;
+    const orgLib = getConfigDefaults();
+    library = orgLib.library;
+    organization = orgLib.organization;
+    // libraryName = `${organization}_${library}`;
+    libraryName = orgLib.currentOrgLib;
+
+    version = orgLib.buildVersion;
+
+    // check to see if devBuild
+    // const devBuild = await getConfigDevBuild();
+    // const devBuild = orgLib.devBuild;
+    // if (devBuild) {
+    //   version = version.concat("-dev");
+    // }
+
+  }
+
+  const tokenAndStaticServer = await getC11NB2STokenAndStaticServer();
+
+  if (tokenAndStaticServer.C11NB2S === undefined) {
+    console.log(chalk.redBright("Need to authenticate, missing services token.\nPublishing a library requires authentication to acquire a token to publish."));
+    process.exit(1);
+  }
+
+  let libVersions = [];
+  if (!libraryName) {
+    const compDef =  getConfigDefaults();
+    organization = compDef.organization;
+    library = compDef.library;
+
+    // libraryName = `${organization}_${library}`;
+    libraryName = compDef.currentOrgLib;
+
+    try {
+      libVersions = await getLocalLibraryVersions(libraryName);
+    }
+    catch (ex) {}
+  }
+
+  console.log(`\nPreparing to publish ${chalk.bold.green(`${libraryName}/${version}`)} `)
+
+  if (libVersions.length > 0 || version) {
+
+    if (!version) {
+      const versionQuestions = await getLibraryVersionQuestion(libVersions);
+      const versionAnswers = await inquirer.prompt(versionQuestions);
+
+      ({version} = versionAnswers);
+    }
+
+
+    let okToPublish = true;
+
+    // this check matches check below, but for JEST, we don't want to go any further, just verifying if will
+    // be caught
+    if (noRealPublish && !version.includes("-dev")) {
+      console.log("PRODUCTION, no publish");
+      return;
+    }
+
+    if (!version.includes("-dev") && !internalPublish) {
+      okToPublish = false;
+      const publishAnswers = await inquirer.prompt([
+
+        {
+          name: 'confirmPublish',
+          type: 'confirm',
+          message: `You are about to publish a ${chalk.bold.yellow('PRODUCTION')} version which can ${chalk.bold.yellow('NOT')} be deleted, proceed ?`,
+          default: false
+        }
+      ]);
+      if (publishAnswers.confirmPublish) {
+        okToPublish = true;
+      }
+    }
+
+    if (noRealPublish) {
+      // this is as far as JEST test can go since need server for rest and don't want to use server.
+      console.log("OK to publish.");
+      return;
+    }
+
+    if (okToPublish) {
+
+      let libVersionExists = await doesLibraryExist(libraryName, version);
+      let overrideExisting = false;
+      let checkDeleted = false;
+
+      await deletePublishExtras(libraryName, version);
+
+
+      if (libVersionExists) {
+          console.log("\nLibrary " + chalk.bold.yellow(`${libraryName}/${version}`) + " already exists.");
+          const questions = [
+            {
+              name: 'override',
+              type: 'confirm',
+              message: `Do you wish to overrite it`,
+              default: false
+            }
+          ];
+
+          await inquirer.prompt(questions).then(async answers => {
+            overrideExisting = answers.override;
+            });
+      }
+
+      if (libVersionExists) {
+        if (overrideExisting) {
+          console.log("\nDeleting existing library " + chalk.bold.yellow(`${libraryName}:${version}`) + " ...");
+addDebugLog("deleteLibVersion", `services call: libraryName: ${libraryName}, version: ${version}`, "");
+          await deleteLibVersion(libraryName, version, tokenAndStaticServer.C11NB2S, tokenAndStaticServer.appStaticContentServer);
+addDebugLog("deleteLibVersion", "services end", "");
+          checkDeleted = true;
+        }
+        else {
+          // don't override, so end
+          console.log(chalk.yellow(`You will need to increment your library version to publish`));
+addDebugLog("publishLibrary", "END", "-");
+          return;
+        }
+      }
+
+      // need a timeout to give services time to delete the library
+      // setTimeout( function(){ await publishNewLibraryAsync(libraryName, version, checkDeleted)}, 700 );
+      await publishNewLibraryAsync(libraryName, version, checkDeleted);
+    }
+
+  }
+  else {
+    console.log(chalk.bold.redBright(`No library versions named ${libraryName}.`));
+    console.log(chalk.bold.redBright(`You need to build library ${libraryName} first.`));
+  }
+
+
+
+addDebugLog("publishLibrary", "END", "-");
+
+  return true;
+};