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

package/src/__tests__/requireDependency.spec.ts

@@ -10,6 +10,7 @@ import { readFileSync, writeFileSync } from "node:fs";
 import * as path from "node:path";
 import * as tmp from "tmp";
 import { afterEach, describe, expect, it, vi } from "vitest";
+import { REMOVE } from "../REMOVE.js";
 import { requireDependency } from "../requireDependency.js";
 import { makeDirectoryRecursively } from "../util/makeDirectory.js";
 import { jsonToString } from "./utils.js";
@@ -55,11 +56,18 @@ const OPTIONS = {
   },
   devDependencies: {
     bar: "^2.0.0",
-    baz: undefined,
+    baz: REMOVE,
   },
 } as const;
 
-const CORRECT_OUTPUT = jsonToString(OPTIONS);
+const CORRECT_OUTPUT = jsonToString({
+  dependencies: {
+    foo: "1.0.0",
+  },
+  devDependencies: {
+    bar: "^2.0.0",
+  },
+});
 
 describe("requireDependency", () => {
   tmp.setGracefulCleanup();
@@ -155,4 +163,253 @@ describe("requireDependency", () => {
     const contents = readFile("./packages/wrong/package.json");
     expect(contents).toEqual(CORRECT_OUTPUT);
   });
+
+  describe("Missing package.json handling", () => {
+    it("handles gracefully when package.json does not exist", () => {
+      const { workspaceContext } = makeWorkspace({ fix: false });
+      // Don't create a package.json file
+
+      expect(() => {
+        requireDependency({ options: { dependencies: { foo: "1.0.0" } } }).check(workspaceContext);
+      }).toThrow(); // Should throw when trying to get package.json
+    });
+  });
+
+  describe("Invalid package.json structure", () => {
+    it("handles package.json with non-object dependencies", () => {
+      const { addFile, checkAndSpy } = makeWorkspace({ fix: false });
+      addFile("./package.json", PACKAGE_ROOT);
+      addFile(
+        "./packages/test/package.json",
+        jsonToString({
+          name: "test-package",
+          dependencies: "invalid-dependencies", // Should be an object
+        }),
+      );
+
+      // This won't throw - it will treat dependencies as undefined and add an error
+      const { addErrorSpy } = checkAndSpy("./packages/test");
+      requireDependency({ options: { dependencies: { foo: "1.0.0" } } }).check(
+        checkAndSpy("./packages/test").context,
+      );
+
+      // Should add error for missing dependencies block
+      expect(addErrorSpy).toHaveBeenCalled();
+    });
+
+    it("handles malformed JSON in package.json", () => {
+      const { addFile, workspaceContext } = makeWorkspace({ fix: false });
+      addFile("./package.json", "{ invalid json }");
+
+      expect(() => {
+        requireDependency({ options: { dependencies: { foo: "1.0.0" } } }).check(workspaceContext);
+      }).toThrow(); // Should throw when parsing invalid JSON
+    });
+  });
+
+  describe("REMOVE symbol edge cases", () => {
+    it("handles REMOVE on non-existent dependency", () => {
+      const { addFile, workspaceContext } = makeWorkspace({ fix: true });
+      addFile("./package.json", PACKAGE_ROOT);
+      addFile(
+        "./packages/test/package.json",
+        jsonToString({
+          name: "test",
+          dependencies: {},
+        }),
+      );
+
+      const context = workspaceContext.createChildContext(
+        path.resolve(workspaceContext.packageDir, "packages/test"),
+      );
+      const addErrorSpy = vi.spyOn(context, "addError");
+
+      requireDependency({
+        options: {
+          dependencies: {
+            nonExistent: REMOVE,
+          },
+        },
+      }).check(context);
+
+      // Should not add any errors since the dependency doesn't exist (desired state achieved)
+      expect(addErrorSpy).toHaveBeenCalledTimes(0);
+    });
+
+    it("handles multiple REMOVE operations", () => {
+      const { addFile, readFile, workspaceContext } = makeWorkspace({ fix: true });
+      addFile("./package.json", PACKAGE_ROOT);
+      addFile(
+        "./packages/test/package.json",
+        jsonToString({
+          name: "test",
+          dependencies: {
+            toRemove1: "1.0.0",
+            toRemove2: "2.0.0",
+            toKeep: "3.0.0",
+          },
+          devDependencies: {
+            devToRemove: "1.0.0",
+          },
+        }),
+      );
+
+      const context = workspaceContext.createChildContext(
+        path.resolve(workspaceContext.packageDir, "packages/test"),
+      );
+      const addErrorSpy = vi.spyOn(context, "addError");
+
+      requireDependency({
+        options: {
+          dependencies: {
+            toRemove1: REMOVE,
+            toRemove2: REMOVE,
+          },
+          devDependencies: {
+            devToRemove: REMOVE,
+          },
+        },
+      }).check(context);
+
+      expect(addErrorSpy).toHaveBeenCalledTimes(3); // Three removals
+
+      const updatedPackage = JSON.parse(readFile("./packages/test/package.json"));
+      expect(updatedPackage.dependencies).toEqual({ toKeep: "3.0.0" });
+      expect(updatedPackage.devDependencies).toEqual({});
+    });
+
+    it("handles REMOVE when dependency section doesn't exist", () => {
+      const { addFile, workspaceContext } = makeWorkspace({ fix: false });
+      addFile("./package.json", PACKAGE_ROOT);
+      addFile(
+        "./packages/test/package.json",
+        jsonToString({
+          name: "test",
+          // No dependencies section at all
+        }),
+      );
+
+      const context = workspaceContext.createChildContext(
+        path.resolve(workspaceContext.packageDir, "packages/test"),
+      );
+      const addErrorSpy = vi.spyOn(context, "addError");
+
+      requireDependency({
+        options: {
+          dependencies: {
+            nonExistent: REMOVE,
+          },
+        },
+      }).check(context);
+
+      // No error should be added since we're only trying to remove from a non-existent block
+      // This is the improved behavior - don't create dependency blocks just for removal
+      expect(addErrorSpy).toHaveBeenCalledTimes(0);
+    });
+
+    it("handles mixed ADD and REMOVE when dependency section doesn't exist", () => {
+      const { addFile, readFile, workspaceContext } = makeWorkspace({ fix: true });
+      addFile("./package.json", PACKAGE_ROOT);
+      addFile(
+        "./packages/test/package.json",
+        jsonToString({
+          name: "test",
+          // No dependencies section at all
+        }),
+      );
+
+      const context = workspaceContext.createChildContext(
+        path.resolve(workspaceContext.packageDir, "packages/test"),
+      );
+      const addErrorSpy = vi.spyOn(context, "addError");
+
+      requireDependency({
+        options: {
+          dependencies: {
+            toAdd: "1.0.0",
+            nonExistent: REMOVE, // This shouldn't create the block
+          },
+        },
+      }).check(context);
+
+      // Should add error only for missing block needed for the ADD operation
+      expect(addErrorSpy).toHaveBeenCalledTimes(1);
+
+      const updatedPackage = JSON.parse(readFile("./packages/test/package.json"));
+      expect(updatedPackage.dependencies).toEqual({ toAdd: "1.0.0" });
+    });
+
+    it("handles mixed ADD and REMOVE with existing dependencies", () => {
+      const { addFile, readFile, workspaceContext } = makeWorkspace({ fix: true });
+      addFile("./package.json", PACKAGE_ROOT);
+      addFile(
+        "./packages/test/package.json",
+        jsonToString({
+          name: "test",
+          dependencies: {
+            existing: "1.0.0",
+            toRemove: "2.0.0",
+          },
+        }),
+      );
+
+      const context = workspaceContext.createChildContext(
+        path.resolve(workspaceContext.packageDir, "packages/test"),
+      );
+      const addErrorSpy = vi.spyOn(context, "addError");
+
+      requireDependency({
+        options: {
+          dependencies: {
+            toAdd: "3.0.0",
+            existing: "1.0.0", // Correct version, no error
+            toRemove: REMOVE,
+          },
+        },
+      }).check(context);
+
+      // Should add errors for ADD and REMOVE operations
+      expect(addErrorSpy).toHaveBeenCalledTimes(2);
+
+      const updatedPackage = JSON.parse(readFile("./packages/test/package.json"));
+      expect(updatedPackage.dependencies).toEqual({
+        existing: "1.0.0",
+        toAdd: "3.0.0",
+      });
+    });
+  });
+
+  describe("Options Validation", () => {
+    it("should accept valid options", () => {
+      const ruleModule = requireDependency({ options: {} });
+
+      expect(() => ruleModule.validateOptions({})).not.toThrow();
+      expect(() => ruleModule.validateOptions({ dependencies: { "react": "^18.0.0" } })).not
+        .toThrow();
+      expect(() =>
+        ruleModule.validateOptions({
+          devDependencies: { "typescript": "^5.0.0" },
+          peerDependencies: { "react": ">=16.0.0" },
+        })
+      ).not.toThrow();
+
+      // Optional versions (REMOVE)
+      expect(() =>
+        ruleModule.validateOptions({
+          dependencies: { "react": REMOVE },
+        })
+      ).not.toThrow();
+    });
+
+    it("should reject invalid options", () => {
+      const ruleModule = requireDependency({ options: {} });
+
+      // @ts-expect-error testing invalid input
+      expect(() => ruleModule.validateOptions({ dependencies: "react" })).toThrow();
+      // @ts-expect-error testing invalid input
+      expect(() => ruleModule.validateOptions({ dependencies: { "react": 123 } })).toThrow();
+      // @ts-expect-error testing invalid input
+      expect(() => ruleModule.validateOptions({ devDependencies: [] })).toThrow();
+    });
+  });
 });

