@bigbinary/neeto-audit-frontend 1.0.2

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@bigbinary/neeto-audit-frontend",
+  "version": "1.0.2",
+  "description": "Audits neeto frontend codebase for issues and suggests a fix.",
+  "type": "module",
+  "bin": "./dist/index.js",
+  "keywords": [
+    "neeto",
+    "audit",
+    "frontend"
+  ],
+  "scripts": {
+    "build": "rollup -c"
+  },
+  "author": "Thejus Paul <thejuspaul@protonmail.ch>",
+  "license": "UNLICENSED",
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "25.0.2",
+    "@rollup/plugin-json": "6.0.0",
+    "@rollup/plugin-node-resolve": "15.1.0",
+    "rollup": "3.26.2",
+    "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": {
+    "chalk": "5.3.0",
+    "commander": "11.0.0",
+    "ramda": "0.29.0"
+  },
+  "engines": {
+    "node": ">=18.16",
+    "pnpm": ">=8.6"
+  }
+}

package/rollup.config.js

@@ -0,0 +1,33 @@
+import path from "path";
+
+import cleaner from "rollup-plugin-cleaner";
+import analyze from "rollup-plugin-analyzer";
+import { nodeResolve } from "@rollup/plugin-node-resolve";
+import json from "@rollup/plugin-json";
+import commonjs from "@rollup/plugin-commonjs";
+import executableScript from "rollup-plugin-executable-script";
+
+const output = {
+  file: "dist/index.js",
+  format: "es",
+  name: "neetoAudit",
+};
+
+export default {
+  input: "./src/cli.js",
+  output,
+  plugins: [
+    // To clean dist directory.
+    cleaner({ targets: [path.resolve("./dist")] }),
+    // Analyze created bundle.
+    analyze({ summaryOnly: true }),
+    // Locates third party modules in node_modules.
+    nodeResolve({ exportConditions: ["node"] }),
+    // To convert CommonJS modules to ES6.
+    commonjs({ include: /node_modules/ }),
+    // To convert .json files to ES6 modules.
+    json(),
+    // To convert output file to an node executable file.
+    executableScript(),
+  ],
+};

package/src/cli.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import { renderErrors } from "./utils/index.js";
+import verifiers from "./verifiers/index.js";
+import chalk from "chalk";
+import { program } from "commander";
+
+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 } = 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!"));
+};
+
+run();

package/src/utils/index.js

