@bigbinary/neeto-audit-frontend 1.0.3 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bigbinary/neeto-audit-frontend",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Audits neeto frontend codebase for issues and suggests a fix.",
   "type": "module",
   "bin": "./dist/index.js",
@@ -15,22 +15,29 @@
   "author": "Thejus Paul <thejuspaul@protonmail.ch>",
   "license": "UNLICENSED",
   "devDependencies": {
-    "@rollup/plugin-commonjs": "25.0.2",
+    "@rollup/plugin-commonjs": "25.0.3",
     "@rollup/plugin-json": "6.0.0",
     "@rollup/plugin-node-resolve": "15.1.0",
-    "rollup": "3.26.2",
+    "rollup": "3.26.3",
     "rollup-plugin-analyzer": "4.0.0",
     "rollup-plugin-cleaner": "1.0.0",
     "rollup-plugin-executable-script": "1.0.1",
     "rollup-plugin-peer-deps-external": "2.2.4"
   },
   "dependencies": {
+    "@bigbinary/neeto-commons-frontend": "2.0.101",
     "chalk": "5.3.0",
     "commander": "11.0.0",
-    "ramda": "0.29.0"
+    "ora": "6.3.1",
+    "ramda": "0.29.0",
+    "simple-git": "3.19.1"
   },
+  "peerDependencies": {
+    "@bigbinary/neeto-commons-frontend": "^2.0.101",
+    "ramda": "^0.29.0"
+  },
+  "packageManager": "pnpm@8.6.9",
   "engines": {
-    "node": ">=18.16",
-    "pnpm": ">=8.6"
+    "node": ">=18"
   }
 }

package/src/cli.js

@@ -1,38 +1,10 @@
-#!/usr/bin/env node
-import { renderErrors } from "./utils/index.js";
-import verifiers from "./verifiers/index.js";
-import chalk from "chalk";
-import { program } from "commander";
+import { getCliOptions, runVerifiers } from "./utils";
+import verifiers from "./verifiers";
 
 const run = async () => {
-  program
-    .usage("[OPTIONS]...")
-    .option("-d, --debug", "Runs in debug mode")
-    .option("-a, --auto-fix", "Automatically fixes the errors")
-    .parse(process.argv);
+  const { autoFix, debug } = getCliOptions();
 
-  const { autoFix, debug } = program.opts();
-
-  let errors = [];
-  const results = verifiers.map(async ([name, verifier]) => {
-    const { isSuccess = false, error, fix } = await verifier(debug);
-
-    !isSuccess && errors.push(error);
-    error && autoFix && fix(debug);
-
-    return { name, isSuccess };
-  });
-
-  const allResults = await Promise.all(results);
-
-  allResults.map(({ name, isSuccess }) => {
-    const resultText = isSuccess ? chalk.bgGreen("PASS") : chalk.bgRed("FAIL");
-    console.log(resultText, name);
-  });
-
-  errors.length > 0 && renderErrors(errors, autoFix);
-  autoFix && console.log(chalk.green("All issues have been fixed!"));
-  console.log();
+  runVerifiers({ verifiers, autoFix, debug });
 };
 
 run();

package/src/constants/index.js

@@ -0,0 +1,3 @@
+import path from "path";
+
+export const PACKAGE_JSON_PATH = path.resolve("./package.json");

package/src/utils/index.js

@@ -1,10 +1,16 @@
+import { isNotEmpty } from "@bigbinary/neeto-commons-frontend/pure";
 import chalk from "chalk";
+import { exec } from "child_process";
+import { program } from "commander";
 import { lstat, mkdir, readFile, writeFile } from "fs/promises";
-import path from "path";
 import { promises } from "fs";
+import ora from "ora";
+import path from "path";
+import { identity, last, split } from "ramda";
+import { simpleGit } from "simple-git";
 import util from "util";
-import { exec } from "child_process";
-import { identity } from "ramda";
+
+import { PACKAGE_JSON_PATH } from "../constants";
 
 const run = util.promisify(exec);
 
@@ -14,6 +20,65 @@ export const execute = async (command, debug) => {
   debug && console.log("stderr:", stderr);
 };
 
