Add custom eslint rule package with enforced using rule

.eslintrc.json

@@ -7,7 +7,7 @@
   "overrides": [
     {
       "files": ["*.ts", "*.js"],
-      "plugins": ["@typescript-eslint", "rxjs", "rxjs-angular", "import"],
+      "plugins": ["@typescript-eslint", "rxjs", "rxjs-angular", "import", "custom-rules"],
       "parser": "@typescript-eslint/parser",
       "parserOptions": {
         "project": ["./tsconfig.eslint.json"],
@@ -35,6 +35,7 @@
         }
       },
       "rules": {
+        "custom-rules/required-using": "error",
         "@angular-eslint/component-class-suffix": 0,
         "@angular-eslint/contextual-lifecycle": 0,
         "@angular-eslint/directive-class-suffix": 0,

.github/renovate.json

@@ -193,10 +193,13 @@
         "@storybook/angular",
         "@storybook/manager-api",
         "@storybook/theming",
+        "@typescript-eslint/utils",
+        "@typescript-eslint/rule-tester",
         "@types/react",
         "autoprefixer",
         "bootstrap",
         "chromatic",
+        "eslint-plugin-custom-rules",
         "jquery",
         "ngx-toastr",
         "popper.js",

jest.config.js

@@ -30,6 +30,7 @@ module.exports = {
     "<rootDir>/libs/billing/jest.config.js",
     "<rootDir>/libs/common/jest.config.js",
     "<rootDir>/libs/components/jest.config.js",
+    "<rootDir>/libs/eslint-plugin-custom-rules/jest.config.js",
     "<rootDir>/libs/tools/export/vault-export/vault-export-core/jest.config.js",
     "<rootDir>/libs/tools/generator/core/jest.config.js",
     "<rootDir>/libs/tools/generator/components/jest.config.js",

libs/common/src/platform/misc/reference-counting/rc.spec.ts

@@ -32,12 +32,14 @@ describe("Rc", () => {
   });
 
   it("should return value on take", () => {
+    // eslint-disable-next-line custom-rules/required-using
     const reference = rc.take();
 
     expect(reference.value).toBe(value);
   });
 
   it("should decrease refCount when disposing reference", () => {
+    // eslint-disable-next-line custom-rules/required-using
     const reference = rc.take();
 
     reference[Symbol.dispose]();
@@ -55,6 +57,7 @@ describe("Rc", () => {
   });
 
   it("should not free value when refCount reaches 0 if not marked for disposal", () => {
+    // eslint-disable-next-line custom-rules/required-using
     const reference = rc.take();
 
     reference[Symbol.dispose]();
@@ -63,6 +66,7 @@ describe("Rc", () => {
   });
 
   it("should free value when refCount reaches 0 and rc is marked for disposal", () => {
+    // eslint-disable-next-line custom-rules/required-using
     const reference = rc.take();
     rc.markForDisposal();
 
@@ -72,6 +76,7 @@ describe("Rc", () => {
   });
 
   it("should free value when marked for disposal if refCount is 0", () => {
+    // eslint-disable-next-line custom-rules/required-using
     const reference = rc.take();
     reference[Symbol.dispose]();
 

libs/common/src/platform/misc/reference-counting/rc.ts

@@ -1,3 +1,5 @@
+import { UsingRequired } from "../using-required";
+
 export type Freeable = { free: () => void };
 
 /**
@@ -19,6 +21,8 @@ export class Rc<T extends Freeable> {
    * This will guarantee that you have a reference to the object
    * and that it won't be freed until your reference goes out of scope.
    *
+   * This function must be used with the `using` keyword.
+   *
    * @example
    * ```typescript
    * function someFunction(rc: Rc<SomeValue>) {
@@ -60,7 +64,7 @@ export class Rc<T extends Freeable> {
   }
 }
 
-export class Ref<T extends Freeable> {
+export class Ref<T extends Freeable> implements UsingRequired {
   constructor(
     private readonly release: () => void,
     readonly value: T,

libs/common/src/platform/misc/using-required.ts

@@ -0,0 +1,11 @@
+export type Disposable = { [Symbol.dispose]: () => void };
+
+/**
+ * Types implementing this type must be used together with the `using` keyword
+ *
+ * @example using ref = rc.take();
+ */
+// We want to use `interface` here because it creates a separate type.
+// Type aliasing would not expose `UsingRequired` to the linter.
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export interface UsingRequired extends Disposable {}

libs/eslint-plugin-custom-rules/jest.config.js

@@ -0,0 +1,17 @@
+const { pathsToModuleNameMapper } = require("ts-jest");
+
+const { compilerOptions } = require("../shared/tsconfig.spec");
+
+const sharedConfig = require("../../libs/shared/jest.config.angular");
+
+/** @type {import('jest').Config} */
+module.exports = {
+  ...sharedConfig,
+  testMatch: ["**/+(*.)+(spec).+(js)"],
+  displayName: "libs/eslint-plugin-custom-rules tests",
+  preset: "jest-preset-angular",
+  setupFilesAfterEnv: ["<rootDir>/test.setup.js"],
+  // moduleNameMapper: pathsToModuleNameMapper(compilerOptions?.paths || {}, {
+  //   prefix: "<rootDir>/",
+  // }),
+};

libs/eslint-plugin-custom-rules/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "eslint-plugin-custom-rules",
+  "version": "1.0.0",
+  "description": "Custom ESlint rules for the clients repository",
+  "main": "src/index.js",
+  "dependencies": {},
+  "devDependencies": {}
+}

libs/eslint-plugin-custom-rules/src/index.js

@@ -0,0 +1,5 @@
+/* eslint-disable no-undef */
+/* eslint-disable @typescript-eslint/no-require-imports */
+
+const plugin = { rules: { "required-using": require("./required-using") } };
+module.exports = plugin;

libs/eslint-plugin-custom-rules/src/keep.ts

@@ -0,0 +1 @@
+// Used to avoid TS errors since this package only uses `tsconfig.json` for dynamically generated test files

libs/eslint-plugin-custom-rules/src/required-using.js

@@ -0,0 +1,87 @@
+/* eslint-disable no-undef */
+/* eslint-disable @typescript-eslint/no-require-imports */
+
+const { ESLintUtils } = require("@typescript-eslint/utils");
+
+const errorMessage = "'using' keyword is required but not used";
+
+module.exports = {
+  errorMessage,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Ensure objects implementing UsingRequired are used with the using keyword",
+      category: "Best Practices",
+      recommended: false,
+    },
+    schema: [],
+  },
+  create(context) {
+    const parserServices = ESLintUtils.getParserServices(context);
+    const checker = parserServices.program.getTypeChecker();
+
+    // Function to check if a type implements the `UsingRequired` interface
+    function implementsUsingRequired(type) {
+      const symbol = type.getSymbol();
+      if (!symbol) {
+        return false;
+      }
+
+      const declarations = symbol.getDeclarations() || [];
+      for (const declaration of declarations) {
+        const heritageClauses = declaration.heritageClauses || [];
+        for (const clause of heritageClauses) {
+          if (
+            clause.types.some(
+              (typeExpression) =>
+                checker.typeToString(checker.getTypeAtLocation(typeExpression.expression)) ===
+                "UsingRequired",
+            )
+          ) {
+            return true;
+          }
+        }
+      }
+
+      return false;
+    }
+
+    // Function to check if a function call returns a `UsingRequired`
+    function returnsUsingRequired(node) {
+      if (node.type === "CallExpression") {
+        const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+        const returnType = checker.getTypeAtLocation(tsNode);
+
+        return implementsUsingRequired(returnType);
+      }
+
+      return false;
+    }
+
+    return {
+      VariableDeclarator(node) {
+        // Skip if `using` is already present
+        if (node.parent.type === "VariableDeclaration" && node.parent.kind === "using") {
+          return;
+        }
+
+        // Check if the initializer returns a `UsingRequired`
+        if (node.init && returnsUsingRequired(node.init)) {
+          context.report({
+            node,
+            message: errorMessage,
+          });
+        }
+      },
+      AssignmentExpression(node) {
+        // Check if the right-hand side returns a `UsingRequired`
+        if (returnsUsingRequired(node.right)) {
+          context.report({
+            node,
+            message: errorMessage,
+          });
+        }
+      },
+    };
+  },
+};

libs/eslint-plugin-custom-rules/src/required-using.spec.js

@@ -0,0 +1,103 @@
+/* eslint-disable no-undef */
+/* eslint-disable @typescript-eslint/no-require-imports */
+
+const { RuleTester } = require("@typescript-eslint/rule-tester");
+
+const rule = require("./required-using");
+
+const errorMessage = rule.errorMessage;
+
+const ruleTester = new RuleTester({
+  languageOptions: {
+    parserOptions: {
+      project: [__dirname + "/../tsconfig.spec.json"],
+      projectService: {
+        allowDefaultProject: ["*.ts*"],
+      },
+      tsconfigRootDir: __dirname + "/..",
+    },
+  },
+});
+
+const setup = `
+  interface UsingRequired {}
+  class Ref implements UsingRequired {}
+
+  const rc = {
+    take(): Ref {
+      return new Ref();
+    },
+  };
+`;
+
+ruleTester.run("required-using", rule, {
+  valid: [
+    {
+      name: "Direct declaration with `using`",
+      code: `
+        ${setup}
+        using client = rc.take();
+      `,
+    },
+    {
+      name: "Function reference with `using`",
+      code: `
+        ${setup}
+        const t = rc.take;
+        using client = t();
+      `,
+    },
+  ],
+  invalid: [
+    {
+      name: "Direct declaration without `using`",
+      code: `
+        ${setup}
+        const client = rc.take();
+      `,
+      errors: [
+        {
+          message: errorMessage,
+        },
+      ],
+    },
+    {
+      name: "Assignment without `using`",
+      code: `
+        ${setup}
+        let client;
+        client = rc.take();
+      `,
+      errors: [
+        {
+          message: errorMessage,
+        },
+      ],
+    },
+    {
+      name: "Function reference without `using`",
+      code: `
+        ${setup}
+        const t = rc.take;
+        const client = t();
+      `,
+      errors: [
+        {
+          message: errorMessage,
+        },
+      ],
+    },
+    {
+      name: "Destructuring without `using`",
+      code: `
+        ${setup}
+        const { value } = rc.take();
+      `,
+      errors: [
+        {
+          message: errorMessage,
+        },
+      ],
+    },
+  ],
+});

libs/eslint-plugin-custom-rules/test.setup.js

@@ -0,0 +1,9 @@
+/* eslint-disable no-undef */
+/* eslint-disable @typescript-eslint/no-require-imports */
+
+const { clearImmediate, setImmediate } = require("node:timers");
+
+Object.defineProperties(globalThis, {
+  clearImmediate: { value: clearImmediate },
+  setImmediate: { value: setImmediate },
+});

libs/eslint-plugin-custom-rules/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "extends": "../shared/tsconfig",
+  "compilerOptions": {},
+  "exclude": ["node_modules", "dist"]
+}

libs/eslint-plugin-custom-rules/tsconfig.spec.json

@@ -0,0 +1,3 @@
+{
+  "extends": "./tsconfig.json"
+}