@pinnacle0/pnpm-single-version 1.0.0

package/README.md

@@ -0,0 +1,74 @@
+# pnpm single version
+
+Enforce Single version of dependencies on pnpm workspace.
+
+## Installation
+
+```bash
+pnpm add -D pnpm-single-version
+```
+
+## Usage
+
+Add following options to `package.json` in project root
+
+```json5
+"pnpmSingleVersion": {
+    "includes": [
+        // Place all the single version dependencies here
+        "@babel/core",
+        "esbuild",
+        // glob is also supported
+        "eslint-plugin-*",
+        "*-plugin",
+    ]
+}
+```
+
+### Maunal Checking using CLI
+
+You can `pnpm-single-version` in Terminal
+
+```bash
+pnpm pnpm-single-version
+```
+
+or
+
+```bash
+pnpm psv
+```
+
+### Automatic resolve (Recommanded)
+
+Apart from manual checking, checking can also be done when `pnpm-lock.yaml` is resolved, where pnpm detected dependencies changes running `pnpm install` , `pnpm update` and `pnpm removed`. This is much effective.
+
+By using `afterAllResolved` hook in `.pnpmfile.cjs`, installation process can be interrupted when non-single version dependencies is detected.
+
+To setup it up,
+
+1. First, install checker via
+
+    ```shell
+    pnpm pnpm-single-version install
+    ```
+
+    this command will generate a checker file inside `.psv` directory of the root directory of workspace.
+
+2. Then you should create a `.pnpmfile.cjs` and add following code
+
+    ```js
+    const hook = require("./.psv/hook");
+
+    module.exports = {
+        hooks: {
+            afterAllResolved: hook,
+        },
+    };
+    ```
+
+Now, when you call `pnpm install` and `pnpm update`, checking is going to be involve automatically only when have dependenices changes.
+
+**PS: You may need to run `psv install` every time you update `pnpm-single-version`**
+
+More about `.pnpmfile.cjs` at https://pnpm.io/pnpmfile

package/dist/checker/error-message.js

@@ -0,0 +1,47 @@
+import chalk from "chalk";
+const Emoji = {
+    sad: "😔",
+    cross: "❌",
+    happy: "🤗"
+};
+const headerMessage = (num)=>`${Emoji.cross} Found ${chalk.redBright(num)} Non-single version dependencies\n`;
+const listVersionMessage = (name, infos)=>`
+    - ${chalk.blueBright(name)} has ${chalk.redBright(infos.length)} distinct versions 
+      ${infos.map((_)=>{
+        var __peersSuffix;
+        return _.version + ((__peersSuffix = _.peersSuffix) !== null && __peersSuffix !== void 0 ? __peersSuffix : "");
+    }).join(", ")}
+`;
+const hintMessage = `
+Well, here is what you can try to do:
+Run ${chalk.blueBright(`$ pnpm why <dependency> -r `)} on project root to figure out the dependencies that contain conflicted version. 
+If the output is too long, try to redirect output, like ${chalk.blueBright(`$ pnpm why <dependency> -r > example.txt`)}
+more about ${chalk.blueBright(`$ pnpm why`)} command, check out ${chalk.greenBright("https://pnpm.io/cli/why")} 
+`;
+export function createErrorMessage(nonSingleVersionDeps) {
+    if (nonSingleVersionDeps.size === 0) {
+        return null;
+    }
+    let message = headerMessage(nonSingleVersionDeps.size);
+    for (const [name, infos] of nonSingleVersionDeps.entries()){
+        message += listVersionMessage(name, infos);
+    }
+    message += hintMessage;
+    return message;
+}
+export const logInstallationInterruptedMessage = (logger)=>{
+    logger.message(`${Emoji.sad} ${chalk.red("Installation Process interrupted.")}`);
+};
+/**
+ *
+ * @param {string | null} message
+ * @returns {boolean} Any Error message logged
+ */ export const logErrorMessage = (logger)=>(message)=>{
+        if (!message) {
+            logger.message(`${Emoji.happy} All Passed!!!`);
+            return false;
+        } else {
+            logger.message(message);
+            return true;
+        }
+    };

package/dist/checker/index.js

@@ -0,0 +1,33 @@
+import { nameVerFromPkgSnapshot } from "@pnpm/lockfile-utils";
+import { pipe } from "../util/pipe.js";
+import { ArrayValueMapHelper } from "../util/array-value-map-Helper.js";
+import { LockfilePackagesMissingError } from "../error.js";
+import { globUtil } from "../util/glob-util.js";
+import { createErrorMessage, logErrorMessage } from "./error-message.js";
+export const filterNonSingleVersionDependencies = (packageInfoMap)=>{
+    const nonSingleVersionPackageInfo = new Map();
+    for (const [path, snapshots] of packageInfoMap.entries()){
+        if (snapshots.length > 1) {
+            nonSingleVersionPackageInfo.set(path, snapshots);
+        }
+    }
+    return nonSingleVersionPackageInfo;
+};
+const filterSnapshotNeededForChecking = (snapshots)=>(depsPattern)=>{
+        const matcher = globUtil.toRegex(depsPattern);
+        const packageInfos = ArrayValueMapHelper.create();
+        for (const [path, snapshot] of Object.entries(snapshots)){
+            const nameVersionInfo = nameVerFromPkgSnapshot(path, snapshot);
+            if (matcher.test(nameVersionInfo.name)) {
+                ArrayValueMapHelper.add(packageInfos, nameVersionInfo.name, nameVersionInfo);
+            }
+        }
+        return packageInfos;
+    };
+export const checker = (lockfile, options, logger)=>{
+    if (!lockfile.packages) {
+        throw new LockfilePackagesMissingError();
+    }
+    logger.message("Verify single version dependencies...");
+    return pipe(filterSnapshotNeededForChecking(lockfile.packages), filterNonSingleVersionDependencies, createErrorMessage, logErrorMessage(logger))(options.includes);
+};