package/src/__tests__/standardTsconfig.spec.ts

@@ -0,0 +1,91 @@
+/*!
+ * Copyright 2019 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+
+import { Context } from "@monorepolint/config";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { standardTsconfig } from "../standardTsconfig.js";
+import { AddErrorSpy, createTestingWorkspace, HOST_FACTORIES, TestingWorkspace } from "./utils.js";
+
+describe.each(HOST_FACTORIES)("standardTsconfig ($name)", (hostFactory) => {
+  let workspace: TestingWorkspace;
+  let spy: AddErrorSpy;
+  let context: Context;
+
+  beforeEach(async () => {
+    workspace = await createTestingWorkspace({
+      fixFlag: true,
+      host: hostFactory.make(),
+    });
+    context = workspace.context;
+    spy = vi.spyOn(workspace.context, "addError");
+  });
+
+  it("creates tsconfig.json when missing with template", async () => {
+    const template = { compilerOptions: { strict: true } };
+
+    await standardTsconfig({ options: { template } }).check(context);
+
+    expect(spy).toHaveBeenCalledTimes(1);
+    expect(workspace.readFile("tsconfig.json")).toContain("\"strict\": true");
+  });
+
+  it("does nothing when tsconfig.json matches template", async () => {
+    const template = { compilerOptions: { strict: true } };
+    const expectedContent = JSON.stringify({ ...template, references: [] }, undefined, 2) + "\n";
+
+    workspace.writeFile("tsconfig.json", expectedContent);
+
+    await standardTsconfig({ options: { template } }).check(context);
+
+    expect(spy).toHaveBeenCalledTimes(0);
+  });
+
+  describe("Options Validation", () => {
+    it("should accept valid options", () => {
+      const ruleModule1 = standardTsconfig({
+        options: { template: { compilerOptions: { strict: true } } },
+      });
+      const ruleModule2 = standardTsconfig({ options: { templateFile: "tsconfig.template.json" } });
+      const ruleModule3 = standardTsconfig({
+        options: { generator: () => JSON.stringify({ compilerOptions: {} }) },
+      });
+
+      expect(() => ruleModule1.validateOptions({ template: { compilerOptions: { strict: true } } }))
+        .not.toThrow();
+      expect(() => ruleModule2.validateOptions({ templateFile: "tsconfig.template.json" })).not
+        .toThrow();
+      expect(() =>
+        ruleModule3.validateOptions({
+          generator: () => JSON.stringify({ compilerOptions: {} }),
+          excludedReferences: ["@types/*"],
+        })
+      ).not.toThrow();
+    });
+
+    it("should reject invalid options", () => {
+      const ruleModule = standardTsconfig({ options: { template: {} } });
+
+      // Missing required source
+      expect(() => ruleModule.validateOptions({})).toThrow();
+
+      // Multiple sources (violates constraint)
+      expect(() =>
+        ruleModule.validateOptions({
+          template: {},
+          templateFile: "file.json",
+        })
+      ).toThrow();
+
+      expect(() =>
+        ruleModule.validateOptions({
+          generator: () => "",
+          template: {},
+        })
+      ).toThrow();
+    });
+  });
+});

package/src/bannedDependencies.ts

@@ -6,10 +6,9 @@
  */
 
 import { Context } from "@monorepolint/config";
