@pega/custom-dx-components/src/tasks/move/index.js

Utility for building custom UI components

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 {
  sanitize,
  checkPathAccess,
  showVersion,
  getComponentsObj,
  getDirectoryFiles,
  addDebugLog,
  checkLibraryAndArchives,
  getConfigDefaults,
  getLibraryBased,
  unZipFromArchive,
  zipVersionAndArchive,
  getLibraryArchivesVersions,
  getLibraryArchiveDirectories,
  cleanUpTemp
} from '../../util.js';
import { TASKS_CONFIG_JSON_FILENAME, COMPONENTS_DIRECTORY_PATH, ARCHIVES_PATH, TEMP_PATH } from '../../constants.js';
import { getComponentKeyQuestion, getLibraryQuestions, getLibraryVersionQuestion } from './helper.js';

export const DXCB_CONFIG_INTERNAL_JSON_FILENAME = 'src/dxcb.config.json';
const currentDirectory = process.cwd();
const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);

import { convertIntoPascalCase, getComponentDirectoryPath } from '../../util.js';

const copy = promisify(ncp);

export const updateConfig = async (
  { oldComponentKey, newComponentKey, compName, library, version, compLabel, targetDirectory },
  options,
  onlyCompanion = false
) => {
  addDebugLog('updateConfig', `oldComponentKey: ${oldComponentKey}, newComponentKey: ${newComponentKey}`, '');

  let configData = fs.readFileSync(join(targetDirectory, '/config.json'), { encoding: 'utf8' });
  configData = configData && JSON.parse(configData);

  configData.name = newComponentKey;
  if (configData.componentKey) configData.componentKey = newComponentKey;
  configData.library = library;
  configData.version = version;

  if (compLabel != '') {
    configData.label = compLabel;
    configData.description = compLabel;
  }

  // stringify "4", makes the json string look like JSON in the file, formatted instead of a single line
  fs.writeFileSync(join(targetDirectory, '/config.json'), JSON.stringify(configData, null, 4), {
    encoding: 'utf8',
    flag: 'w'
  });
};

export const updateFile = async (fileName, oldComponentKeyPC, newComponentKeyPC, 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) {
    fileData = fileData.replaceAll(oldComponentKeyPC, newComponentKeyPC);

    fs.writeFileSync(join(targetDirectory, '/', fileName), fileData, { encoding: 'utf8', flag: 'w' });
  }
};

// rename the component
export const renameComponent = async (componentKey, library, version, copyMove, compName = '', compLabel = '', options) => {
  addDebugLog('renameComponent', `library: ${library}, componentKey: ${componentKey}`, '');

  // const componentName = componentKey.split("_")[2];
  const newComponentKey = `${library}_${compName}`;
  const oldComponentKey = componentKey;
  const newComponentKeyPC = convertIntoPascalCase(newComponentKey);
  const oldComponentKeyPC = convertIntoPascalCase(oldComponentKey);

  const currentDirectory = process.cwd();
  const tempDirectory = join(currentDirectory, TEMP_PATH, 'src', 'components');
  const existingDirectory = await getComponentDirectoryPath(componentKey);
  const targetDirectory = await getComponentDirectoryPath(newComponentKey, tempDirectory);

  if (copyMove === 'Move') {
    // custom component
    try {
      fs.renameSync(existingDirectory, targetDirectory);
    } catch (err) {
      console.log(err);
    }
  } else {
    // copy
    // custom component
    try {
      fs.cpSync(existingDirectory, targetDirectory, { recursive: true });
    } 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,
          compName,
          library,
          version,
          compLabel,
          targetDirectory
        },
        options
      );
    } else {
      await updateFile(fileName, oldComponentKeyPC, newComponentKeyPC, targetDirectory);
    }
  } // for

  return newComponentKey;
};