+const renderErrors = (errors = [], isAutoFixFlagPresent = false) => {
+  console.log(`\n${chalk.bgRed.black("ERRORS")}`);
+  console.log(chalk.red(` \u2022 ${errors.join("\n \u2022 ")}`));
+  if (!isAutoFixFlagPresent) {
+    console.log(
+      chalk.yellowBright(
+        "\nPlease run the following command to auto-fix the errors: "
+      ) + chalk.bgYellowBright.black(" yarn neeto-audit-frontend -a ")
+    );
+    process.exitCode = 1;
+  }
+};
+
+const getResults = async ({ verifiers, debug }) => {
+  let errors = [];
+  const results = verifiers.map(async ([name, verifier]) => {
+    const { isSuccess = false, error } = await verifier(debug);
+    !isSuccess && errors.push(error);
+
+    return { name, isSuccess };
+  });
+
+  const allResults = await Promise.all(results);
+
+  return { results: allResults, errors };
+};
+
+const runAutoFix = async ({ verifiers, autoFix, debug }) => {
+  const results = verifiers.map(async ([name, verifier]) => {
+    const spinner = ora({ text: name, spinner: "dots" });
+    const { error, fix } = await verifier(debug);
+
+    try {
+      spinner.start();
+      error && autoFix && (await fix(debug));
+      spinner.succeed(name);
+      return true;
+    } catch (errors) {
+      spinner.fail(name);
+      debug && console.log(errors);
+      return false;
+    }
+  });
+
+  const allResults = await Promise.all(results);
+
+  return allResults.every(identity);
+};
+
+export const getCliOptions = () => {
+  program
+    .usage("[OPTIONS]...")
+    .option("-d, --debug", "Runs in debug mode")
+    .option("-a, --auto-fix", "Automatically fixes the errors")
+    .parse(process.argv);
+
+  return program.opts();
+};
+
 export const getFileContent = async ({
   relativeFilePath = "",
   debug = false,
@@ -48,13 +113,6 @@ export const createOrReplaceFile = async ({
   }
 };
 
-export const renderErrors = (errors = [], isAutoFixFlagPresent = false) => {
-  console.log();
-  console.log(chalk.bgRed("ERRORS"));
-  console.log(chalk.red(` \u2022 ${errors.join("\n \u2022 ")}`));
-  if (!isAutoFixFlagPresent) process.exitCode = 1;
-};
-
 export const identicalFiles = async ({
   sourceFile = "",
   destinationFile = "",
@@ -156,3 +214,56 @@ export const createOrReplaceDirectoryFiles = async ({
     return null;
   }
 };
+
+export const runVerifiers = async ({ verifiers, autoFix, debug }) => {
+  const { results, errors } = await getResults({ verifiers, autoFix, debug });
+  const isErrorPresent = isNotEmpty(errors);
+
+  results.map(({ name, isSuccess }) => {
+    const resultText = isSuccess
+      ? chalk.bgGreen.black("PASS")
+      : chalk.bgRed.black("FAIL");
+    console.log(resultText, name);
+  });
+
+  isErrorPresent && renderErrors(errors, autoFix);
+
+  if (isErrorPresent && autoFix) {
+    console.log("\nRunning auto-fix:");
+    const result = await runAutoFix({ verifiers, autoFix, debug });
+    if (result) {
+      console.log("\n" + chalk.green("All issues have been fixed!"));
+    } else {
+      console.log(
+        "\n" +
+          chalk.red(
+            "We were not able to fix all issues. Please fix the issues manually."
+          )
+      );
+      process.exitCode = 1;
+    }
+  }
+  console.log();
+};
+
+export const getNanoType = async () => {
+  const git = simpleGit();
+  const { value: remoteOriginUrl } = await git.getConfig("remote.origin.url");
+
+  const projectName = remoteOriginUrl
+    .split("https://github.com/bigbinary/")
+    .at(1)
+    .split(".git")
+    .at(0);
+
+  return last(split("-", projectName));
+};
+
+export const getPackageJson = async (debug) => {
+  const packageJsonContent = await getFileContent({
+    relativeFilePath: PACKAGE_JSON_PATH,
+    debug,
+  });
+
+  return JSON.parse(packageJsonContent);
+};

package/src/verifiers/currentNodeVersion/index.js

@@ -1,6 +1,6 @@
-import { createOrReplaceFile, getFileContent } from "../../utils/index.js";
-import { NVMRC_FILE_PATH, REQUIRED_NODE_VERSION } from "./constants.js";
-import { getSemVer } from "./utils.js";
+import { NVMRC_FILE_PATH, REQUIRED_NODE_VERSION } from "./constants";
+import { createOrReplaceFile, getFileContent } from "../../utils";
+import { getSemVer } from "./utils";
 
 const currentNodeVersion = async (debug) => {
   const fix = async (debug) => {

package/src/verifiers/eslint/constants.js

@@ -1,7 +1,5 @@
 import path from "path";
 
-export const ESLINT_SOURCE_DIRECTORY = path.resolve(
-  "./node_modules/@bigbinary/neeto-audit-frontend/common/eslint"
-);
-
 export const ESLINT_DESTINATION_DIRECTORY = path.resolve("./");
+
+export const NANOS_TO_OVERRIDE = ["nano", "extension"];

package/src/verifiers/eslint/index.js

@@ -1,24 +1,34 @@
+import path from "path";
 import { identity } from "ramda";
+
 import {
   createOrReplaceDirectoryFiles,
+  getNanoType,
   identicalDirectoryFiles,
-} from "../../utils/index.js";
-import {
-  ESLINT_DESTINATION_DIRECTORY,
-  ESLINT_SOURCE_DIRECTORY,
-} from "./constants.js";
+} from "../../utils";
+import { ESLINT_DESTINATION_DIRECTORY, NANOS_TO_OVERRIDE } from "./constants";
 
 const eslint = async (debug) => {
+  const nanoType = await getNanoType();
+
+  const eslintCommonSource = NANOS_TO_OVERRIDE.includes(nanoType)
+    ? nanoType
+    : "common";
+
+  const eslintSourceDirectory = path.resolve(
+    `./node_modules/@bigbinary/neeto-audit-frontend/common/eslint/${eslintCommonSource}`
+  );
+
   const fix = async (debug) => {
     await createOrReplaceDirectoryFiles({
-      sourceDirectory: ESLINT_SOURCE_DIRECTORY,
+      sourceDirectory: eslintSourceDirectory,
       destinationDirectory: ESLINT_DESTINATION_DIRECTORY,
       debug,
     });
   };
 
   const eslintDirectory = await identicalDirectoryFiles({
-    sourceDirectory: ESLINT_SOURCE_DIRECTORY,
+    sourceDirectory: eslintSourceDirectory,
     destinationDirectory: ESLINT_DESTINATION_DIRECTORY,
     debug,
   });

package/src/verifiers/husky/constants.js

@@ -4,6 +4,10 @@ export const HUSKY_SOURCE_DIRECTORY = path.resolve(
   "./node_modules/@bigbinary/neeto-audit-frontend/common/.husky"
 );
 
+export const HUSKY_COMMON_SOURCE_DIRECTORY = path.resolve(
+  "./node_modules/@bigbinary/neeto-audit-frontend/common/.husky/common"
+);
+
 export const HUSKY_DESTINATION_DIRECTORY = path.resolve("./.husky");
 
 export const HUSKY_GIT_IGNORE_PATH = path.resolve("./.husky/.gitignore");

package/src/verifiers/husky/index.js

@@ -1,19 +1,33 @@
 import { identity } from "ramda";
+
 import {
   createOrReplaceDirectoryFiles,
   createOrReplaceFile,
+  getNanoType,
   identicalDirectoryFiles,
-} from "../../utils/index.js";
+} from "../../utils";
 import {
   HUSKY_DESTINATION_DIRECTORY,
   HUSKY_GIT_IGNORE_PATH,
   HUSKY_SOURCE_DIRECTORY,
-} from "./constants.js";
+  HUSKY_COMMON_SOURCE_DIRECTORY,
+} from "./constants";
 
 const husky = async (debug) => {
+  const nanoType = await getNanoType();
+
+  const nanoSourceDirectory = `${HUSKY_SOURCE_DIRECTORY}/${nanoType}`;
+
   const fix = async (debug) => {
     await createOrReplaceDirectoryFiles({
-      sourceDirectory: HUSKY_SOURCE_DIRECTORY,
+      sourceDirectory: HUSKY_COMMON_SOURCE_DIRECTORY,
+      destinationDirectory: HUSKY_DESTINATION_DIRECTORY,
+      debug,
+      options: { mode: 0o755 },
+    });
+
+    await createOrReplaceDirectoryFiles({
+      sourceDirectory: nanoSourceDirectory,
       destinationDirectory: HUSKY_DESTINATION_DIRECTORY,
       debug,
       options: { mode: 0o755 },
@@ -26,13 +40,22 @@ const husky = async (debug) => {
     });
   };
 
-  const huskyDirectory = await identicalDirectoryFiles({
-    sourceDirectory: HUSKY_SOURCE_DIRECTORY,
+  const huskyCommonDirectory = await identicalDirectoryFiles({
+    sourceDirectory: HUSKY_COMMON_SOURCE_DIRECTORY,
+    destinationDirectory: HUSKY_DESTINATION_DIRECTORY,
+    debug,
+  });
+
+  const huskyNanoDirectory = await identicalDirectoryFiles({
+    sourceDirectory: nanoSourceDirectory,
     destinationDirectory: HUSKY_DESTINATION_DIRECTORY,
     debug,
   });
 
-  const huskyFiles = await Promise.all(huskyDirectory);
+  const huskyFiles = await Promise.all([
+    ...huskyCommonDirectory,
+    ...huskyNanoDirectory,
+  ]);
 
   const isSuccess = huskyFiles.every(identity);
 

package/src/verifiers/index.js

@@ -1,9 +1,8 @@
-import currentNodeVersion from "./currentNodeVersion/index.js";
-
-import husky from "./husky/index.js";
-import prettier from "./prettier/index.js";
-import eslint from "./eslint/index.js";
-import recommendedPackageVersions from "./recommendedPackageVersions/index.js";
+import currentNodeVersion from "./currentNodeVersion";
+import eslint from "./eslint";
+import husky from "./husky";
+import prettier from "./prettier";
+import recommendedPackageVersions from "./recommendedPackageVersions";
 
 const verifiers = [
   ["Current node version", currentNodeVersion],

package/src/verifiers/prettier/constants.js

@@ -1,7 +1,3 @@
 import path from "path";
 
-export const PRETTIER_SOURCE_PATH = path.resolve(
-  "./node_modules/@bigbinary/neeto-audit-frontend/common/prettier"
-);
-
 export const PRETTIER_DESTINATION_PATH = path.resolve("./");

package/src/verifiers/prettier/index.js

@@ -1,24 +1,32 @@
+import path from "path";
 import { identity } from "ramda";
+
 import {
   createOrReplaceDirectoryFiles,
+  getNanoType,
   identicalDirectoryFiles,
-} from "../../utils/index.js";
-import {
-  PRETTIER_DESTINATION_PATH,
-  PRETTIER_SOURCE_PATH,
-} from "./constants.js";
+} from "../../utils";
+import { PRETTIER_DESTINATION_PATH } from "./constants";
 
 const prettier = async (debug) => {
+  const nanoType = await getNanoType();
+
+  const prettierCommonSource = nanoType === "extension" ? nanoType : "common";
+
+  const prettierSourceDirectory = path.resolve(
+    `./node_modules/@bigbinary/neeto-audit-frontend/common/prettier/${prettierCommonSource}`
+  );
+
   const fix = async (debug) => {
     await createOrReplaceDirectoryFiles({
-      sourceDirectory: PRETTIER_SOURCE_PATH,
+      sourceDirectory: prettierSourceDirectory,
       destinationDirectory: PRETTIER_DESTINATION_PATH,
       debug,
     });
   };
 
   const prettierDirectory = await identicalDirectoryFiles({
-    sourceDirectory: PRETTIER_SOURCE_PATH,
+    sourceDirectory: prettierSourceDirectory,
     destinationDirectory: PRETTIER_DESTINATION_PATH,
     debug,
   });

package/src/verifiers/recommendedPackageVersions/constants.js

@@ -2,8 +2,8 @@ import path from "path";
 
 export const PACKAGE_JSON_PATH = path.resolve("./package.json");
 
-export const DEPENDENCY_TYPES = [
-    "dependencies",
-    "peerDependencies",
-    "devDependencies",
-  ];
+export const DEPENDENCY_TYPES = {
+  dependencies: "",
+  devDependencies: "--dev",
+  peerDependencies: "--peer",
+};

package/src/verifiers/recommendedPackageVersions/index.js

@@ -1,38 +1,63 @@
-import { identity, isEmpty, mergeDeepRight } from "ramda";
+import { existsBy, isNotEmpty } from "@bigbinary/neeto-commons-frontend/pure";
+import { mergeDeepRight, objOf } from "ramda";
+
+import recommendedDependencies from "../../../common/recommendedDependencies";
+import { PACKAGE_JSON_PATH } from "../../constants";
 import {
+  createOrReplaceFile,
+  execute,
   getNanoType,
-  getOutdatedPackages,
   getPackageJson,
+} from "../../utils";
+import {
+  getInstallationCommands,
+  getOutdatedPackages,
   sortByKey,
-} from "./utils.js";
-import { createOrReplaceFile, execute } from "../../utils/index.js";
-import recommendedDependencies from "../../../common/recommendedDependencies/index.js";
-import { PACKAGE_JSON_PATH } from "./constants.js";
+} from "./utils";
 
 const recommendedPackageVersions = async (debug) => {
   const packageJson = await getPackageJson(debug);
 
-  const nanoType = getNanoType(packageJson);
+  const nanoType = await getNanoType();
 
-  const dependencyTypes = getOutdatedPackages(nanoType, packageJson);
+  const recommendedVersions = mergeDeepRight(
+    recommendedDependencies["common"],
+    recommendedDependencies[nanoType]
+  );
+
+  const packagesToUpdate = getOutdatedPackages(
+    recommendedVersions,
+    packageJson
+  );
 
   const fix = async (debug) => {
-    const recommendedVersions = recommendedDependencies[nanoType];
-    let newPackageJson = mergeDeepRight(packageJson, recommendedVersions);
+    let newPackageJson = mergeDeepRight(
+      packageJson,
+      objOf("peerDependencies", recommendedVersions.peerDependencies)
+    );
     newPackageJson = sortByKey(newPackageJson);
 
-    await createOrReplaceFile({
-      relativeFilePath: PACKAGE_JSON_PATH,
-      content: JSON.stringify(newPackageJson, null, 2),
-      debug,
-    });
+    isNotEmpty(recommendedVersions.peerDependencies) &&
+      (await createOrReplaceFile({
+        relativeFilePath: PACKAGE_JSON_PATH,
+        content: JSON.stringify(newPackageJson, null, 2),
+        debug,
+      }));
+
+    const commands = getInstallationCommands(
+      recommendedVersions,
+      packagesToUpdate
+    );
+
+    const results = commands.map((command) => command && execute(command));
 
-    await execute("yarn install --check-files");
+    return Promise.all(results);
   };
 
-  const isSuccess = dependencyTypes
-    .map(({ outdatedPackages }) => isEmpty(outdatedPackages))
-    .every(identity);
+  const isSuccess = !existsBy(
+    { outdatedPackages: isNotEmpty },
+    packagesToUpdate
+  );
 
   if (!isSuccess) {
     return {

package/src/verifiers/recommendedPackageVersions/utils.js

@@ -1,37 +1,26 @@
-import recommendedDependencies from "../../../common/recommendedDependencies/index.js";
-import { getFileContent } from "../../utils/index.js";
-import { DEPENDENCY_TYPES, PACKAGE_JSON_PATH } from "./constants.js";
-
 import {
   eqProps,
-  last,
   pickBy,
   mapObjIndexed,
   not,
-  split,
   map,
   is,
   fromPairs,
   toPairs,
+  isEmpty,
 } from "ramda";
+import { findBy } from "@bigbinary/neeto-commons-frontend/pure";
 
-export const getPackageJson = async (debug) => {
-  const packageJsonContent = await getFileContent({
-    relativeFilePath: PACKAGE_JSON_PATH,
-    debug,
-  });
-
-  return JSON.parse(packageJsonContent);
-};
+import { DEPENDENCY_TYPES } from "./constants";
 
-export const getNanoType = ({ name }) => last(split("-", name));
+export const getOutdatedPackages = (recommendedVersions, packageJson) =>
+  Object.keys(DEPENDENCY_TYPES).map((type) => {
+    const recommendedList = recommendedVersions[type];
 
-export const getOutdatedPackages = (nanoType, packageJson) =>
-  DEPENDENCY_TYPES.map((type) => {
-    const recommendedList = recommendedDependencies[nanoType][type];
+    const dependencyTypePackages = packageJson[type] ?? {};
 
     const packages = mapObjIndexed(
-      (_, key) => eqProps(key, recommendedList, packageJson[type]),
+      (_, key) => eqProps(key, recommendedList, dependencyTypePackages),
       recommendedList
     );
 
@@ -48,3 +37,18 @@ export const sortByKey = (object) =>
         : value,
     object
   );
+
+export const getInstallationCommands = (recommendPackages, packagesToUpdate) =>
+  Object.entries(recommendPackages).map(([type, packages]) => {
+    const { outdatedPackages } = findBy({ type }, packagesToUpdate);
+
+    if (isEmpty(outdatedPackages) || type === "peerDependencies") {
+      return;
+    }
+
+    const packagesWithVersion = outdatedPackages
+      .map((packageName) => `${packageName}@${packages[packageName]}`)
+      .join(" ");
+
+    return `yarn add ${DEPENDENCY_TYPES[type]} ${packagesWithVersion}`;
+  });