@monorepolint/rules 0.5.0-alpha.82 → 0.5.0-alpha.85

package/src/bannedDependencies.ts

@@ -6,109 +6,141 @@
  */
 
 import { Context, RuleModule } from "@monorepolint/core";
-import { writeJson } from "@monorepolint/utils";
-import diff from "jest-diff";
-import minimatch from "minimatch";
+import { matchesAnyGlob } from "@monorepolint/utils";
+import { AggregateTiming } from "@monorepolint/utils";
 import path from "path";
 import * as r from "runtypes";
 import { IPackageDependencyGraphNode, PackageDependencyGraphService } from "./util/packageDependencyGraphService";
 
+// FIXME: This rule is messed. bannedTransitiveDependencies doesnt glob
+
+const bannedDepGlobsField = r.Union(
+  r.Array(r.String),
+  r.Record({
+    glob: r.Array(r.String).optional(),
+    exact: r.Array(r.String).optional(),
+  })
+);
+
 const Options = r.Union(
-  r
-    .Record({
-      bannedDependencies: r.Array(r.String),
-    })
-    .And(
-      r.Partial({
-        bannedTransitiveDependencies: r.Undefined,
-      })
-    ),
-  r
-    .Record({
-      bannedTransitiveDependencies: r.Array(r.String),
-    })
-    .And(
-      r.Partial({
-        bannedDependencies: r.Undefined,
-      })
-    ),
   r.Record({
-    bannedDependencies: r.Array(r.String),
+    bannedDependencies: bannedDepGlobsField,
+    bannedTransitiveDependencies: r.Undefined.optional(),
+  }),
+
+  r.Record({
+    bannedDependencies: bannedDepGlobsField.optional(),
     bannedTransitiveDependencies: r.Array(r.String),
+  }),
+
+  r.Record({
+    bannedDependencies: bannedDepGlobsField.optional(),
+    bannedTransitiveDependencies: r.Array(r.String).optional(),
   })
 );
 
 export type Options = r.Static<typeof Options>;
 
