@monorepolint/rules 0.5.0-alpha.10 → 0.5.0-alpha.103

package/src/nestedWorkspaces.ts

@@ -0,0 +1,61 @@
+/*!
+ * Copyright 2019 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+
+import { Context, RuleModule } from "@monorepolint/config";
+import * as globby from "globby";
+import * as path from "node:path";
+import * as r from "runtypes";
+import { createNewRuleConversion } from "./util/createNewRuleConversion.js";
+export const Options = r.Undefined;
+
+type Options = r.Static<typeof Options>;
+
+// Enforce that the root package.json contains all of the workspaces in the repo (including nested packages)
+export const nestedWorkspaces: RuleModule<typeof Options> = {
+  check: (context: Context) => {
+    const rootPackageJson = context.getWorkspaceContext().getPackageJson();
+
+    // Expand a set of globs covering all package.json files in the entire repo (except the root)
+    const packageJsonPaths = globby.globbySync(["*/**/package.json", "!**/node_modules/**"]);
+
+    const workspaces = Array.isArray(rootPackageJson.workspaces)
+      ? rootPackageJson.workspaces
+      : rootPackageJson.workspaces !== undefined
+      ? rootPackageJson.workspaces.packages
+      : undefined;
+
+    if (workspaces === undefined && packageJsonPaths.length > 0) {
+      context.addError({
+        file: context.getPackageJsonPath(),
+        message: 'The "workspace" field is missing, even though there are workspaces in the repository.',
+      });
+      return;
+    }
+
+    // Build a set of globs for each package.json that exists in packages specified by a workspace.
+    const workspacePackageJsons = (workspaces || []).map((item) => `${item}/package.json`);
+
+    // Expand the globs to get an array of all package.json files that are in packages specified by a workspace.
+    const expandedWorkspacesGlobs = globby.globbySync([...workspacePackageJsons, "!**/node_modules/**"]);
+
+    // Ensure there are no package.jsons which are not included in the globbed workspaces set
+    const difference = packageJsonPaths.filter((packageJsonPath) => !expandedWorkspacesGlobs.includes(packageJsonPath));
+
+    if (difference.length !== 0) {
+      const differencesList = difference.map((packageJsonPath) => path.dirname(packageJsonPath)).join(", ");
+      context.addError({
+        file: context.getPackageJsonPath(),
+        message:
+          `The "workspace" field is missing one or more values: ${differencesList}. ` +
+          'You may be able to use a glob to avoid listing each workspace individually, e.g. "packages/nested-workspace/*".',
+      });
+    }
+  },
+  optionsRuntype: Options,
+};
+
+export const NestedWorkspaces = createNewRuleConversion("NestedWorkspaces", nestedWorkspaces);

package/src/packageEntry.ts

@@ -5,42 +5,87 @@
  *
  */
 
-import { Context, RuleModule } from "@monorepolint/core";
+import { Context, RuleModule } from "@monorepolint/config";
 import { mutateJson, PackageJson } from "@monorepolint/utils";
-import diff from "jest-diff";
+import { diff } from "jest-diff";
 import * as r from "runtypes";
-
-export const Options = r.Record({
-  entries: r.Dictionary(r.Unknown), // string => unknown
-});
+import { createNewRuleConversion } from "./util/createNewRuleConversion.js";
+export const Options = r.Union(
+  r
+    .Record({
+      entries: r.Dictionary(r.Unknown), // string => unknown, enforces existence of keys and their values
+    })
+    .And(
+      r.Partial({
+        entriesExist: r.Undefined,
+      })
+    ),
+  r
+    .Record({
+      entriesExist: r.Array(r.String), // enforces existence of keys, but not values
+    })
+    .And(
+      r.Partial({
+        entries: r.Undefined,
+      })
+    ),
+  r.Record({
+    entries: r.Dictionary(r.Unknown), // string => unknown, enforces existence of keys and their values
+    entriesExist: r.Array(r.String),
+  })
+);
 
 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();
 
