@cloud-ru/ft-deps-validator 1.1.1 → 1.1.2-preview-8996d18.0

package/dist/esm/index.js

@@ -1,4 +1,3 @@
-#!/usr/bin/env node
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -8,63 +7,23 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import depCheck from 'depcheck';
-import { globSync } from 'glob';
-import { logDebug, logError, logInfo } from './utils/console';
-import { getCliArguments } from './utils/getCliArguments';
-import { getConfigFile } from './utils/getConfigFile';
-import { initializeState } from './utils/initializeState';
+import { MonorepoChecker, RepoChecker } from './Checker';
+import { MonorepoConfig } from './Config';
+import { RepoConfig } from './Config/RepoConfig';
+import { logError } from './utils/console';
+import { getEnvironment, isMonorepoEnv } from './utils/getEnvironment';
 (() => __awaiter(void 0, void 0, void 0, function* () {
     try {
-        const args = getCliArguments();
-        const configFile = getConfigFile(args.cwd);
-        const config = configFile ? Object.assign(args, configFile) : args;
-        const options = {
-            ignoreBinPackage: false,
-            skipMissing: false,
-            ignorePatterns: config.ignorePatterns.map(pattern => pattern.toString()),
-            ignoreMatches: config.ignoreMatches.map(match => match.toString()),
-        };
-        const folders = globSync(config.rootPackagesFolderPattern, {
-            ignore: config.ignoredPackagesFolderFiles.map(path => path.toString()),
-        });
-        const state = initializeState({
-            cwd: args.cwd,
-            folders,
-            prefix: config.prefix,
-        });
-        for (const folder of folders) {
-            const { dependencies, missing: missingDepsPerPackage } = yield depCheck(folder, options);
-            state.unusedDeps.push(...dependencies.map(x => `${folder}: ${x}`));
-            if (Object.keys(missingDepsPerPackage).length) {
-                state.missing.push(missingDepsPerPackage);
-            }
-        }
-        if (Object.values(state).every(result => result.length < 1)) {
-            logInfo('Dependencies have been checked. Everything is ok.');
-            process.exit(0);
-            return;
-        }
-        if (state.wrongVersions.length) {
-            logError('You have to fix wrong version of internal packages:');
-            state.wrongVersions.forEach(logDebug);
-        }
-        if (state.internalAsDev.length) {
-            logError('You have to fix wrong usage of internal packages in dev dependencies (either delete them or move to dependencies):');
-            state.internalAsDev.forEach(logDebug);
-        }
-        if (state.unusedDeps.length) {
-            logError('You have to fix following unused dependencies:');
-            state.unusedDeps.forEach(logDebug);
-        }
-        if (state.missing.length) {
-            logError('You have to fix following missed dependencies:');
-            state.missing.forEach(x => logDebug(JSON.stringify(x, null, 2)));
-        }
-        process.exit(1);
+        const env = getEnvironment();
+        const checker = isMonorepoEnv(env)
+            ? new MonorepoChecker(new MonorepoConfig(env))
+            : new RepoChecker(new RepoConfig(env));
+        const report = yield checker.check();
+        const exitCode = report.printResultAndGetExitCode();
+        process.exit(exitCode);
     }
-    catch (err) {
-        console.error(err);
+    catch (e) {
+        logError(`${e}`);
         process.exit(1);
     }
 }))();

package/dist/{cjs/types/config.d.ts → esm/types.d.ts}

@@ -1,12 +1,23 @@
-export type Config = {
+type BaseEnvType = {
     /**  Directories names that should be ignored */
     ignorePatterns?: string[];
     /**  Names of packages that should be ignored */
     ignoreMatches?: string[];
-    /** Monorepo prefix (if skipped will try to find automatically) */
-    prefix?: string;
+};
+export type RawRepoEnvType = BaseEnvType & {
+    packages?: Record<string, BaseEnvType>;
+};
+export type RawMonorepoEnvType = {
     /** One or more paths that should be ignored in packages folder */
     ignoredPackagesFolderFiles?: string[];
     /** Folder containing packages (glob pattern, e.g., "packages/*" or "apps/*") */
     rootPackagesFolderPattern?: string;
+} & RawRepoEnvType;
+export type RepoEnvType = RawRepoEnvType & {
+    cwd: string;
+};
+export type MonorepoEnvType = RawMonorepoEnvType & {
+    cwd: string;
+    rootPackagesFolderPattern: string;
 };
+export {};

package/dist/esm/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/utils/__tests__/getCliArguments.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/utils/__tests__/getCliArguments.spec.js

@@ -0,0 +1,68 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { getCliArguments } from '../getCliArguments';
+describe('@cloud-ru/ft-deps-validator/getCliArguments', () => {
+    const originalArgv = process.argv;
+    beforeEach(() => {
+        process.argv = originalArgv;
+        vi.clearAllMocks();
+    });
+    it('should return empty object when no arguments provided', () => {
+        process.argv = ['node', 'script.js'];
+        const result = getCliArguments();
+        expect(result.cwd).toBeUndefined();
+        expect(result.rootPackagesFolderPattern).toBeUndefined();
+        expect(result.ignoredPackagesFolderFiles).toBeUndefined();
+        expect(result.ignorePatterns).toBeUndefined();
+        expect(result.ignoreMatches).toBeUndefined();
+    });
+    it('should parse cwd option', () => {
+        const testCwd = '/test/directory';
+        process.argv = ['node', 'script.js', '--cwd', testCwd];
+        const result = getCliArguments();
+        expect(result.cwd).toBe(testCwd);
+    });
+    it('should parse cwd option with alias -d', () => {
+        const testCwd = '/test/directory';
+        process.argv = ['node', 'script.js', '-d', testCwd];
+        const result = getCliArguments();
+        expect(result.cwd).toBe(testCwd);
+    });
+    it('should parse rootPackagesFolderPattern option', () => {
+        const pattern = 'apps/*';
+        process.argv = ['node', 'script.js', '--rootPackagesFolderPattern', pattern];
+        const result = getCliArguments();
+        expect(result.rootPackagesFolderPattern).toBe(pattern);
+    });
+    it('should parse rootPackagesFolderPattern option with alias -p', () => {
+        const pattern = 'apps/*';
+        process.argv = ['node', 'script.js', '-p', pattern];
+        const result = getCliArguments();
+        expect(result.rootPackagesFolderPattern).toBe(pattern);
+    });
+    it('should parse ignoredPackagesFolderFiles option', () => {
+        const files = ['file1.json', 'file2.json'];
+        process.argv = ['node', 'script.js', '--ignoredPackagesFolderFiles', ...files];
+        const result = getCliArguments();
+        expect(result.ignoredPackagesFolderFiles).toEqual(files);
+    });
+    it('should parse ignorePatterns option', () => {
+        const patterns = ['test', 'build'];
+        process.argv = ['node', 'script.js', '--ignorePatterns', ...patterns];
+        const result = getCliArguments();
+        expect(result.ignorePatterns).toEqual(patterns);
+    });
+    it('should parse ignoreMatches option', () => {
+        const matches = ['package1', 'package2'];
+        process.argv = ['node', 'script.js', '--ignoreMatches', ...matches];
+        const result = getCliArguments();
+        expect(result.ignoreMatches).toEqual(matches);
+    });
+    it('should parse multiple options together', () => {
+        const testCwd = '/test/directory';
+        const pattern = 'apps/*';
+        process.argv = ['node', 'script.js', '--cwd', testCwd, '--rootPackagesFolderPattern', pattern];
+        const result = getCliArguments();
+        expect(result.cwd).toBe(testCwd);
+        expect(result.rootPackagesFolderPattern).toBe(pattern);
+    });
+});

package/dist/esm/utils/getCliArguments.d.ts

@@ -1,10 +1,10 @@
 export declare function getCliArguments(): {
-    cwd: string;
-    rootPackagesFolderPattern: string;
-    ignoredPackagesFolderFiles: string[];
-    prefix: string | undefined;
-    ignorePatterns: string[] | (string | number)[];
-    ignoreMatches: string[] | (string | number)[];
+    [x: string]: unknown;
+    cwd: string | undefined;
+    rootPackagesFolderPattern: string | undefined;
+    ignoredPackagesFolderFiles: (string | number)[] | undefined;
+    ignorePatterns: (string | number)[] | undefined;
+    ignoreMatches: (string | number)[] | undefined;
     _: (string | number)[];
     $0: string;
 };

package/dist/esm/utils/getCliArguments.js

@@ -1,46 +1,26 @@
-import path from 'path';
 import yargs from 'yargs';
 export function getCliArguments() {
-    const parsed = yargs(process.argv.slice(2))
+    return yargs(process.argv.slice(2))
         .option('cwd', {
         alias: 'd',
         type: 'string',
-        default: process.cwd(),
         description: 'working directory (default: current working directory, cwd)',
-    })
-        .option('prefix', {
-        type: 'string',
-        description: 'monorepo prefix (if skipped will try to find automatically)',
     })
         .option('rootPackagesFolderPattern', {
         alias: 'p',
         type: 'string',
-        default: 'packages/*',
         description: 'folder containing packages (glob pattern, e.g., "packages/*" or "apps/*")',
     })
         .option('ignoredPackagesFolderFiles', {
         type: 'array',
-        default: ['packages/tsconfig.cjs.json', 'packages/tsconfig.esm.json'],
         description: 'specify one or more paths that should be ignored in packages folder',
     })
         .option('ignorePatterns', {
         type: 'array',
-        default: ['stories', 'dist', '__tests__', '__e2e__'],
         description: 'specify one or more directories names that should be ignored',
     })
         .option('ignoreMatches', {
         type: 'array',
-        default: [
-            'react',
-            'react-dom',
-            'react-docgen-typescript',
-            '@snack-uikit/figma-tokens',
-            '@sbercloud/figma-tokens-cloud-platform',
-            '@sbercloud/figma-tokens-mlspace',
-            '@sbercloud/figma-tokens-admin',
-            '@sbercloud/figma-tokens-web',
-            '@sbercloud/figma-tokens-giga-id',
-        ],
         description: 'specify one or more packages that should be ignored',
     })
         .locale('en')
@@ -48,10 +28,4 @@ export function getCliArguments() {
         .alias('h', 'help')
         .alias('v', 'version')
         .parseSync();
-    const cwd = path.resolve(parsed.cwd);
-    const rootPackagesFolderPattern = path.resolve(cwd, parsed.rootPackagesFolderPattern);
-    const ignoredPackagesFolderFiles = parsed.ignoredPackagesFolderFiles.map(file => path.resolve(cwd, file.toString()));
-    return Object.assign(Object.assign({}, parsed), { cwd,
-        rootPackagesFolderPattern,
-        ignoredPackagesFolderFiles });
 }

package/dist/esm/utils/getConfigFile.d.ts

@@ -1,3 +1,4 @@
-import { CliArguments } from '../types/cliArguments';
-import { Config } from '../types/config';
-export declare function getConfigFile(cwd: CliArguments['cwd']): Config | null;
+import { RawMonorepoEnvType, RawRepoEnvType } from '../types';
+type PossibleConfig = RawMonorepoEnvType & RawRepoEnvType;
+export declare function getConfigFile(cwd: string): PossibleConfig;
+export {};

package/dist/esm/utils/getConfigFile.js

@@ -4,14 +4,8 @@ const CONFIG_FILE_NAME = 'deps-validator.config.json';
 export function getConfigFile(cwd) {
     const configPath = path.resolve(cwd, CONFIG_FILE_NAME);
     if (!fs.existsSync(configPath)) {
-        return null;
-    }
-    try {
-        const configContent = fs.readFileSync(configPath, 'utf-8');
-        const config = JSON.parse(configContent);
-        return config;
-    }
-    catch (_a) {
-        return null;
+        return { packages: {} };
     }
+    const configContent = fs.readFileSync(configPath, 'utf-8');
+    return JSON.parse(configContent);
 }

package/dist/esm/utils/getEnvironment.d.ts

@@ -0,0 +1,3 @@
+import { MonorepoEnvType, RepoEnvType } from '../types';
+export declare function getEnvironment(): MonorepoEnvType | RepoEnvType;
+export declare const isMonorepoEnv: (env: MonorepoEnvType | RepoEnvType) => env is MonorepoEnvType;

package/dist/esm/utils/getEnvironment.js

@@ -0,0 +1,42 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { getCliArguments } from './getCliArguments';
+import { getConfigFile } from './getConfigFile';
+export function getEnvironment() {
+    const defaultConfig = {
+        cwd: process.cwd(),
+        ignoredPackagesFolderFiles: ['packages/tsconfig.cjs.json', 'packages/tsconfig.esm.json'],
+        ignorePatterns: ['stories', 'dist', '__tests__', '__e2e__'],
+        ignoreMatches: [
+            'react',
+            'react-dom',
+            'react-docgen-typescript',
+            '@snack-uikit/figma-tokens',
+            '@sbercloud/figma-tokens-cloud-platform',
+            '@sbercloud/figma-tokens-mlspace',
+            '@sbercloud/figma-tokens-admin',
+            '@sbercloud/figma-tokens-web',
+            '@sbercloud/figma-tokens-giga-id',
+        ],
+    };
+    const configFile = getConfigFile(defaultConfig.cwd);
+    const configArguments = getCliArguments();
+    const rootIsNotPassed = !configFile.rootPackagesFolderPattern && !configArguments.ignoredPackagesFolderFiles;
+    const rawConfig = Object.assign(defaultConfig, 
+    /* конфиг файл имеет меньший приоритет перед cli-аргументами */
+    configFile, configArguments);
+    if (rootIsNotPassed) {
+        /*
+          Если папку не передали в конфиге, то проверим на наличие папки сами,
+          если она есть, то считаем что это монорепа
+        */
+        if (fs.existsSync(path.resolve(defaultConfig.cwd, './packages'))) {
+            rawConfig.rootPackagesFolderPattern = 'packages/*';
+        }
+        else {
+            delete rawConfig.rootPackagesFolderPattern;
+        }
+    }
+    return rawConfig;
+}
+export const isMonorepoEnv = (env) => Boolean('rootPackagesFolderPattern' in env);

package/dist/esm/utils/readPackageJsonFile.d.ts

@@ -0,0 +1,9 @@
+type PackageJson = {
+    name: string;
+    version: string;
+    dependencies: Record<string, string>;
+    devDependencies: Record<string, string>;
+};
+export declare const readPackageJsonFile: (folder: string) => Promise<PackageJson>;
+export declare const readPackageJsonFileSync: (folder: string) => PackageJson;
+export {};

package/dist/esm/utils/readPackageJsonFile.js

@@ -0,0 +1,20 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+export const readPackageJsonFile = (folder) => __awaiter(void 0, void 0, void 0, function* () {
+    const file = yield fsp.readFile(path.relative(folder, './package.json'), 'utf8');
+    return JSON.parse(file);
+});
+export const readPackageJsonFileSync = (folder) => {
+    const file = fs.readFileSync(path.resolve(folder, './package.json'), 'utf8');
+    return JSON.parse(file);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloud-ru/ft-deps-validator",
-  "version": "1.1.1",
+  "version": "1.1.2-preview-8996d18.0",
   "description": "Validator for unused, missing or wrong version dependencies in monorepo's packages",
   "publishConfig": {
     "access": "public"
@@ -38,5 +38,5 @@
     "glob": "10.5.0",
     "yargs": "18.0.0"
   },
-  "gitHead": "c8e488ecae08fbcda9738fc27674415b707038ec"
+  "gitHead": "7564a8b88cec298ec89adf8265978420d475c337"
 }

package/src/Checker/MonorepoChecker.ts

@@ -0,0 +1,45 @@
+import { MonorepoConfig } from '../Config';
+import { readPackageJsonFile, readPackageJsonFileSync } from '../utils/readPackageJsonFile';
+import { RepoChecker } from './RepoChecker';
+
+export class MonorepoChecker extends RepoChecker {
+  private actualVersions: Record<string, string> = {};
+
+  constructor(config: MonorepoConfig) {
+    super(config);
+
+    this.config.getFolders().reduce((acc, folder) => {
+      const pkg = readPackageJsonFileSync(folder);
+      acc[pkg.name] = pkg.version;
+      return acc;
+    }, this.actualVersions);
+  }
+
+  protected async checkFolder(path: string) {
+    const [result, pkg] = await Promise.all([super.checkFolder(path), readPackageJsonFile(path)]);
+
+    for (const [dep, version] of Object.entries(pkg.dependencies)) {
+      const actualVersion = this.actualVersions[dep];
+      if (actualVersion !== version) {
+        const message = `"${dep}" has wrong version "${version}", but need "${actualVersion}".`;
+        if (result.wrongVersions) {
+          result.wrongVersions.push();
+        } else {
+          result.wrongVersions = [message];
+        }
+      }
+    }
+
+    for (const devDep of Object.keys(pkg.devDependencies)) {
+      if (this.actualVersions[devDep]) {
+        if (result.internalAsDev) {
+          result.internalAsDev.push(devDep);
+        } else {
+          result.internalAsDev = [devDep];
+        }
+      }
+    }
+
+    return result;
+  }
+}

package/src/Checker/RepoChecker.ts

@@ -0,0 +1,23 @@
+import depcheck from 'depcheck';
+
+import { RepoConfig } from '../Config';
+import { CheckState, Report } from '../Report';
+
+export class RepoChecker {
+  protected config: RepoConfig;
+
+  constructor(config: RepoConfig) {
+    this.config = config;
+  }
+
+  public async check(): Promise<Report> {
+    const folders = this.config.getFolders();
+    const report = new Report();
+    await Promise.all(folders.map(folder => this.checkFolder(folder).then(result => report.add(folder, result))));
+    return report;
+  }
+
+  protected async checkFolder(path: string): Promise<CheckState> {
+    return depcheck(path, this.config.getFolderOptions(path));
+  }
+}