@pega/custom-dx-components 24.1.11 → 24.2.10

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;
+};

package/src/tasks/quarantine/index.js

@@ -0,0 +1,84 @@
+import fs from 'fs';
+import path, {join} from 'path';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+
+
+import {
+  showVersion,
+  addDebugLog,
+  getJestFunctionalTestList } from '../../util.js';
+
+import { JEST_TESTS_FUNCTIONAL_PATH } from '../../constants.js';
+
+
+export const quarnUnquarnTests = async(answers) => {
+  switch (answers.QuarUnQuar) {
+    case "Quarantine" :
+      await quarantineTests(answers);
+      break;
+    case "Unquarantine" :
+      await unquarantineTests(answers);
+      break;
+  }
+}
+
+
+
+export const quarantineTests = async(answers) => {
+  const testList = await getJestFunctionalTestList(answers.whichTests);
+  const functionalPath = join(path.resolve(), JEST_TESTS_FUNCTIONAL_PATH);
+
+  // rename .test to .notest
+  for (const testName of testList) {
+    const quarantineName = testName.replace(".test", ".notest");
+    fs.renameSync(join(functionalPath, testName), join(functionalPath, quarantineName));
+  }
+
+}
+
+export const unquarantineTests = async(answers) => {
+  const testList = await getJestFunctionalTestList(answers.whichTests);
+  const functionalPath = join(path.resolve(), JEST_TESTS_FUNCTIONAL_PATH);
+
+  // rename .test to .notest
+  for (const testName of testList) {
+    const restoreName = testName.replace(".notest", ".test");
+    fs.renameSync(join(functionalPath, testName), join(functionalPath, restoreName));
+  }
+
+}
+
+
+export default async options => {
+
+addDebugLog("quarantine", "", "+");
+
+  await showVersion();
+
+  const quaranAnswers = await inquirer.prompt([
+
+    {
+      name: 'QuarUnQuar',
+      type: 'rawlist',
+      message: `Quarantine or UnQuarantine tests`,
+      choices: ["Quarantine", "Unquarantine"],
+      default: 'Quarantine'
+
+    },
+    {
+      name: 'whichTests',
+      type: 'rawlist',
+      message: (answers) => `Which tests to ${answers.QuarUnQuar}`,
+      default: 'ALL',
+      choices: ["ALL", "Original", "Library"]
+    }
+  ]);
+
+  // await showCurrentStatus();
+  await quarnUnquarnTests(quaranAnswers);
+
+
+addDebugLog("quarantine", "END", "-");
+
+}

package/src/tasks/rename/index.js

@@ -7,7 +7,7 @@ import inquirer from 'inquirer';
 import ncp from 'ncp';
 import chalk from 'chalk';
 
-import { checkPathAccess, showVersion, getComponentsObj, getDirectoryFiles } from '../../util.js';
+import { checkPathAccess, showVersion, getComponentsObj, getDirectoryFiles, addDebugLog, checkLibraryAndArchives, getConfigDefaults, getLibraryBased } from '../../util.js';
 import { TASKS_CONFIG_JSON_FILENAME, COMPONENTS_DIRECTORY_PATH, COMPONENTS_PATH } from '../../constants.js';
 
 
@@ -21,7 +21,6 @@ import {
   convertIntoPascalCase,
   getComponentDirectoryPath,
   getPegaConfig,
-  getComponentDefaults,
   sanitize,
   validateSemver
 } from '../../util.js';
