@monorepolint/rules 0.6.0-alpha.1 → 0.6.0-alpha.3

package/src/bannedDependencies.ts

@@ -11,7 +11,10 @@ import { AggregateTiming } from "@monorepolint/utils";
 import * as path from "node:path";
 import * as r from "runtypes";
 import { createRuleFactory } from "./util/createRuleFactory.js";
-import { IPackageDependencyGraphNode, PackageDependencyGraphService } from "./util/packageDependencyGraphService.js";
+import {
+  IPackageDependencyGraphNode,
+  PackageDependencyGraphService,
+} from "./util/packageDependencyGraphService.js";
 // FIXME: This rule is messed. bannedTransitiveDependencies doesnt glob
 
 const bannedDepGlobsField = r.Union(
@@ -19,7 +22,7 @@ const bannedDepGlobsField = r.Union(
   r.Record({
     glob: r.Array(r.String).optional(),
     exact: r.Array(r.String).optional(),
-  })
+  }),
 );
 
 const Options = r.Union(
@@ -27,16 +30,14 @@ const Options = r.Union(
     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>;
@@ -57,11 +58,17 @@ export const bannedDependencies = createRuleFactory<Options>({
     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 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 {
+      bannedDependencies: banned,
+      bannedTransitiveDependencies: transitives,
+    } = opts;
 
     const globs = banned && (Array.isArray(banned) ? banned : banned.glob);
     const exacts = banned && (Array.isArray(banned) ? undefined : banned.exact);
@@ -89,8 +96,8 @@ export const bannedDependencies = createRuleFactory<Options>({
       context.addError({
         file: packagePath,
         message:
-          `Found ${violations.size} banned dependencies of package.json:\n\t` +
-          Array.from(violations)
+          `Found ${violations.size} banned dependencies of package.json:\n\t`
+          + Array.from(violations)
             .map((v) => `'${v}'`)
             .join(", "),
       });
@@ -113,7 +120,11 @@ export const bannedDependencies = createRuleFactory<Options>({
   },
 });
 
-function populateProblemsExact(banned: Set<string>, dependencies: ReadonlyArray<string>, violations: Set<string>) {
+function populateProblemsExact(
+  banned: Set<string>,
+  dependencies: ReadonlyArray<string>,
+  violations: Set<string>,
+) {
   for (const dependency of dependencies) {
     if (banned.has(dependency)) {
       violations.add(dependency);
@@ -124,7 +135,7 @@ function populateProblemsExact(banned: Set<string>, dependencies: ReadonlyArray<
 function populateProblemsGlobs(
   bannedDependencyGlobs: ReadonlyArray<string>,
   dependencies: ReadonlyArray<string>,
-  violations: Set<string>
+  violations: Set<string>,
 ) {
   for (const dependency of dependencies) {
     if (matchesAnyGlob(dependency, bannedDependencyGlobs)) {
@@ -136,13 +147,19 @@ function populateProblemsGlobs(
 // 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);
+  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(" -> ");
+        const pathing = [
+          ...importPathWithoutRoot.map(nameOrPackageJsonPath),
+          dependency,
+        ].join(" -> ");
 
         context.addError({
           file: root.paths.packageJsonPath,

package/src/consistentDependencies.ts

@@ -28,7 +28,11 @@ export const consistentDependencies = createRuleFactory<Options>({
   validateOptions: Options.check,
 });
 
-function checkDeps(context: Context, args: Options, 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];
@@ -37,10 +41,9 @@ function checkDeps(context: Context, args: Options, block: "dependencies" | "dev
   const workspaceDependencies = workspacePackageJson[block];
 
   const ignoredDeps = args?.ignoredDependencies ?? [];
-  const depsToCheck =
-    workspaceDependencies == null || ignoredDeps.length === 0
-      ? workspaceDependencies
-      : omit(workspaceDependencies, ignoredDeps);
+  const depsToCheck = workspaceDependencies == null || ignoredDeps.length === 0
+    ? workspaceDependencies
+    : omit(workspaceDependencies, ignoredDeps);
 
   if (dependencies === undefined || depsToCheck === undefined) {
     return;
@@ -65,12 +68,17 @@ function checkDeps(context: Context, args: Options, block: "dependencies" | "dev
   }
 }
 
-function filterKeys(ob: Record<string, string>, filterOb: Record<string, string>) {
+function filterKeys(
+  ob: Record<string, string>,
+  filterOb: Record<string, string>,
+) {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   const newOb: Record<string, any> = {};
 
   for (const key of Object.keys(filterOb)) {
-    if (ob[key] !== undefined && skippedVersions.indexOf(filterOb[key]) === -1) {
+    if (
+      ob[key] !== undefined && skippedVersions.indexOf(filterOb[key]) === -1
+    ) {
       newOb[key] = ob[key];
     }
   }
@@ -78,10 +86,15 @@ function filterKeys(ob: Record<string, string>, filterOb: Record<string, string>
   return newOb;
 }
 
-function omit<T>(obj: Record<string, T>, keysToOmit: readonly string[]): Record<string, T> {
+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));
+  const filtered = Object.entries(obj).filter(([key]) =>
+    !keysToOmit.includes(key)
+  );
   for (const [key, value] of filtered) {
     newObj[key] = value;
   }

package/src/consistentVersions.ts

@@ -23,13 +23,24 @@ export const consistentVersions = createRuleFactory({
 });
 
 function checkConsistentVersions(context: Context, options: Options) {
-  for (const [dependencyPackageName, expectedPackageDependencyValue] of Object.entries(
-    options.matchDependencyVersions
-  )) {
+  for (
+    const [dependencyPackageName, expectedPackageDependencyValue] of Object
+      .entries(
+        options.matchDependencyVersions,
+      )
+  ) {
     if (Array.isArray(expectedPackageDependencyValue)) {
-      ensurePackageMatchesSomeVersion(context, dependencyPackageName, expectedPackageDependencyValue);
+      ensurePackageMatchesSomeVersion(
+        context,
+        dependencyPackageName,
+        expectedPackageDependencyValue,
+      );
     } else {
-      ensurePackageIsCorrectVersion(context, dependencyPackageName, expectedPackageDependencyValue);
+      ensurePackageIsCorrectVersion(
+        context,
+        dependencyPackageName,
+        expectedPackageDependencyValue,
+      );
     }
   }
 }
@@ -37,48 +48,59 @@ function checkConsistentVersions(context: Context, options: Options) {
 const ensurePackageIsCorrectVersion = (
   context: Context,
   dependencyPackageName: string,
-  expectedPackageDependencyValue: string
+  expectedPackageDependencyValue: string,
 ) => {
   const packageJson = context.getPackageJson();
   const packageJsonPath = context.getPackageJsonPath();
 
-  const expectedPackageDependencyVersion = coerce(expectedPackageDependencyValue);
+  const expectedPackageDependencyVersion = coerce(
+    expectedPackageDependencyValue,
+  );
   if (expectedPackageDependencyVersion == null) {
     throw new Error(
-      `Malformed expected package dependency version defined in monorepolint configuration: ${dependencyPackageName} @ '${expectedPackageDependencyValue}'`
+      `Malformed expected package dependency version defined in monorepolint configuration: ${dependencyPackageName} @ '${expectedPackageDependencyValue}'`,
     );
   }
 
-  const actualPackageDependencyValue = packageJson.dependencies && packageJson.dependencies[dependencyPackageName];
+  const actualPackageDependencyValue = packageJson.dependencies
+    && packageJson.dependencies[dependencyPackageName];
   const actualPackageDependencyVersion = coerce(actualPackageDependencyValue);
   if (
-    actualPackageDependencyVersion != null &&
-    actualPackageDependencyVersion.raw !== expectedPackageDependencyVersion.raw
+    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.`,
+      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;
+          input.dependencies![dependencyPackageName] =
+            expectedPackageDependencyValue;
           return input;
         }),
     });
   }
 
-  const actualPackageDevDependencyValue =
-    packageJson.devDependencies && packageJson.devDependencies[dependencyPackageName];
-  const actualPackageDevDependencyVersion = coerce(actualPackageDevDependencyValue);
+  const actualPackageDevDependencyValue = packageJson.devDependencies
+    && packageJson.devDependencies[dependencyPackageName];
+  const actualPackageDevDependencyVersion = coerce(
+    actualPackageDevDependencyValue,
+  );
   if (
-    actualPackageDevDependencyVersion != null &&
-    actualPackageDevDependencyVersion.raw !== expectedPackageDependencyVersion.raw
+    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`,
+      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;
+          input.devDependencies![dependencyPackageName] =
+            expectedPackageDependencyValue;
           return input;
         }),
     });
@@ -88,54 +110,69 @@ const ensurePackageIsCorrectVersion = (
 const ensurePackageMatchesSomeVersion = (
   context: Context,
   dependencyPackageName: string,
-  acceptedPackageDependencyValues: 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}'`
+  const acceptedPackageDependencyVersions: SemVer[] =
+    acceptedPackageDependencyValues.map(
+      (acceptedPackageDependencyValue) => {
+        const acceptedPackageDependencyVersion = coerce(
+          acceptedPackageDependencyValue,
         );
-      }
-      return acceptedPackageDependencyVersion;
-    }
-  );
+        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 actualPackageDependencyValue = packageJson.dependencies
+    && packageJson.dependencies[dependencyPackageName];
   const actualPackageDependencyVersion = coerce(actualPackageDependencyValue);
   if (
-    actualPackageDependencyVersion != null &&
-    acceptedPackageDependencyVersions.every(
-      (acceptedPackageDependencyVersion) => actualPackageDependencyVersion.raw !== acceptedPackageDependencyVersion.raw
+    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.`,
+      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);
+  const actualPackageDevDependencyValue = packageJson.devDependencies
+    && packageJson.devDependencies[dependencyPackageName];
+  const actualPackageDevDependencyVersion = coerce(
+    actualPackageDevDependencyValue,
+  );
   if (
-    actualPackageDevDependencyVersion != null &&
-    acceptedPackageDependencyVersions.every(
+    actualPackageDevDependencyVersion != null
+    && acceptedPackageDependencyVersions.every(
       (acceptedPackageDependencyVersion) =>
-        actualPackageDevDependencyVersion.raw !== acceptedPackageDependencyVersion.raw
+        actualPackageDevDependencyVersion.raw
+          !== acceptedPackageDependencyVersion.raw,
     )
   ) {
     context.addError({
       file: packageJsonPath,
-      message: `Expected devDependency on ${dependencyPackageName} to match one of '${JSON.stringify(
-        acceptedPackageDependencyValues
-      )}', got '${actualPackageDevDependencyValue}' instead.`,
+      message:
+        `Expected devDependency on ${dependencyPackageName} to match one of '${
+          JSON.stringify(
+            acceptedPackageDependencyValues,
+          )
+        }', got '${actualPackageDevDependencyValue}' instead.`,
     });
   }
 };

package/src/fileContents.ts

@@ -13,24 +13,24 @@ import { createRuleFactory } from "./util/createRuleFactory.js";
 const Options = r.Union(
   r.Record({
     file: r.String,
-    generator: r.Function.withGuard((x): x is (context: Context) => string | Promise<string> => x != undefined),
+    generator: r.Function.withGuard((
+      x,
+    ): x is (context: Context) => string | Promise<string> => x != undefined),
     template: r.Undefined.optional(),
     templateFile: r.Undefined.optional(),
   }),
-
   r.Record({
     file: r.String,
     generator: r.Undefined.optional(),
-    template: r.String,
+    template: r.String.Or(r.Undefined),
     templateFile: r.Undefined.optional(),
   }),
-
   r.Record({
     file: r.String,
     generator: r.Undefined.optional(),
     template: r.Undefined.optional(),
     templateFile: r.String,
-  })
+  }),
 );
 
 type Options = r.Static<typeof Options>;
@@ -42,18 +42,30 @@ export const fileContents = createRuleFactory<Options>({
     const expectedContent = await getExpectedContents(context, opts);
 
     const pathExists = context.host.exists(fullPath);
-    const actualContent = pathExists ? context.host.readFile(fullPath, { encoding: "utf-8" }) : undefined;
+    const actualContent = pathExists
+      ? context.host.readFile(fullPath, { encoding: "utf-8" })
+      : undefined;
     if (actualContent !== expectedContent) {
+      const longMessage = pathExists && expectedContent == undefined
+        ? undefined
+        : diff(expectedContent, actualContent, { expand: true });
+
+      const message = pathExists && expectedContent == undefined
+        ? "File should not exist"
+        : "Expect file contents to match";
+
       context.addError({
         file: fullPath,
-        message: "Expect file contents to match",
-        longMessage: diff(expectedContent, actualContent, { expand: true }),
+        message,
+        longMessage,
         fixer: () => {
           if (expectedContent === undefined) {
             if (pathExists) context.host.deleteFile(fullPath);
           } else {
             context.host.mkdir(path.dirname(fullPath), { recursive: true });
-            context.host.writeFile(fullPath, expectedContent, { encoding: "utf-8" });
+            context.host.writeFile(fullPath, expectedContent, {
+              encoding: "utf-8",
+            });
           }
         },
       });
@@ -64,7 +76,9 @@ export const fileContents = createRuleFactory<Options>({
 
 const optionsCache = new Map<
   Options,
-  ((context: Context) => Promise<string> | string | undefined) | string | undefined
+  | ((context: Context) => Promise<string> | string | undefined)
+  | string
+  | undefined
 >();
 
 async function getExpectedContents(context: Context, opts: Options) {

package/src/index.ts

@@ -12,12 +12,12 @@ export { consistentDependencies } from "./consistentDependencies.js";
 export { consistentVersions } from "./consistentVersions.js";
 export { fileContents } from "./fileContents.js";
 export { mustSatisfyPeerDependencies } from "./mustSatisfyPeerDependencies.js";
-export { packageOrder } from "./packageOrder.js";
+export { nestedWorkspaces } from "./nestedWorkspaces.js";
 export { packageEntry } from "./packageEntry.js";
+export { packageOrder } from "./packageOrder.js";
 export { packageScript } from "./packageScript.js";
-export { standardTsconfig } from "./standardTsconfig.js";
-export { nestedWorkspaces } from "./nestedWorkspaces.js";
 export { requireDependency } from "./requireDependency.js";
+export { standardTsconfig } from "./standardTsconfig.js";
 
 export {
   createRuleFactory,