-    for (const key of Object.keys(options.entries)) {
-      const value = options.entries[key];
-
-      const entryDiff = diff(JSON.stringify(value) + "\n", (JSON.stringify(packageJson[key]) || "") + "\n");
-      if (
-        (typeof value !== "object" && value !== packageJson[key]) ||
-        (entryDiff == null || !entryDiff.includes("Compared values have no visual difference"))
-      ) {
-        context.addError({
-          file: context.getPackageJsonPath(),
-          message: `Expected standardized entry for '${key}'`,
-          longMessage: entryDiff,
-          fixer: () => {
-            mutateJson<PackageJson>(context.getPackageJsonPath(), input => {
-              input[key] = value;
-              return input;
-            });
-          },
-        });
+    if (options.entries) {
+      for (const key of Object.keys(options.entries)) {
+        const value = options.entries[key];
+
+        const entryDiff = diff(JSON.stringify(value) + "\n", (JSON.stringify(packageJson[key]) || "") + "\n");
+        if (
+          (typeof value !== "object" && value !== packageJson[key]) ||
+          entryDiff == null ||
+          !entryDiff.includes("Compared values have no visual difference")
+        ) {
+          context.addError({
+            file: context.getPackageJsonPath(),
+            message: createStandardizedEntryErrorMessage(key),
+            longMessage: entryDiff,
+            fixer: () => {
+              mutateJson<PackageJson>(context.getPackageJsonPath(), context.host, (input) => {
+                input[key] = value;
+                return input;
+              });
+            },
+          });
+        }
+      }
+    }
+
+    if (options.entriesExist) {
+      for (const key of options.entriesExist) {
+        if (packageJson[key] === undefined) {
+          context.addError({
+            file: context.getPackageJsonPath(),
+            message: createExpectedEntryErrorMessage(key),
+          });
+        }
       }
     }
   },
   optionsRuntype: Options,
-} as RuleModule<typeof Options>;
+};
+
+export const PackageEntry = createNewRuleConversion("PackageEntry", packageEntry);
+
+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

@@ -5,11 +5,10 @@
  *
  */
 
-import { Context, RuleModule } from "@monorepolint/core";
-import { writeJson } from "@monorepolint/utils";
-import diff from "jest-diff";
+import { Context, RuleModule } from "@monorepolint/config";
+import { diff } from "jest-diff";
 import * as r from "runtypes";
-
+import { createNewRuleConversion } from "./util/createNewRuleConversion.js";
 type OrderFunction = (context: Context) => (a: string, b: string) => number;
 
 const Options = r