@@ -0,0 +1,159 @@
+import chalk from "chalk";
+import { lstat, mkdir, readFile, writeFile } from "fs/promises";
+import path from "path";
+import { promises } from "fs";
+import util from "util";
+import { exec } from "child_process";
+import { identity } from "ramda";
+
+const run = util.promisify(exec);
+
+export const execute = async (command, debug) => {
+  const { stdout, stderr } = await run(command);
+  debug && console.log("stdout:", stdout);
+  debug && console.log("stderr:", stderr);
+};
+
+export const getFileContent = async ({
+  relativeFilePath = "",
+  debug = false,
+}) => {
+  const resolvedFilePath = path.resolve(relativeFilePath);
+
+  try {
+    return await readFile(resolvedFilePath, { encoding: "utf8" });
+  } catch (error) {
+    debug && console.error(error);
+    return null;
+  }
+};
+
+export const createOrReplaceFile = async ({
+  relativeFilePath = "",
+  content = "",
+  debug = false,
+  options = {},
+}) => {
+  const resolvedFilePath = path.resolve(relativeFilePath);
+
+  try {
+    return await writeFile(resolvedFilePath, content, {
+      encoding: "utf8",
+      flag: "w",
+      ...options,
+    });
+  } catch (error) {
+    debug && console.error(error);
+    return null;
+  }
+};
+
+export const renderErrors = (errors = [], isAutoFixFlagPresent = false) => {
+  console.log();
+  console.log(chalk.red("Errors:"));
+  console.log(chalk.red(`- ${errors.join("\n- ")}`));
+  console.log();
+  if (!isAutoFixFlagPresent) process.exitCode = 1;
+};
+
+export const identicalFiles = async ({
+  sourceFile = "",
+  destinationFile = "",
+  debug = false,
+}) => {
+  try {
+    const sourceFileContent = await readFile(sourceFile);
+    const destinationFileContent = await readFile(destinationFile);
+
+    const result = Buffer.compare(sourceFileContent, destinationFileContent);
+
+    return result === 0;
+  } catch (error) {
+    debug && console.error(error);
+    return false;
+  }
+};
+
+export const identicalDirectoryFiles = async ({
+  sourceDirectory,
+  destinationDirectory,
+  debug,
+}) => {
+  try {
+    const files = await promises.readdir(sourceDirectory);
+    await mkdir(destinationDirectory, { recursive: true });
+    const results = files.map(async (file) => {
+      const sourceFile = `${sourceDirectory}/${file}`;
+      const destinationFile = `${destinationDirectory}/${file}`;
+
+      const isFile = (await lstat(sourceFile)).isFile();
+
+      if (isFile) {
+        return await identicalFiles({
+          sourceFile,
+          destinationFile,
+          debug,
+        });
+      } else {
+        await mkdir(destinationFile, { recursive: true });
+        const identicalFiles = await identicalDirectoryFiles({
+          sourceDirectory: sourceFile,
+          destinationDirectory: destinationFile,
+          debug,
+        });
+
+        const results = await Promise.all(identicalFiles);
+
+        return results.every(identity);
+      }
+    });
+
+    return results;
+  } catch (error) {
+    debug && console.error(error);
+    return null;
+  }
+};
+
+export const createOrReplaceDirectoryFiles = async ({
+  sourceDirectory,
+  destinationDirectory,
+  debug,
+  options,
+}) => {
+  try {
+    const files = await promises.readdir(sourceDirectory);
+    await mkdir(destinationDirectory, { recursive: true });
+    files.forEach(async (file) => {
+      const sourcePath = `${sourceDirectory}/${file}`;
+      const destinationPath = `${destinationDirectory}/${file}`;
+
+      const isFile = (await lstat(sourcePath)).isFile();
+
+      if (isFile) {
+        const content = await getFileContent({
+          relativeFilePath: sourcePath,
+          debug,
+        });
+
+        await createOrReplaceFile({
+          relativeFilePath: destinationPath,
+          content,
+          debug,
+          options,
+        });
+      } else {
+        await mkdir(destinationPath, { recursive: true });
+        await createOrReplaceDirectoryFiles({
+          sourceDirectory: sourcePath,
+          destinationDirectory: destinationPath,
+          debug,
+          options,
+        });
+      }
+    });
+  } catch (error) {
+    debug && console.log(error);
+    return null;
+  }
+};

package/src/verifiers/currentNodeVersion/constants.js

@@ -0,0 +1,3 @@
+export const NVMRC_FILE_PATH = "./.nvmrc";
+
+export const REQUIRED_NODE_VERSION = { major: 18, minor: 0, patch: 0 };

package/src/verifiers/currentNodeVersion/index.js

@@ -0,0 +1,37 @@
+import { createOrReplaceFile, getFileContent } from "../../utils/index.js";
+import { NVMRC_FILE_PATH, REQUIRED_NODE_VERSION } from "./constants.js";
+import { getSemVer } from "./utils.js";
+
+const currentNodeVersion = async (debug) => {
+  const fix = async (debug) => {
+    await createOrReplaceFile({
+      relativeFilePath: NVMRC_FILE_PATH,
+      content: Object.values(REQUIRED_NODE_VERSION).join("."),
+      debug,
+    });
+  };
+
+  const nodeVersionFileContent = await getFileContent({
+    relativeFilePath: NVMRC_FILE_PATH,
+    debug,
+  });
+
+  if (!nodeVersionFileContent) {
+    return { error: "No file or content found in the .nvmrc file.", fix };
+  }
+
+  const [major = 0, minor = 0, patch = 0] = getSemVer(nodeVersionFileContent);
+
+  const isSuccess =
+    major === REQUIRED_NODE_VERSION.major &&
+    minor >= REQUIRED_NODE_VERSION.minor &&
+    patch >= REQUIRED_NODE_VERSION.patch;
+
+  if (!isSuccess) {
+    return { error: "There is a mismatch in the node version.", fix };
+  }
+
+  return { isSuccess };
+};
+
+export default currentNodeVersion;

