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

package/src/consistentVersions.ts

@@ -76,8 +76,7 @@ const ensurePackageIsCorrectVersion = (
         `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;
         }),
     });
@@ -99,8 +98,7 @@ const ensurePackageIsCorrectVersion = (
         `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;
         }),
     });
@@ -115,20 +113,19 @@ const ensurePackageMatchesSomeVersion = (
   const packageJson = context.getPackageJson();
   const packageJsonPath = context.getPackageJsonPath();
 
-  const acceptedPackageDependencyVersions: SemVer[] =
-    acceptedPackageDependencyValues.map(
-      (acceptedPackageDependencyValue) => {
-        const acceptedPackageDependencyVersion = coerce(
-          acceptedPackageDependencyValue,
+  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}'`,
         );
-        if (acceptedPackageDependencyVersion == null) {
-          throw new Error(
-            `Malformed accepted package dependency version defined in monorepolint configuration: ${dependencyPackageName} @ '${acceptedPackageDependencyValue}'`,
-          );
-        }
-        return acceptedPackageDependencyVersion;
-      },
-    );
+      }
+      return acceptedPackageDependencyVersion;
+    },
+  );
 
   const actualPackageDependencyValue = packageJson.dependencies
     && packageJson.dependencies[dependencyPackageName];
@@ -143,12 +140,11 @@ const ensurePackageMatchesSomeVersion = (
   ) {
     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.`,
     });
   }
 
@@ -167,12 +163,11 @@ const ensurePackageMatchesSomeVersion = (
   ) {
     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/forceError.ts

@@ -0,0 +1,33 @@
+import { createRuleFactory } from "./util/createRuleFactory.js";
+
+export const forceError = createRuleFactory<{ customMessage?: string }>({
+  name: "forceError",
+
+  check: async (context, opts) => {
+    context.addError({
+      message: opts?.customMessage
+        ?? "Forced error (often used to debug package selection)",
+      file: context.getPackageJsonPath(),
+    });
+  },
+
+  validateOptions: (opts): asserts opts is null | { customMessage: string } => {
+    if (opts == null) return;
+
+    if (typeof opts !== "object") {
+      throw new Error("options must be an object if provided");
+    }
+
+    const numKeys = Object.keys(opts).length;
+
+    if (numKeys === 0) return;
+
+    if (Object.keys(opts).length > 1 || !("customMessage" in opts)) {
+      throw new Error("options must only have `customMessage` property");
+    }
+
+    if (typeof opts.customMessage !== "string") {
+      throw new Error("customMessage must be a string");
+    }
+  },
+});

package/src/index.ts

@@ -11,8 +11,10 @@ export { bannedDependencies } from "./bannedDependencies.js";
 export { consistentDependencies } from "./consistentDependencies.js";
 export { consistentVersions } from "./consistentVersions.js";
 export { fileContents } from "./fileContents.js";
+export { forceError } from "./forceError.js";
 export { mustSatisfyPeerDependencies } from "./mustSatisfyPeerDependencies.js";
 export { nestedWorkspaces } from "./nestedWorkspaces.js";
+export { oncePerPackage } from "./oncePerPackage.js";
 export { packageEntry } from "./packageEntry.js";
 export { packageOrder } from "./packageOrder.js";
 export { packageScript } from "./packageScript.js";

package/src/mustSatisfyPeerDependencies.ts

@@ -303,8 +303,7 @@ function checkSatisfyPeerDependencies(context: Context, opts: Options) {
     if (dependencyRange != null) {
       context.addError({
         file: packageJsonPath,
-        message:
-          `[0] Package ${packageName} has overloaded ${peerDependencyName} dependencies.\n\t`
+        message: `[0] Package ${packageName} has overloaded ${peerDependencyName} dependencies.\n\t`
           + `Peer dependency '${peerDependencyRange}' and regular dependency '${dependencyRange}'.`,
       });
     }
@@ -446,8 +445,7 @@ function checkSatisfyPeerDependencies(context: Context, opts: Options) {
 
     // for every inherited peer dependency, this package must declare a dependency or peer dependency
     // equal to or stricter than `mostStrictPeerRequirement`
-    const packagePeerDependencyRange =
-      packagePeerDependencies[peerDependencyName];
+    const packagePeerDependencyRange = packagePeerDependencies[peerDependencyName];
     if (packageDependencyRange == null && packagePeerDependencyRange == null) {
       context.addError({
         file: packageJsonPath,
@@ -523,22 +521,17 @@ function getMostStrictStatement(
   mostStrictPeerRequirement: IResolvedPeerDependencyRequirement,
 ) {
   if (mostStrictPeerRequirement.fromPeerDependencyRequirements.length === 1) {
-    const dependencyName =
-      mostStrictPeerRequirement.fromPeerDependencyRequirements[0]
-        .fromPackageName;
+    const dependencyName = mostStrictPeerRequirement.fromPeerDependencyRequirements[0]
+      .fromPackageName;
     return `Dependency ${dependencyName} requires '${mostStrictPeerRequirement.range}'.`;
   } else {
     const dependencyNames = mostStrictPeerRequirement
       .fromPeerDependencyRequirements
-      .map((peerDependencyRequirement) =>
-        peerDependencyRequirement.fromPackageName
-      )
+      .map((peerDependencyRequirement) => peerDependencyRequirement.fromPackageName)
       .join(", ");
     const dependencyRequirements = mostStrictPeerRequirement
       .fromPeerDependencyRequirements
-      .map((peerDependencyRequirement) =>
-        `'${peerDependencyRequirement.range}'`
-      )
+      .map((peerDependencyRequirement) => `'${peerDependencyRequirement.range}'`)
       .join(", ");
     return (
       `Dependencies [${dependencyNames}] require [${dependencyRequirements}] respectively, `
@@ -612,9 +605,7 @@ export function findIntersection(
       .map((bVersion) => {
         const bSemVer = coerce(bVersion)!;
         if (bVersion.startsWith("^") && bSemVer.major >= aSemVer.major) {
-          return `^${
-            bSemVer.compare(aSemVer) >= 0 ? bSemVer.raw : aSemVer.raw
-          }`;
+          return `^${bSemVer.compare(aSemVer) >= 0 ? bSemVer.raw : aSemVer.raw}`;
         }
         return bSemVer.compare(aSemVer) !== -1 ? bVersion : undefined;
       })
@@ -633,9 +624,7 @@ export function findIntersection(
       .map((aVersion) => {
         const aSemVer = coerce(aVersion)!;
         if (aVersion.startsWith("^") && aSemVer.major >= bSemVer.major) {
-          return `^${
-            aSemVer.compare(bSemVer) >= 0 ? aSemVer.raw : bSemVer.raw
-          }`;
+          return `^${aSemVer.compare(bSemVer) >= 0 ? aSemVer.raw : bSemVer.raw}`;
         }
         return aSemVer.compare(bSemVer) !== -1 ? aVersion : undefined;
       })
@@ -649,9 +638,7 @@ export function findIntersection(
   const compatibleVersions = aVersions
     .map((aVersion) => {
       const aSemVer = coerce(aVersion)!;
-      const majorMatchingBVersion = bVersions.find((m) =>
-        coerce(m)!.major === aSemVer.major
-      );
+      const majorMatchingBVersion = bVersions.find((m) => coerce(m)!.major === aSemVer.major);
       if (majorMatchingBVersion === undefined) {
         // there is no intersecting `b` major version for this `a` major version
         return undefined;
@@ -757,9 +744,7 @@ export function doesASatisfyB(a: ValidRange, b: ValidRange): boolean {
 
   return aVersions.every((aVersion) => {
     const aSemVer = coerce(aVersion)!;
-    const majorMatchingBVersion = bVersions.find((m) =>
-      coerce(m)!.major === aSemVer.major
-    );
+    const majorMatchingBVersion = bVersions.find((m) => coerce(m)!.major === aSemVer.major);
     if (majorMatchingBVersion === undefined) {
       // `a` permits a major version that is not permitted by `b`, therefore `a` is "less strict"
       return false;

package/src/nestedWorkspaces.ts

@@ -42,9 +42,7 @@ export const nestedWorkspaces = createRuleFactory({
     }
 
     // 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`
-    );
+    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([
@@ -58,13 +56,11 @@ export const nestedWorkspaces = createRuleFactory({
     );
 
     if (difference.length !== 0) {
-      const differencesList = difference.map((packageJsonPath) =>
-        path.dirname(packageJsonPath)
-      ).join(", ");
+      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}. `
+        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/*\".",
       });
     }

package/src/oncePerPackage.ts

@@ -0,0 +1,32 @@
+import * as r from "runtypes";
+import { createRuleFactory } from "./util/createRuleFactory.js";
+
+export const Options = r.Record({
+  singletonKey: r.String.Or(r.Symbol),
+  customMessage: r.String.optional(),
+});
+
+export type Options = r.Static<typeof Options>;
+
+const visitedMap = new Map<string | symbol, Set<string>>();
+
+export const oncePerPackage = createRuleFactory<Options>({
+  name: "oncePerPackage",
+
+  check: async (context, options) => {
+    const visited = visitedMap.get(options.singletonKey) ?? new Set<string>();
+    visitedMap.set(options.singletonKey, visited);
+
+    if (visited.has(context.getName())) {
+      context.addError({
+        message: "This package has already been visited for this key: "
+          + options.singletonKey.toString(),
+        file: context.getPackageJsonPath(),
+      });
+    } else {
+      visited.add(context.getName());
+    }
+  },
+
+  validateOptions: Options.assert,
+});

package/src/requireDependency.ts

@@ -44,9 +44,7 @@ export const requireDependency = createRuleFactory({
           fixer: () => {
             mutateJson<PackageJson>(packageJsonPath, context.host, (input) => {
               input[type] = Object.fromEntries(
-                Object.entries(expectedEntries).filter(([, v]) =>
-                  v !== undefined
-                ),
+                Object.entries(expectedEntries).filter(([, v]) => v !== undefined),
               ) as Record<string, string>;
               return input;
             });

package/src/util/packageDependencyGraphService.ts

@@ -38,9 +38,7 @@ export interface IPackageDependencyGraphService {
 }
 
 /** Default implementation of the package dependency graph service. */
-export class PackageDependencyGraphService
-  implements IPackageDependencyGraphService
-{
+export class PackageDependencyGraphService implements IPackageDependencyGraphService {
   /** Construct a graph of package dependencies and return the root node. */
   public buildDependencyGraph(
     startPackageJsonPath: string,

package/vitest.config.mjs

@@ -1,8 +1,4 @@
-import {
-  coverageConfigDefaults,
-  defaultExclude,
-  defineProject,
-} from "vitest/config";
+import { coverageConfigDefaults, defaultExclude, defineProject } from "vitest/config";
 
 export default defineProject({
   test: {