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

package/src/oncePerPackage.ts

@@ -1,12 +1,12 @@
-import * as r from "runtypes";
+import { z } from "zod";
 import { createRuleFactory } from "./util/createRuleFactory.js";
 
-export const Options = r.Record({
-  singletonKey: r.String.Or(r.Symbol),
-  customMessage: r.String.optional(),
+export const Options = z.object({
+  singletonKey: z.union([z.string(), z.symbol()]),
+  customMessage: z.string().optional(),
 });
 
-export type Options = r.Static<typeof Options>;
+export type Options = z.infer<typeof Options>;
 
 const visitedMap = new Map<string | symbol, Set<string>>();
 
@@ -28,5 +28,5 @@ export const oncePerPackage = createRuleFactory<Options>({
     }
   },
 
-  validateOptions: Options.assert,
+  validateOptions: Options.parse,
 });

package/src/packageEntry.ts

@@ -7,35 +7,20 @@
 
 import { mutateJson, PackageJson } from "@monorepolint/utils";
 import { diff } from "jest-diff";
-import * as r from "runtypes";
+import { z } from "zod";
+import { REMOVE } from "./REMOVE.js";
 import { createRuleFactory } from "./util/createRuleFactory.js";
+import { ZodRemove } from "./util/zodSchemas.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 const Options = z.object({
+  entries: z.record(z.string(), z.union([z.unknown(), ZodRemove])).optional(), // string => unknown | REMOVE, enforces existence of keys and their values or removal
+  entriesExist: z.array(z.string()).optional(), // enforces existence of keys, but not values
+}).refine(
+  (data) => data.entries !== undefined || data.entriesExist !== undefined,
+  { message: "At least one of 'entries' or 'entriesExist' must be provided" },
 );
 
-export type Options = r.Static<typeof Options>;
+export type Options = z.infer<typeof Options>;
 
 export const packageEntry = createRuleFactory<Options>({
   name: "packageEntry",
@@ -46,30 +31,51 @@ export const packageEntry = createRuleFactory<Options>({
       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 (value === REMOVE) {
+          // Handle removal: only add error if key exists
+          if (packageJson[key] !== undefined) {
+            context.addError({
+              file: context.getPackageJsonPath(),
+              message: createRemovalEntryErrorMessage(key),
+              fixer: () => {
+                mutateJson<PackageJson>(
+                  context.getPackageJsonPath(),
+                  context.host,
+                  (input) => {
+                    delete input[key];
+                    return input;
+                  },
+                );
+              },
+            });
+          }
+        } else {
+          // Handle regular value checking
+          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;
+                  },
+                );
+              },
+            });
+          }
         }
       }
     }
@@ -85,7 +91,7 @@ export const packageEntry = createRuleFactory<Options>({
       }
     }
   },