package/src/verifiers/currentNodeVersion/utils.js

@@ -0,0 +1,5 @@
+export const getSemVer = (version) =>
+  version
+    .trim()
+    .split(".")
+    .map((value) => parseInt(value, 10));

package/src/verifiers/eslint/constants.js

@@ -0,0 +1,7 @@
+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("./");

package/src/verifiers/eslint/index.js

@@ -0,0 +1,37 @@
+import { identity } from "ramda";
+import {
+  createOrReplaceDirectoryFiles,
+  identicalDirectoryFiles,
+} from "../../utils/index.js";
+import {
+  ESLINT_DESTINATION_DIRECTORY,
+  ESLINT_SOURCE_DIRECTORY,
+} from "./constants.js";
+
+const eslint = async (debug) => {
+  const fix = async (debug) => {
+    await createOrReplaceDirectoryFiles({
+      sourceDirectory: ESLINT_SOURCE_DIRECTORY,
+      destinationDirectory: ESLINT_DESTINATION_DIRECTORY,
+      debug,
+    });
+  };
+
+  const eslintDirectory = await identicalDirectoryFiles({
+    sourceDirectory: ESLINT_SOURCE_DIRECTORY,
+    destinationDirectory: ESLINT_DESTINATION_DIRECTORY,
+    debug,
+  });
+
+  const eslintFiles = await Promise.all(eslintDirectory);
+
+  const isSuccess = eslintFiles.every(identity);
+
+  if (!isSuccess) {
+    return { error: "ESLint and its related files are not present.", fix };
+  }
+
+  return { isSuccess };
+};
+
+export default eslint;

package/src/verifiers/husky/constants.js

@@ -0,0 +1,9 @@
+import path from "path";
+
+export const HUSKY_SOURCE_DIRECTORY = path.resolve(
+  "./node_modules/@bigbinary/neeto-audit-frontend/common/.husky"
+);
+
+export const HUSKY_DESTINATION_DIRECTORY = path.resolve("./.husky");
+
+export const HUSKY_GIT_IGNORE_PATH = path.resolve("./.husky/.gitignore");

package/src/verifiers/husky/index.js

@@ -0,0 +1,46 @@
+import { identity } from "ramda";
+import {
+  createOrReplaceDirectoryFiles,
+  createOrReplaceFile,
+  identicalDirectoryFiles,
+} from "../../utils/index.js";
+import {
+  HUSKY_DESTINATION_DIRECTORY,
+  HUSKY_GIT_IGNORE_PATH,
+  HUSKY_SOURCE_DIRECTORY,
+} from "./constants.js";
+
+const husky = async (debug) => {
+  const fix = async (debug) => {
+    await createOrReplaceDirectoryFiles({
+      sourceDirectory: HUSKY_SOURCE_DIRECTORY,
+      destinationDirectory: HUSKY_DESTINATION_DIRECTORY,
+      debug,
+      options: { mode: 0o755 },
+    });
+
+    await createOrReplaceFile({
+      relativeFilePath: HUSKY_GIT_IGNORE_PATH,
+      content: "_\n",
+      debug,
+    });
+  };
+
+  const huskyDirectory = await identicalDirectoryFiles({
+    sourceDirectory: HUSKY_SOURCE_DIRECTORY,
+    destinationDirectory: HUSKY_DESTINATION_DIRECTORY,
+    debug,
+  });
+
+  const huskyFiles = await Promise.all(huskyDirectory);
+
+  const isSuccess = huskyFiles.every(identity);
+
+  if (!isSuccess) {
+    return { error: "Some husky helper files are not present.", fix };
+  }
+
+  return { isSuccess };
+};
+
+export default husky;

package/src/verifiers/index.js

@@ -0,0 +1,16 @@
+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";
+
+const verifiers = [
+  ["Current node version", currentNodeVersion],
+  ["Use recommended package versions", recommendedPackageVersions],
+  ["Husky and its helper files", husky],
+  ["Prettier and its helper files", prettier],
+  ["ESLint configuration file", eslint],
+];
+
+export default verifiers;

