@pinnacle0/pnpm-single-version 1.0.0

package/dist/util/glob-util.js

@@ -0,0 +1,16 @@
+import { minimatch } from "minimatch";
+function isMatch(target, patterns) {
+    let matched = false;
+    for (const pattern of patterns){
+        matched = minimatch(target, pattern);
+        if (matched) return matched;
+    }
+    return matched;
+}
+function toRegex(patterns) {
+    return new RegExp(patterns.map((_)=>minimatch.makeRe(_)).filter((_)=>_ !== false).map((_)=>_.source).join("|"));
+}
+export const globUtil = Object.freeze({
+    isMatch,
+    toRegex
+});

package/dist/util/logger.js

@@ -0,0 +1,19 @@
+import chalk from "chalk";
+import { APP_NAME } from "../constant.js";
+export function createCheckerMessage(message) {
+    return chalk.magenta(APP_NAME + ": ") + message;
+}
+function debug(object) {
+    console.info(object);
+}
+function message(value) {
+    console.info(createCheckerMessage(value));
+}
+function error(error) {
+    console.info(createCheckerMessage(`${chalk.bgRed(" ERROR ")} ${error.message}`));
+}
+export const Logger = Object.freeze({
+    debug,
+    message,
+    error
+});

package/dist/util/pipe.js

@@ -0,0 +1,3 @@
+export function pipe(...fns) {
+    return (initial)=>fns.reduce((p, f)=>f(p), initial);
+}

package/dist/util/pnpm-logger.js

@@ -0,0 +1,15 @@
+import { createCheckerMessage } from "./logger.js";
+import { hookLogger } from "@pnpm/core-loggers";
+function message(value) {
+    hookLogger.info({
+        message: createCheckerMessage(value),
+        prefix: ""
+    });
+}
+function error(error) {
+    hookLogger.error(error);
+}
+export const pnpmLogger = Object.freeze({
+    message,
+    error
+});

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@pinnacle0/pnpm-single-version",
+  "version": "1.0.0",
+  "author": "Pinnacle",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pinnacle0/frontend-libraries.git",
+    "directory": "packages/pnpm-single-version"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "bin": {
+    "pnpm-single-version": "./dist/command/index.js",
+    "psv": "./dist/command/index.js"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "dependencies": {
+    "@pnpm/find-workspace-dir": "1000.1.0",
+    "@pnpm/lockfile-file": "9.1.3",
+    "@pnpm/lockfile-utils": "11.0.4",
+    "@pnpm/logger": "1000.0.0",
+    "@pnpm/core-loggers": "1000.1.5",
+    "chalk": "5.4.1",
+    "commander": "10.0.1",
+    "find-up": "5.0.0",
+    "is-ci": "3.0.1",
+    "minimatch": "10.0.1"
+  },
+  "devDependencies": {
+    "@swc/cli": "0.1.62",
+    "@swc/core": "1.4.4",
+    "@types/is-ci": "^3.0.0",
+    "@types/minimatch": "5.1.2",
+    "@types/node": "22.10.1",
+    "esbuild": "0.18.15",
+    "@pinnacle0/devtool-util": "1.3.2"
+  },
+  "scripts": {
+    "build": "pnpm run test && pnpm tsx script/build.ts",
+    "test": "vitest --config config/vitest.config.ts --run"
+  }
+}

package/src/checker/error-message.ts

