@pega/custom-dx-components/src/tasks/import-comp/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,
  getDirectoryFiles,
  addDebugLog,
  checkLibraryAndArchives,
  getConfigDefaults,
  getComponents,
  getUseInputConfig,
  getInputConfigForCommand,
  convertYNToBoolean
 } from '../../util.js';
import { TASKS_CONFIG_JSON_FILENAME } from '../../constants.js';
import { getFilePathQuestions, getFileNameQuestions, updateSavedFilePath  } from './helper.js';

import buildComponent from '../build-comp/index.js';

import inquirerFuzzyPath from '@pega/inquirer-fuzzy-path';

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);

let gFilePath = "";


export const updateConfig = async (
  {
    oldComponentKey,
    newComponentKey,
    library,
    version,
    targetDirectory,
    newLabel = "",
    organization
  },
  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;
  configData.organization = organization;

  if (newLabel != "") {
    configData.label = newLabel;
    configData.description = newLabel;
  }

  // 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' });

};

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' });
  }

};


// rename the component
export const renameComponent = async (
    componentKey,
    orgLib,
    version,
    newName = "",
    newLabel = "",
    organization,
    options
) => {

addDebugLog("renameComponent", `orgLib: ${orgLib}, componentKey: ${componentKey}`, "");

  const componentName = newName != "" ? newName : componentKey.split("_")[2];
  const newComponentKey = `${orgLib}_${componentName}`;
  const library = orgLib.split("_")[1];
  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,
          library,
          version,
          targetDirectory,
          newLabel,
          organization
        },
        options
      );
    }
    else {
      await updateFile(
          fileName,
          oldComponentKeyPC,
          newComponentKeyPC,
          targetDirectory );

    }

  } // for


  return newComponentKey;

};


export const importComp = async(filePath, fileName, askValidate) => {
addDebugLog("importComp", `filePath: ${filePath}, fileName: ${fileName}`, "");

  const currentDirectory = process.cwd();
  // const compDirectory = join(currentDirectory, "src", "components");

  const copyFilePath = join(filePath, fileName);

  const configDef = getConfigDefaults();
  const copyDir = await getComponentDirectoryPath(fileName);
  let configData;
  let newName = "";
  let newLabel = "";

  if (fs.existsSync(copyDir)) {
    configData = fs.readFileSync(join(copyDir, "/config.json"), { encoding: 'utf8' });
    configData = configData && JSON.parse(configData);

    const compName = configData.componentKey.split("_")[2];
    const potentialCompKey = `${configDef.currentOrgLib}_${compName}`;
    const currentCompList = await getComponents();


    if (currentCompList && currentCompList.includes(potentialCompKey)) {
      console.log(`\nComponent ${chalk.yellow(`${potentialCompKey}`)} already exists.`);
      const proceedAnswers = await inquirer.prompt([

        {
          name: 'proceedAs',
          type: 'rawlist',
          message: `Proceed as ?`,
          default: 'No import',
          choices: ['No import', 'Overwrite', 'New name']
        },
        {
          name: 'componentName',
          message: 'Enter component name (required)',
          when(answers) {
            return answers.proceedAs === 'New name';
          },
          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)',
          when(answers) {
            return answers.proceedAs === 'New name';
          },
          validate: value => {
            if (value) {
              return true;
            }
            return 'Please provide value for label';
          }
        }
      ]);


      switch (proceedAnswers.proceedAs) {
        case 'No import':
          // removed copied
          // fs.rmSync(copyDir, { recursive: true, force: true, maxRetries: 2 });
          process.exit();
          break;
        case 'Overwrite':
          // remove existing
          const existingComp = await getComponentDirectoryPath(potentialCompKey);
          fs.rmSync(existingComp, { recursive: true, force: true, maxRetries: 2 });
          break;
        case 'New name':
          newName = proceedAnswers.componentName;
          newLabel = proceedAnswers.componentLabel;
          break;
      }

    }
  }

  if (fs.existsSync(copyFilePath)) {
    fs.cpSync(copyFilePath, copyDir, { recursive: true, force: true  });
    configData = fs.readFileSync(join(copyDir, "/config.json"), { encoding: 'utf8' });

    configData = configData && JSON.parse(configData);

    const newCompKey = await renameComponent(configData.componentKey, configDef.currentOrgLib, configDef.buildVersion, newName, newLabel, configDef.organization, null);
    console.log(`\n${chalk.green(`${fileName}`)} has been imported as ${chalk.green(`${newCompKey}`)}\n`);

    if (askValidate) {
      const validateAnswers = await inquirer.prompt([
        {
          name: 'doValidate',
          type: 'confirm',
          message: `Validate ${chalk.yellow(`${newCompKey}`)}`,
          default: true
        }]);

      if (validateAnswers.doValidate) {
        const args  = [ '','', '', `${newCompKey}`];
        let myOptions = {};
        myOptions["params"] = args;

        await buildComponent(myOptions);
      }
    }

  }

}


export const getFolderList = async (filePath) => {
addDebugLog("getFolderList", `filePath: ${filePath}`, "");
  if (fs.existsSync(filePath)) {
    return fs
      .readdirSync(filePath, { withFileTypes: true })
      .filter(dirent => dirent.isDirectory()  && !dirent.name.startsWith("."))
      .map(dirent => dirent.name);
  }
  else {
    console.log(chalk.red.bold(`File path: ${filePath} does not exist or no permissions.`));
    process.exit(1);
  }
}

export const hasConfig = (dir) => {
  const configPath = join(gFilePath, dir, "config.json");
  if (fs.existsSync(configPath)) {
    return true;
  }

  return false;
}

export const getComponentList = async(filePath) => {
addDebugLog("getComponentList", `filePath: ${filePath}`, "");
  let compList = await getFolderList(filePath);

  gFilePath = filePath;

  if (compList.length > 0) {
    return compList.filter(hasConfig);
  }

  return compList;

}

export default async options => {
  await showVersion();
  await checkLibraryAndArchives();
  await checkPathAccess(pegaConfigJsonPath);
  const useInputConfig = getUseInputConfig();

addDebugLog("importComponent", "", "+");

  if (options.params.length >= 5) {
    const filePath = options.params[3];
    const fileName = options.params[4];
    let askValidate = true;

    if (options.params.length >= 6) {
      if (options.params[5] === "noAskValidate") {
        askValidate = false;
      }

    }

    await importComp( filePath, fileName, askValidate);

  }
  else {

    let filePath;
    let fileName;

    if (useInputConfig) {
      const inputConfig = await getInputConfigForCommand("importComponent");
      filePath = inputConfig.fileLocation;
      fileName = inputConfig.fileName;

      await importComp( filePath, fileName, false);
    }
    else {
      inquirer.registerPrompt('fuzzypath', inquirerFuzzyPath);

      const filePathQuestions = await getFilePathQuestions();
      const filePathAnswers = await inquirer.prompt(filePathQuestions);
      const { filePath } = filePathAnswers;

      const compFileList = await getComponentList(filePath);

      if (!compFileList || compFileList.length === 0) {
        console.log(chalk.red.bold(`No component files exist at path: ${filePath}`));
        process.exit();
      }

      await updateSavedFilePath(filePath);

      const fileNameQuestions = await getFileNameQuestions(compFileList);
      const fileNameAnswers = await inquirer.prompt(fileNameQuestions);
      const {fileName} = fileNameAnswers;

      await importComp( filePath, fileName, true);
    }

  }

addDebugLog("importComponent", "END", "-");

};