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

package/src/consistentVersions.ts

@@ -7,19 +7,19 @@
 
 import { Context } from "@monorepolint/config";
 import { mutateJson, PackageJson } from "@monorepolint/utils";
-import * as r from "runtypes";
 import { coerce, SemVer } from "semver";
+import { z } from "zod";
 import { createRuleFactory } from "./util/createRuleFactory.js";
-export const Options = r.Record({
-  matchDependencyVersions: r.Dictionary(r.Union(r.String, r.Array(r.String))),
+export const Options = z.object({
+  matchDependencyVersions: z.record(z.string(), z.union([z.string(), z.array(z.string())])),
 });
 
-export type Options = r.Static<typeof Options>;
+export type Options = z.infer<typeof Options>;
 
 export const consistentVersions = createRuleFactory({
   name: "consistentVersions",
   check: checkConsistentVersions,
-  validateOptions: Options.check,
+  validateOptions: Options.parse,
 });
 
 function checkConsistentVersions(context: Context, options: Options) {
@@ -45,6 +45,39 @@ function checkConsistentVersions(context: Context, options: Options) {
   }
 }
 
+const shouldUpdateVersion = (
+  actualValue: string,
+  expectedValue: string,
+  isProtocolVersionString: boolean,
+  expectedSemVer: SemVer | null,
+): boolean => {
+  if (isProtocolVersionString) {
+    return actualValue !== expectedValue;
+  }
+
+  const actualSemVer = coerce(actualValue);
+  return actualSemVer != null && actualSemVer.raw !== expectedSemVer!.raw;
+};
+
+const matchesAnyVersion = (
+  actualValue: string,
+  protocolVersions: string[],
+  acceptedSemVerVersions: SemVer[],
+): boolean => {
+  if (protocolVersions.includes(actualValue)) {
+    return true;
+  }
+
+  const actualSemVer = coerce(actualValue);
+  if (actualSemVer == null) {
+    return false;
+  }
+
+  return acceptedSemVerVersions.some(
+    (acceptedSemVer) => actualSemVer.raw === acceptedSemVer.raw,
+  );
+};
+
 const ensurePackageIsCorrectVersion = (
   context: Context,
   dependencyPackageName: string,
@@ -53,55 +86,67 @@ const ensurePackageIsCorrectVersion = (
   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}'`,
-    );
+  // Allow protocol version strings like "catalog:", "workspace:", etc.
+  const isProtocolVersion = expectedPackageDependencyValue.endsWith(":");
+  let expectedPackageDependencyVersion: SemVer | null = null;
+
+  if (!isProtocolVersion) {
+    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, context.host, (input) => {
-          input.dependencies![dependencyPackageName] = expectedPackageDependencyValue;
-          return input;
-        }),
-    });
+
+  if (actualPackageDependencyValue != null) {
+    const shouldUpdate = shouldUpdateVersion(
+      actualPackageDependencyValue,
+      expectedPackageDependencyValue,
+      isProtocolVersion,
+      expectedPackageDependencyVersion,
+    );
+
+    if (shouldUpdate) {
+      context.addError({
+        file: packageJsonPath,
+        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;
+            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, context.host, (input) => {
-          input.devDependencies![dependencyPackageName] = expectedPackageDependencyValue;
-          return input;
-        }),
-    });
+
+  if (actualPackageDevDependencyValue != null) {
+    const shouldUpdateDev = shouldUpdateVersion(
+      actualPackageDevDependencyValue,
+      expectedPackageDependencyValue,
+      isProtocolVersion,
+      expectedPackageDependencyVersion,
+    );
+
+    if (shouldUpdateDev) {
+      context.addError({
+        file: packageJsonPath,
+        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;
+            return input;
+          }),
+      });
+    }
   }
 };
 
