@pega/custom-dx-components 0.25.13 → 0.25.15

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

@@ -5,12 +5,14 @@ import fetch from 'node-fetch';
 import archiver from 'archiver';
 import path from 'path';
 import fs from 'fs';
+import ora from 'ora';
 
 import validate from '../validator/index.js';
 import { lintComponent } from '../linter/index.js';
 import { constructCompleteUrl, getComponentDirectoryPath, getHttpsAgent, getPegaServerConfig, showVersion, getC11NB2STokenAndStaticServer, getLocalLibraryVersions, getLibraryBased, getLibraryBasedCL, deletePublishExtras, addDebugLog, checkLibraryAndArchives, checkJWTExpiration, getConfigDefaults } from '../../util.js';
 
 import { publishLib, listLibJSONResponse, deleteLibVersion } from '@pega/constellation-dx-components-build-utils/index.js';
+import { default as buildLibrary } from '../build-lib/index.js';
 
 import { getLibraryVersionQuestion } from './helper.js';
 
@@ -165,6 +167,11 @@ export const publishComponentLibraryToServer = async (data, doFetch) => {
             headers.Authorization = `${tokenType} ${accessToken}`;
           }
 
+          let spinner;
+
+          console.log();
+          spinner = ora(chalk.green.bold('Publishing library...')).start();
+
           const response = await fetch(url, {
             method: 'POST',
             agent: getHttpsAgent(defaultPegaConfig),
@@ -172,6 +179,8 @@ export const publishComponentLibraryToServer = async (data, doFetch) => {
             body: JSON.stringify(apiBody)
           });
 
+          spinner.stop();
+
           status = response.status;
           if (!response.ok) {
             if (status === 401) {
@@ -192,18 +201,25 @@ export const publishComponentLibraryToServer = async (data, doFetch) => {
           }
 
           try {
-            const respData = isLaunchpad ? await response.text() : await response.json();
-            console.log(chalk.bold.green(`Success : ${isLaunchpad ? respData : respData.message}`));
+            // const respData = isLaunchpad ? await response.text() : await response.json();
+            const headerType = response.headers.get('content-type');
+            const respData = headerType.includes("json") ? await response.json() : await response.text();
+            let respMessage = headerType.includes("json") ? respData.message : respData;
+
 
             if (status === 500) {
               status = 999;
-              throw new Error(respData.message);
+              if (respMessage === '') {
+                respMessage = `Server error, please check server logs for error.`;
+              }
+              throw new Error(respMessage);
             }
+
+            console.log(chalk.bold.green(`Success : ${respMessage }`));
+
           } catch (err) {
             if (status === 500) {
-              throw new Error(
-                `Error occurred in authentication. Please regenerate using authenticate`
-              );
+              throw new Error(`Server error, please check server logs for error.`);
             } else if (status === 999) {
               throw new Error(err);
             }
@@ -417,62 +433,64 @@ addDebugLog("publishLibrary", "", "+");
       return;
     }
 
-    if (okToPublish) {
-
- // /*
-
-      let libVersionExists = await doesLibraryExist(libraryName, version);
-      let overrideExisting = false;
-      let checkDeleted = false;
 
-      await deletePublishExtras(libraryName, version);
+    const isLibraryBasedCL =  getLibraryBasedCL();
+    if (okToPublish) {
+      if (isLibraryBasedCL) {
+        // developer test
 
+        let content = { libraryName, version, rulesetName, rulesetVersion };
+        await publishUILibraryComponentToInfinity(content);
 
-      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 {
+        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;
+              });
         }
-        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);
- // */
+        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;
+          }
+        }
 
-      // developer test
-      const isLibraryBasedCL =  getLibraryBasedCL();
-      if (isLibraryBasedCL) {
-        let content = { libraryName, version, rulesetName, rulesetVersion };
+        // need a timeout to give services time to delete the library
+        // setTimeout( function(){ await publishNewLibraryAsync(libraryName, version, checkDeleted)}, 700 );
+        await publishNewLibraryAsync(libraryName, version, checkDeleted);
 
-        await publishUILibraryComponentToInfinity(content);
       }
 
+
     }
 
   }

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