export const moveComp = async (componentKey, copyMove, orgLibName, version, copyShared, localComponents, options) => {
  // put lib/version into temp directory
  const currentDirectory = process.cwd();
  const tempDirectory = join(currentDirectory, TEMP_PATH);
  const archiveDirectory = join(currentDirectory, ARCHIVES_PATH, `${orgLibName}`, `${version}`);
  const fileName = `${orgLibName}_${version}.arch.zip`;
  const archFileName = join(archiveDirectory, fileName);
  const currentCompPath = join(currentDirectory, 'src', 'components');
  const tempCompPath = join(tempDirectory, 'src', 'components');
  const configDef = getConfigDefaults();

  await unZipFromArchive(archFileName);

  const copiedOrMoved = copyMove === 'Copy' ? 'Copied' : 'Moved';

  let newComponentKey;

  if (componentKey === 'ALL') {
    for (let index in localComponents) {
      // skip first ALL
      if (index > 0) {
        const localComponentKey = localComponents[index];
        newComponentKey = await localMoveCopyComp(localComponentKey.value, orgLibName, version, copyMove, currentDirectory, tempDirectory);
        if (newComponentKey) {
          console.log(
            `${copiedOrMoved} ${chalk.green(`${localComponentKey.value}`)} to ${chalk.green(`${orgLibName}/${version}`)} as ${chalk.green(`${newComponentKey}`)}`
          );
        } else {
          console.log(chalk.yellow(`Not ${copiedOrMoved}`));
        }
      }
    }

    const currentSharedPath = join(currentCompPath, 'shared');
    const targetSharedPath = join(tempCompPath, 'shared');

    // copy shared
    if (copyShared) {
      fs.cpSync(currentSharedPath, targetSharedPath, { recursive: true, force: true });
    }

    // rearchive temp directory
    await zipVersionAndArchive(orgLibName, version, tempDirectory);

    // delete temp directory
    fs.rmSync(tempDirectory, { recursive: true, force: true, maxRetries: 5 });
  } else {
    const newComponentKey = await localMoveCopyComp(componentKey, orgLibName, version, copyMove, currentDirectory, tempDirectory);

    if (newComponentKey) {
      const currentSharedPath = join(currentCompPath, 'shared');
      const targetSharedPath = join(tempCompPath, 'shared');

      // copy shared
      if (copyShared) {
        fs.cpSync(currentSharedPath, targetSharedPath, { recursive: true, force: true });
      }

      console.log(
        `\n${copiedOrMoved} ${chalk.green(`${componentKey}`)} to ${chalk.green(`${orgLibName}/${version}`)} as ${chalk.green(`${newComponentKey}`)}\n`
      );

      // rearchive temp directory
      await zipVersionAndArchive(orgLibName, version, tempDirectory);

      // update current /src/components because we copied to it (as well as the archive)
      if (orgLibName === configDef.currentOrgLib && version === configDef.buildVersion && copyMove === 'Copy') {
        fs.cpSync(join(tempCompPath, newComponentKey), join(currentCompPath, newComponentKey), {
          recursive: true,
          force: true
        });
      }
    } else {
      console.log(chalk.yellow(`No components were ${copiedOrMoved}`));
    }

    // delete temp directory
    fs.rmSync(tempDirectory, { recursive: true, force: true, maxRetries: 5 });
  }
};

export const localMoveCopyComp = async (componentKey, orgLibName, version, copyMove, currentDirectory, tempDirectory) => {
  const currentCompPath = join(currentDirectory, 'src', 'components');
  const tempCompPath = join(tempDirectory, 'src', 'components');
  const configDef = getConfigDefaults();

  const tempCompName = componentKey.split('_')[2];
  let newTempComponentKey = `${orgLibName}_${tempCompName}`;
  const tempDirComp = join(tempCompPath, `${newTempComponentKey}`);

  let compLabel = '';
  let compName = tempCompName;

  if (fs.existsSync(join(tempCompPath, componentKey)) && version === configDef.buildVersion && copyMove === 'Copy') {
    // need to rename
    console.log(`\n${chalk.yellow(`${tempCompName}`)} exists, select new name and label for copied component.`);
    const nameAnswers = await inquirer.prompt([
      {
        name: 'componentName',
        message: 'Enter component name (required)',
        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, no spaces.';
        }
      },
      {
        name: 'componentLabel',
        message: 'Enter component label for display (required)',
        validate: value => {
          if (value) {
            return true;
          }
          return 'Please provide value for label';
        }
      }
    ]);

    //
    compName = nameAnswers.componentName;
    compLabel = nameAnswers.componentLabel;
  } else if (fs.existsSync(tempDirComp)) {
    const answers = await inquirer.prompt([
      {
        name: 'confirmOverride',
        type: 'confirm',
        message: `Component ${chalk.yellow(`${tempCompName}`)} currently exists in ${chalk.yellow(`${orgLibName}/${version}`)}, override?`,
        default: false
      }
    ]);
    if (!answers.confirmOverride) {
      return null;
    } else {
      // delete the one in the temp directory, so can move/copy latest
      fs.rmSync(tempDirComp, { recursive: true, force: true, maxRetries: 2 });
    }
  }

  // rename the component
  const newComponentKey = await renameComponent(componentKey, orgLibName, version, copyMove, compName, compLabel);

  return newComponentKey;
};