@@ -0,0 +1,58 @@
+import chalk from "chalk";
+import type {LoggerType, PackageInfo} from "../type.js";
+
+const Emoji = {
+    sad: "😔",
+    cross: "❌",
+    happy: "🤗",
+};
+
+const headerMessage = (num: number) => `${Emoji.cross} Found ${chalk.redBright(num)} Non-single version dependencies\n`;
+
+const listVersionMessage = (name: string, infos: PackageInfo[]): string =>
+    `
+    - ${chalk.blueBright(name)} has ${chalk.redBright(infos.length)} distinct versions 
+      ${infos.map(_ => _.version + (_.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: Map<string, PackageInfo[]>): string | null {
+    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: LoggerType) => {
+    logger.message(`${Emoji.sad} ${chalk.red("Installation Process interrupted.")}`);
+};
+
+/**
+ *
+ * @param {string | null} message
+ * @returns {boolean} Any Error message logged
+ */
+export const logErrorMessage =
+    (logger: LoggerType) =>
+    (message: string | null): boolean => {
+        if (!message) {
+            logger.message(`${Emoji.happy} All Passed!!!`);
+            return false;
+        } else {
+            logger.message(message);
+            return true;
+        }
+    };

package/src/checker/index.ts

@@ -0,0 +1,46 @@
+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";
+import type {CheckerOptions, LoggerType, PackageInfo} from "../type.js";
+import type {Lockfile, PackageSnapshots} from "@pnpm/lockfile-utils";
+
+export const filterNonSingleVersionDependencies = (packageInfoMap: Map<string, PackageInfo[]>): Map<string, PackageInfo[]> => {
+    const nonSingleVersionPackageInfo = new Map<string, PackageInfo[]>();
+
+    for (const [path, snapshots] of packageInfoMap.entries()) {
+        if (snapshots.length > 1) {
+            nonSingleVersionPackageInfo.set(path, snapshots);
+        }
+    }
+
+    return nonSingleVersionPackageInfo;
+};
+
+const filterSnapshotNeededForChecking =
+    (snapshots: PackageSnapshots) =>
+    (depsPattern: string[]): Map<string, PackageInfo[]> => {
+        const matcher = globUtil.toRegex(depsPattern);
+        const packageInfos = ArrayValueMapHelper.create<PackageInfo>();
+
+        for (const [path, snapshot] of Object.entries(snapshots)) {
+            const nameVersionInfo: PackageInfo = nameVerFromPkgSnapshot(path, snapshot);
+            if (matcher.test(nameVersionInfo.name)) {
+                ArrayValueMapHelper.add(packageInfos, nameVersionInfo.name, nameVersionInfo);
+            }
+        }
+
+        return packageInfos;
+    };
+
+export const checker = (lockfile: Lockfile, options: CheckerOptions, logger: LoggerType) => {
+    if (!lockfile.packages) {
+        throw new LockfilePackagesMissingError();
+    }
+
+    logger.message("Verify single version dependencies...");
+
+    return pipe(filterSnapshotNeededForChecking(lockfile.packages), filterNonSingleVersionDependencies, createErrorMessage, logErrorMessage(logger))(options.includes);
+};

package/src/command/checkDeps.ts

@@ -0,0 +1,27 @@
+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 = async () => {
+    try {
+        const projectRoot = await findProjectRoot();
+        const options = await parseOptions(projectRoot);
+        const lockfile = await 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);
+    }
+};

package/src/command/index.ts

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

package/src/command/install.ts

@@ -0,0 +1,17 @@
+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 = async () => {
+    const root = await 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");
+};

package/src/command/pnpmfile/.pnpmfile.cjs

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

package/src/command/pnpmfile/hook.ts

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

package/src/command/setup.ts

@@ -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/src/constant.ts

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

package/src/error.ts

@@ -0,0 +1,43 @@
+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: string) {
+        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";
+    }
+}

package/src/hook.ts

@@ -0,0 +1,23 @@
+import type {Lockfile} from "@pnpm/lockfile-file";
+import {checker} from "./checker/index.js";
+import {parseOptions} from "./parser-option/parse-option.js";
+import {findProjectRoot} from "./parser-option/find-project-root.js";
+import {pnpmLogger} from "./util/pnpm-logger.js";
+import {logInstallationInterruptedMessage} from "./checker/error-message.js";
+import {logger} from "@pnpm/logger";
+
+export const hook = async (lockfile: Lockfile) => {
+    try {
+        const logger = pnpmLogger;
+        const projectRoot = await findProjectRoot();
+        const options = await parseOptions(projectRoot);
+        if (checker(lockfile, options, logger)) {
+            logInstallationInterruptedMessage(logger);
+            process.exit(1);
+        }
+        return lockfile;
+    } catch (error) {
+        error instanceof Error ? logger.error(error) : console.error("Unexpected error", error);
+        process.exit(1);
+    }
+};

package/src/index.ts

@@ -0,0 +1,3 @@
+import {hook} from "./hook.js";
+
+export const checkSingleVersion = hook;

package/src/parser-option/find-project-root.ts

@@ -0,0 +1,22 @@
+import {findWorkspaceDir} from "@pnpm/find-workspace-dir";
+import {realpath} from "fs/promises";
+import findUp from "find-up";
+import {ProjectRootError} from "../error.js";
+import path from "path";
+
+/**
+ * Can find the root path of the package and monorepo
+ */
+export const findProjectRoot = async (): Promise<string> => {
+    let projectRoot = await findWorkspaceDir(process.cwd());
+    if (!projectRoot) {
+        const packageJSONPath = await findUp("package.json", {cwd: await realpath(process.cwd())});
+        projectRoot = packageJSONPath ? path.parse(packageJSONPath).dir : undefined;
+    }
+
+    if (!projectRoot) {
+        throw new ProjectRootError();
+    }
+
+    return projectRoot;
+};

package/src/parser-option/parse-option.ts

@@ -0,0 +1,38 @@
+import fs from "fs/promises";
+import path from "path";
+import {TextDecoder} from "util";
+import {PACKAGE_JSON_OPTIONS_KEY} from "../constant.js";
+import {OptionNotFoundError, OptionSyntaxError} from "../error.js";
+import type {CheckerOptions} from "../type.js";
+
+const validateOptions = (options: any): CheckerOptions => {
+    if (!options || typeof options !== "object") {
+        throw new OptionNotFoundError();
+    }
+
+    const o = options as Partial<CheckerOptions>;
+
+    if (!Array.isArray(o?.includes)) {
+        throw new OptionSyntaxError("Please make sure you have included single version dependencies in option.");
+    }
+
+    if (o?.failOnCI !== undefined && typeof o.failOnCI !== "boolean") {
+        throw new OptionSyntaxError("Please use boolean for failedOnCI option");
+    }
+
+    return options as CheckerOptions;
+};
+
+export const parseOptions = async (projectRoot: string): Promise<CheckerOptions> => {
+    const packageJsonfile = await fs.readFile(path.join(projectRoot, "package.json"));
+    // @see https://github.dev/sindresorhus/load-json-file
+    const packageJSON = JSON.parse(new TextDecoder().decode(packageJsonfile));
+
+    const options = validateOptions((packageJSON as any)?.[PACKAGE_JSON_OPTIONS_KEY]);
+
+    if (options.failOnCI === undefined) {
+        options.failOnCI = true;
+    }
+
+    return options;
+};

package/src/type.ts

@@ -0,0 +1,17 @@
+import type {nameVerFromPkgSnapshot} from "@pnpm/lockfile-utils";
+
+export interface CheckerOptions {
+    includes: string[];
+    /**
+     * default: true
+     * In CI env, exit with status code 1 when checker found multiple version on specified dependencies.
+     */
+    failOnCI?: boolean;
+}
+
+export interface LoggerType {
+    error(error: Error): void;
+    message(value: string): void;
+}
+
+export type PackageInfo = ReturnType<typeof nameVerFromPkgSnapshot>;

package/src/util/array-value-map-Helper.ts

@@ -0,0 +1,19 @@
+type ArrayValueMap<Value, Key = string> = Map<Key, Value[]>
+
+function get<Value, Key = string>(map: ArrayValueMap<Value, Key>, key: Key): Value[] {
+    return map.get(key) ?? []
+}
+
+function add<Value, Key = string>(map: ArrayValueMap<Value, Key>, key: Key, value: Value): void {
+    map.set(key, [...get(map, key), value])
+}
+
+function create<Value, Key = string>(): Map<Key, Value[]> {
+    return new Map()
+}
+
+export const ArrayValueMapHelper = Object.freeze({
+    add,
+    get,
+    create
+})

package/src/util/glob-util.ts

@@ -0,0 +1,25 @@
+import {minimatch} from "minimatch";
+
+function isMatch(target: string, patterns: string[]): boolean {
+    let matched = false;
+    for (const pattern of patterns) {
+        matched = minimatch(target, pattern);
+        if (matched) return matched;
+    }
+    return matched;
+}
+
+function toRegex(patterns: string[]): RegExp {
+    return new RegExp(
+        patterns
+            .map(_ => minimatch.makeRe(_))
+            .filter((_): _ is RegExp => _ !== false)
+            .map(_ => _.source)
+            .join("|")
+    );
+}
+
+export const globUtil = Object.freeze({
+    isMatch,
+    toRegex,
+});

package/src/util/logger.ts

@@ -0,0 +1,24 @@
+import chalk from "chalk";
+import {APP_NAME} from "../constant.js";
+
+export function createCheckerMessage(message: string): string {
+    return chalk.magenta(APP_NAME + ": ") + message;
+}
+
+function debug(object: object) {
+    console.info(object);
+}
+
+function message(value: string) {
+    console.info(createCheckerMessage(value));
+}
+
+function error(error: Error) {
+    console.info(createCheckerMessage(`${chalk.bgRed(" ERROR ")} ${error.message}`));
+}
+
+export const Logger = Object.freeze({
+    debug,
+    message,
+    error,
+});

package/src/util/pipe.ts

@@ -0,0 +1,43 @@
+type OperationFunction<P, R> = (value: P) => R
+
+export function pipe<P, A>(op1: OperationFunction<P, A>): (initial: P) => A
+export function pipe<P, A, B>(op1: OperationFunction<P, A>, op2: OperationFunction<A, B>): (initial?: P) => B
+export function pipe<P, A, B, C>(
+    op1: OperationFunction<P, A>,
+    op2: OperationFunction<A, B>,
+    op3: OperationFunction<B, C>
+): (initial?: P) => C
+export function pipe<P, A, B, C, D>(
+    op1: OperationFunction<P, A>,
+    op2: OperationFunction<A, B>,
+    op3: OperationFunction<B, C>,
+    op4: OperationFunction<C, D>
+): (initial?: P) => D
+export function pipe<P, A, B, C, D, E>(
+    op1: OperationFunction<P, A>,
+    op2: OperationFunction<A, B>,
+    op3: OperationFunction<B, C>,
+    op4: OperationFunction<C, D>,
+    op5: OperationFunction<D, E>
+): (initial?: P) => E
+export function pipe<P, A, B, C, D, E, F>(
+    op1: OperationFunction<P, A>,
+    op2: OperationFunction<A, B>,
+    op3: OperationFunction<B, C>,
+    op4: OperationFunction<C, D>,
+    op5: OperationFunction<D, E>,
+    op6: OperationFunction<E, F>
+): (initial?: P) => F
+export function pipe<P, A, B, C, D, E, F, G>(
+    op1: OperationFunction<P, A>,
+    op2: OperationFunction<A, B>,
+    op3: OperationFunction<B, C>,
+    op4: OperationFunction<C, D>,
+    op5: OperationFunction<D, E>,
+    op6: OperationFunction<E, F>,
+    op7: OperationFunction<F, G>
+): (initial?: P) => G
+export function pipe(...ops: Array<OperationFunction<any, any>>): (initial?: any) => any
+export function pipe(...fns: any[]) {
+    return (initial: any) => fns.reduce((p, f) => f(p), initial)
+}

package/src/util/pnpm-logger.ts

@@ -0,0 +1,15 @@
+import {createCheckerMessage} from "./logger.js";
+import {hookLogger} from "@pnpm/core-loggers";
+
+function message(value: string) {
+    hookLogger.info({message: createCheckerMessage(value), prefix: ""});
+}
+
+function error(error: Error) {
+    hookLogger.error(error);
+}
+
+export const pnpmLogger = Object.freeze({
+    message,
+    error,
+});