@pega/custom-dx-components 0.24.16 → 0.242.1

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

@@ -0,0 +1,53 @@
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+
+import {
+  getPegaServerConfig,
+  checkPathAccess,
+  getComponentDefaults
+} from '../../util.js';
+import { TASKS_CONFIG_JSON_FILENAME, COMPONENTS_DIRECTORY_PATH, COMPONENTS_PATH } from '../../constants.js';
+
+const pegaConfigJsonPath = path.join(path.resolve(), TASKS_CONFIG_JSON_FILENAME);
+
+export const getOrgLib = async () => {
+  const defaultPegaConfig = await getPegaServerConfig();
+
+  await checkPathAccess(pegaConfigJsonPath);
+
+  let data = fs.readFileSync(pegaConfigJsonPath, { encoding: 'utf8' });
+  data = data && JSON.parse(data);
+
+  if (!data[COMPONENTS_DIRECTORY_PATH]) {
+    console.error(`${chalk.red.bold('ERROR')} Could not able find components directory path in config.json`);
+    process.exit(1);
+  }
+
+  const componentData = data[COMPONENTS_PATH];
+
+  let library;
+  ({ library } = componentData);
+  let { organization } = JSON.parse(fs.readFileSync(path.resolve('package.json'), 'utf8'));
+
+  const componentDefaults = await getComponentDefaults();
+  componentDefaults.library = library;
+  componentDefaults.organization = organization;
+
+  return componentDefaults;
+}
+
+
+
+export const getLibraryVersionQuestion = async(libVersions) => {
+
+    return [
+      {
+        name: 'version',
+        type: 'rawlist',
+        message: 'Select library version to publish',
+        choices: libVersions
+      }
+    ];
+
+}

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

