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

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,7 +86,10 @@ 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));

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,27 +48,32 @@ 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;
@@ -66,16 +82,20 @@ const ensurePackageIsCorrectVersion = (
     });
   }
 
-  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;
@@ -88,54 +108,66 @@ 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);
+      const acceptedPackageDependencyVersion = coerce(
+        acceptedPackageDependencyValue,
+      );
       if (acceptedPackageDependencyVersion == null) {
         throw new Error(
-          `Malformed accepted package dependency version defined in monorepolint configuration: ${dependencyPackageName} @ '${acceptedPackageDependencyValue}'`
+          `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.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,13 +42,17 @@ 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 longMessage = pathExists && expectedContent == undefined
+        ? undefined
+        : diff(expectedContent, actualContent, { expand: true });
 
-      const message =
-        pathExists && expectedContent == undefined ? "File should not exist" : "Expect file contents to match";
+      const message = pathExists && expectedContent == undefined
+        ? "File should not exist"
+        : "Expect file contents to match";
 
       context.addError({
         file: fullPath,
@@ -59,7 +63,9 @@ export const fileContents = createRuleFactory<Options>({
             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",
+            });
           }
         },
       });
@@ -70,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/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,13 +11,15 @@ 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 { packageOrder } from "./packageOrder.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";
-export { standardTsconfig } from "./standardTsconfig.js";
-export { nestedWorkspaces } from "./nestedWorkspaces.js";
 export { requireDependency } from "./requireDependency.js";
+export { standardTsconfig } from "./standardTsconfig.js";
 
 export {
   createRuleFactory,