@@ -113,7 +158,11 @@ const ensurePackageMatchesSomeVersion = (
   const packageJson = context.getPackageJson();
   const packageJsonPath = context.getPackageJsonPath();
 
-  const acceptedPackageDependencyVersions: SemVer[] = acceptedPackageDependencyValues.map(
+  // Separate protocol versions from regular semver versions
+  const protocolVersions = acceptedPackageDependencyValues.filter(val => val.endsWith(":"));
+  const regularVersions = acceptedPackageDependencyValues.filter(val => !val.endsWith(":"));
+
+  const acceptedPackageDependencyVersions: SemVer[] = regularVersions.map(
     (acceptedPackageDependencyValue) => {
       const acceptedPackageDependencyVersion = coerce(
         acceptedPackageDependencyValue,
@@ -129,45 +178,45 @@ const ensurePackageMatchesSomeVersion = (
 
   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.`,
-    });
+
+  if (actualPackageDependencyValue != null) {
+    const matches = matchesAnyVersion(
+      actualPackageDependencyValue,
+      protocolVersions,
+      acceptedPackageDependencyVersions,
+    );
+
+    if (!matches) {
+      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.`,
-    });
+
+  if (actualPackageDevDependencyValue != null) {
+    const matches = matchesAnyVersion(
+      actualPackageDevDependencyValue,
+      protocolVersions,
+      acceptedPackageDependencyVersions,
+    );
+
+    if (!matches) {
+      context.addError({
+        file: packageJsonPath,
+        message: `Expected devDependency on ${dependencyPackageName} to match one of '${
+          JSON.stringify(
+            acceptedPackageDependencyValues,
+          )
+        }', got '${actualPackageDevDependencyValue}' instead.`,
+      });
+    }
   }
 };

package/src/fileContents.ts

@@ -8,49 +8,69 @@
 import { Context } from "@monorepolint/config";
 import { diff } from "jest-diff";
 import * as path from "path";
-import * as r from "runtypes";
+import { z } from "zod";
+import { REMOVE } from "./REMOVE.js";
 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),
-    template: r.Undefined.optional(),
-    templateFile: r.Undefined.optional(),
+import { ZodRemove } from "./util/zodSchemas.js";
+
+const Options = z.union([
+  z.object({
+    file: z.string(),
+    generator: z.custom<
+      (context: Context) => string | typeof REMOVE | Promise<string | typeof REMOVE>
+    >((val) => {
+      return typeof val === "function";
+    }),
+    template: z.undefined().optional(),
+    templateFile: z.undefined().optional(),
   }),
-  r.Record({
-    file: r.String,
-    generator: r.Undefined.optional(),
-    template: r.String.Or(r.Undefined),
-    templateFile: r.Undefined.optional(),
+  z.object({
+    file: z.string(),
+    generator: z.undefined().optional(),
+    template: z.union([
+      z.string(),
+      ZodRemove,
+    ]),
+    templateFile: z.undefined().optional(),
   }),
-  r.Record({
-    file: r.String,
-    generator: r.Undefined.optional(),
-    template: r.Undefined.optional(),
-    templateFile: r.String,
+  z.object({
+    file: z.string(),
+    generator: z.undefined().optional(),
+    template: z.undefined().optional(),
+    templateFile: z.string(),
   }),
-);
+]);
 
-type Options = r.Static<typeof Options>;
+type Options = z.infer<typeof Options>;
 
 export const fileContents = createRuleFactory<Options>({
   name: "fileContents",
   check: async (context, opts) => {
     const fullPath = path.join(context.packageDir, opts.file);
+
+    // Validate that the file path doesn't contain null bytes or other invalid characters
+    if (fullPath.includes("\0")) {
+      throw new Error(`Invalid file path: path contains null bytes`);
+    }
+
     const expectedContent = await getExpectedContents(context, opts);
 
+    // If the generator function failed, an unfixable error was already added, so we should return early
+    if (expectedContent === Symbol.for("GENERATOR_ERROR")) {
+      return;
+    }
+
     const pathExists = context.host.exists(fullPath);
     const actualContent = pathExists
       ? context.host.readFile(fullPath, { encoding: "utf-8" })
-      : undefined;
+      : REMOVE;
     if (actualContent !== expectedContent) {
-      const longMessage = pathExists && expectedContent == undefined
-        ? undefined
-        : diff(expectedContent, actualContent, { expand: true });
+      const longMessage =
+        pathExists && (expectedContent === undefined || expectedContent === REMOVE)
+          ? undefined
+          : diff(expectedContent, actualContent, { expand: true });
 
-      const message = pathExists && expectedContent == undefined
+      const message = pathExists && (expectedContent === undefined || expectedContent === REMOVE)
         ? "File should not exist"
         : "Expect file contents to match";
 
@@ -59,9 +79,9 @@ export const fileContents = createRuleFactory<Options>({
         message,
         longMessage,
         fixer: () => {
-          if (expectedContent === undefined) {
+          if (expectedContent === REMOVE) {
             if (pathExists) context.host.deleteFile(fullPath);
-          } else {
+          } else if (expectedContent !== undefined && typeof expectedContent === "string") {
             context.host.mkdir(path.dirname(fullPath), { recursive: true });
             context.host.writeFile(fullPath, expectedContent, {
               encoding: "utf-8",
@@ -71,29 +91,52 @@ export const fileContents = createRuleFactory<Options>({
       });
     }
   },
-  validateOptions: Options.check,
+  validateOptions: Options.parse,
 });
 
 const optionsCache = new Map<
   Options,
-  | ((context: Context) => Promise<string> | string | undefined)
+  | ((context: Context) => Promise<string | typeof REMOVE> | string | typeof REMOVE)
   | string
-  | undefined
+  | typeof REMOVE
 >();
 
-async function getExpectedContents(context: Context, opts: Options) {
+async function getExpectedContents(
+  context: Context,
+  opts: Options,
+): Promise<string | typeof REMOVE | symbol> {
   // we need to use has because undefined is a valid value in the cache
   if (optionsCache.has(opts)) {
     const cachedEntry = optionsCache.get(opts);
     if (cachedEntry && typeof cachedEntry === "function") {
       return cachedEntry(context);
     }
-    return cachedEntry;
+    return cachedEntry as string | typeof REMOVE;
   }
 
   if (opts.generator) {
     optionsCache.set(opts, opts.generator);
-    return opts.generator(context);
+    try {
+      const result = await opts.generator(context);
+      if (typeof result !== "string" && result !== REMOVE) {
+        throw new Error(`Generator function must return a string or REMOVE, got ${typeof result}`);
+      }
+      return result;
+    } catch (error) {
+      // Instead of throwing, create an unfixable error and return a special marker
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const fullPath = path.join(context.packageDir, opts.file);
+
+      context.addError({
+        file: fullPath,
+        message: `Generator function failed: ${errorMessage}`,
+        longMessage:
+          `The generator function for file "${opts.file}" threw an error:\n\n${errorMessage}`,
+      });
+
+      // Return a special marker that will prevent the file comparison from proceeding
+      return Symbol.for("GENERATOR_ERROR");
+    }
   } else if (opts.templateFile) {
     const { packageDir: workspacePackageDir } = context.getWorkspaceContext();
     const fullPath = path.resolve(workspacePackageDir, opts.templateFile);
@@ -101,8 +144,10 @@ async function getExpectedContents(context: Context, opts: Options) {
 
     optionsCache.set(opts, template);
     return template;
-  } else {
+  } else if (opts.template !== undefined) {
     optionsCache.set(opts, opts.template);
     return opts.template;
+  } else {
+    throw new Error("Unable to get expected contents");
   }
 }

package/src/index.ts

@@ -28,3 +28,5 @@ export {
   RuleFactoryOptions,
   ValidateOptionsFn,
 } from "./util/createRuleFactory.js";
+
+export { REMOVE } from "./REMOVE.js";

package/src/mustSatisfyPeerDependencies.ts

@@ -9,185 +9,23 @@ import { Context } from "@monorepolint/config";
 import { Host, mutateJson, PackageJson } from "@monorepolint/utils";
 import * as path from "node:path";
 import resolvePackagePath from "resolve-package-path";
-import * as r from "runtypes";
 import { coerce } from "semver";
+import { z } from "zod";
 import { createRuleFactory } from "./util/createRuleFactory.js";
 
-const Options = r.Union(
-  r.Partial({
-    skipUnparseableRanges: r.Undefined,
-    dependencyWhitelist: r.Undefined,
-    dependencyBlacklist: r.Undefined,
-    enforceForDevDependencies: r.Undefined,
-  }),
-  r
-    .Record({
-      skipUnparseableRanges: r.Boolean,
-    })
-    .And(
-      r.Partial({
-        dependencyWhitelist: r.Undefined,
-        dependencyBlacklist: r.Undefined,
-        enforceForDevDependencies: r.Undefined,
-      }),
-    ),
-  r
-    .Record({
-      dependencyWhitelist: r.Array(r.String),
-    })
-    .And(
-      r.Partial({
-        skipUnparseableRanges: r.Undefined,
-        dependencyBlacklist: r.Undefined,
-        enforceForDevDependencies: r.Undefined,
-      }),
-    ),
-  r
-    .Record({
-      dependencyBlacklist: r.Array(r.String),
-    })
-    .And(
-      r.Partial({
-        skipUnparseableRanges: r.Undefined,
-        dependencyWhitelist: r.Undefined,
-        enforceForDevDependencies: r.Undefined,
-      }),
-    ),
-  r
-    .Record({
-      enforceForDevDependencies: r.Boolean,
-    })
-    .And(
-      r.Partial({
-        skipUnparseableRanges: r.Undefined,
-        dependencyWhitelist: r.Undefined,
-        dependencyBlacklist: r.Undefined,
-      }),
-    ),
-  r
-    .Record({
-      skipUnparseableRanges: r.Boolean,
-      dependencyWhitelist: r.Array(r.String),
-    })
-    .And(
-      r.Partial({
-        dependencyBlacklist: r.Undefined,
-        enforceForDevDependencies: r.Undefined,
-      }),
-    ),
-  r
-    .Record({
-      skipUnparseableRanges: r.Boolean,
-      dependencyBlacklist: r.Array(r.String),
-    })
-    .And(
-      r.Partial({
-        dependencyWhitelist: r.Undefined,
-        enforceForDevDependencies: r.Undefined,
-      }),
-    ),
-  r
-    .Record({
-      skipUnparseableRanges: r.Boolean,
-      enforceForDevDependencies: r.Boolean,
-    })
-    .And(
-      r.Partial({
-        dependencyWhitelist: r.Undefined,
-        dependencyBlacklist: r.Undefined,
-      }),
-    ),
-  r
-    .Record({
-      dependencyWhitelist: r.Array(r.String),
-      dependencyBlacklist: r.Array(r.String),
-    })
-    .And(
-      r.Partial({
-        skipUnparseableRanges: r.Undefined,
-        enforceForDevDependencies: r.Undefined,
-      }),
-    ),
-  r
-    .Record({
-      dependencyWhitelist: r.Array(r.String),
-      enforceForDevDependencies: r.Boolean,
-    })
-    .And(
-      r.Partial({
-        skipUnparseableRanges: r.Undefined,
-        dependencyBlacklist: r.Undefined,
-      }),
-    ),
-  r
-    .Record({
-      dependencyBlacklist: r.Array(r.String),
-      enforceForDevDependencies: r.Boolean,
-    })
-    .And(
-      r.Partial({
-        skipUnparseableRanges: r.Undefined,
-        dependencyWhitelist: r.Undefined,
-      }),
-    ),
-  r
-    .Record({
-      skipUnparseableRanges: r.Boolean,
-      dependencyWhitelist: r.Array(r.String),
-      dependencyBlacklist: r.Array(r.String),
-    })
-    .And(
-      r.Partial({
-        enforceForDevDependencies: r.Undefined,
-      }),
-    ),
-  r
-    .Record({
-      skipUnparseableRanges: r.Boolean,
-      dependencyWhitelist: r.Array(r.String),
-      enforceForDevDependencies: r.Boolean,
-    })
-    .And(
-      r.Partial({
-        dependencyBlacklist: r.Undefined,
-      }),
-    ),
-  r
-    .Record({
-      skipUnparseableRanges: r.Boolean,
-      dependencyBlacklist: r.Array(r.String),
-      enforceForDevDependencies: r.Boolean,
-    })
-    .And(
-      r.Partial({
-        dependencyWhitelist: r.Undefined,
-      }),
-    ),
-  r
-    .Record({
-      dependencyWhitelist: r.Array(r.String),
-      dependencyBlacklist: r.Array(r.String),
-      enforceForDevDependencies: r.Boolean,
-    })
-    .And(
-      r.Partial({
-        skipUnparseableRanges: r.Undefined,
-      }),
-    ),
-  r.Record({
-    skipUnparseableRanges: r.Boolean,
-    dependencyWhitelist: r.Array(r.String),
-    dependencyBlacklist: r.Array(r.String),
-    enforceForDevDependencies: r.Boolean,
-  }),
-);
-
-export type Options = r.Static<typeof Options>;
+const Options = z.object({
+  skipUnparseableRanges: z.boolean().optional(),
+  dependencyWhitelist: z.array(z.string()).optional(),
+  dependencyBlacklist: z.array(z.string()).optional(),
+  enforceForDevDependencies: z.boolean().optional(),
+});
+
+export type Options = z.infer<typeof Options>;
 
 export const mustSatisfyPeerDependencies = createRuleFactory({
   name: "mustSatisfyPeerDependencies",
   check: checkSatisfyPeerDependencies,
-  validateOptions: Options.check,
+  validateOptions: Options.parse,
 });
 
 /**

package/src/nestedWorkspaces.ts

@@ -7,12 +7,12 @@
 
 import * as globby from "globby";
 import * as path from "node:path";
-import * as r from "runtypes";
+import { z } from "zod";
 import { createRuleFactory } from "./util/createRuleFactory.js";
 
-export const Options = r.Undefined;
+export const Options = z.undefined();
 
-type Options = r.Static<typeof Options>;
+type Options = z.infer<typeof Options>;
 
 // Enforce that the root package.json contains all of the workspaces in the repo (including nested packages)
 export const nestedWorkspaces = createRuleFactory({
@@ -65,5 +65,5 @@ export const nestedWorkspaces = createRuleFactory({
       });
     }
   },
-  validateOptions: Options.check,
+  validateOptions: Options.parse,
 });