feat: able to exit only on CI when checker failed

Author: Shad02w

package.json

@@ -43,6 +43,7 @@
         "commander": "9.4.0",
         "find-up": "5.0.0",
         "fs-extra": "10.1.0",
+        "is-ci": "^3.0.1",
         "minimatch": "5.1.0"
     },
     "devDependencies": {
@@ -52,6 +53,7 @@
         "@swc/cli": "0.1.57",
         "@swc/core": "1.2.244",
         "@types/fs-extra": "9.0.13",
+        "@types/is-ci": "^3.0.0",
         "@types/jest": "28.1.3",
         "@types/minimatch": "5.1.1",
         "@types/node": "18.7.14",

pnpm-lock.yaml

@@ -1,5 +1,6 @@
 import { readWantedLockfile } from '@pnpm/lockfile-file'
 import { Logger } from '../util/logger'
+import isCI from 'is-ci'
 import { check } from '../checker'
 import { parseOptions } from '../parser-option/parse-option'
 import { findProjectRoot } from '../parser-option/find-project-root'
@@ -9,17 +10,19 @@ 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`
             )
-            return
+            process.exit(1)
+        }
+        const haveError = check(lockfile, options, Logger)
+        if (haveError && options.failOnCI && isCI) {
+            process.exit(1)
         }
-        check(lockfile, options, Logger)
     } catch (error) {
         if (error instanceof Error) {
             Logger.error(error)

src/command/checkDeps.ts

@@ -27,8 +27,8 @@ export class OptionNotFoundError extends Error {
 }
 
 export class OptionSyntaxError extends Error {
-    constructor() {
-        super(`Invalid option, please make sure you have included single version dependencies.`)
+    constructor(message: string) {
+        super(`Invalid option: ${message}`)
         this.name = 'OptionSyntaxError'
     }
 }

src/error.ts

@@ -6,16 +6,18 @@ import { OptionNotFoundError, OptionSyntaxError } from '../error'
 import type { CheckerOptions } from '../type'
 
 const validateOptions = (options: any): CheckerOptions => {
-    if (!options) {
+    if (!options || typeof options !== 'object') {
         throw new OptionNotFoundError()
     }
 
-    if (!Array.isArray(options?.includes) && !Array.isArray(options?.include)) {
-        throw new OptionSyntaxError()
+    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 (options.include) {
-        options.includes = options.include
+    if (o?.failOnCI !== undefined && typeof o.failOnCI !== 'boolean') {
+        throw new OptionSyntaxError('Please use boolean for failedOnCI option')
     }
 
     return options as CheckerOptions
@@ -25,5 +27,12 @@ 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))
-    return validateOptions((packageJSON as any)?.[PACKAGE_JSON_OPTIONS_KEY])
+
+    const options = validateOptions((packageJSON as any)?.[PACKAGE_JSON_OPTIONS_KEY])
+
+    if (options.failOnCI === undefined) {
+        options.failOnCI = true
+    }
+
+    return options
 }

src/parser-option/parse-option.ts

@@ -2,6 +2,11 @@ import { 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 {

src/type.ts

@@ -1,22 +1,20 @@
 import chalk from 'chalk'
 import { APP_NAME } from '../constant'
 
-const log = console.log
-
 export function createCheckerMessage(message: string): string {
     return chalk.magenta(APP_NAME + ': ') + message
 }
 
 function debug(object: Object) {
-    log(object)
+    console.log(object)
 }
 
 function message(value: string) {
-    log(createCheckerMessage(value))
+    console.log(createCheckerMessage(value))
 }
 
 function error(error: Error) {
-    log(createCheckerMessage(`${chalk.bgRed(' ERROR ')} ${error.message}`))
+    console.log(createCheckerMessage(`${chalk.bgRed(' ERROR ')} ${error.message}`))
 }
 
 export const Logger = Object.freeze({