@monorepolint/rules 0.5.0-alpha.98 → 0.5.0-beta.1

package/src/__tests__/packageEntry.spec.ts

@@ -8,8 +8,9 @@
 // tslint:disable:no-console
 
 import { Context, Failure } from "@monorepolint/config";
-import { createExpectedEntryErrorMessage, createStandardizedEntryErrorMessage, packageEntry } from "../packageEntry";
-import { AddErrorSpy, createTestingWorkspace, HOST_FACTORIES, TestingWorkspace } from "./utils";
+import { createExpectedEntryErrorMessage, createStandardizedEntryErrorMessage, packageEntry } from "../packageEntry.js";
+import { AddErrorSpy, createTestingWorkspace, HOST_FACTORIES, TestingWorkspace } from "./utils.js";
+import { describe, expect, it, beforeEach, afterEach, jest } from "@jest/globals";
 
 const PACKAGE_MISSING_ENTRY =
   JSON.stringify(
@@ -75,12 +76,14 @@ describe.each(HOST_FACTORIES)("expectPackageEntries ($name)", (hostFactory) => {
     it("fixes missing entries", () => {
       workspace.writeFile("package.json", PACKAGE_MISSING_ENTRY);
 
-      packageEntry.check(context, {
-        entries: {
-          license: "UNLICENSED",
+      packageEntry({
+        options: {
+          entries: {
+            license: "UNLICENSED",
+          },
+          entriesExist: undefined,
         },
-        entriesExist: undefined,
-      });
+      }).check(context);
 
       expect(spy).toHaveBeenCalledTimes(1);
 
@@ -99,15 +102,17 @@ describe.each(HOST_FACTORIES)("expectPackageEntries ($name)", (hostFactory) => {
     it("fixes missing nested entries", () => {
       workspace.writeFile("package.json", PACKAGE_MISSING_ENTRY);
 
-      packageEntry.check(context, {
-        entries: {
-          repository: {
-            type: "git",
-            url: "https://github.com:foo/foo",
+      packageEntry({
+        options: {
+          entries: {
+            repository: {
+              type: "git",
+              url: "https://github.com:foo/foo",
+            },
           },
+          entriesExist: undefined,
         },
-        entriesExist: undefined,
-      });
+      }).check(context);
 
       expect(spy).toHaveBeenCalledTimes(1);
 
@@ -126,15 +131,17 @@ describe.each(HOST_FACTORIES)("expectPackageEntries ($name)", (hostFactory) => {
     it("doesn't error for nested entries that are defined", () => {
       workspace.writeFile("package.json", PACKAGE_REPOSITORY);
 
-      packageEntry.check(context, {
-        entries: {
-          repository: {
-            type: "git",
-            url: "https://github.com:foo/foo",
+      packageEntry({
+        options: {
+          entries: {
+            repository: {
+              type: "git",
+              url: "https://github.com:foo/foo",
+            },
           },
+          entriesExist: undefined,
         },
-        entriesExist: undefined,
-      });
+      }).check(context);
 
       expect(spy).toHaveBeenCalledTimes(0);
       expect(workspace.readFile("package.json")).toEqual(PACKAGE_REPOSITORY);
@@ -143,10 +150,12 @@ describe.each(HOST_FACTORIES)("expectPackageEntries ($name)", (hostFactory) => {
     it("errors for keys that are missing", () => {
       workspace.writeFile("package.json", PACKAGE_REPOSITORY);
 
-      packageEntry.check(context, {
-        entries: undefined,
-        entriesExist: ["bugs"],
-      });
+      packageEntry({
+        options: {
+          entries: undefined,
+          entriesExist: ["bugs"],
+        },
+      }).check(context);
 
       expect(spy).toHaveBeenCalledTimes(1);
 
@@ -164,15 +173,17 @@ describe.each(HOST_FACTORIES)("expectPackageEntries ($name)", (hostFactory) => {
     it("handles both entries and entriesExist", () => {
       workspace.writeFile("package.json", PACKAGE_MISSING_ENTRY);
 
-      packageEntry.check(context, {
-        entries: {
-          repository: {
-            type: "git",
-            url: "https://github.com:foo/foo",
+      packageEntry({
+        options: {
+          entries: {
+            repository: {
+              type: "git",
+              url: "https://github.com:foo/foo",
+            },
           },
+          entriesExist: ["bugs"],
         },
-        entriesExist: ["bugs"],
-      });
+      }).check(context);
 
       expect(spy).toHaveBeenCalledTimes(2);
 

package/src/__tests__/packageOrder.spec.ts

@@ -6,9 +6,10 @@
  */
 
 // tslint:disable:no-console
-import { AddErrorSpy, createTestingWorkspace, HOST_FACTORIES, TestingWorkspace } from "./utils";
+import { AddErrorSpy, createTestingWorkspace, HOST_FACTORIES, TestingWorkspace } from "./utils.js";
 import { Context, Failure } from "@monorepolint/config";
-import { packageOrder } from "../packageOrder";
+import { packageOrder } from "../packageOrder.js";
+import { describe, expect, it, beforeEach, jest } from "@jest/globals";
 
 const PACKAGE_UNORDERED =
   JSON.stringify(
@@ -100,9 +101,11 @@ describe.each(HOST_FACTORIES)("expectPackageOrder ($name)", (hostFactory) => {
     it("fixes order for expected keys", () => {
       workspace.writeFile("package.json", PACKAGE_UNORDERED);
 
-      packageOrder.check(context, {
-        order: orderArray,
-      });
+      packageOrder({
+        options: {
+          order: orderArray,
+        },
+      }).check(context);
 
       expect(spy).toHaveBeenCalledTimes(1);
 
@@ -121,9 +124,11 @@ describe.each(HOST_FACTORIES)("expectPackageOrder ($name)", (hostFactory) => {
     it("fixes order for unexpected keys", () => {
       workspace.writeFile("package.json", PACKAGE_UNORDERED_UNKOWN_KEYS);
 
-      packageOrder.check(context, {
-        order: orderArray,
-      });
+      packageOrder({
+        options: {
+          order: orderArray,
+        },
+      }).check(context);
 
       expect(spy).toHaveBeenCalledTimes(1);
 
@@ -142,9 +147,11 @@ describe.each(HOST_FACTORIES)("expectPackageOrder ($name)", (hostFactory) => {
     it("fixes order using function", () => {
       workspace.writeFile("package.json", PACKAGE_UNORDERED);
 
-      packageOrder.check(context, {
-        order: orderFunction,
-      });
+      packageOrder({
+        options: {
+          order: orderFunction,
+        },
+      }).check(context);
 
       expect(spy).toHaveBeenCalledTimes(1);
 
@@ -163,9 +170,11 @@ describe.each(HOST_FACTORIES)("expectPackageOrder ($name)", (hostFactory) => {
     it("does nothing if already order", () => {
       workspace.writeFile("package.json", PACKAGE_ORDERED_UNKOWN_KEYS);
 
-      packageOrder.check(context, {
-        order: orderArray,
-      });
+      packageOrder({
+        options: {
+          order: orderArray,
+        },
+      }).check(context);
 
       expect(spy).not.toHaveBeenCalled();
 

package/src/__tests__/packageScript.spec.ts

@@ -6,10 +6,10 @@
  */
 
 // tslint:disable:no-console
-
+import { describe, expect, it, beforeEach, jest } from "@jest/globals";
 import { Context, Failure } from "@monorepolint/config";
-import { packageScript } from "../packageScript";
-import { AddErrorSpy, createTestingWorkspace, HOST_FACTORIES, TestingWorkspace } from "./utils";
+import { packageScript } from "../packageScript.js";
+import { AddErrorSpy, createTestingWorkspace, HOST_FACTORIES, TestingWorkspace } from "./utils.js";
 
 const json = (a: unknown) => JSON.stringify(a, undefined, 2) + "\n";
 
@@ -47,11 +47,13 @@ describe.each(HOST_FACTORIES)("expectPackageScript ($name)", (hostFactory) => {
     it("handles an empty script section", () => {
       workspace.writeFile("package.json", PACKAGE_WITHOUT_SCRIPTS);
 
-      packageScript.check(workspace.context, {
-        scripts: {
-          foo: "bar",
+      packageScript({
+        options: {
+          scripts: {
+            foo: "bar",
+          },
         },
-      });
+      }).check(workspace.context);
 
       expect(spy).toHaveBeenCalledTimes(1);
 
@@ -84,11 +86,13 @@ describe.each(HOST_FACTORIES)("expectPackageScript ($name)", (hostFactory) => {
     it("fixes an empty script section", () => {
       workspace.writeFile("package.json", PACKAGE_WITHOUT_SCRIPTS);
 
-      packageScript.check(context, {
-        scripts: {
-          foo: "bar",
+      packageScript({
+        options: {
+          scripts: {
+            foo: "bar",
+          },
         },
-      });
+      }).check(context);
 
       expect(spy).toHaveBeenCalledTimes(1);
 
@@ -107,11 +111,13 @@ describe.each(HOST_FACTORIES)("expectPackageScript ($name)", (hostFactory) => {
     it("adds a script", () => {
       workspace.writeFile("package.json", PACKAGE_WITH_SCRIPTS);
 
-      packageScript.check(context, {
-        scripts: {
-          [MISSING_SCRIPT_NAME]: MISSING_SCRIPT_VALUE,
+      packageScript({
+        options: {
+          scripts: {
+            [MISSING_SCRIPT_NAME]: MISSING_SCRIPT_VALUE,
+          },
         },
-      });
+      }).check(context);
 
       expect(spy).toHaveBeenCalledTimes(1);
 
@@ -120,7 +126,9 @@ describe.each(HOST_FACTORIES)("expectPackageScript ($name)", (hostFactory) => {
         workspace.failureMatcher({
           file: "package.json",
           hasFixer: true,
-          message: expect.stringContaining(`Expected standardized script entry for '${MISSING_SCRIPT_NAME}'`),
+          message: expect.stringContaining(
+            `Expected standardized script entry for '${MISSING_SCRIPT_NAME}'`
+          ) as unknown as string,
         })
       );
 
@@ -132,11 +140,13 @@ describe.each(HOST_FACTORIES)("expectPackageScript ($name)", (hostFactory) => {
     it("does nothing if the value exists", () => {
       workspace.writeFile("package.json", PACKAGE_WITH_SCRIPTS);
 
-      packageScript.check(context, {
-        scripts: {
-          [SCRIPT_NAME]: SCRIPT_VALUE,
+      packageScript({
+        options: {
+          scripts: {
+            [SCRIPT_NAME]: SCRIPT_VALUE,
+          },
         },
-      });
+      }).check(context);
 
       expect(spy).not.toHaveBeenCalled();
 
@@ -148,13 +158,15 @@ describe.each(HOST_FACTORIES)("expectPackageScript ($name)", (hostFactory) => {
     it("errors if long form is used and no value matches and there is no fixValue", () => {
       workspace.writeFile("package.json", PACKAGE_WITH_SCRIPTS);
 
-      packageScript.check(context, {
-        scripts: {
-          foo: {
-            options: ["a", "b"],
+      packageScript({
+        options: {
+          scripts: {
+            foo: {
+              options: ["a", "b"],
+            },
           },
         },
-      });
+      }).check(context);
 
       const errors = spy.mock.calls;
 
@@ -165,14 +177,16 @@ describe.each(HOST_FACTORIES)("expectPackageScript ($name)", (hostFactory) => {
     it("uses the fixValue for fixing if provided", () => {
       workspace.writeFile("package.json", PACKAGE_WITH_SCRIPTS);
 
-      packageScript.check(context, {
-        scripts: {
-          foo: {
-            options: ["a", "b"],
-            fixValue: "a",
+      packageScript({
+        options: {
+          scripts: {
+            foo: {
+              options: ["a", "b"],
+              fixValue: "a",
+            },
           },
         },
-      });
+      }).check(context);
 
       const errors = spy.mock.calls;
 
@@ -188,14 +202,16 @@ describe.each(HOST_FACTORIES)("expectPackageScript ($name)", (hostFactory) => {
     it("can fix to empty", () => {
       workspace.writeFile("package.json", PACKAGE_WITH_SCRIPTS);
 
-      packageScript.check(context, {
-        scripts: {
-          [SCRIPT_NAME]: {
-            options: ["a", undefined],
-            fixValue: undefined,
+      packageScript({
+        options: {
+          scripts: {
+            [SCRIPT_NAME]: {
+              options: ["a", undefined],
+              fixValue: undefined,
+            },
           },
         },
-      });
+      }).check(context);
 
       const errors = spy.mock.calls;
 
@@ -208,14 +224,16 @@ describe.each(HOST_FACTORIES)("expectPackageScript ($name)", (hostFactory) => {
     it("can allow only empty", () => {
       workspace.writeFile("package.json", PACKAGE_WITH_SCRIPTS);
 
-      packageScript.check(context, {
-        scripts: {
-          [SCRIPT_NAME]: {
-            options: [undefined],
-            fixValue: undefined,
+      packageScript({
+        options: {
+          scripts: {
+            [SCRIPT_NAME]: {
+              options: [undefined],
+              fixValue: undefined,
+            },
           },
         },
-      });
+      }).check(context);
 
       const errors = spy.mock.calls;
 

package/src/__tests__/requireDependency.spec.ts

@@ -6,12 +6,13 @@
  */
 import { WorkspaceContextImpl } from "@monorepolint/core";
 import { SimpleHost } from "@monorepolint/utils";
-import { readFileSync, writeFileSync } from "fs";
-import * as path from "path";
+import { readFileSync, writeFileSync } from "node:fs";
+import * as path from "node:path";
 import * as tmp from "tmp";
-import { requireDependency } from "../requireDependency";
-import { makeDirectoryRecursively } from "../util/makeDirectory";
-import { jsonToString } from "./utils";
+import { requireDependency } from "../requireDependency.js";
+import { makeDirectoryRecursively } from "../util/makeDirectory.js";
+import { jsonToString } from "./utils.js";
+import { describe, expect, it, afterEach, jest } from "@jest/globals";
 
 const PACKAGE_ROOT = jsonToString({
   workspaces: {
@@ -88,7 +89,7 @@ describe("requireDependency", () => {
     function checkAndSpy(q: string) {
       const context = workspaceContext.createChildContext(path.resolve(dir.name, q));
       const addErrorSpy = jest.spyOn(context, "addError");
-      requireDependency.check(context, OPTIONS);
+      requireDependency({ options: OPTIONS }).check(context);
       return { context, addErrorSpy };
     }
 
@@ -115,7 +116,7 @@ describe("requireDependency", () => {
     addFile("./packages/wrong/package.json", PACKAGE_WITH_WRONG_ENTRIES);
     addFile("./packages/right/package.json", PACKAGE_WITH_RIGHT_ENTRIES);
 
-    requireDependency.check(workspaceContext, OPTIONS);
+    requireDependency({ options: OPTIONS }).check(workspaceContext);
 
     const none = checkAndSpy("./packages/none");
     expect(none.addErrorSpy).toHaveBeenCalledTimes(2);

package/src/__tests__/utils.ts

@@ -8,10 +8,11 @@
 import { AddErrorOptions, WorkspaceContext } from "@monorepolint/config";
 import { WorkspaceContextImpl } from "@monorepolint/core";
 import { CachingHost, Host, SimpleHost } from "@monorepolint/utils";
-import * as path from "path";
+import { expect, jest } from "@jest/globals";
+import * as path from "node:path";
 import * as tmp from "tmp";
 
-export function jsonToString(obj: {}) {
+export function jsonToString(obj: unknown) {
   return JSON.stringify(obj, undefined, 2) + "\n";
 }
 
@@ -75,7 +76,10 @@ export interface TestingWorkspace {
 }
 
 class DefaultTestingWorkspace implements TestingWorkspace {
-  constructor(private opts: RealTestingWorkspaceOpts, public readonly context: WorkspaceContext) {}
+  constructor(
+    private opts: RealTestingWorkspaceOpts,
+    public readonly context: WorkspaceContext
+  ) {}
 
   addProject(name: string, fields: object) {
     this.writeJsonFile(path.join("packages", name, "package.json"), {
@@ -118,7 +122,7 @@ class DefaultTestingWorkspace implements TestingWorkspace {
   }
 }
 
-export type AddErrorSpy = jest.SpyInstance<void, [AddErrorOptions]>;
+export type AddErrorSpy = jest.SpiedFunction<(options: AddErrorOptions) => void>;
 
 export const HOST_FACTORIES: Array<{ name: string; make: () => Host }> = [
   { name: "SimpleHost", make: () => new SimpleHost() },

package/src/alphabeticalDependencies.ts

@@ -5,20 +5,15 @@
  *
  */
 
-import { Context, RuleModule } from "@monorepolint/config";
-import * as r from "runtypes";
-import { checkAlpha } from "./util/checkAlpha";
-import { createNewRuleConversion } from "./util/createNewRuleConversion";
+import { checkAlpha } from "./util/checkAlpha.js";
+import { makeRule } from "./util/makeRule.js";
 
-const Options = r.Undefined;
-
-export const alphabeticalDependencies: RuleModule<typeof Options> = {
-  check: function expectAlphabeticalDependencies(context: Context) {
+export const alphabeticalDependencies = makeRule<undefined>({
+  name: "alphabeticalDependencies",
+  check: (context) => {
     checkAlpha(context, "dependencies");
     checkAlpha(context, "devDependencies");
     checkAlpha(context, "peerDependencies");
   },
-  optionsRuntype: Options,
-};
-
-export const AlphabeticalDependencies = createNewRuleConversion("AlphabetialDependencies", alphabeticalDependencies);
+  validateOptions: () => {},
+});

package/src/alphabeticalScripts.ts

@@ -5,18 +5,13 @@
  *
  */
 
-import { Context, RuleModule } from "@monorepolint/config";
-import * as r from "runtypes";
-import { checkAlpha } from "./util/checkAlpha";
-import { createNewRuleConversion } from "./util/createNewRuleConversion";
+import { checkAlpha } from "./util/checkAlpha.js";
+import { makeRule } from "./util/makeRule.js";
 
-const Options = r.Undefined;
-
-export const alphabeticalScripts: RuleModule<typeof Options> = {
-  check: function expectAlphabeticalScripts(context: Context) {
+export const alphabeticalScripts = makeRule<undefined>({
+  name: "alphabeticalScripts",
+  check: (context) => {
     checkAlpha(context, "scripts");
   },
-  optionsRuntype: Options,
-};
-
-export const AlphabeticalScripts = createNewRuleConversion("AlphabeticalScripts", alphabeticalScripts);
+  validateOptions: () => {},
+});

package/src/bannedDependencies.ts

@@ -5,14 +5,13 @@
  *
  */
 
-import { Context, RuleModule } from "@monorepolint/config";
+import { Context } from "@monorepolint/config";
 import { matchesAnyGlob } from "@monorepolint/utils";
 import { AggregateTiming } from "@monorepolint/utils";
-import path from "path";
+import * as path from "node:path";
 import * as r from "runtypes";
-import { createNewRuleConversion } from "./util/createNewRuleConversion";
-import { IPackageDependencyGraphNode, PackageDependencyGraphService } from "./util/packageDependencyGraphService";
-
+import { makeRule } from "./util/makeRule.js";
+import { IPackageDependencyGraphNode, PackageDependencyGraphService } from "./util/packageDependencyGraphService.js";
 // FIXME: This rule is messed. bannedTransitiveDependencies doesnt glob
 
 const bannedDepGlobsField = r.Union(
@@ -50,10 +49,9 @@ const setCache = new Map<ReadonlyArray<string>, Set<string>>();
 
 const aggregateTiming = new AggregateTiming(":bannedDependencies stats");
 
-export const bannedDependencies: RuleModule<typeof Options> & {
-  printStats: () => void;
-} = {
-  check: function expectAllowedDependencies(context, opts, extra) {
+export const bannedDependencies = makeRule<Options>({
+  name: "bannedDependencies",
+  check: (context, opts, extra) => {
     aggregateTiming.start(extra?.id ?? "unknown id");
 
     const packageJson = context.getPackageJson();
@@ -109,12 +107,11 @@ export const bannedDependencies: RuleModule<typeof Options> & {
 
     aggregateTiming.stop();
   },
-  optionsRuntype: Options,
+  validateOptions: Options.check,
   printStats: () => {
     aggregateTiming.printResults();
   },
-};
-export const BannedDependencies = createNewRuleConversion("BannedDependencies", bannedDependencies);
+});
 
 function populateProblemsExact(banned: Set<string>, dependencies: ReadonlyArray<string>, violations: Set<string>) {
   for (const dependency of dependencies) {

package/src/consistentDependencies.ts

@@ -5,11 +5,10 @@
  *
  */
 
-import { Context, RuleModule } from "@monorepolint/config";
-import diff from "jest-diff";
+import { Context } from "@monorepolint/config";
+import { diff } from "jest-diff";
 import * as r from "runtypes";
-import { createNewRuleConversion } from "./util/createNewRuleConversion";
-
+import { makeRule } from "./util/makeRule.js";
 const Options = r
   .Record({
     ignoredDependencies: r.Array(r.String).Or(r.Undefined),
@@ -19,16 +18,15 @@ export type Options = r.Static<typeof Options>;
 
 const skippedVersions = ["*", "latest"];
 
-export const consistentDependencies = {
-  check: function expectConsistentDependencies(context: Context, args: Options) {
+export const consistentDependencies = makeRule<Options>({
+  name: "consistentDependencies",
+  check: (context, args) => {
     checkDeps(context, args, "dependencies");
     checkDeps(context, args, "devDependencies");
     // we don't check peer deps since they can be more lenient
   },
-  optionsRuntype: Options,
-} as RuleModule<typeof Options>;
-
-export const ConsistentDependencies = createNewRuleConversion("ConsistentDependencies", consistentDependencies);
+  validateOptions: Options.check,
+});
 
 function checkDeps(context: Context, args: Options, block: "dependencies" | "devDependencies" | "peerDependencies") {
   const packageJson = context.getPackageJson();
@@ -68,6 +66,7 @@ function checkDeps(context: Context, args: Options, block: "dependencies" | "dev
 }
 
 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)) {

package/src/consistentVersions.ts

@@ -5,22 +5,22 @@
  *
  */
 
-import { Context, RuleModule } from "@monorepolint/config";
+import { Context } from "@monorepolint/config";
 import { mutateJson, PackageJson } from "@monorepolint/utils";
 import * as r from "runtypes";
 import { coerce, SemVer } from "semver";
-import { createNewRuleConversion } from "./util/createNewRuleConversion";
-
+import { makeRule } from "./util/makeRule.js";
 export const Options = r.Record({
   matchDependencyVersions: r.Dictionary(r.Union(r.String, r.Array(r.String))),
 });
 
 export type Options = r.Static<typeof Options>;
 
-export const consistentVersions: RuleModule<typeof Options> = {
+export const consistentVersions = makeRule({
+  name: "consistentVersions",
   check: checkConsistentVersions,
-  optionsRuntype: Options,
-};
+  validateOptions: Options.check,
+});
 
 function checkConsistentVersions(context: Context, options: Options) {
   for (const [dependencyPackageName, expectedPackageDependencyValue] of Object.entries(
@@ -139,5 +139,3 @@ const ensurePackageMatchesSomeVersion = (
     });
   }
 };
-
-export const ConsistentVersions = createNewRuleConversion("ConsistentVersions", consistentVersions);