@monorepolint/rules 0.5.0-alpha.7 → 0.5.0-alpha.70

package/src/consistentDependencies.ts

@@ -10,19 +10,25 @@ 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,19 +36,25 @@ 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 };
@@ -57,10 +69,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, (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, (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

@@ -11,6 +11,7 @@ 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({
@@ -43,17 +44,18 @@ export const fileContents = {
     const generator = getGenerator(context, opts);
     const expectedContent = generator(context);
 
-    const actualContent = existsSync(fullPath) ? readFileSync(fullPath, "utf-8") : undefined;
-
+    const pathExists = existsSync(fullPath);
+    const actualContent = pathExists ? readFileSync(fullPath, "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) {
+          if (expectedContent === undefined && pathExists) {
             unlinkSync(fullPath);
           } else {
+            makeDirectoryRecursively(path.dirname(fullPath));
             writeFileSync(fullPath, expectedContent);
           }
         },

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";