-import { matchesAnyGlob } from "@monorepolint/utils";
-import { AggregateTiming } from "@monorepolint/utils";
+import { AggregateTiming, matchesAnyGlob } from "@monorepolint/utils";
 import * as path from "node:path";
-import * as r from "runtypes";
+import { z } from "zod";
 import { createRuleFactory } from "./util/createRuleFactory.js";
 import {
   IPackageDependencyGraphNode,
@@ -17,30 +16,20 @@ import {
 } from "./util/packageDependencyGraphService.js";
 // FIXME: This rule is messed. bannedTransitiveDependencies doesnt glob
 
-const bannedDepGlobsField = r.Union(
-  r.Array(r.String),
-  r.Record({
-    glob: r.Array(r.String).optional(),
-    exact: r.Array(r.String).optional(),
+const bannedDepGlobsField = z.union([
+  z.array(z.string()),
+  z.object({
+    glob: z.array(z.string()).optional(),
+    exact: z.array(z.string()).optional(),
   }),
-);
+]);
 
-const Options = r.Union(
-  r.Record({
-    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(),
-  }),
-);
+const Options = z.object({
+  bannedDependencies: bannedDepGlobsField.optional(),
+  bannedTransitiveDependencies: z.array(z.string()).optional(),
+});
 
-export type Options = r.Static<typeof Options>;
+export type Options = z.infer<typeof Options>;
 
 /**
  * We use this locally to avoid making a billion sets. Because check is called once per package
@@ -113,7 +102,7 @@ export const bannedDependencies = createRuleFactory<Options>({
 
     aggregateTiming.stop();
   },
-  validateOptions: Options.check,
+  validateOptions: Options.parse,
   printStats: () => {
     aggregateTiming.printResults();
   },

package/src/consistentDependencies.ts

@@ -7,14 +7,16 @@
 
 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";
-const Options = r
-  .Record({
-    ignoredDependencies: r.Array(r.String).Or(r.Undefined),
-  })
-  .Or(r.Undefined);
-export type Options = r.Static<typeof Options>;
+
+const Options = z.union([
+  z.undefined(),
+  z.object({
+    ignoredDependencies: z.array(z.string()),
+  }),
+]);
+export type Options = z.infer<typeof Options>;
 
 const skippedVersions = ["*", "latest"];
 
@@ -25,7 +27,7 @@ export const consistentDependencies = createRuleFactory<Options>({
     checkDeps(context, args, "devDependencies");
     // we don't check peer deps since they can be more lenient
   },
-  validateOptions: Options.check,
+  validateOptions: Options.parse,
 });
 
 function checkDeps(