-  validateOptions: Options.check,
+  validateOptions: Options.parse,
 });
 
 export function createStandardizedEntryErrorMessage(key: string) {
@@ -95,3 +101,7 @@ export function createStandardizedEntryErrorMessage(key: string) {
 export function createExpectedEntryErrorMessage(key: string) {
   return `Expected entry for '${key}' to exist`;
 }
+
+export function createRemovalEntryErrorMessage(key: string) {
+  return `Entry '${key}' should be removed`;
+}

package/src/packageOrder.ts

@@ -7,17 +7,27 @@
 
 import { Context } from "@monorepolint/config";
 import { diff } from "jest-diff";
-import * as r from "runtypes";
+import { z } from "zod";
 import { createRuleFactory } from "./util/createRuleFactory.js";
 type OrderFunction = (context: Context) => (a: string, b: string) => number;
 
-const Options = r
-  .Record({
-    order: r.Union(r.Array(r.String), r.Function),
-  })
-  .Or(r.Undefined);
-
-type Options = r.Static<typeof Options>;
+const Options = z.union([
+  z.undefined(),
+  z.object({
+    order: z.union([
+      z.array(z.string()),
+      z.function({
+        input: [z.any()],
+        output: z.function({
+          input: [z.string(), z.string()],
+          output: z.number(),
+        }),
+      }),
+    ]),
+  }),
+]);
+
+type Options = z.infer<typeof Options>;
 
 const defaultKeyOrder = [
   "name",
@@ -86,7 +96,7 @@ export const packageOrder = createRuleFactory<Options>({
       });
     }
   },
-  validateOptions: Options.check,
+  validateOptions: Options.parse,
 });
 
 function arrayOrderCompare(a: ReadonlyArray<string>, b: ReadonlyArray<string>) {

package/src/packageScript.ts

@@ -7,22 +7,35 @@
 
 import { mutateJson, PackageJson } from "@monorepolint/utils";
 import { diff } from "jest-diff";
-import * as r from "runtypes";
+import { z } from "zod";
+import { REMOVE } from "./REMOVE.js";
 import { createRuleFactory } from "./util/createRuleFactory.js";
+import { ZodRemove } from "./util/zodSchemas.js";
 
-export const Options = r.Record({
-  scripts: r.Dictionary(
-    r.Union(
-      r.String,
-      r.Record({
-        options: r.Array(r.String.Or(r.Undefined)),
-        fixValue: r.Union(r.String, r.Undefined, r.Literal(false)).optional(),
+export const Options = z.object({
+  scripts: z.record(
+    z.string(),
+    z.union([
+      z.string(),
+      ZodRemove, // Allow direct REMOVE values like { "build": REMOVE }
+      z.object({
+        options: z.array(z.union([
+          z.string(),
+          z.undefined(),
+          ZodRemove,
+        ])),
+        fixValue: z.union([
+          z.string(),
+          z.undefined(),
+          z.literal(false),
+          ZodRemove,
+        ]).optional(),
       }),
-    ),
-  ), // string => string
+    ]),
+  ), // string => string | REMOVE | object
 });
 
-export type Options = r.Static<typeof Options>;
+export type Options = z.infer<typeof Options>;
 
 export const MSG_NO_SCRIPTS_BLOCK = "No scripts block in package.json";
 
@@ -48,28 +61,63 @@ export const packageScript = createRuleFactory<Options>({
       return;
     }
     for (const [name, value] of Object.entries(options.scripts)) {
-      const allowedValues = new Set<string | undefined>();
-      let fixValue: string | undefined | false;
+      const allowedValues = new Set<string | undefined | typeof REMOVE>();
+      let fixValue: string | undefined | false | typeof REMOVE;
       let allowEmpty = false;
       let fixToEmpty = false;
+      let fixToRemove = false;
 
       if (typeof value === "string") {
         allowedValues.add(value);
         fixValue = value;
+      } else if (value === REMOVE) {
+        // Handle direct REMOVE value: script should be removed
+        allowedValues.add(REMOVE);
+        fixValue = REMOVE;
+        fixToRemove = true;
       } else {
         for (const q of value.options) {
           if (q === undefined) {
             allowEmpty = true;
+          } else if (q === REMOVE) {
+            allowEmpty = true;
           }
           allowedValues.add(q);
         }
         fixToEmpty = Object.prototype.hasOwnProperty.call(value, "fixValue")
           && value.fixValue === undefined;
+        fixToRemove = Object.prototype.hasOwnProperty.call(value, "fixValue")
+          && value.fixValue === REMOVE;
         fixValue = value.fixValue;
       }
 
       const actualValue = packageJson.scripts[name];
 
+      // Special handling for direct REMOVE: only error if script exists
+      if (value === REMOVE) {
+        if (actualValue !== undefined) {
+          // Script exists but should be removed
+          const fixer = () => {
+            mutateJson<PackageJson>(
+              context.getPackageJsonPath(),
+              context.host,
+              (input) => {
+                delete input.scripts![name];
+                return input;
+              },
+            );
+          };
+
+          context.addError({
+            file: context.getPackageJsonPath(),
+            message: `Script '${name}' should be removed`,
+            fixer,
+          });
+        }
+        // If script doesn't exist, no error needed
+        continue;
+      }
+
       if (
         !allowedValues.has(actualValue)
         && !(allowEmpty === true && actualValue === undefined)
@@ -77,7 +125,8 @@ export const packageScript = createRuleFactory<Options>({
         let fixer;
 
         if (
-          fixValue !== false && (fixValue !== undefined || fixToEmpty === true)
+          fixValue !== false
+          && (fixValue !== undefined || fixToEmpty === true || fixToRemove === true)
         ) {
           const q = fixValue;
           fixer = () => {
@@ -85,10 +134,10 @@ export const packageScript = createRuleFactory<Options>({
               context.getPackageJsonPath(),
               context.host,
               (input) => {
-                if (fixToEmpty && q === undefined) {
+                if ((fixToEmpty && q === undefined) || (fixToRemove && q === REMOVE)) {
                   delete input.scripts![name];
                 } else {
-                  input.scripts![name] = q!;
+                  input.scripts![name] = q as string;
                 }
                 return input;
               },
@@ -97,7 +146,7 @@ export const packageScript = createRuleFactory<Options>({
         }
 
         const validOptionsString = Array.from(allowedValues.values())
-          .map((a) => (a === undefined ? "(empty)" : `'${a}'`))
+          .map((a) => (a === undefined || a === REMOVE ? "(empty)" : `'${a}'`))
           .join(", ");
 
         context.addError({
@@ -113,5 +162,5 @@ export const packageScript = createRuleFactory<Options>({
       }
     }
   },
-  validateOptions: Options.check,
+  validateOptions: Options.parse,
 });

package/src/requireDependency.ts

@@ -8,17 +8,43 @@
 import { Context } from "@monorepolint/config";
 import { mutateJson, PackageJson } from "@monorepolint/utils";
 import { diff } from "jest-diff";
-import * as r from "runtypes";
+import { z } from "zod";
+import { REMOVE } from "./REMOVE.js";
 import { createRuleFactory } from "./util/createRuleFactory.js";
+import { ZodRemove } from "./util/zodSchemas.js";
 
-const Options = r.Partial({
-  dependencies: r.Dictionary(r.String.optional()),
-  devDependencies: r.Dictionary(r.String.optional()),
-  peerDependencies: r.Dictionary(r.String.optional()),
-  optionalDependencies: r.Dictionary(r.String.optional()),
-});
+const Options = z.object({
+  dependencies: z.record(
+    z.string(),
+    z.union([
+      z.string(),
+      ZodRemove,
+    ]).optional(),
+  ).optional(),
+  devDependencies: z.record(
+    z.string(),
+    z.union([
+      z.string(),
+      ZodRemove,
+    ]).optional(),
+  ).optional(),
+  peerDependencies: z.record(
+    z.string(),
+    z.union([
+      z.string(),
+      ZodRemove,
+    ]).optional(),
+  ).optional(),
+  optionalDependencies: z.record(
+    z.string(),
+    z.union([
+      z.string(),
+      ZodRemove,
+    ]).optional(),
+  ).optional(),
+}).partial();
 
-type Options = r.Static<typeof Options>;
+type Options = z.infer<typeof Options>;
 
 export const requireDependency = createRuleFactory({
   name: "requireDependency",
@@ -37,29 +63,40 @@ export const requireDependency = createRuleFactory({
         return;
       }
 
+      // Separate additions from removals upfront
+      const dependenciesToAdd = Object.entries(expectedEntries).filter(
+        ([, version]) => version !== REMOVE && version !== undefined,
+      );
+      const dependenciesToRemove = Object.entries(expectedEntries).filter(
+        ([, version]) => version === REMOVE,
+      );
+
+      // Handle missing dependency block
       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] = Object.fromEntries(
-                Object.entries(expectedEntries).filter(([, v]) => v !== undefined),
-              ) as Record<string, string>;
-              return input;
-            });
-          },
-        });
-        return;
+        // Only create block if there are dependencies to add (REMOVE entries shouldn't create blocks)
+        if (dependenciesToAdd.length > 0) {
+          context.addError({
+            file: packageJsonPath,
+            message: `No ${type} block, cannot add required ${type}.`,
+            fixer: () => {
+              mutateJson<PackageJson>(packageJsonPath, context.host, (input) => {
+                input[type] = Object.fromEntries(dependenciesToAdd) as Record<string, string>;
+                return input;
+              });
+            },
+          });
+        }
+        return; // Can't remove from non-existent block
       }
 
-      for (const [dep, version] of Object.entries(options[type]!)) {
+      // Process additions
+      for (const [dep, version] of dependenciesToAdd) {
         if (packageJson[type]?.[dep] !== version) {
           context.addError({
             file: packageJsonPath,
-            message: `Expected dependency ${dep}@${version}`,
+            message: `Expected dependency ${dep}@${version as string}`,
             longMessage: diff(
-              `${dep}@${version}\n`,
+              `${dep}@${version as string}\n`,
               `${dep}@${packageJson[type]![dep] || "missing"}\n`,
             )!,
             fixer: () => {
@@ -67,12 +104,28 @@ export const requireDependency = createRuleFactory({
                 packageJsonPath,
                 context.host,
                 (input) => {
-                  if (version === undefined) {
-                    input[type] = { ...input[type] };
-                    delete input[type][dep];
-                  } else {
-                    input[type] = { ...input[type], [dep]: version };
-                  }
+                  input[type] = { ...input[type], [dep]: version as string };
+                  return input;
+                },
+              );
+            },
+          });
+        }
+      }
+
+      // Process removals
+      for (const [dep] of dependenciesToRemove) {
+        if (packageJson[type]?.[dep] !== undefined) {
+          context.addError({
+            file: packageJsonPath,
+            message: `Dependency ${dep} should be removed`,
+            fixer: () => {
+              mutateJson<PackageJson>(
+                packageJsonPath,
+                context.host,
+                (input) => {
+                  input[type] = { ...input[type] };
+                  delete input[type][dep];
                   return input;
                 },
               );
@@ -82,5 +135,5 @@ export const requireDependency = createRuleFactory({
       }
     });
   },
-  validateOptions: Options.check,
+  validateOptions: Options.parse,
 });

package/src/standardTsconfig.ts

@@ -9,38 +9,38 @@ import { Context } from "@monorepolint/config";
 import { matchesAnyGlob } from "@monorepolint/utils";
 import { diff } from "jest-diff";
 import * as path from "path";
-import * as r from "runtypes";
+import { z } from "zod";
 import { createRuleFactory } from "./util/createRuleFactory.js";
 
 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;
-    if (generator) {
-      count++;
-    }
-    if (template) {
-      count++;
-    }
-    if (templateFile) {
-      count++;
-    }
+const Options = z.object({
+  file: z.string().optional(),
+  generator: z.custom<(context: Context) => Promise<string> | string>().optional(),
+  tsconfigReferenceFile: z.string().optional(),
+  template: z.record(z.string(), z.unknown()).optional(),
+  templateFile: z.string().optional(),
+  excludedReferences: z.array(z.string()).optional(),
+  additionalReferences: z.array(z.string()).optional(),
+}).partial().refine(({ generator, template, templateFile }) => {
+  let count = 0;
+  if (generator) {
+    count++;
+  }
+  if (template) {
+    count++;
+  }
+  if (templateFile) {
+    count++;
+  }
 
-    return count === 1 || "Expect one of { generator, template, templateFile }";
-  });
+  return count === 1;
+}, {
+  message: "Expect one of { generator, template, templateFile }",
+});
 
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-export interface Options extends r.Static<typeof Options> {}
+export interface Options extends z.infer<typeof Options> {}
 
 export const standardTsconfig = createRuleFactory<Options>({
   name: "standardTsconfig",
@@ -75,7 +75,7 @@ export const standardTsconfig = createRuleFactory<Options>({
       });
     }
   },
-  validateOptions: Options.check,
+  validateOptions: Options.parse,
 });
 
 function getGenerator(context: Context, opts: Options) {

package/src/util/zodSchemas.ts

@@ -0,0 +1,15 @@
+/*!
+ * Copyright 2019 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+
+import { z } from "zod";
+import { REMOVE } from "../REMOVE.js";
+
+/**
+ * Reusable Zod schema for the REMOVE symbol.
+ * This schema validates that a value is exactly the REMOVE symbol.
+ */
+export const ZodRemove = z.custom<typeof REMOVE>((x) => x === REMOVE);