-export const bannedDependencies: RuleModule<typeof Options> = {
-  check: function expectAllowedDependencies(context: Context, opts: Options) {
-    // tslint:disable-next-line:no-shadowed-variable
-    const { bannedDependencies, bannedTransitiveDependencies } = opts;
+/**
+ * We use this locally to avoid making a billion sets. Because check is called once per package
+ * (with the exact same config object reference) we can save quite a bit of time by reusing this cache.
+ */
+const setCache = new Map<ReadonlyArray<string>, Set<string>>();
 
-    if (bannedDependencies) {
-      checkBanned(context, bannedDependencies, "dependencies");
-      checkBanned(context, bannedDependencies, "devDependencies");
-      checkBanned(context, bannedDependencies, "peerDependencies");
-    }
+const aggregateTiming = new AggregateTiming(":bannedDependencies stats");
 
-    if (bannedTransitiveDependencies) {
-      checkTransitives(context, bannedTransitiveDependencies);
-    }
-  },
-  optionsRuntype: Options,
-};
+export const bannedDependencies: RuleModule<typeof Options> & {
+  printStats: () => void;
+} = {
+  check: function expectAllowedDependencies(context, opts, extra) {
+    aggregateTiming.start(extra?.id ?? "unknown id");
 
-function checkBanned(
-  context: Context,
-  // tslint:disable-next-line:no-shadowed-variable
-  bannedDependencies: ReadonlyArray<string>,
-  block: "dependencies" | "devDependencies" | "peerDependencies"
-) {
-  const packageJson = context.getPackageJson();
-  const packagePath = context.getPackageJsonPath();
+    const packageJson = context.getPackageJson();
+    const packagePath = context.getPackageJsonPath();
 
-  const dependencies = packageJson[block];
+    const curDeps = packageJson.dependencies && Object.keys(packageJson.dependencies);
+    const curDevDeps = packageJson.devDependencies && Object.keys(packageJson.devDependencies);
+    const curPeerDeps = packageJson.peerDependencies && Object.keys(packageJson.peerDependencies);
 
-  if (dependencies === undefined) {
-    return;
-  }
+    const { bannedDependencies: banned, bannedTransitiveDependencies: transitives } = opts;
+
+    const globs = banned && (Array.isArray(banned) ? banned : banned.glob);
+    const exacts = banned && (Array.isArray(banned) ? undefined : banned.exact);
 
-  const newPackageJson = { ...packageJson };
-  const violations: string[] = [];
+    const violations = new Set<string>();
 
-  for (const dependency of Object.keys(dependencies)) {
-    for (const bannedDependency of bannedDependencies) {
-      if (minimatch(dependency, bannedDependency)) {
-        violations.push(dependency);
-        delete newPackageJson[block]![dependency];
+    if (globs) {
+      if (curDeps) populateProblemsGlobs(globs, curDeps, violations);
+      if (curDevDeps) populateProblemsGlobs(globs, curDevDeps, violations);
+      if (curPeerDeps) populateProblemsGlobs(globs, curPeerDeps, violations);
+    }
+
+    if (exacts) {
+      let set = setCache.get(exacts);
+      if (set === undefined) {
+        set = new Set(exacts);
+        setCache.set(exacts, set);
       }
+      if (curDeps) populateProblemsExact(set, curDeps, violations);
+      if (curDevDeps) populateProblemsExact(set, curDevDeps, violations);
+      if (curPeerDeps) populateProblemsExact(set, curPeerDeps, violations);
     }
-  }
 
-  if (violations.length > 0) {
-    context.addError({
-      file: packagePath,
-      message:
-        `Found ${violations.length} banned dependencies in '${block}' block of package.json:\n\t` +
-        violations.map((v) => `'${v}'`).join(", "),
-      longMessage: diff(newPackageJson[block], dependencies, { expand: true }),
-      fixer: () => {
-        writeJson(packagePath, newPackageJson);
-      },
-    });
+    if (violations.size > 0) {
+      context.addError({
+        file: packagePath,
+        message:
+          `Found ${violations.size} banned dependencies of package.json:\n\t` +
+          Array.from(violations)
+            .map((v) => `'${v}'`)
+            .join(", "),
+      });
+    }
+
+    if (transitives) {
+      let set = setCache.get(transitives);
+      if (set === undefined) {
+        set = new Set(transitives);
+        setCache.set(transitives, set);
+      }
+      checkTransitives(context, set);
+    }
+
+    aggregateTiming.stop();
+  },
+  optionsRuntype: Options,
+  printStats: () => {
+    aggregateTiming.printResults();
+  },
+};
+
+function populateProblemsExact(banned: Set<string>, dependencies: ReadonlyArray<string>, violations: Set<string>) {
+  for (const dependency of dependencies) {
+    if (banned.has(dependency)) {
+      violations.add(dependency);
+    }
   }
 }
 
-function checkTransitives(
-  context: Context,
-  // tslint:disable-next-line: no-shadowed-variable
-  bannedDependencies: ReadonlyArray<string>
+function populateProblemsGlobs(
+  bannedDependencyGlobs: ReadonlyArray<string>,
+  dependencies: ReadonlyArray<string>,
+  violations: Set<string>
 ) {
+  for (const dependency of dependencies) {
+    if (matchesAnyGlob(dependency, bannedDependencyGlobs)) {
+      violations.add(dependency);
+    }
+  }
+}
+
+// This function is slow. God help you if you use this on a big repo
+function checkTransitives(context: Context, banned: Set<string>) {
   const graphService = new PackageDependencyGraphService();
-  const root = graphService.buildDependencyGraph(path.resolve(context.getPackageJsonPath()));
+  const root = graphService.buildDependencyGraph(path.resolve(context.getPackageJsonPath()), context.host);
   for (const { dependencies, importPath } of graphService.traverse(root)) {
     for (const [dependency] of dependencies) {
-      if (bannedDependencies.includes(dependency)) {
+      if (banned.has(dependency)) {
         // Remove the starting package since it's obvious in CLI output.
         const [, ...importPathWithoutRoot] = importPath;
         const pathing = [...importPathWithoutRoot.map(nameOrPackageJsonPath), dependency].join(" -> ");

package/src/consistentDependencies.ts

@@ -6,7 +6,6 @@
  */
 
 import { Context, RuleModule } from "@monorepolint/core";
-import { writeJson } from "@monorepolint/utils";
 import diff from "jest-diff";
 import * as r from "runtypes";
 
@@ -59,7 +58,7 @@ function checkDeps(context: Context, args: Options, block: "dependencies" | "dev
       fixer: () => {
         const newPackageJson = { ...packageJson };
         newPackageJson[block] = expectedDependencies;
-        writeJson(packagePath, newPackageJson);
+        context.host.writeJson(packagePath, newPackageJson);
       },
     });
   }

package/src/consistentVersions.ts

@@ -58,7 +58,7 @@ const ensurePackageIsCorrectVersion = (
       file: packageJsonPath,
       message: `Expected dependency on ${dependencyPackageName} to match version defined in monorepolint configuration '${expectedPackageDependencyValue}', got '${actualPackageDependencyValue}' instead.`,
       fixer: () =>
-        mutateJson<PackageJson>(packageJsonPath, (input) => {
+        mutateJson<PackageJson>(packageJsonPath, context.host, (input) => {
           input.dependencies![dependencyPackageName] = expectedPackageDependencyValue;
           return input;
         }),
@@ -76,7 +76,7 @@ const ensurePackageIsCorrectVersion = (
       file: packageJsonPath,
       message: `Expected devDependency on ${dependencyPackageName} to match version defined in monorepolint configuration '${expectedPackageDependencyValue}', got '${actualPackageDevDependencyValue}' instead`,
       fixer: () =>
-        mutateJson<PackageJson>(packageJsonPath, (input) => {
+        mutateJson<PackageJson>(packageJsonPath, context.host, (input) => {
           input.devDependencies![dependencyPackageName] = expectedPackageDependencyValue;
           return input;
         }),

package/src/fileContents.ts

@@ -7,31 +7,29 @@
 
 import { Context } from "@monorepolint/core";
 import { RuleModule } from "@monorepolint/core";
-import { existsSync, readFileSync, unlinkSync, writeFileSync } from "fs";
 import diff from "jest-diff";
 import * as path from "path";
 import * as r from "runtypes";
-import { makeDirectoryRecursively } from "./util/makeDirectory";
 
 const Options = r.Union(
   r.Record({
     file: r.String,
     generator: r.Function,
-    template: r.Undefined,
-    templateFile: r.Undefined,
+    template: r.Undefined.optional(),
+    templateFile: r.Undefined.optional(),
   }),
 
   r.Record({
     file: r.String,
-    generator: r.Undefined,
+    generator: r.Undefined.optional(),
     template: r.String,
-    templateFile: r.Undefined,
+    templateFile: r.Undefined.optional(),
   }),
 
   r.Record({
     file: r.String,
-    generator: r.Undefined,
-    template: r.Undefined,
+    generator: r.Undefined.optional(),
+    template: r.Undefined.optional(),
     templateFile: r.String,
   })
 );
@@ -41,22 +39,21 @@ type Options = r.Static<typeof Options>;
 export const fileContents = {
   check: function expectFileContents(context: Context, opts: Options) {
     const fullPath = path.join(context.packageDir, opts.file);
-    const generator = getGenerator(context, opts);
-    const expectedContent = generator(context);
+    const expectedContent = getExpectedContents(context, opts);
 
-    const pathExists = existsSync(fullPath);
-    const actualContent = pathExists ? readFileSync(fullPath, "utf-8") : undefined;
+    const pathExists = context.host.exists(fullPath);
+    const actualContent = pathExists ? context.host.readFile(fullPath, { encoding: "utf-8" }) : undefined;
     if (actualContent !== expectedContent) {
       context.addError({
         file: fullPath,
         message: "Expect file contents to match",
         longMessage: diff(expectedContent, actualContent, { expand: true }),
         fixer: () => {
-          if (expectedContent === undefined && pathExists) {
-            unlinkSync(fullPath);
+          if (expectedContent === undefined) {
+            if (pathExists) context.host.deleteFile(fullPath);
           } else {
-            makeDirectoryRecursively(path.dirname(fullPath));
-            writeFileSync(fullPath, expectedContent);
+            context.host.mkdir(path.dirname(fullPath), { recursive: true });
+            context.host.writeFile(fullPath, expectedContent, { encoding: "utf-8" });
           }
         },
       });
@@ -65,25 +62,30 @@ export const fileContents = {
   optionsRuntype: Options,
 } as RuleModule<typeof Options>;
 
-function getGenerator(context: Context, opts: Options) {
+const optionsCache = new Map<Options, ((context: Context) => string | undefined) | string | undefined>();
+
+function getExpectedContents(context: Context, opts: Options) {
+  // we need to use has because undefined is a valid value in the cache
+  if (optionsCache.has(opts)) {
+    const cachedEntry = optionsCache.get(opts);
+    if (cachedEntry && typeof cachedEntry === "function") {
+      return cachedEntry(context);
+    }
+    return cachedEntry;
+  }
+
   if (opts.generator) {
-    return opts.generator;
+    optionsCache.set(opts, opts.generator);
+    return opts.generator(context) as string | undefined; // we have no guarentee its the right kind of function
   } else if (opts.templateFile) {
     const { packageDir: workspacePackageDir } = context.getWorkspaceContext();
     const fullPath = path.resolve(workspacePackageDir, opts.templateFile);
-    const template = readFileSync(fullPath, "utf-8");
+    const template = context.host.readFile(fullPath, { encoding: "utf-8" });
 
-    return makeGenerator(template);
-  } else if (opts.template) {
-    return makeGenerator(opts.template);
+    optionsCache.set(opts, template);
+    return template;
   } else {
-    throw new Error("Unable to make generator");
+    optionsCache.set(opts, opts.template);
+    return opts.template;
   }
 }
-
-function makeGenerator(template: string) {
-  // tslint:disable-next-line:variable-name
-  return function generator(_context: Context) {
-    return template;
-  };
-}

package/src/mustSatisfyPeerDependencies.ts

@@ -6,7 +6,7 @@
  */
 
 import { Context, RuleModule } from "@monorepolint/core";
-import { mutateJson, PackageJson } from "@monorepolint/utils";
+import { Host, mutateJson, PackageJson } from "@monorepolint/utils";
 import path from "path";
 import resolvePackagePath from "resolve-package-path";
 import * as r from "runtypes";
@@ -398,6 +398,7 @@ function checkSatisfyPeerDependencies(context: Context, opts: Options) {
           dependencyType: "peerDependencies",
           dependencyName: peerDependencyName,
           version: mostStrictPeerRequirement.range,
+          host: context.host,
         }),
       });
     }
@@ -423,6 +424,7 @@ function checkSatisfyPeerDependencies(context: Context, opts: Options) {
             dependencyType: "peerDependencies",
             dependencyName: peerDependencyName,
             version: mostStrictPeerRequirement.range,
+            host: context.host,
           }),
         });
       }
@@ -717,14 +719,16 @@ function getAddDependencyTypeFixer({
   dependencyType,
   dependencyName,
   version,
+  host,
 }: {
   packageJsonPath: string;
   dependencyType: IDependencyType;
   dependencyName: string;
   version: string;
+  host: Host;
 }) {
   return () => {
-    mutateJson<PackageJson>(packageJsonPath, (packageJson) => {
+    mutateJson<PackageJson>(packageJsonPath, host, (packageJson) => {
       if (packageJson[dependencyType] == null) {
         packageJson[dependencyType] = {};
       }

package/src/packageEntry.ts

@@ -37,7 +37,7 @@ export const Options = r.Union(
 
 export type Options = r.Static<typeof Options>;
 
-export const packageEntry = {
+export const packageEntry: RuleModule<typeof Options> = {
   check: function expectPackageEntry(context: Context, options: Options) {
     const packageJson = context.getPackageJson();
 
@@ -53,10 +53,10 @@ export const packageEntry = {
         ) {
           context.addError({
             file: context.getPackageJsonPath(),
-            message: `Expected standardized entry for '${key}'`,
+            message: createStandardizedEntryErrorMessage(key),
             longMessage: entryDiff,
             fixer: () => {
-              mutateJson<PackageJson>(context.getPackageJsonPath(), (input) => {
+              mutateJson<PackageJson>(context.getPackageJsonPath(), context.host, (input) => {
                 input[key] = value;
                 return input;
               });
@@ -71,11 +71,19 @@ export const packageEntry = {
         if (packageJson[key] === undefined) {
           context.addError({
             file: context.getPackageJsonPath(),
-            message: `Expected entry for '${key}' to exist`,
+            message: createExpectedEntryErrorMessage(key),
           });
         }
       }
     }
   },
   optionsRuntype: Options,
-} as RuleModule<typeof Options>;
+};
+
+export function createStandardizedEntryErrorMessage(key: string) {
+  return `Expected standardized entry for '${key}'`;
+}
+
+export function createExpectedEntryErrorMessage(key: string) {
+  return `Expected entry for '${key}' to exist`;
+}

package/src/packageOrder.ts

@@ -6,7 +6,6 @@
  */
 
 import { Context, RuleModule } from "@monorepolint/core";
-import { writeJson } from "@monorepolint/utils";
 import diff from "jest-diff";
 import * as r from "runtypes";
 
@@ -73,7 +72,7 @@ export const packageOrder = {
             expectedPackageJson[key] = packageJson[key];
           });
 
-          writeJson(packagePath, expectedPackageJson);
+          context.host.writeJson(packagePath, expectedPackageJson);
         },
       });
     }

package/src/packageScript.ts

@@ -39,7 +39,7 @@ export const packageScript = {
         file: context.getPackageJsonPath(),
         message: MSG_NO_SCRIPTS_BLOCK,
         fixer: () => {
-          mutateJson<PackageJson>(context.getPackageJsonPath(), (input) => {
+          mutateJson<PackageJson>(context.getPackageJsonPath(), context.host, (input) => {
             input.scripts = {};
             return input;
           });
@@ -75,7 +75,7 @@ export const packageScript = {
         if (fixValue !== false && (fixValue !== undefined || fixToEmpty === true)) {
           const q = fixValue;
           fixer = () => {
-            mutateJson<PackageJson>(context.getPackageJsonPath(), (input) => {
+            mutateJson<PackageJson>(context.getPackageJsonPath(), context.host, (input) => {
               if (fixToEmpty && q === undefined) {
                 delete input.scripts![name];
               } else {

package/src/requireDependency.ts

@@ -39,7 +39,7 @@ export const requireDependency = {
           file: packageJsonPath,
           message: `No ${type} block, cannot add required ${type}.`,
           fixer: () => {
-            mutateJson<PackageJson>(packageJsonPath, (input) => {
+            mutateJson<PackageJson>(packageJsonPath, context.host, (input) => {
               input[type] = options[type];
               return input;
             });
@@ -55,7 +55,7 @@ export const requireDependency = {
             message: `Expected dependency ${dep}@${version}`,
             longMessage: diff(`${dep}@${version}\n`, `${dep}@${packageJson[type][dep] || "missing"}\n`)!,
             fixer: () => {
-              mutateJson<PackageJson>(packageJsonPath, (input) => {
+              mutateJson<PackageJson>(packageJsonPath, context.host, (input) => {
                 input[type] = { ...input[type], [dep]: version };
                 return input;
               });

package/src/standardTsconfig.ts

@@ -6,9 +6,8 @@
  */
 
 import { Context, RuleModule } from "@monorepolint/core";
-import { existsSync, readFileSync, writeFileSync } from "fs";
+import { matchesAnyGlob } from "@monorepolint/utils";
 import diff from "jest-diff";
-import minimatch from "minimatch";
 import * as path from "path";
 import * as r from "runtypes";
 
@@ -48,7 +47,9 @@ export const standardTsconfig = {
     const generator = getGenerator(context, opts);
     const expectedContent = generator(context);
 
-    const actualContent = existsSync(fullPath) ? readFileSync(fullPath, "utf-8") : undefined;
+    const actualContent = context.host.exists(fullPath)
+      ? context.host.readFile(fullPath, { encoding: "utf-8" })
+      : undefined;
 
     if (expectedContent === undefined) {
       context.addWarning({
@@ -64,7 +65,9 @@ export const standardTsconfig = {
         message: "Expect file contents to match",
         longMessage: diff(expectedContent, actualContent, { expand: true }),
         fixer: () => {
-          writeFileSync(fullPath, expectedContent);
+          context.host.writeFile(fullPath, expectedContent, {
+            encoding: "utf-8",
+          });
         },
       });
     }
@@ -78,7 +81,7 @@ function getGenerator(context: Context, opts: Options) {
   } else if (opts.templateFile) {
     const { packageDir: workspacePackageDir } = context.getWorkspaceContext();
     const fullPath = path.resolve(workspacePackageDir, opts.templateFile);
-    const template = JSON.parse(readFileSync(fullPath, "utf-8"));
+    const template = JSON.parse(context.host.readFile(fullPath, { encoding: "utf-8" }));
 
     return makeGenerator(template, opts.excludedReferences, opts.additionalReferences, opts.tsconfigReferenceFile);
   } else if (opts.template) {
@@ -90,8 +93,8 @@ function getGenerator(context: Context, opts: Options) {
 
 function makeGenerator(
   template: any,
-  excludedReferences: ReadonlyArray<string> = [],
-  additionalReferences: ReadonlyArray<string> = [],
+  excludedReferences: ReadonlyArray<string> | undefined,
+  additionalReferences: ReadonlyArray<string> | undefined,
   tsconfigReferenceFile?: string
 ) {
   return function generator(context: Context) {
@@ -105,24 +108,24 @@ function makeGenerator(
     const packageJson = context.getPackageJson();
     const deps = [...Object.keys(packageJson.dependencies || {}), ...Object.keys(packageJson.devDependencies || {})];
 
-    deps
-      .filter(
-        (name) => nameToDirectory.has(name) && !excludedReferences.some((excludedRef) => minimatch(name, excludedRef))
-      )
-      .forEach((packageName) => {
-        const packageDir = nameToDirectory.get(packageName)!;
+    for (const dep of deps) {
+      const packageDir = nameToDirectory.get(dep);
+      if (packageDir !== undefined && (excludedReferences === undefined || matchesAnyGlob(dep, excludedReferences))) {
         const absoluteReferencePath =
           tsconfigReferenceFile !== undefined ? path.join(packageDir, tsconfigReferenceFile) : packageDir;
         template.references.push({
           path: path.relative(context.packageDir, absoluteReferencePath),
         });
-      });
+      }
+    }
 
-    additionalReferences.forEach((additionalReference) => {
-      template.references.push({
-        path: additionalReference,
-      });
-    });
+    if (additionalReferences) {
+      for (const additionalReference of additionalReferences) {
+        template.references.push({
+          path: additionalReference,
+        });
+      }
+    }
 
     return JSON.stringify(template, undefined, 2) + "\n";
   };

package/src/util/checkAlpha.ts

@@ -6,7 +6,6 @@
  */
 
 import { Context } from "@monorepolint/core";
-import { writeJson } from "@monorepolint/utils";
 import diff from "jest-diff";
 
 export function checkAlpha(
@@ -28,7 +27,7 @@ export function checkAlpha(
   if (!arrayOrderCompare(actualOrder, expectedOrder)) {
     context.addError({
       file: packagePath,
-      message: `Incorrect order of ${block} in ${packageJson.name}'s package.json`,
+      message: createIncorrectOrderErrorMessage(block, packageJson.name!),
       longMessage: diff(expectedOrder, actualOrder, { expand: true }),
       fixer: () => {
         const expectedDependencies: Record<string, string> = {};
@@ -39,7 +38,7 @@ export function checkAlpha(
 
         const newPackageJson = { ...packageJson };
         newPackageJson[block] = expectedDependencies;
-        writeJson(packagePath, newPackageJson);
+        context.host.writeJson(packagePath, newPackageJson);
       },
     });
   }
@@ -54,3 +53,7 @@ function arrayOrderCompare(a: ReadonlyArray<string>, b: ReadonlyArray<string>) {
 
   return true;
 }
+
+export function createIncorrectOrderErrorMessage(block: string, packageName: string) {
+  return `Incorrect order of ${block} in ${packageName}'s package.json`;
+}

package/src/util/packageDependencyGraphService.ts

@@ -2,7 +2,7 @@
  * @license Copyright 2019 Palantir Technologies, Inc. All rights reserved.
  */
 
-import { PackageJson } from "@monorepolint/utils";
+import { Host, PackageJson } from "@monorepolint/utils";
 import path from "path";
 import resolvePackagePath from "resolve-package-path";
 
@@ -19,7 +19,7 @@ export interface IPackageDependencyGraphNode {
 /** Service abstraction for constructing and traversing package dependency graphs. */
 export interface IPackageDependencyGraphService {
   /** Construct a graph of package dependencies. */
-  buildDependencyGraph(packageJsonPath: string, maxDepth?: number): IPackageDependencyGraphNode;
+  buildDependencyGraph(packageJsonPath: string, host: Host, maxDepth?: number): IPackageDependencyGraphNode;
 
   /** Traverse a package dependency graph. */
   traverse(
@@ -34,15 +34,18 @@ export interface IPackageDependencyGraphService {
 /** Default implementation of the package dependency graph service. */
 export class PackageDependencyGraphService implements IPackageDependencyGraphService {
   /** Construct a graph of package dependencies and return the root node. */
-  public buildDependencyGraph(startPackageJsonPath: string, maxDepth?: number): IPackageDependencyGraphNode {
+  public buildDependencyGraph(
+    startPackageJsonPath: string,
+    host: Host,
+    maxDepth?: number
+  ): IPackageDependencyGraphNode {
     const nodes = new Map<string, IPackageDependencyGraphNode>();
-
     const visit = (packageJsonPath: string, currentDepth: number): IPackageDependencyGraphNode => {
       if (nodes.has(packageJsonPath)) {
         return nodes.get(packageJsonPath)!;
       }
 
-      const packageJson: PackageJson = require(packageJsonPath);
+      const packageJson: PackageJson = host.readJson(packageJsonPath);
       const node: IPackageDependencyGraphNode = {
         packageJson,
         dependencies: new Map<string, IPackageDependencyGraphNode>(),