@monorepolint/rules 0.5.0-alpha.9 → 0.5.0-alpha.95

package/src/bannedDependencies.ts

@@ -6,64 +6,154 @@
  */
 
 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";
 
-const Options = r.Record({
-  bannedDependencies: r.Array(r.String),
-});
+// FIXME: This rule is messed. bannedTransitiveDependencies doesnt glob
 
-type Options = r.Static<typeof Options>;
+const bannedDepGlobsField = r.Union(
+  r.Array(r.String),
+  r.Record({
+    glob: r.Array(r.String).optional(),
+    exact: r.Array(r.String).optional(),
+  })
+);
 
-export const bannedDependencies: RuleModule<typeof Options> = {
-  check: function expectAllowedDependencies(context: Context, opts: Options) {
-    // tslint:disable-next-line:no-shadowed-variable
-    const { bannedDependencies } = opts;
+const Options = r.Union(
+  r.Record({
+    bannedDependencies: bannedDepGlobsField,
+    bannedTransitiveDependencies: r.Undefined.optional(),
+  }),
 
-    checkBanned(context, bannedDependencies, "dependencies");
-    checkBanned(context, bannedDependencies, "devDependencies");
-    checkBanned(context, bannedDependencies, "peerDependencies");
+  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>;
+
+/**
+ * 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>>();
+
+const aggregateTiming = new AggregateTiming(":bannedDependencies stats");
+
+export const bannedDependencies: RuleModule<typeof Options> & {
+  printStats: () => void;
+} = {
+  check: function expectAllowedDependencies(context, opts, extra) {
+    aggregateTiming.start(extra?.id ?? "unknown id");
+
+    const packageJson = context.getPackageJson();
+    const packagePath = context.getPackageJsonPath();
+
+    const curDeps = packageJson.dependencies && Object.keys(packageJson.dependencies);
+    const curDevDeps = packageJson.devDependencies && Object.keys(packageJson.devDependencies);
+    const curPeerDeps = packageJson.peerDependencies && Object.keys(packageJson.peerDependencies);
+
+    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 violations = new Set<string>();
+
+    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.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 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 dependencies = packageJson[block];
+function populateProblemsExact(banned: Set<string>, dependencies: ReadonlyArray<string>, violations: Set<string>) {
+  for (const dependency of dependencies) {
+    if (banned.has(dependency)) {
+      violations.add(dependency);
+    }
+  }
+}
 
-  if (dependencies === undefined) {
-    return;
+function populateProblemsGlobs(
+  bannedDependencyGlobs: ReadonlyArray<string>,
+  dependencies: ReadonlyArray<string>,
+  violations: Set<string>
+) {
+  for (const dependency of dependencies) {
+    if (matchesAnyGlob(dependency, bannedDependencyGlobs)) {
+      violations.add(dependency);
+    }
   }
+}
 
-  const expectedDependencies: Record<string, string> = {};
+// 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()), context.host);
+  for (const { dependencies, importPath } of graphService.traverse(root)) {
+    for (const [dependency] of dependencies) {
+      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(" -> ");
 
-  for (const dependency of Object.keys(dependencies)) {
-    for (const bannedDependency of bannedDependencies) {
-      if (!minimatch(dependency, bannedDependency)) {
-        expectedDependencies[dependency] = dependencies[dependency];
+        context.addError({
+          file: root.paths.packageJsonPath,
+          message: `Banned transitive dependencies in repo: ${pathing}`,
+        });
       }
     }
   }
+}
 
-  if (Object.keys(expectedDependencies).length !== Object.keys(dependencies).length) {
-    context.addError({
-      file: packagePath,
-      message: `Banned depdendencies in ${block} in package.json`,
-      longMessage: diff(expectedDependencies, dependencies, { expand: true }),
-      fixer: () => {
-        const newPackageJson = { ...packageJson };
-        newPackageJson[block] = expectedDependencies;
-        writeJson(packagePath, newPackageJson);
-      },
-    });
-  }
+function nameOrPackageJsonPath(node: IPackageDependencyGraphNode): string {
+  return node.packageJson.name ?? node.paths.packageJsonPath;
 }

package/src/consistentDependencies.ts

@@ -6,23 +6,28 @@
  */
 
 import { Context, RuleModule } from "@monorepolint/core";
-import { writeJson } from "@monorepolint/utils";
 import diff from "jest-diff";
 import * as r from "runtypes";
 
-const Options = r.Undefined;
-type Options = r.Static<typeof Options>;
+const Options = r
+  .Record({
+    ignoredDependencies: r.Array(r.String).Or(r.Undefined),
+  })
+  .Or(r.Undefined);
+export type Options = r.Static<typeof Options>;
+
+const skippedVersions = ["*", "latest"];
 
 export const consistentDependencies = {
-  check: function expectConsistentDependencies(context: Context) {
-    checkDeps(context, "dependencies");
-    checkDeps(context, "devDependencies");
+  check: function expectConsistentDependencies(context: Context, args: Options) {
+    checkDeps(context, args, "dependencies");
+    checkDeps(context, args, "devDependencies");
     // we don't check peer deps since they can be more lenient
   },
   optionsRuntype: Options,
 } as RuleModule<typeof Options>;
 
-function checkDeps(context: Context, block: "dependencies" | "devDependencies" | "peerDependencies") {
+function checkDeps(context: Context, args: Options, block: "dependencies" | "devDependencies" | "peerDependencies") {
   const packageJson = context.getPackageJson();
   const packagePath = context.getPackageJsonPath();
   const dependencies = packageJson[block];
@@ -30,24 +35,30 @@ function checkDeps(context: Context, block: "dependencies" | "devDependencies" |
   const workspacePackageJson = context.getWorkspaceContext().getPackageJson();
   const workspaceDependencies = workspacePackageJson[block];
 
-  if (dependencies === undefined || workspaceDependencies === undefined) {
+  const ignoredDeps = args?.ignoredDependencies ?? [];
+  const depsToCheck =
+    workspaceDependencies == null || ignoredDeps.length === 0
+      ? workspaceDependencies
+      : omit(workspaceDependencies, ignoredDeps);
+
+  if (dependencies === undefined || depsToCheck === undefined) {
     return;
   }
 
   const expectedDependencies = {
     ...dependencies,
-    ...filterKeys(workspaceDependencies, dependencies),
+    ...filterKeys(depsToCheck, dependencies),
   };
 
   if (JSON.stringify(dependencies) !== JSON.stringify(expectedDependencies)) {
     context.addError({
       file: packagePath,
-      message: `Inconsitent ${block} with root in package.json`,
+      message: `Inconsistent ${block} with root in package.json`,
       longMessage: diff(expectedDependencies, dependencies, { expand: true }),
       fixer: () => {
         const newPackageJson = { ...packageJson };
         newPackageJson[block] = expectedDependencies;
-        writeJson(packagePath, newPackageJson);
+        context.host.writeJson(packagePath, newPackageJson);
       },
     });
   }
@@ -57,10 +68,21 @@ function filterKeys(ob: Record<string, string>, filterOb: Record<string, string>
   const newOb: Record<string, any> = {};
 
   for (const key of Object.keys(filterOb)) {
-    if (ob[key] !== undefined && filterOb[key] !== "*") {
+    if (ob[key] !== undefined && skippedVersions.indexOf(filterOb[key]) === -1) {
       newOb[key] = ob[key];
     }
   }
 
   return newOb;
 }
+
+function omit<T>(obj: Record<string, T>, keysToOmit: readonly string[]): Record<string, T> {
+  const newObj: Record<string, T> = {};
+
+  const filtered = Object.entries(obj).filter(([key]) => !keysToOmit.includes(key));
+  for (const [key, value] of filtered) {
+    newObj[key] = value;
+  }
+
+  return newObj;
+}

package/src/consistentVersions.ts

@@ -0,0 +1,140 @@
+/*!
+ * Copyright 2020 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+
+import { Context, RuleModule } from "@monorepolint/core";
+import { mutateJson, PackageJson } from "@monorepolint/utils";
+import * as r from "runtypes";
+import { coerce, SemVer } from "semver";
+
+export const Options = r.Record({
+  matchDependencyVersions: r.Dictionary(r.Union(r.String, r.Array(r.String))),
+});
+
+export type Options = r.Static<typeof Options>;
+
+export const consistentVersions: RuleModule<typeof Options> = {
+  check: checkConsistentVersions,
+  optionsRuntype: Options,
+};
+
+function checkConsistentVersions(context: Context, options: Options) {
+  for (const [dependencyPackageName, expectedPackageDependencyValue] of Object.entries(
+    options.matchDependencyVersions
+  )) {
+    if (Array.isArray(expectedPackageDependencyValue)) {
+      ensurePackageMatchesSomeVersion(context, dependencyPackageName, expectedPackageDependencyValue);
+    } else {
+      ensurePackageIsCorrectVersion(context, dependencyPackageName, expectedPackageDependencyValue);
+    }
+  }
+}
+
+const ensurePackageIsCorrectVersion = (
+  context: Context,
+  dependencyPackageName: string,
+  expectedPackageDependencyValue: string
+) => {
+  const packageJson = context.getPackageJson();
+  const packageJsonPath = context.getPackageJsonPath();
+
+  const expectedPackageDependencyVersion = coerce(expectedPackageDependencyValue);
+  if (expectedPackageDependencyVersion == null) {
+    throw new Error(
+      `Malformed expected package dependency version defined in monorepolint configuration: ${dependencyPackageName} @ '${expectedPackageDependencyValue}'`
+    );
+  }
+
+  const actualPackageDependencyValue = packageJson.dependencies && packageJson.dependencies[dependencyPackageName];
+  const actualPackageDependencyVersion = coerce(actualPackageDependencyValue);
+  if (
+    actualPackageDependencyVersion != null &&
+    actualPackageDependencyVersion.raw !== expectedPackageDependencyVersion.raw
+  ) {
+    context.addError({
+      file: packageJsonPath,
+      message: `Expected dependency on ${dependencyPackageName} to match version defined in monorepolint configuration '${expectedPackageDependencyValue}', got '${actualPackageDependencyValue}' instead.`,
+      fixer: () =>
+        mutateJson<PackageJson>(packageJsonPath, context.host, (input) => {
+          input.dependencies![dependencyPackageName] = expectedPackageDependencyValue;
+          return input;
+        }),
+    });
+  }
+
+  const actualPackageDevDependencyValue =
+    packageJson.devDependencies && packageJson.devDependencies[dependencyPackageName];
+  const actualPackageDevDependencyVersion = coerce(actualPackageDevDependencyValue);
+  if (
+    actualPackageDevDependencyVersion != null &&
+    actualPackageDevDependencyVersion.raw !== expectedPackageDependencyVersion.raw
+  ) {
+    context.addError({
+      file: packageJsonPath,
+      message: `Expected devDependency on ${dependencyPackageName} to match version defined in monorepolint configuration '${expectedPackageDependencyValue}', got '${actualPackageDevDependencyValue}' instead`,
+      fixer: () =>
+        mutateJson<PackageJson>(packageJsonPath, context.host, (input) => {
+          input.devDependencies![dependencyPackageName] = expectedPackageDependencyValue;
+          return input;
+        }),
+    });
+  }
+};
+
+const ensurePackageMatchesSomeVersion = (
+  context: Context,
+  dependencyPackageName: string,
+  acceptedPackageDependencyValues: string[]
+) => {
+  const packageJson = context.getPackageJson();
+  const packageJsonPath = context.getPackageJsonPath();
+
+  const acceptedPackageDependencyVersions: SemVer[] = acceptedPackageDependencyValues.map(
+    (acceptedPackageDependencyValue) => {
+      const acceptedPackageDependencyVersion = coerce(acceptedPackageDependencyValue);
+      if (acceptedPackageDependencyVersion == null) {
+        throw new Error(
+          `Malformed accepted package dependency version defined in monorepolint configuration: ${dependencyPackageName} @ '${acceptedPackageDependencyValue}'`
+        );
+      }
+      return acceptedPackageDependencyVersion;
+    }
+  );
+
+  const actualPackageDependencyValue = packageJson.dependencies && packageJson.dependencies[dependencyPackageName];
+  const actualPackageDependencyVersion = coerce(actualPackageDependencyValue);
+  if (
+    actualPackageDependencyVersion != null &&
+    acceptedPackageDependencyVersions.every(
+      (acceptedPackageDependencyVersion) => actualPackageDependencyVersion.raw !== acceptedPackageDependencyVersion.raw
+    )
+  ) {
+    context.addError({
+      file: packageJsonPath,
+      message: `Expected dependency on ${dependencyPackageName} to match one of '${JSON.stringify(
+        acceptedPackageDependencyValues
+      )}', got '${actualPackageDependencyValue}' instead.`,
+    });
+  }
+
+  const actualPackageDevDependencyValue =
+    packageJson.devDependencies && packageJson.devDependencies[dependencyPackageName];
+  const actualPackageDevDependencyVersion = coerce(actualPackageDevDependencyValue);
+  if (
+    actualPackageDevDependencyVersion != null &&
+    acceptedPackageDependencyVersions.every(
+      (acceptedPackageDependencyVersion) =>
+        actualPackageDevDependencyVersion.raw !== acceptedPackageDependencyVersion.raw
+    )
+  ) {
+    context.addError({
+      file: packageJsonPath,
+      message: `Expected devDependency on ${dependencyPackageName} to match one of '${JSON.stringify(
+        acceptedPackageDependencyValues
+      )}', got '${actualPackageDevDependencyValue}' instead.`,
+    });
+  }
+};

package/src/fileContents.ts

@@ -7,7 +7,6 @@
 
 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";
@@ -16,21 +15,21 @@ 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,
   })
 );
@@ -40,11 +39,10 @@ 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 actualContent = existsSync(fullPath) ? readFileSync(fullPath, "utf-8") : undefined;
+    const expectedContent = getExpectedContents(context, opts);
 
+    const pathExists = context.host.exists(fullPath);
+    const actualContent = pathExists ? context.host.readFile(fullPath, { encoding: "utf-8" }) : undefined;
     if (actualContent !== expectedContent) {
       context.addError({
         file: fullPath,
@@ -52,9 +50,10 @@ export const fileContents = {
         longMessage: diff(expectedContent, actualContent, { expand: true }),
         fixer: () => {
           if (expectedContent === undefined) {
-            unlinkSync(fullPath);
+            if (pathExists) context.host.deleteFile(fullPath);
           } else {
-            writeFileSync(fullPath, expectedContent);
+            context.host.mkdir(path.dirname(fullPath), { recursive: true });
+            context.host.writeFile(fullPath, expectedContent, { encoding: "utf-8" });
           }
         },
       });
@@ -63,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/index.ts

@@ -6,10 +6,15 @@
  */
 
 export { alphabeticalDependencies } from "./alphabeticalDependencies";
+export { alphabeticalScripts } from "./alphabeticalScripts";
 export { bannedDependencies } from "./bannedDependencies";
 export { consistentDependencies } from "./consistentDependencies";
+export { consistentVersions } from "./consistentVersions";
 export { fileContents } from "./fileContents";
+export { mustSatisfyPeerDependencies } from "./mustSatisfyPeerDependencies";
 export { packageOrder } from "./packageOrder";
 export { packageEntry } from "./packageEntry";
 export { packageScript } from "./packageScript";
 export { standardTsconfig } from "./standardTsconfig";
+export { nestedWorkspaces } from "./nestedWorkspaces";
+export { requireDependency } from "./requireDependency";