@@ -0,0 +1,212 @@
+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, getLibraryVersions, getLibraryBased } from '../../util.js';
+
+import { publishLib, listLibJSONResponse, deleteLibVersion } from '@pega/constellation-dx-components-build-utils/index.js';
+
+import { getLibraryVersionQuestion, getOrgLib } from './helper.js';
+;
+
+const isLibraryBased = await getLibraryBased();
+
+export function getCustomTasks(componentKey, sourceMap, devBuild, options) {
+
+  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) => {
+
+  const tokenAndStaticServer = await getC11NB2STokenAndStaticServer();
+  const libList = await listLibJSONResponse(tokenAndStaticServer.C11NB2S, tokenAndStaticServer.appStaticContentServer);
+  const oList = JSON.parse(libList);
+
+  let libVersionExists = false;
+  let overrideExisting = false;
+  if (oList && Object.keys(oList).length !== 0 ) {
+    // need to parse data to find versions
+    let versionList = oList[libraryName];
+
+    if (versionList && versionList.includes(libraryVersion)) {
+      libVersionExists = true;
+    }
+  }
+
+  return libVersionExists;
+}
+
+
+export const publishNewLibraryAsync = async (libraryName, version, checkDeleted = false) => {
+
+  const tokenAndStaticServer = await getC11NB2STokenAndStaticServer();
+
+  if (checkDeleted ) {
+    console.log(chalk.yellow(`Verifying library has been deleted..`));
+    let libExists = await doesLibraryExist(libraryName, version);
+    let count = 0;
+    while (libExists) {
+      // 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(chalk.green.bold(`Publishing Library ${libraryName}:${version} ... `));
+  publishLib(libraryName, version, tokenAndStaticServer.C11NB2S, tokenAndStaticServer.appStaticContentServer);
+
+}
+
+
+export default async (options) => {
+  if (!isLibraryBased) {
+    console.log(`Command only supported for ${chalk.bold.green('library based')} components.`)
+    process.exit();
+  }
+
+  showVersion();
+
+  let organization;
+  let library;
+  let version;
+  let devBuild;
+
+  let libraryName;
+
+
+  if (options.params.length >= 6) {
+    organization = options.params[3];
+    library = options.params[4];
+    version = options.params[5];
+    libraryName = organization.concat("_").concat(library);
+  }
+  else {
+
+    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);
+    }
+
+    const compDef = await getOrgLib();
+    organization = compDef.organization;
+    library = compDef.library;
+
+    libraryName = organization.concat("_").concat(library);
+
+    console.log(`\nLibrary ${chalk.bold.green(libraryName)} `)
+
+    const libVersions = await getLibraryVersions(libraryName);
+
+    if (libVersions.length > 0) {
+      const versionQuestions = await getLibraryVersionQuestion(libVersions);
+      const versionAnswers = await inquirer.prompt(versionQuestions);
+
+      ({version} = versionAnswers);
+
+      let okToPublish = true;
+      if (!version.includes("-dev")) {
+        okToPublish = false;
+        const publishAnswers = await inquirer.prompt([
+
+          {
+            name: 'confirmPublish',
+            type: 'confirm',
+            message: 'You are about to publish a PRODUCTION version which can NOT be deleted, proceed ?',
+            default: false
+          }
+        ]);
+        if (publishAnswers.confirmPublish) {
+          okToPublish = true;
+        }
+      }
+
+      if (okToPublish) {
+
+        let libVersionExists = await doesLibraryExist(libraryName, version);
+        let overrideExisting = false;
+        let checkDeleted = false;
+
+        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}`) + " ...");
+            await deleteLibVersion(libraryName, version, tokenAndStaticServer.C11NB2S, tokenAndStaticServer.appStaticContentServer);
+
+            checkDeleted = true;
+          }
+          else {
+            // don't override, so end
+            console.log(chalk.yellow(`You will need to increment your library version to publish`));
+            return;
+          }
+        }
+
+        // need a timeout to give services time to delete the library
+        setTimeout( function(){ publishNewLibraryAsync(libraryName, version, checkDeleted)}, 700 );
+
+
+      }
+
+
+
+    }
+    else {
+      console.log(chalk.bold.redBright(`No library versions in ${libraryName}`));
+    }
+
+  }
+
+  return true;
+};

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

@@ -0,0 +1,353 @@
+import path from 'path';
+import fs from 'fs';
+import { promisify } from 'util';
+import { join } from 'path';
+
+import inquirer from 'inquirer';
+import ncp from 'ncp';
+import chalk from 'chalk';
+
+import { checkPathAccess, showVersion, getComponentsObj, getDirectoryFiles, getPegaServerConfig, getLibraryBased, deleteLocalLibrary, getC11NB2STokenAndStaticServer, updateComponentDefaultLibrary, updateDefaultOrganization } from '../../util.js';
+import { TASKS_CONFIG_JSON_FILENAME, COMPONENTS_DIRECTORY_PATH, COMPONENTS_PATH } from '../../constants.js';
+
+import { buildLib } from '@pega/constellation-dx-components-build-utils/index.js';
+
+export const DXCB_CONFIG_INTERNAL_JSON_FILENAME = 'src/dxcb.config.json';
+const currentDirectory = process.cwd();
+const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
+
+const isLibraryBased = await getLibraryBased();
+
+
+import {
+  convertIntoPascalCase,
+  getComponentDirectoryPath,
+  getPegaConfig,
+  getComponentDefaults,
+  getComponents,
+  sanitize
+} from '../../util.js';
+import { deleteLocalComponents } from '@pega/custom-dx-components/src/tasks/delete/helper.js';
+
+const copy = promisify(ncp);
+
+
+export const getOrgLib = async () => {
+  const defaultPegaConfig = await getPegaServerConfig();
+
+  await checkPathAccess(pegaConfigJsonPath);
+
+  let data = fs.readFileSync(pegaConfigJsonPath, { encoding: 'utf8' });
+  data = data && JSON.parse(data);
+
+  if (!data[COMPONENTS_DIRECTORY_PATH]) {
+    console.error(`${chalk.red.bold('ERROR')} Could not able find components directory path in config.json`);
+    process.exit(1);
+  }
+
+  const componentData = data[COMPONENTS_PATH];
+
+  let library;
+  ({ library } = componentData);
+  let { organization } = JSON.parse(fs.readFileSync(path.resolve('package.json'), 'utf8'));
+
+  const componentDefaults = await getComponentDefaults();
+  componentDefaults.library = library;
+  componentDefaults.organization = organization;
+
+  return componentDefaults;
+}
+
+export const updateConfig = async (
+  {
+    oldComponentKey,
+    newComponentKey,
+    library,
+    organization,
+    componentName,
+    componentLabel,
+    version,
+    description,
+    allowedApplications,
+    targetDirectory,
+  },
+  options,
+  onlyCompanion = false
+) => {
+
+  let configData = fs.readFileSync(join(targetDirectory, "/config.json"), { encoding: 'utf8' });
+  configData = configData && JSON.parse(configData);
+
+  configData.name = newComponentKey;
+  configData.label = componentLabel;
+  configData.organization = organization;
+  if (configData.componentKey) configData.componentKey = newComponentKey;
+  configData.library = library;
+  configData.version = version;
+  configData.description = (description != '') ? description : componentLabel;
+
+  configData.allowedApplications = allowedApplications;
+
+  // stringify "4", makes the json string look like JSON in the file, formated instead of a single line
+  fs.writeFileSync(join(targetDirectory, "/config.json"), JSON.stringify(configData, null, 4), { encoding: 'utf8' });
+
+};
+
+export const updateFile = async (
+    fileName,
+    oldComponentKeyPC,
+    newComponentKeyPC,
+    targetDirectory,
+) => {
+
+  let fileData = fs.readFileSync(join(targetDirectory, "/", fileName), { encoding: 'utf8' });
+
+  if (fileData.indexOf(oldComponentKeyPC) >= 0) {
+    fileData = fileData.replaceAll(oldComponentKeyPC, newComponentKeyPC);
+
+    fs.writeFileSync(join(targetDirectory, "/", fileName), fileData, { encoding: 'utf8' });
+  }
+
+};
+
+export const renameLibrary = async ({library, organization}, options) => {
+
+  const compDef = await getOrgLib();
+  const currentOrganization = compDef.organization;
+  const currentLibrary = compDef.library;
+  const currentVersion = compDef.version;
+
+  let compVersion;
+
+  const tokenAndStaticServer = await getC11NB2STokenAndStaticServer();
+
+  if (tokenAndStaticServer.C11NB2S === undefined) {
+    console.log(chalk.redBright("Need to authenticate, missing services token.\nBuilding a library requires authentication to acquire a token to build."));
+    process.exit(1);
+
+  }
+
+  const currentOrgLib = currentOrganization.concat("_").concat(currentLibrary);
+  const newOrgLib = organization.concat("_").concat(library);
+
+  // reaname all the components
+  const components = await getComponents();
+  for (const index in components) {
+    const componentKey = components[index];
+    const componentName = componentKey.split('_')[2];
+    const currentDirectory = await getComponentDirectoryPath(componentKey);
+
+    let configData = fs.readFileSync(join(currentDirectory, "/config.json"), { encoding: 'utf8' });
+    configData = configData && JSON.parse(configData);
+
+    const componentLabel = configData.label.substring(0, configData.label.indexOf("(")).concat(`(${newOrgLib})`);
+    const description = configData.description.substring(0, configData.description.indexOf("(")).concat(`(${newOrgLib})`);
+    const version = configData.version;
+    compVersion = version;
+    const allowedApplications = configData.allowedApplications;
+
+    await renameComponent({library, organization, componentKey, componentName, componentLabel,
+      version, description, allowedApplications}, options);
+
+
+
+  }
+
+
+  // delete and rebuild library
+  try {
+    await deleteLocalLibrary(currentOrgLib);
+  }
+  catch (ex) {}
+
+
+  // update config
+  await updateComponentDefaultLibrary(library);
+  await updateDefaultOrganization(organization);
+
+  // call constellation-dx-components-build-utils build library, which will create a directory of the "buildLibName"
+  // with subdirectories for each version.
+  // If "buildDev", we append to version "-dev".  Currently, only "-dev" versions, when published, can be deleted.
+  buildLib(newOrgLib, compVersion, tokenAndStaticServer.C11NB2S, tokenAndStaticServer.appStaticContentServer);
+
+
+
+
+}
+
+
+export const renameComponent = async (
+  {
+    library,
+    organization,
+    componentKey,
+    componentName,
+    componentLabel,
+    version,
+    description,
+    allowedApplications
+  },
+  options,
+  onlyCompanion = false
+) => {
+
+
+  let pegaConfig = await getPegaConfig();
+
+  const newComponentKey = `${organization}_${library}_${componentName}`;
+
+  const oldComponentKey = componentKey;
+  const newComponentKeyPC = convertIntoPascalCase(newComponentKey);
+  const oldComponentKeyPC = convertIntoPascalCase(oldComponentKey);
+
+  const currentDirectory = await getComponentDirectoryPath(componentKey);
+  const targetDirectory = await getComponentDirectoryPath(newComponentKey);
+
+
+
+
+  // custom component
+  try {
+    fs.renameSync(currentDirectory, targetDirectory);
+  } catch(err) {
+    console.log(err)
+  }
+
+  const targetFileList = await getDirectoryFiles(targetDirectory);
+
+  for (var fileIndex in targetFileList) {
+    const fileName = targetFileList[fileIndex];
+
+    if (fileName === "config.json") {
+      await updateConfig(
+        {
+          oldComponentKey,
+          newComponentKey,
+          componentName,
+          componentLabel,
+          library,
+          version,
+          description,
+          allowedApplications,
+          organization,
+          targetDirectory,
+        },
+        options
+      );
+    }
+    else {
+      await updateFile(
+          fileName,
+          oldComponentKeyPC,
+          newComponentKeyPC,
+          targetDirectory );
+
+    }
+
+  } // for
+
+
+  console.log(chalk.green(`Component ${oldComponentKey} renamed to ${newComponentKey}`));
+
+};
+
+
+
+
+
+export default async options => {
+  if (!isLibraryBased) {
+    console.log(`Command only supported for ${chalk.bold.green('library based')} components.`)
+    process.exit();
+  }
+
+  showVersion();
+
+  await checkPathAccess(pegaConfigJsonPath);
+
+  let data = fs.readFileSync(pegaConfigJsonPath, { encoding: 'utf8' });
+  data = data && JSON.parse(data);
+
+  if (!data[COMPONENTS_DIRECTORY_PATH]) {
+    console.error(
+      `${chalk.red.bold('ERROR')} Could not able find components directory path in config.json`
+    );
+    process.exit(1);
+  }
+
+  const componentData = data[COMPONENTS_PATH];
+
+  const { library } = componentData;
+  const { organization } = JSON.parse(fs.readFileSync(path.resolve('package.json'), 'utf8'));
+
+  let componentDefaults = await getComponentDefaults();
+  componentDefaults.library = library;
+
+  const localComponents = await getComponentsObj();
+
+
+  if (options.params.length >= 11) {
+    const organization = options.params[6];
+    const library = options.params[8];
+
+
+    await renameLibrary(
+      {
+        library,
+        organization
+      },
+      options
+    );
+
+  }
+  else {
+    const questions = [
+      {
+        name: 'organization',
+        message: 'Enter new component organization',
+        default: organization,
+        validate: value => {
+          if (value) {
+            return true;
+          }
+          return 'Please provide value for organization';
+        }
+      },
+      {
+        name: 'library',
+        message: 'Enter new library name',
+        default: componentDefaults.library,
+        validate: value => {
+          /* value should not be empty
+            It should not have spaces
+            It should not start with a number
+            Only case-insensitive alphanumeric values are allowed
+          */
+          if (value && !/^\d/.test(value) && value === sanitize(value)) {
+            return true;
+          }
+          return 'Only alphanumeric values are allowed, starting with alphabets';
+        }
+      }
+    ];
+
+    await inquirer.prompt(questions).then(async answers => {
+      const {
+        organization,
+        library
+      } = answers;
+
+      await renameLibrary(
+        {
+          library,
+          organization
+        },
+        options
+      );
+
+    });
+  }
+
+
+
+};

package/src/tasks/revert-webpack/index.js

@@ -9,13 +9,15 @@ import { up } from 'inquirer/lib/utils/readline.js';
 import {
   convertIntoPascalCase,
   showVersion,
-  updateUseWebPackPromotion
+  updateUseWebPackPromotion,
+  getLibraryBased
 } from '../../util.js';
 import {
   WEBPACK_CONFIG_JS_FILENAME,
   BUILDER_INDEX_FILE_PATH
 } from '../../constants.js';
 
+const isLibraryBased = await getLibraryBased();
 
 
 export const renamePromotedWebPack = async () => {
@@ -42,6 +44,11 @@ export const renamePromotedWebPack = async () => {
 
 
 export default async options => {
+  if (isLibraryBased) {
+    console.log(`Command only supported for ${chalk.bold.green('non library based')} components.`)
+    process.exit();
+  }
+
   showVersion();
 
   await renamePromotedWebPack();