@@ -19,7 +19,8 @@ import {
   updateDefaultOrganization,
   addDebugLog,
   checkLibraryAndArchives,
-  getConfigDefaults
+  getConfigDefaults,
+  getLibraryBasedCL
 } from '../../util.js';
 import {
   TASKS_CONFIG_JSON_FILENAME,
@@ -105,6 +106,8 @@ addDebugLog("renameLibrary", `library: ${library}, organization: ${organization}
   const currentLibrary = compDef.library;
   const currentVersion = compDef.version;
 
+  const isLibraryBasedCL = getLibraryBasedCL();
+
   let compVersion;
 
   const tokenAndStaticServer = await getC11NB2STokenAndStaticServer();
@@ -143,6 +146,12 @@ addDebugLog("renameLibrary", `library: ${library}, organization: ${organization}
     if (compVersion && compVersion.indexOf('-dev') != -1) {
       wasDevBuild = true;
     }
+
+    // no -dev with PegaInfinity
+    if (isLibraryBasedCL) {
+      wasDevBuild = false;
+    }
+
     const allowedApplications = configData.allowedApplications;
 
     await renameComponent(

package/src/util.js

@@ -8,6 +8,7 @@ import { createRequire } from 'module';
 import {jwtDecode} from 'jwt-decode';
 import archiver from 'archiver';
 import {unarchive} from 'unarchive';
+import ora from 'ora';
 
 import chalk from 'chalk';
 import mustache from 'mustache';
@@ -21,10 +22,12 @@ import {
   COMPONENTS_CONFIG_FILE_NAME,
   TASKS_CONFIG_JSON_FILENAME,
   PACKAGE_JSON_FILENAME,
+  PACKAGE_LOCK_JSON_FILENAME,
   TOKEN_PATH,
   OOTB_COMPONENT_SERVICE_REST_ENDPOINT,
   DELETE_COMPONENT_SERVICE_REST_ENDPOINT,
   LP_DELETE_COMPONENT_SERVICE_REST_ENDPOINT,
+  DELETE_COMPONENT_LIBRARY_SERVICE_REST_ENDPOINT,
   OOTB_COMPONENTS,
   USE_PROMOTED_WEB_PACK,
   BOOTSTRAP_CONFIG,
@@ -42,6 +45,7 @@ import {
 } from './constants.js';
 
 
+
 const access = promisify(fs.access);
 
 let showDebug = false;
@@ -288,19 +292,34 @@ export const applyPegaData = async (configJson) => {
 if (showDebug) addDebugLog("applyPegaData", "", "");
   const tokenAndStaticServer = await getC11NB2STokenAndStaticServer();
   const currentDirectory = process.cwd()
-  const currentPackagePath = join(currentDirectory, PACKAGE_JSON_FILENAME);
-  let currentPackageData;
+  // const currentPackagePath = join(currentDirectory, PACKAGE_JSON_FILENAME);
+  const currentPackageLockPath = join(currentDirectory, PACKAGE_LOCK_JSON_FILENAME);
+  // let currentPackageData;
+  let currentPackageLockData;
+
+  // try {
+  //   currentPackageData = fs.readFileSync(currentPackagePath);
+  // }
+  // catch (ex) {
+  //   console.log(chalk.red(`\nUnable to retrieve current package.json.`));
+  //   process.exit(1);
+  // }
 
   try {
-    currentPackageData = fs.readFileSync(currentPackagePath);
+    currentPackageLockData = fs.readFileSync(currentPackageLockPath);
   }
   catch (ex) {
-    console.log($chalk.red(`\nUnable to retrieve current package.json.`))
+    console.log(chalk.red(`\nUnable to retrieve current package-lock.json.`));
     process.exit(1);
   }
 
-  const cData = JSON.parse(currentPackageData);
-  const cosmosVersion = cData.dependencies["@pega/cosmos-react-core"];
+  // const cData = JSON.parse(currentPackageData);
+  // const cosmosVersion = cData.dependencies["@pega/cosmos-react-core"];
+
+  const cData = JSON.parse(currentPackageLockData);
+  const cosmosReact = cData.packages["node_modules/@pega/cosmos-react-core"];
+  const cosmosVersion = cosmosReact.version;
+
   let infinityVersion = "";
 
   if (tokenAndStaticServer.C11NB2S === undefined) {
@@ -361,6 +380,20 @@ export const checkAccessTokenExpiration = async() => {
 
 }
 
+export const getApplicationAndVersionFromToken = async() => {
+  const tokenAndStaticServer = await getC11NB2STokenAndStaticServer();
+
+  if (tokenAndStaticServer.access_token === undefined) {
+    console.log(chalk.redBright("Need to authenticate, missing token.\n"));
+    process.exit(1);
+  }
+
+  const jwt = jwtDecode(tokenAndStaticServer.access_token);
+  const { app_name, app_version } = jwt;
+  return { app_name, app_version };
+
+}
+
 export const getLibraryBased = () => {
 if (showDebug) addDebugLog("getLibraryBased", "", "");
 //   const currentDirectory = process.cwd();
@@ -1300,6 +1333,91 @@ if (showDebug) addDebugLog("deleteInfinityServerComponent", `componentKey: ${com
   }
 };
 
+export const deleteInfinityServerComponentLibrary = async (libraryName, rulesetName, rulesetVersion) => {
+if (showDebug) addDebugLog("deleteInfinityServerComponentLibrary", `componentKey: ${componentKey}, rulesetName: ${rulesetName}, rulesetVersion: ${rulesetVersion}`, "");
+  const serverConfig = await getPegaServerConfig();
+  const { server } = serverConfig;
+  const url = constructCompleteUrl(server, DELETE_COMPONENT_LIBRARY_SERVICE_REST_ENDPOINT);
+  const deleteUrl = `${url}/${libraryName}/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);
+      let spinner;
+
+      console.log();
+      spinner = ora(chalk.green.bold('Deleting component library...')).start();
+
+      const response = await fetch(deleteUrl, {
+        method: 'DELETE',
+        agent: getHttpsAgent(serverConfig),
+        headers: {
+          Authorization: `${tokenType} ${accessToken}`
+        }
+      });
+
+      spinner.stop();
+      console.log();
+
+      status = response.status;
+      if (!response.ok) {
+        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 === 404){
+          throw new Error('404: Server resource not found');
+        }
+        else if (status === 405){
+          throw new Error('405: Server method not allowed');
+        }
+        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.'
+          );
+        }
+
+      }
+
+      try {
+        const respData = await response.json();
+        console.log(
+              chalk.bold.green(`${respData.message}`)
+        );
+
+        if (status === 500) {
+          status = 999;
+          throw new Error(respData.message);
+        }
+      }
+      catch (err) {
+        if (status === 500) {
+            throw new Error(
+              `Error occurred in authentication. Please regenerate using authenticate`
+            );
+        }
+        else if (status === 999) {
+          throw new Error (err);
+        }
+      }
+
+    }
+  } catch (error) {
+
+    throw new Error(error);
+  }
+};
+
+
 export const deleteLaunchpadServerComponent = async componentKey => {
 if (showDebug) addDebugLog("deleteLaunchpadServerComponent", `componentKey: ${componentKey}`, "");
   const { server, isolationId } = await getPegaServerConfig();
@@ -1729,6 +1847,161 @@ if (showDebug) addDebugLog("zipVersionAndArchive", `orgLibName: ${orgLibName}, v
 
 };
 
+export const zipVersionAndArchiveAndReturnBuffer = async (orgLibName, version, currentDirectory = "") => {
+if (showDebug) addDebugLog("zipVersionAndArchive", `orgLibName: ${orgLibName}, version: ${version}`, "");
+  // const srcDirectoryPath = await getSrcDirectoryPath();
+  if (currentDirectory === "") {
+    currentDirectory = process.cwd();
+  }
+  const srcDirectoryPath = join(currentDirectory, "src");
+  const tasksConfig = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
+  const packageJson = join(currentDirectory, PACKAGE_JSON_FILENAME);
+  const archiveFileName = `${orgLibName}_${version}.arch.zip`;
+
+
+  // const configContent = Buffer.from(fs.readFileSync(configJson)).toString();
+  const mainDirectory = process.cwd();
+  const archiveDirectory = join (mainDirectory, ARCHIVES_PATH, `${orgLibName}`, `${version}`);
+  if (!fs.existsSync(archiveDirectory)) {
+    fs.mkdirSync(archiveDirectory, { recursive: true });
+  }
+
+  // create componentsconfig.json
+  await createComponentsConfigFile(archiveDirectory, join(srcDirectoryPath, "components"));
+
+  const archiveFile = join(archiveDirectory, archiveFileName);
+  if (fs.existsSync(orgLibName)) {
+
+  }
+
+  const output = fs.createWriteStream(archiveFile);
+  const archive = archiver('zip', {
+    zlib: { level: 9 } // Sets the compression level.
+  });
+
+  const zipChunks = [];
+  archive.on('data', chunk => zipChunks.push(chunk));
+
+
+  // Add src directory
+  archive.directory(srcDirectoryPath, 'src');
+
+  // grab all files (not directories and archive)
+  const configFiles = await getTopLevelConfigFiles(currentDirectory);
+  if (configFiles && configFiles.length > 0) {
+    for (const configF of configFiles) {
+      if (configF !== "package-lock.json") {
+        archive.file(
+          join(currentDirectory, configF), { name: configF });
+      }
+
+    }
+  }
+
+  // pipe archive data to the file
+  archive.pipe(output);
+
+  output.on('end', function() {
+    console.log('Data has been drained');
+  });
+
+
+  // good practice to catch warnings (ie stat failures and other non-blocking errors)
+  archive.on('warning', function(err) {
+    if (err.code === 'ENOENT') {
+      // log warning
+    } else {
+      // throw error
+      throw err;
+    }
+  });
+
+  // good practice to catch this error explicitly
+  archive.on('error', function(err) {
+    throw err;
+  });
+
+  await archive.finalize();
+
+  const zipBuffer = Buffer.concat(zipChunks);
+  const zipContent = zipBuffer.toString('base64');
+
+  return { output, zipContent};
+
+};
+
+export const zipUnArchiveToTempAndReturnBuffer = async(orgLibName, version) => {
+
+  // unarchive to temp
+  const currentDirectory = process.cwd();
+  const tempDirectory = join (currentDirectory, TEMP_PATH);
+  const srcDirectoryPath = join(tempDirectory, "src");
+
+  const archiveFileName = `${orgLibName}_${version}.arch.zip`;
+  const archiveDirectory = join (currentDirectory, ARCHIVES_PATH, `${orgLibName}`, `${version}`);
+  const archFileName = join(archiveDirectory, archiveFileName);
+
+  await unZipFromArchive(archFileName);
+
+  // archive is in temp directory
+  const archiveFile = join(tempDirectory, archiveFileName);
+
+  const output = fs.createWriteStream(archiveFile);
+  const archive = archiver('zip', {
+    zlib: { level: 9 } // Sets the compression level.
+  });
+
+  const zipChunks = [];
+  archive.on('data', chunk => zipChunks.push(chunk));
+
+  // Add src directory
+  archive.directory(srcDirectoryPath, 'src');
+
+  // grab all files (not directories and archive)
+  const configFiles = await getTopLevelConfigFiles(tempDirectory);
+  if (configFiles && configFiles.length > 0) {
+    for (const configF of configFiles) {
+      if (configF !== "package-lock.json") {
+        archive.file(
+          join(currentDirectory, configF), { name: configF });
+      }
+
+    }
+  }
+
+  // pipe archive data to the file
+  archive.pipe(output);
+
+  output.on('end', function() {
+    console.log('Data has been drained');
+  });
+
+
+  // good practice to catch warnings (ie stat failures and other non-blocking errors)
+  archive.on('warning', function(err) {
+    if (err.code === 'ENOENT') {
+      // log warning
+    } else {
+      // throw error
+      throw err;
+    }
+  });
+
+  // good practice to catch this error explicitly
+  archive.on('error', function(err) {
+    throw err;
+  });
+
+  await archive.finalize();
+
+  const zipBuffer = Buffer.concat(zipChunks);
+  const zipContent = zipBuffer.toString('base64');
+
+  return { output, zipContent};
+
+
+}
+
 export const zipVersionAndArchiveCL = async (orgLibName, version, currentDirectory = "") => {
 if (showDebug) addDebugLog("zipVersionAndArchiveCL", `orgLibName: ${orgLibName}, version: ${version}, currentDirectory: ${currentDirectory}`, "");
   // const srcDirectoryPath = await getSrcDirectoryPath();