feat: add package.json parser #20

src/container/index.ts

@@ -13,6 +13,7 @@ import { packageInfoModulesBinder } from '../utils/packageInfo';
 import { nodeModulesBinder } from './nodeModulesContainer';
 import { enginesResolveModulesBinder } from '../resolvers/enginesResolver';
 import { loggerModuleBinder } from '../utils/logger';
+import { packageJsonParserModulesBinder } from '../utils/packageJsonParser';
 
 export const container = new Container({
   skipBaseClassChecks: true,
@@ -34,6 +35,7 @@ const binders: Binder[] = [
   packageInfoModulesBinder,
   enginesResolveModulesBinder,
   loggerModuleBinder,
+  packageJsonParserModulesBinder,
 ];
 
 container.load(

src/dependencyChecker/interfaces/IDependencyChecker.ts

@@ -1,10 +1,5 @@
 import { Moment } from 'moment';
-
-export enum DependencyType {
-  PROD = `production`,
-  DEV = `development`,
-  PEER = `peer`,
-}
+import { DependencyType } from '../../utils/packageJsonParser';
 
 export interface IDependencyCheckerRunOptions {
   pkg: {

src/utils/packageJsonParser/impl/packageJsonParser.ts

@@ -0,0 +1,66 @@
+import { inject, injectable } from 'inversify';
+import { FS, TYPES } from '../../../container/nodeModulesContainer';
+import { ILoggerFactory } from '../../logger';
+import { ILogger } from '../../logger/interfaces/ILogger';
+import { Dependency, DependencyType, IPackageJsonData, IPackageJsonParseOptions, IPackageJsonParser } from '..';
+import * as path from 'path';
+import { Manifest } from 'pacote';
+
+const PKG_FILE = `package.json`;
+
+@injectable()
+export class PackageJsonParser extends IPackageJsonParser {
+  private readonly logger: ILogger;
+
+  constructor(@inject(TYPES.FS) private readonly fs: FS, loggerFactory: ILoggerFactory) {
+    super();
+    this.logger = loggerFactory.getLogger(`Package Json Parser`);
+  }
+
+  public async parse({ cwd, include }: IPackageJsonParseOptions): Promise<IPackageJsonData> {
+    this.logger.info(`Reading package.json information`);
+    const pgkFilePath = path.join(cwd, PKG_FILE);
+    this.logger.debug(`Reading file`, pgkFilePath);
+    const content = await this.fs.promises.readFile(pgkFilePath, `utf-8`);
+    const pkg: Manifest = JSON.parse(content);
+    const dependencies = new Set<Dependency>();
+    // handle filtering
+    this.handleDepType(include.dev, pkg.devDependencies, DependencyType.DEV, dependencies, `dev`);
+    this.handleDepType(include.prod, pkg.dependencies, DependencyType.PROD, dependencies, `production`);
+    this.handleDepType(include.peer, pkg.peerDependencies, DependencyType.PEER, dependencies, `peer`);
+    this.handleDepType(include.optional, pkg.optionalDependencies, DependencyType.OPTIONAL, dependencies, `optional`);
+    const scripts = pkg.scripts || {};
+    this.logger.info(`Going to check ${dependencies.size} dependencies`);
+    return {
+      scripts,
+      dependencies,
+    };
+  }
+
+  private handleDepType(
+    included: boolean,
+    list: undefined | Record<string, string>,
+    type: DependencyType,
+    deps: Set<Dependency>,
+    typeStr: string,
+  ): void {
+    if (included) {
+      if (list) {
+        let count = 0;
+        for (const [name, semver] of Object.entries(list)) {
+          count++;
+          deps.add({
+            name,
+            semver,
+            dependencyType: type,
+          });
+        }
+        this.logger.info(`Found ${count} ${typeStr} dependencies`);
+      } else {
+        this.logger.info(`No ${typeStr} dependencies defined`);
+      }
+    } else {
+      this.logger.info(`Skipping ${typeStr} dependencies`);
+    }
+  }
+}

src/utils/packageJsonParser/index.ts

@@ -0,0 +1,10 @@
+import { interfaces } from 'inversify';
+import Bind = interfaces.Bind;
+import { IPackageJsonParser } from './interfaces/IPackageJsonParser';
+import { PackageJsonParser } from './impl/packageJsonParser';
+
+export const packageJsonParserModulesBinder = (bind: Bind): void => {
+  bind<IPackageJsonParser>(IPackageJsonParser).to(PackageJsonParser).inSingletonScope();
+};
+
+export * from './interfaces/IPackageJsonParser';

src/utils/packageJsonParser/interfaces/IPackageJsonParser.ts

@@ -0,0 +1,36 @@
+export enum DependencyType {
+  PROD = `production`,
+  DEV = `development`,
+  PEER = `peer`,
+  OPTIONAL = `optional`,
+  GLOBAL = `global`,
+}
+
+export type Scripts = Record<string, string>;
+
+export interface Dependency {
+  semver: string;
+  name: string;
+  dependencyType: DependencyType;
+}
+
+export interface IPackageJsonParseOptions {
+  cwd: string;
+  packageFile: string | undefined;
+  include: {
+    prod: boolean;
+    dev: boolean;
+    optional: boolean;
+    peer: boolean;
+    global: boolean;
+  };
+}
+
+export interface IPackageJsonData {
+  dependencies: Set<Dependency>;
+  scripts: Scripts;
+}
+
+export abstract class IPackageJsonParser {
+  public abstract async parse(options: IPackageJsonParseOptions): Promise<IPackageJsonData>;
+}

test/src/utils/nodeVersions/index.spec.ts

@@ -3,7 +3,7 @@ import { INodeVersions, nodeVersionsModulesBinder } from '../../../../src/utils/
 import { NodeVersions } from '../../../../src/utils/nodeVersions/impl/nodeVersions';
 
 testBindings({
-  name: `lts module container`,
+  name: `node version module container`,
   binderFn: nodeVersionsModulesBinder,
   bindings: [
     {

test/src/utils/packageJsonParser/impl/packageJsonParser.spec.ts

@@ -0,0 +1,5 @@
+describe(`package json parser`, () => {
+  it(`dummy`, () => {
+    expect(1).toBe(1);
+  });
+});

test/src/utils/packageJsonParser/index.spec.ts

@@ -0,0 +1,15 @@
+import { BindingTypes, testBindings } from '../../../common/testers/bindingTester';
+import { IPackageJsonParser, packageJsonParserModulesBinder } from '../../../../src/utils/packageJsonParser';
+import { PackageJsonParser } from '../../../../src/utils/packageJsonParser/impl/packageJsonParser';
+
+testBindings({
+  name: `package json parser module container`,
+  binderFn: packageJsonParserModulesBinder,
+  bindings: [
+    {
+      binder: IPackageJsonParser,
+      binded: PackageJsonParser,
+      type: BindingTypes.SINGELTON,
+    },
+  ],
+});