package/dist/command/checkDeps.js

@@ -0,0 +1,62 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+import { readWantedLockfile } from "@pnpm/lockfile-file";
+import { Logger } from "../util/logger.js";
+import isCI from "is-ci";
+import { checker } from "../checker/index.js";
+import { parseOptions } from "../parser-option/parse-option.js";
+import { findProjectRoot } from "../parser-option/find-project-root.js";
+import chalk from "chalk";
+import { logInstallationInterruptedMessage } from "../checker/error-message.js";
+export const checkDeps = function() {
+    var _ref = _async_to_generator(function*() {
+        try {
+            const projectRoot = yield findProjectRoot();
+            const options = yield parseOptions(projectRoot);
+            const lockfile = yield readWantedLockfile(projectRoot, {
+                ignoreIncompatible: false
+            });
+            if (!lockfile) {
+                Logger.message(`Cannot find ${chalk.blueBright("pnpm-lock.yaml")}, try to run ${chalk.blueBright("$ pnpm install")} first`);
+                process.exit(1);
+            }
+            if (checker(lockfile, options, Logger) && options.failOnCI && isCI) {
+                logInstallationInterruptedMessage(Logger);
+                process.exit(1);
+            }
+        } catch (error) {
+            error instanceof Error ? Logger.error(error) : console.error("Unexpected error", error);
+            process.exit(1);
+        }
+    });
+    return function checkDeps() {
+        return _ref.apply(this, arguments);
+    };
+}();

package/dist/command/index.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "./setup.js";

package/dist/command/install.js

@@ -0,0 +1,51 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+import fs from "fs";
+import path from "path";
+import { findProjectRoot } from "../parser-option/find-project-root.js";
+import { Logger } from "../util/logger.js";
+export const install = function() {
+    var _ref = _async_to_generator(function*() {
+        const root = yield findProjectRoot();
+        const psvDotFolderPath = path.join(root, ".psv");
+        if (fs.existsSync(psvDotFolderPath)) {
+            fs.rmSync(psvDotFolderPath, {
+                force: true,
+                recursive: true
+            });
+        }
+        fs.mkdirSync(psvDotFolderPath);
+        fs.copyFileSync(path.join(import.meta.dirname, "../hook-bundle.js"), path.join(psvDotFolderPath, "hook.js"));
+        Logger.message("installed .psv");
+    });
+    return function install() {
+        return _ref.apply(this, arguments);
+    };
+}();

package/dist/command/pnpmfile/.pnpmfile.cjs

@@ -0,0 +1,7 @@
+const hook = require('./.psv/hook')
+
+module.exports = {
+    hooks: {
+        afterAllResolved: hook
+    }
+}

package/dist/command/pnpmfile/hook.js

@@ -0,0 +1,2 @@
+import { hook } from "../../hook.js";
+export default hook;

package/dist/command/setup.js

@@ -0,0 +1,13 @@
+import { Command } from "commander";
+import { checkDeps } from "./checkDeps.js";
+import { install } from "./install.js";
+import packageJSON from "../../package.json" with {
+    type: "json"
+};
+const program = new Command();
+program.name("pnpm-single-version").alias("psv").version(packageJSON.version);
+program.command("check", {
+    isDefault: true
+}).description("Verify single version dependencies").action(checkDeps);
+program.command("install").description("Install the checker file into .psv").action(install);
+program.parse();

package/dist/constant.js

@@ -0,0 +1,2 @@
+export const PACKAGE_JSON_OPTIONS_KEY = 'pnpmSingleVersion';
+export const APP_NAME = 'Single Version Checker';

package/dist/error.js

@@ -0,0 +1,37 @@
+import chalk from "chalk";
+import { PACKAGE_JSON_OPTIONS_KEY } from "./constant.js";
+export class ProjectRootError extends Error {
+    constructor(){
+        super("Can not find project root");
+        this.name = "ProjectRootError";
+    }
+}
+export class PackageJsonNotFoundError extends Error {
+    constructor(){
+        super(`Unable to read package.json of root project `);
+        this.name = "PackageJsonNotFoundError";
+    }
+}
+export class OptionNotFoundError extends Error {
+    constructor(){
+        super(`Unable to find option ${chalk.blueBright(`'${PACKAGE_JSON_OPTIONS_KEY}'`)} in package.json of root project `);
+        this.name = "OptionsNotFound";
+    }
+}
+export class OptionSyntaxError extends Error {
+    constructor(message){
+        super(`Invalid option: ${message}`);
+        this.name = "OptionSyntaxError";
+    }
+}
+export class LockFileError extends Error {
+    constructor(){
+        super("Unable to read lock file");
+    }
+}
+export class LockfilePackagesMissingError extends Error {
+    constructor(){
+        super(`'packages' in lockfile is missing`);
+        this.name = "LockfilePackagesMissingError";
+    }
+}