chore: consider replacing any usage of any with unknown #59

src/dependencyChecker/impl/dependencyChecker.ts

@@ -9,9 +9,9 @@ import { ICacheResolver } from '../../resolvers/cacheResolver';
 import { ICIResolver } from '../../resolvers/ciResolver';
 import { ITestResolver } from '../../resolvers/testResolver';
 import { IEnginesResolver } from '../../resolvers/enginesResolver';
-import { IPackageInfo } from '../../utils/packageInfo';
 import { ILoggerFactory } from '../../utils/logger';
 import { ILogger } from '../../utils/logger/interfaces/ILogger';
+import { IPackageInfoCache } from '..';
 
 @injectable()
 export class DependencyChecker extends IDependencyChecker {
@@ -23,7 +23,7 @@ export class DependencyChecker extends IDependencyChecker {
     private readonly ciResolver: ICIResolver,
     private readonly testResolver: ITestResolver,
     private readonly engineResolver: IEnginesResolver,
-    private readonly packageInfo: IPackageInfo,
+    private readonly packageInfoCache: IPackageInfoCache,
     loggerFactory: ILoggerFactory
   ) {
     super();
@@ -58,48 +58,53 @@ export class DependencyChecker extends IDependencyChecker {
         }
       }
     }
-    // TODO get packageInfo from cache, probably we should move all this logic to a different unit
-    const packageInfo = await this.packageInfo.getPackageInfo({
+    const dependencyVersion = await this.packageInfoCache.getPackageInfo({
       semver: pkg.version,
       name: pkg.name,
     });
     const engineResult = await this.engineResolver.resolve({
       targetNode,
-      engines: packageInfo.engines,
-      releaseDate: packageInfo.releaseDate,
+      engines: dependencyVersion.engines || undefined,
+      releaseDate: dependencyVersion.releaseDate || undefined,
     });
     if (engineResult.isMatch) {
       return {
         isMatch: true,
         resolverName: engineResult.resolverName,
       };
     }
-    if (!packageInfo.repoUrl) {
+    if (!dependencyVersion.repoUrl) {
       const reason = `Failed to get repository url for ${pkg.dependencyType} dependency - ${pkg.name}@${pkg.version}`;
       this.logger.error(reason);
       return {
         isError: true,
         reason,
       };
     }
-    if (!packageInfo.releaseDate) {
+    if (!dependencyVersion.releaseDate) {
       const reason = `Failed to get package release date for ${pkg.dependencyType} dependency - ${pkg.name}@${pkg.version}`;
       this.logger.error(reason);
       return {
         isError: true,
         reason,
       };
     }
-    const repoPath = await this.gitCheckout.checkoutRepo({
+    const { repoPath, commitSha } = await this.gitCheckout.checkoutRepo({
       tag: pkg.version,
-      commitSha: packageInfo.commitSha,
+      commitSha: dependencyVersion.commitSha || undefined,
       baseDir: workDir,
-      url: packageInfo.repoUrl,
+      url: dependencyVersion.repoUrl,
     });
+    if (!dependencyVersion.commitSha) {
+      await this.packageInfoCache.updateCommitSha({
+        dependencyVersion,
+        commitSha,
+      });
+    }
     const ciResult = await this.ciResolver.resolve({
       targetNode,
       repoPath,
-      packageReleaseDate: packageInfo.releaseDate,
+      packageReleaseDate: dependencyVersion.releaseDate,
     });
     if (ciResult.isMatch) {
       return {

src/dependencyChecker/impl/packageInfoCache.ts

@@ -0,0 +1,80 @@
+import { injectable } from 'inversify';
+import { IPackageInfo, IPackageInfoOptions } from '../../utils/packageInfo';
+import { ILoggerFactory } from '../../utils/logger';
+import { ILogger } from '../../utils/logger/interfaces/ILogger';
+import { DependencyVersion, IDependencyVersionRepositoryProvider } from '../../db';
+import { IPackageInfoCache, IPackageInfoCacheOptions, IUpdateCommitShaOptions } from '../interfaces/IPackageInfoCache';
+import { memoize } from '../../utils/memoize/memoize';
+
+const keyBuilder = ({ name, semver }: IPackageInfoOptions): string => {
+  return `${name}@${semver}`;
+};
+
+@injectable()
+export class PackageInfoCache extends IPackageInfoCache {
+  private readonly logger: ILogger;
+
+  constructor(
+    private readonly packageInfo: IPackageInfo,
+    private readonly dependencyVersionRepositoryProvider: IDependencyVersionRepositoryProvider,
+    loggerFactory: ILoggerFactory
+  ) {
+    super();
+    this.logger = loggerFactory.getLogger(`Package Info Cache`);
+  }
+
+  @memoize(keyBuilder)
+  public async getPackageInfo({ name, semver }: IPackageInfoCacheOptions): Promise<DependencyVersion> {
+    this.logger.info(`Checking if package info is cached ${name}@$${semver}`);
+    const dependencyVersionRepository = await this.dependencyVersionRepositoryProvider.getRepository();
+    try {
+      const cachedDependencyVersion = await dependencyVersionRepository.findOne({
+        name,
+        semver,
+      });
+      if (cachedDependencyVersion) {
+        this.logger.info(`Located cached package info for ${name}@$${semver}`);
+        return cachedDependencyVersion;
+      } else {
+        this.logger.info(`No cached package info for ${name}@$${semver}`);
+      }
+    } catch (err) {
+      this.logger.error(`Failed to locate cached package info for ${name}@$${semver}`, err);
+    }
+    this.logger.debug(`Locating package info for ${name}@$${semver}`);
+    const packageInfo = await this.packageInfo.getPackageInfo({
+      semver,
+      name,
+    });
+    const dependencyVersion = new DependencyVersion({
+      ...packageInfo,
+      engines: packageInfo.engines || null,
+      commitSha: packageInfo.commitSha || null,
+      releaseDate: packageInfo.releaseDate || null,
+      repoUrl: packageInfo.repoUrl || null,
+    });
+    this.logger.debug(`Saving package info for ${name}@$${semver} in cache`);
+    await dependencyVersionRepository.save(dependencyVersion);
+    return dependencyVersion;
+  }
+
+  public async updateCommitSha({ commitSha, dependencyVersion }: IUpdateCommitShaOptions): Promise<void> {
+    this.logger.debug(
+      `Updating commit sha of package info ${dependencyVersion.name}@$${dependencyVersion.semver} to ${commitSha}`
+    );
+    const dependencyVersionRepository = await this.dependencyVersionRepositoryProvider.getRepository();
+    dependencyVersion.commitSha = commitSha;
+    await dependencyVersionRepository.update(
+      {
+        name: dependencyVersion.name,
+        semver: dependencyVersion.semver,
+      },
+      {
+        commitSha,
+      }
+    );
+    this.logger.debug(
+      `Done updating commit sha of package info ${dependencyVersion.name}@$${dependencyVersion.semver}`
+    );
+  }
+}

src/dependencyChecker/index.ts

@@ -2,9 +2,13 @@ import { IDependencyChecker } from './interfaces/IDependencyChecker';
 import { DependencyChecker } from './impl/dependencyChecker';
 import { interfaces } from 'inversify';
 import Bind = interfaces.Bind;
+import { IPackageInfoCache } from './interfaces/IPackageInfoCache';
+import { PackageInfoCache } from './impl/packageInfoCache';
 
 export const dependencyCheckerModulesBinder = (bind: Bind): void => {
   bind<IDependencyChecker>(IDependencyChecker).to(DependencyChecker).inSingletonScope();
+  bind<IPackageInfoCache>(IPackageInfoCache).to(PackageInfoCache).inSingletonScope();
 };
 
 export * from './interfaces/IDependencyChecker';
+export * from './interfaces/IPackageInfoCache';

src/dependencyChecker/interfaces/IPackageInfoCache.ts

@@ -0,0 +1,16 @@
+import { DependencyVersion } from '../../db';
+
+export interface IPackageInfoCacheOptions {
+  name: string;
+  semver: string;
+}
+
+export interface IUpdateCommitShaOptions {
+  dependencyVersion: DependencyVersion;
+  commitSha: string;
+}
+
+export abstract class IPackageInfoCache {
+  public abstract async getPackageInfo(options: IPackageInfoCacheOptions): Promise<DependencyVersion>;
+  public abstract async updateCommitSha(options: IUpdateCommitShaOptions): Promise<void>;
+}

src/resolvers/cacheResolver/impl/cacheResolver.ts

@@ -45,7 +45,7 @@ export class CacheResolver extends ICacheResolver {
         };
       }
     } catch (err) {
-      this.logger.debug(`Failed to located cache results for ${repo.name}@$${repo.version}`, err);
+      this.logger.error(`Failed to locate cached results for ${repo.name}@$${repo.version}`, err);
       return {
         isMatch: false,
       };

src/utils/git/impl/gitCheckout.ts

@@ -1,6 +1,6 @@
 import * as path from 'path';
 import { inject, injectable } from 'inversify';
-import { ICheckoutOptions, IGitCheckout } from '../interfaces/IGitCheckout';
+import { ICheckoutOptions, ICheckoutResult, IGitCheckout } from '../interfaces/IGitCheckout';
 import { getRepoDirName } from './getRepoDirName';
 import { Git } from './git';
 import { FS, TYPES } from '../../../container/nodeModulesContainer';
@@ -15,7 +15,7 @@ export class GitCheckout extends IGitCheckout {
     this.logger = loggerFactory.getLogger(`GitCheckout`);
   }
 
-  public async checkoutRepo({ url, baseDir, tag, commitSha }: ICheckoutOptions): Promise<string> {
+  public async checkoutRepo({ url, baseDir, tag, commitSha }: ICheckoutOptions): Promise<ICheckoutResult> {
     const dirName = await getRepoDirName({ url });
     const fullDir = path.join(baseDir, dirName);
     this.logger.info(`Cloning repo ${url} to ${fullDir}`);
@@ -45,14 +45,17 @@ export class GitCheckout extends IGitCheckout {
       });
     } else {
       this.logger.debug(`Looking for commit of tag ${tag}`);
-      const reference = await this.git.locateTag({ repo, tag });
-      this.logger.debug(`Checking out found commit ${reference} for tag ${tag}`);
+      commitSha = await this.git.locateTag({ repo, tag });
+      this.logger.debug(`Checking out found commit ${commitSha} for tag ${tag}`);
       await this.git.checkoutCommit({
         repo,
-        commitSha: reference,
+        commitSha,
       });
     }
     this.logger.success(`Checking out repo ${dirName}`);
-    return fullDir;
+    return {
+      repoPath: fullDir,
+      commitSha,
+    };
   }
 }

src/utils/git/interfaces/IGitCheckout.ts

@@ -5,6 +5,11 @@ export interface ICheckoutOptions {
   commitSha?: string;
 }
 
+export interface ICheckoutResult {
+  commitSha: string;
+  repoPath: string;
+}
+
 export abstract class IGitCheckout {
-  public abstract async checkoutRepo(options: ICheckoutOptions): Promise<string>;
+  public abstract async checkoutRepo(options: ICheckoutOptions): Promise<ICheckoutResult>;
 }

test/src/dependencyChecker/index.spec.ts

@@ -1,6 +1,7 @@
 import { BindingTypes, testBindings } from '../../common/testers/bindingTester';
-import { dependencyCheckerModulesBinder, IDependencyChecker } from '../../../src/dependencyChecker';
+import { dependencyCheckerModulesBinder, IDependencyChecker, IPackageInfoCache } from '../../../src/dependencyChecker';
 import { DependencyChecker } from '../../../src/dependencyChecker/impl/dependencyChecker';
+import { PackageInfoCache } from '../../../src/dependencyChecker/impl/packageInfoCache';
 
 testBindings({
   name: `dependency checker module container`,
@@ -11,5 +12,10 @@ testBindings({
       binded: DependencyChecker,
       type: BindingTypes.SINGELTON,
     },
+    {
+      binder: IPackageInfoCache,
+      binded: PackageInfoCache,
+      type: BindingTypes.SINGELTON,
+    },
   ],
 });

test/src/utils/git/impl/gitCheckout.spec.ts

@@ -35,7 +35,7 @@ describe(`git checkout`, () => {
       tag,
       commitSha,
     });
-    expect(result).toBe(fullDir);
+    expect(result).toEqual({ repoPath: fullDir, commitSha });
     expect(fsMock.promises.stat).toHaveBeenCalledTimes(1);
     expect(fsMock.promises.stat).toHaveBeenCalledWith(fullDir);
     expect(gitMock.openRepo).toHaveBeenCalledTimes(1);
@@ -59,7 +59,7 @@ describe(`git checkout`, () => {
       tag,
       commitSha,
     });
-    expect(result).toBe(fullDir);
+    expect(result).toEqual({ repoPath: fullDir, commitSha });
     expect(fsMock.promises.stat).toHaveBeenCalledTimes(1);
     expect(fsMock.promises.stat).toHaveBeenCalledWith(fullDir);
     expect(fsMock.promises.mkdir).toHaveBeenCalledTimes(1);
@@ -86,7 +86,7 @@ describe(`git checkout`, () => {
       baseDir,
       tag,
     });
-    expect(result).toBe(fullDir);
+    expect(result).toEqual({ repoPath: fullDir, commitSha });
     expect(fsMock.promises.stat).toHaveBeenCalledTimes(1);
     expect(fsMock.promises.stat).toHaveBeenCalledWith(fullDir);
     expect(gitMock.openRepo).toHaveBeenCalledTimes(1);

testE2E/src/utils/git/impl/gitCheckout.spec.ts

@@ -29,20 +29,22 @@ describe(`git checkout`, () => {
   it(
     `should checkout existing tag`,
     async () => {
-      const name = await gitCheckout.checkoutRepo({
+      const { repoPath: name, commitSha } = await gitCheckout.checkoutRepo({
         url,
         baseDir: tmpDir,
         tag: `1.2.1`,
       });
       const expected = path.join(tmpDir, dirName);
       expect(name).toBe(expected);
+      expect(commitSha).toBe(`v1.2.1`);
       await verifyVersion(name, `1.2.1`);
-      const name2 = await gitCheckout.checkoutRepo({
+      const { repoPath: name2, commitSha: commitSha2 } = await gitCheckout.checkoutRepo({
         url,
         baseDir: tmpDir,
         tag: `1.2.2`,
       });
       expect(name2).toBe(expected);
+      expect(commitSha2).toBe(`v1.2.2`);
       await verifyVersion(name, `1.2.2`);
     },
     timeout
@@ -51,22 +53,24 @@ describe(`git checkout`, () => {
   it(
     `should checkout existing commit`,
     async () => {
-      const name = await gitCheckout.checkoutRepo({
+      const { repoPath: name, commitSha } = await gitCheckout.checkoutRepo({
         url,
         baseDir: tmpDir,
         tag: `4.0.9`,
         commitSha: `e2942bb0f6a3d402cfef5714153263aef8e1466f`,
       });
       const expected = path.join(tmpDir, dirName);
       expect(name).toBe(expected);
+      expect(commitSha).toBe(`e2942bb0f6a3d402cfef5714153263aef8e1466f`);
       await verifyVersion(name, `4.0.9`);
-      const name2 = await gitCheckout.checkoutRepo({
+      const { repoPath: name2, commitSha: commitSha2 } = await gitCheckout.checkoutRepo({
         url,
         baseDir: tmpDir,
         tag: `1.2.2`,
         commitSha: `e803d4cafb3a81d378117726a582cc7d561c5b47`,
       });
       expect(name2).toBe(expected);
+      expect(commitSha2).toBe(`e803d4cafb3a81d378117726a582cc7d561c5b47`);
       await verifyVersion(name, `1.2.2`);
     },
     timeout