export default async options => {
  await showVersion();
  await checkLibraryAndArchives();

  addDebugLog('move', '', '+');

  await checkPathAccess(pegaConfigJsonPath);
  const isLibraryBased = getLibraryBased();
  if (!isLibraryBased) {
    console.log(`Command only supported for ${chalk.bold.green('library mode')} components.`);
    process.exit();
  }

  await cleanUpTemp();

  let data = fs.readFileSync(pegaConfigJsonPath, { encoding: 'utf8' });
  data = data && JSON.parse(data);

  if (!data[COMPONENTS_DIRECTORY_PATH]) {
    console.error(`${chalk.red.bold('ERROR')} Unable find to components directory path in config.json`);
    process.exit(1);
  }

  let copyMove;
  let copyMoveLC;
  let componentKey;
  let orgLibName;
  let version;
  let copyShared;

  let localComponents = await getComponentsObj();

  const configDef = getConfigDefaults();

  if (!localComponents || localComponents.length === 0) {
    console.log(chalk.red.bold('No components to move/copy.'));
    process.exit();
  }

  if (options.params.length >= 8) {
    copyMove = options.params[3];
    componentKey = options.params[4];
    orgLibName = options.params[5];
    version = options.params[6];
    copyShared = options.params[7];

    await moveComp(componentKey, copyMove, orgLibName, version, copyShared, localComponents, options);
  } else {
    // VS Code plugin would send in the component
    let paramComponentKey;
    if (options.params.length == 4) {
      paramComponentKey = options.params[3];
    }

    const configDef = getConfigDefaults();
    console.log(`Current library: ${chalk.green(`${configDef.displayLibVersion}`)}`);

    // test to see if current library has more than one version
    // if no available versions can not move/copy to it, so send in current lib
    // as library to be removed from the list
    let removeOrgLib = '';
    let libVersions;
    try {
      // libVersions = await getLibraryArchivesVersions(configDef.currentOrgLib, configDef.buildVersion);
      libVersions = await getLibraryArchivesVersions(configDef.currentOrgLib, '0.0.0');
    } catch (ex) {}
    if (!libVersions || libVersions.length === 0) {
      removeOrgLib = configDef.currentOrgLib;
    }

    const archLibs = await getLibraryArchiveDirectories(removeOrgLib);

    if (!archLibs || archLibs.length === 0) {
      console.log(chalk.red.bold('No available libraries to move/copy to.'));
      process.exit();
    }

    const copyMoveQuestion = [
      {
        name: 'copyMove',
        type: 'rawlist',
        message: 'Copy or Move',
        choices: ['Copy', 'Move'],
        default: 'Copy'
      }
    ];

    const copyMoveAnswer = await inquirer.prompt(copyMoveQuestion);
    ({ copyMove } = copyMoveAnswer);
    copyMoveLC = copyMove.toLowerCase();

    if (localComponents && localComponents.length > 1) {
      localComponents.unshift({ name: 'ALL', value: 'ALL' });
    }

    const keyQuestions = await getComponentKeyQuestion(localComponents, copyMoveLC, paramComponentKey);

    const answers = await inquirer.prompt(keyQuestions);
    ({ componentKey = paramComponentKey } = answers);

    const libQuestions = await getLibraryQuestions(archLibs);
    const libAnswers = await inquirer.prompt(libQuestions);
    orgLibName = libAnswers.libraryName;
    const buildVersion = configDef.currentOrgLib === orgLibName ? (copyMove === 'Move' ? configDef.buildVersion : '') : '';

    try {
      libVersions = await getLibraryArchivesVersions(orgLibName, buildVersion);
    } catch (ex) {}

    if (libVersions.length == 0) {
      console.log(`Current library: ${chalk.green(`${orgLibName}`)} has NO available versions to move to.`);
      process.exit();
    }

    const versionQuestions = await getLibraryVersionQuestion(orgLibName, libVersions, copyMoveLC);
    const versionAnswers = await inquirer.prompt(versionQuestions);
    ({ version, copyShared } = versionAnswers);

    await moveComp(componentKey, copyMove, orgLibName, version, copyShared, localComponents, options);
  }

  addDebugLog('rename', 'END', '-');
};