@@ -28,9 +27,12 @@ const defaultKeyOrder = [
   "contributors",
   "url",
   "license",
+  "type",
+  "exports",
   "private",
   "engines",
   "bin",
+  "types",
   "main",
   "module",
   "typings",
@@ -56,10 +58,10 @@ export const packageOrder = {
 
     const order: string[] | OrderFunction = opts === undefined ? defaultKeyOrder : opts.order;
 
-    const compartor = isOrderFunction(order) ? order(context) : createCompartor(order);
+    const comparator = isOrderFunction(order) ? order(context) : createComparator(order);
 
     const actualOrder = Object.keys(packageJson);
-    const expectedOrder = actualOrder.slice().sort(compartor); // sort mutates, so we need to copy the previous result
+    const expectedOrder = actualOrder.slice().sort(comparator); // sort mutates, so we need to copy the previous result
 
     if (!arrayOrderCompare(actualOrder, expectedOrder)) {
       context.addError({
@@ -69,11 +71,11 @@ export const packageOrder = {
         fixer: () => {
           const expectedPackageJson: Record<string, any> = {};
 
-          expectedOrder.forEach(key => {
+          expectedOrder.forEach((key) => {
             expectedPackageJson[key] = packageJson[key];
           });
 
-          writeJson(packagePath, expectedPackageJson);
+          context.host.writeJson(packagePath, expectedPackageJson);
         },
       });
     }
@@ -81,6 +83,8 @@ export const packageOrder = {
   optionsRuntype: Options,
 } as RuleModule<typeof Options>;
 
+export const PackageOrder = createNewRuleConversion("PackageOrder", packageOrder);
+
 function arrayOrderCompare(a: ReadonlyArray<string>, b: ReadonlyArray<string>) {
   for (let index = 0; index < a.length; index++) {
     if (a[index] !== b[index]) {
@@ -91,7 +95,7 @@ function arrayOrderCompare(a: ReadonlyArray<string>, b: ReadonlyArray<string>) {
   return true;
 }
 
-function createCompartor(order: ReadonlyArray<string>) {
+function createComparator(order: ReadonlyArray<string>) {
   return (a: string, b: string) => {
     const aIndex = order.indexOf(a);
     const bIndex = order.indexOf(b);

package/src/packageScript.ts

@@ -5,24 +5,20 @@
  *
  */
 
-import { Context, RuleModule } from "@monorepolint/core";
+import { Context, RuleModule } from "@monorepolint/config";
 import { mutateJson, PackageJson } from "@monorepolint/utils";
-import diff from "jest-diff";
+import { createNewRuleConversion } from "./util/createNewRuleConversion.js";
+import { diff } from "jest-diff";
 import * as r from "runtypes";
 
 export const Options = r.Record({
   scripts: r.Dictionary(
     r.Union(
       r.String,
-      r
-        .Record({
-          options: r.Array(r.String.Or(r.Undefined)),
-        })
-        .And(
-          r.Partial({
-            fixValue: r.Union(r.String, r.Undefined, r.Literal(false)),
-          })
-        )
+      r.Record({
+        options: r.Array(r.String.Or(r.Undefined)),
+        fixValue: r.Union(r.String, r.Undefined, r.Literal(false)).optional(),
+      })
     )
   ), // string => string
 });
@@ -39,7 +35,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;
           });
@@ -63,7 +59,7 @@ export const packageScript = {
           }
           allowedValues.add(q);
         }
-        fixToEmpty = value.hasOwnProperty("fixValue") && value.fixValue === undefined;
+        fixToEmpty = Object.prototype.hasOwnProperty.call(value, "fixValue") && value.fixValue === undefined;
         fixValue = value.fixValue;
       }
 
@@ -75,7 +71,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 {
@@ -87,7 +83,7 @@ export const packageScript = {
         }
 
         const validOptionsString = Array.from(allowedValues.values())
-          .map(a => (a === undefined ? "(empty)" : `'${a}'`))
+          .map((a) => (a === undefined ? "(empty)" : `'${a}'`))
           .join(", ");
 
         context.addError({
@@ -101,3 +97,5 @@ export const packageScript = {
   },
   optionsRuntype: Options,
 } as RuleModule<typeof Options>;
+
+export const PackageScript = createNewRuleConversion("PackageScript", packageScript);

package/src/requireDependency.ts

@@ -0,0 +1,71 @@
+/*!
+ * Copyright 2019 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+
+import { Context, RuleModule } from "@monorepolint/config";
+import { mutateJson, PackageJson } from "@monorepolint/utils";
+import { diff } from "jest-diff";
+import * as r from "runtypes";
+import { createNewRuleConversion } from "./util/createNewRuleConversion.js";
+const Options = r.Partial({
+  dependencies: r.Dictionary(r.String),
+  devDependencies: r.Dictionary(r.String),
+  peerDependencies: r.Dictionary(r.String),
+  optionalDependencies: r.Dictionary(r.String),
+});
+
+type Options = r.Static<typeof Options>;
+
+export const requireDependency = {
+  check: function expectPackageEntry(context: Context, options: Options) {
+    const packageJson = context.getPackageJson();
+    const packageJsonPath = context.getPackageJsonPath();
+
+    [
+      "dependencies" as const,
+      "devDependencies" as const,
+      "peerDependencies" as const,
+      "optionalDependencies" as const,
+    ].forEach((type) => {
+      if (!options[type]) {
+        return;
+      }
+
+      if (packageJson[type] === undefined) {
+        context.addError({
+          file: packageJsonPath,
+          message: `No ${type} block, cannot add required ${type}.`,
+          fixer: () => {
+            mutateJson<PackageJson>(packageJsonPath, context.host, (input) => {
+              input[type] = options[type];
+              return input;
+            });
+          },
+        });
+        return;
+      }
+
+      for (const [dep, version] of Object.entries(options[type]!)) {
+        if (packageJson[type][dep] !== version) {
+          context.addError({
+            file: packageJsonPath,
+            message: `Expected dependency ${dep}@${version}`,
+            longMessage: diff(`${dep}@${version}\n`, `${dep}@${packageJson[type][dep] || "missing"}\n`)!,
+            fixer: () => {
+              mutateJson<PackageJson>(packageJsonPath, context.host, (input) => {
+                input[type] = { ...input[type], [dep]: version };
+                return input;
+              });
+            },
+          });
+        }
+      }
+    });
+  },
+  optionsRuntype: Options,
+} as RuleModule<typeof Options>;
+
+export const RequireDependency = createNewRuleConversion("RequireDependency", requireDependency);

package/src/standardTsconfig.ts

@@ -5,20 +5,24 @@
  *
  */
 
-import { Context, RuleModule } from "@monorepolint/core";
-import { getPackageNameToDir } from "@monorepolint/utils";
-import { existsSync, readFileSync, writeFileSync } from "fs";
-import diff from "jest-diff";
-import minimatch from "minimatch";
+import { Context, RuleModule } from "@monorepolint/config";
+import { matchesAnyGlob } from "@monorepolint/utils";
+import { diff } from "jest-diff";
+import { createNewRuleConversion } from "./util/createNewRuleConversion.js";
 import * as path from "path";
 import * as r from "runtypes";
 
+const DEFAULT_TSCONFIG_FILENAME = "tsconfig.json";
+
 const Options = r
   .Partial({
+    file: r.String,
     generator: r.Function,
+    tsconfigReferenceFile: r.String,
     template: r.Record({}).Or(r.String),
     templateFile: r.String,
     excludedReferences: r.Array(r.String).Or(r.Undefined),
+    additionalReferences: r.Array(r.String).Or(r.Undefined),
   })
   .withConstraint(({ generator, template, templateFile }) => {
     let count = 0;
@@ -35,15 +39,18 @@ const Options = r
     return count === 1 || "Expect one of { generator, template, templateFile }";
   });
 
-export type Options = r.Static<typeof Options>;
+export interface Options extends r.Static<typeof Options> {}
 
 export const standardTsconfig = {
-  check: function expectStandardTsconfig(context: Context, opts: Options) {
-    const fullPath = path.resolve(context.packageDir, "tsconfig.json");
+  check: async function expectStandardTsconfig(context: Context, opts: Options) {
+    const tsconfigFileName = opts.file ?? DEFAULT_TSCONFIG_FILENAME;
+    const fullPath = path.resolve(context.packageDir, tsconfigFileName);
     const generator = getGenerator(context, opts);
-    const expectedContent = generator(context);
+    const expectedContent = await 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({
@@ -59,7 +66,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",
+          });
         },
       });
     }
@@ -67,43 +76,59 @@ export const standardTsconfig = {
   optionsRuntype: Options,
 } as RuleModule<typeof Options>;
 
+export const StandardTsConfig = createNewRuleConversion("StandardTsconfig", standardTsconfig);
+
 function getGenerator(context: Context, opts: Options) {
   if (opts.generator) {
     return opts.generator;
   } 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);
+    return makeGenerator(template, opts.excludedReferences, opts.additionalReferences, opts.tsconfigReferenceFile);
   } else if (opts.template) {
-    return makeGenerator(opts.template, opts.excludedReferences);
+    return makeGenerator(opts.template, opts.excludedReferences, opts.additionalReferences, opts.tsconfigReferenceFile);
   } else {
     throw new Error("Unable to make generator");
   }
 }
 
-function makeGenerator(template: any, excludedReferences: ReadonlyArray<string> = []) {
-  return function generator(context: Context) {
+function makeGenerator(
+  template: any,
+  excludedReferences: ReadonlyArray<string> | undefined,
+  additionalReferences: ReadonlyArray<string> | undefined,
+  tsconfigReferenceFile?: string
+) {
+  return async function generator(context: Context) {
     template = {
       ...template,
       references: [],
     }; // make a copy and ensure we have a references array
 
-    const nameToDirectory = getPackageNameToDir(context.getWorkspaceContext().packageDir);
+    const nameToDirectory = await context.getWorkspaceContext().getPackageNameToDir();
 
     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 => {
+    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, nameToDirectory.get(packageName)!),
+          path: path.relative(context.packageDir, absoluteReferencePath),
         });
-      });
+      }
+    }
+
+    if (additionalReferences) {
+      for (const additionalReference of additionalReferences) {
+        template.references.push({
+          path: additionalReference,
+        });
+      }
+    }
 
     return JSON.stringify(template, undefined, 2) + "\n";
   };

package/src/util/checkAlpha.ts

@@ -0,0 +1,59 @@
+/*!
+ * Copyright 2019 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+
+import { Context } from "@monorepolint/config";
+import { diff } from "jest-diff";
+
+export function checkAlpha(
+  context: Context,
+  block: "dependencies" | "devDependencies" | "peerDependencies" | "scripts"
+) {
+  const packageJson = context.getPackageJson();
+  const packagePath = context.getPackageJsonPath();
+
+  const blockToSort = packageJson[block];
+
+  if (blockToSort === undefined) {
+    return;
+  }
+
+  const actualOrder = Object.keys(blockToSort);
+  const expectedOrder = actualOrder.slice().sort(); // sort mutates, so we need to copy the previous result
+
+  if (!arrayOrderCompare(actualOrder, expectedOrder)) {
+    context.addError({
+      file: packagePath,
+      message: createIncorrectOrderErrorMessage(block, packageJson.name!),
+      longMessage: diff(expectedOrder, actualOrder, { expand: true }),
+      fixer: () => {
+        const expectedDependencies: Record<string, string> = {};
+
+        expectedOrder.forEach((dep) => {
+          expectedDependencies[dep] = blockToSort[dep];
+        });
+
+        const newPackageJson = { ...packageJson };
+        newPackageJson[block] = expectedDependencies;
+        context.host.writeJson(packagePath, newPackageJson);
+      },
+    });
+  }
+}
+
+function arrayOrderCompare(a: ReadonlyArray<string>, b: ReadonlyArray<string>) {
+  for (let index = 0; index < a.length; index++) {
+    if (a[index] !== b[index]) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+export function createIncorrectOrderErrorMessage(block: string, packageName: string) {
+  return `Incorrect order of ${block} in ${packageName}'s package.json`;
+}

package/src/util/createNewRuleConversion.ts

@@ -0,0 +1,38 @@
+/*!
+ * Copyright 2022 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+
+import { Checker, Context, NewRuleModule, RuleModule, RuleEntry } from "@monorepolint/config";
+import * as r from "runtypes";
+
+// tslint:disable max-classes-per-file
+
+let id = 0;
+export class NewRuleConverterBase<T extends r.Runtype<unknown>> implements NewRuleModule<T> {
+  public readonly id: string;
+  options: r.Static<T> | undefined;
+
+  constructor(
+    public readonly name: string,
+    public checkFunc: Checker<T>,
+    public readonly optionsRuntype: T,
+    public readonly ruleEntry: RuleEntry<r.Static<T>>
+  ) {
+    this.options = ruleEntry.options;
+    this.id = `${this.name} :: ${id++}`;
+    //
+  }
+
+  public check = (context: Context) => this.checkFunc(context, this.ruleEntry.options, { id: this.id });
+}
+
+export function createNewRuleConversion<T extends r.Runtype<unknown>>(name: string, old: RuleModule<T>) {
+  return class NewRule extends NewRuleConverterBase<T> {
+    constructor(ruleEntry: RuleEntry<r.Static<T>>) {
+      super(name, old.check, old.optionsRuntype, ruleEntry);
+    }
+  };
+}

package/src/util/makeDirectory.ts

@@ -0,0 +1,24 @@
+/*!
+ * Copyright 2019 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+
+import { existsSync, mkdirSync } from "fs";
+import * as path from "path";
+
+export function makeDirectoryRecursively(directoryPath: string) {
+  // node < 10 doesn't support mkdirSync w/ recursive: true
+  // so we manually do it instead
+  const dirSegments = directoryPath.split(path.sep);
+  for (let i = 0; i < dirSegments.length; i++) {
+    if (dirSegments[i].length > 0) {
+      // we skip the empty segment
+      const curDirPath = dirSegments.slice(0, i + 1).join(path.sep);
+      if (!existsSync(curDirPath)) {
+        mkdirSync(curDirPath);
+      }
+    }
+  }
+}