package/src/verifiers/prettier/constants.js

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,40 @@
+import { identity } from "ramda";
+import {
+  createOrReplaceDirectoryFiles,
+  identicalDirectoryFiles,
+} from "../../utils/index.js";
+import {
+  PRETTIER_DESTINATION_PATH,
+  PRETTIER_SOURCE_PATH,
+} from "./constants.js";
+
+const prettier = async (debug) => {
+  const fix = async (debug) => {
+    await createOrReplaceDirectoryFiles({
+      sourceDirectory: PRETTIER_SOURCE_PATH,
+      destinationDirectory: PRETTIER_DESTINATION_PATH,
+      debug,
+    });
+  };
+
+  const prettierDirectory = await identicalDirectoryFiles({
+    sourceDirectory: PRETTIER_SOURCE_PATH,
+    destinationDirectory: PRETTIER_DESTINATION_PATH,
+    debug,
+  });
+
+  const prettierFiles = await Promise.all(prettierDirectory);
+
+  const isSuccess = prettierFiles.every(identity);
+
+  if (!isSuccess) {
+    return {
+      error: "There are some discrepancy in the prettier configurations.",
+      fix,
+    };
+  }
+
+  return { isSuccess };
+};
+
+export default prettier;

package/src/verifiers/recommendedPackageVersions/constants.js

@@ -0,0 +1,9 @@
+import path from "path";
+
+export const PACKAGE_JSON_PATH = path.resolve("./package.json");
+
+export const DEPENDENCY_TYPES = [
+    "dependencies",
+    "peerDependencies",
+    "devDependencies",
+  ];

package/src/verifiers/recommendedPackageVersions/index.js

@@ -0,0 +1,41 @@
+import { identity, isEmpty, mergeDeepRight } from "ramda";
+import { getNanoType, getOutdatedPackages, getPackageJson } from "./utils.js";
+import { createOrReplaceFile, execute } from "../../utils/index.js";
+import recommendedDependencies from "../../../common/recommendedDependencies/index.js";
+import { PACKAGE_JSON_PATH } from "./constants.js";
+
+const recommendedPackageVersions = async (debug) => {
+  const packageJson = await getPackageJson(debug);
+
+  const nanoType = getNanoType(packageJson);
+
+  const dependencyTypes = getOutdatedPackages(nanoType, packageJson);
+
+  const fix = async (debug) => {
+    const recommendedVersions = recommendedDependencies[nanoType];
+    const newPackageJson = mergeDeepRight(packageJson, recommendedVersions);
+
+    await createOrReplaceFile({
+      relativeFilePath: PACKAGE_JSON_PATH,
+      content: JSON.stringify(newPackageJson, null, 2),
+      debug,
+    });
+
+    await execute("yarn install --check-files");
+  };
+
+  const isSuccess = dependencyTypes
+    .map(({ outdatedPackages }) => isEmpty(outdatedPackages))
+    .every(identity);
+
+  if (!isSuccess) {
+    return {
+      error: "The dependency packages are not using the recommended versions.",
+      fix,
+    };
+  }
+
+  return { isSuccess };
+};
+
+export default recommendedPackageVersions;

package/src/verifiers/recommendedPackageVersions/utils.js

@@ -0,0 +1,30 @@
+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 } from "ramda";
+
+export const getPackageJson = async (debug) => {
+  const packageJsonContent = await getFileContent({
+    relativeFilePath: PACKAGE_JSON_PATH,
+    debug,
+  });
+
+  return JSON.parse(packageJsonContent);
+};
+
+export const getNanoType = ({ name }) => last(split("-", name));
+
+export const getOutdatedPackages = (nanoType, packageJson) =>
+  DEPENDENCY_TYPES.map((type) => {
+    const recommendedList = recommendedDependencies[nanoType][type];
+
+    const packages = mapObjIndexed(
+      (_, key) => eqProps(key, recommendedList, packageJson[type]),
+      recommendedList
+    );
+
+    const outdatedPackages = pickBy(not, packages);
+
+    return { type, outdatedPackages: Object.keys(outdatedPackages) };
+  });