@@ -47,6 +46,8 @@ export const updateConfig = async (
   onlyCompanion = false
 ) => {
 
+addDebugLog("updateConfig", `oldComponentKey: ${oldComponentKey}, newComponentKey: ${newComponentKey}`, "");
+
   let configData = fs.readFileSync(join(targetDirectory, "/config.json"), { encoding: 'utf8' });
   configData = configData && JSON.parse(configData);
 
@@ -83,6 +84,8 @@ export const updateFile = async (
     targetDirectory,
 ) => {
 
+addDebugLog("updateFile", `fileName: ${fileName}, oldComponentKeyPC: ${oldComponentKeyPC}, newComponentKeyPC: ${newComponentKeyPC}, targetDirectory: ${targetDirectory}`, "");
+
   let fileData = fs.readFileSync(join(targetDirectory, "/", fileName), { encoding: 'utf8' });
 
   if (fileData.indexOf(oldComponentKeyPC) >= 0) {
@@ -109,6 +112,7 @@ export const renameComponent = async (
   onlyCompanion = false
 ) => {
 
+addDebugLog("renameComponent", `library: ${library}, organization: ${organization}, componentKey: ${componentKey}`, "");
 
   let pegaConfig = await getPegaConfig();
 
@@ -174,9 +178,13 @@ export const renameComponent = async (
 
 
 export default async options => {
-  showVersion();
+  await showVersion();
+  await checkLibraryAndArchives();
+
+addDebugLog("rename", "", "+");
 
   await checkPathAccess(pegaConfigJsonPath);
+  const isLibraryBased = getLibraryBased();
 
   let data = fs.readFileSync(pegaConfigJsonPath, { encoding: 'utf8' });
   data = data && JSON.parse(data);
@@ -193,7 +201,7 @@ export default async options => {
   const { library } = componentData;
   const { organization } = JSON.parse(fs.readFileSync(path.resolve('package.json'), 'utf8'));
 
-  let componentDefaults = await getComponentDefaults();
+  let componentDefaults = getConfigDefaults();
   componentDefaults.library = library;
 
   const localComponents = await getComponentsObj();
@@ -225,13 +233,21 @@ export default async options => {
 
   }
   else {
+
+    // VS Code pluggin would send in the component
+    let paramComponentKey;
+    if (options.params.length == 4) {
+      paramComponentKey = options.params[3];
+    }
+
     const questions = [
       {
         name: 'componentKey',
         type: 'rawlist',
         pageSize: 15,
         message: 'Select component to rename',
-        choices: localComponents
+        choices: localComponents,
+        when: () => !paramComponentKey
       },
       {
         name: 'componentName',
@@ -267,7 +283,8 @@ export default async options => {
             return true;
           }
           return 'Please provide value for organization';
-        }
+        },
+        when: () => !isLibraryBased
       },
       {
         name: 'version',
@@ -278,7 +295,8 @@ export default async options => {
             return true;
           }
           return 'Please provide semver compatible version e.g 0.0.1';
-        }
+        },
+        when: () => !isLibraryBased
       },
       {
         name: 'library',
@@ -294,12 +312,14 @@ export default async options => {
             return true;
           }
           return 'Only alphanumeric values are allowed, starting with alphabets';
-        }
+        },
+        when: () => !isLibraryBased
       },
       {
         name: 'allowedApplications',
         message: 'Please enter the application names to be supported (comma-separated). ',
-        suffix: 'Keep empty for all applications'
+        suffix: 'Keep empty for all applications',
+        when: () => !isLibraryBased
       },
       {
         name: 'description',
@@ -312,15 +332,25 @@ export default async options => {
 
     await inquirer.prompt(questions).then(async answers => {
       const {
-        componentKey,
+        componentKey = paramComponentKey,
         componentName,
         componentLabel,
+        description,
+      } = answers;
+      let {
         organization,
         library,
         version,
-        description,
-        allowedApplications
-      } = answers;
+        allowedApplications } = answers;
+
+      if (isLibraryBased) {
+        // these answers come from defaults
+        const orgLib = getConfigDefaults();
+        library = orgLib.library;
+        version = orgLib.buildVersion;
+        organization = orgLib.organization;
+        allowedApplications = "";
+      }
 
       await renameComponent(
         {
@@ -339,6 +369,6 @@ export default async options => {
     });
   }
 
-
+addDebugLog("rename", "END", "-");
 
 };