Feat/enforce custom provider type

src/rules/enforce-custom-provider-type.rule.ts

@@ -0,0 +1,160 @@
+import {
+  ASTUtils,
+  AST_NODE_TYPES,
+  ESLintUtils,
+  type TSESTree,
+} from '@typescript-eslint/utils';
+
+const createRule = ESLintUtils.RuleCreator(
+  (name) => `https://eslint.org/docs/latest/rules/${name}`
+);
+
+type ProviderType = 'class' | 'factory' | 'value' | 'existing' | 'unknown';
+
+export type Options = [
+  {
+    prefer: ProviderType;
+  },
+];
+
+const defaultOptions: Options = [
+  {
+    prefer: 'factory',
+  },
+];
+
+export type MessageIds = 'providerTypeMismatch';
+
+export default createRule<Options, MessageIds>({
+  name: 'enforce-custom-provider-type',
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Ensure that custom providers are of the preferred type',
+    },
+    fixable: undefined,
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          prefer: {
+            type: 'string',
+            enum: ['class', 'factory', 'value'],
+          },
+        },
+      },
+    ],
+    messages: {
+      providerTypeMismatch: 'Provider is not of type {{ preferred }}',
+    },
+  },
+  defaultOptions,
+  create(context) {
+    const options = context.options[0] || defaultOptions[0];
+    const preferredType = options.prefer;
+    const providerTypesImported: string[] = [];
+    return {
+      'ImportDeclaration[source.value="@nestjs/common"]': (
+        node: TSESTree.ImportDeclaration
+      ) => {
+        const specifiers = node.specifiers;
+
+        const isImportSpecifier = (
+          node: TSESTree.ImportClause
+        ): node is TSESTree.ImportSpecifier =>
+          node.type === AST_NODE_TYPES.ImportSpecifier;
+
+        const isProviderImport = (spec: TSESTree.ImportSpecifier) =>
+          [
+            'Provider',
+            'ClassProvider',
+            'FactoryProvider',
+            'ValueProvider',
+          ].includes(spec.imported.name);
+
+        specifiers
+          .filter(isImportSpecifier)
+          .filter(isProviderImport)
+          .forEach((spec) =>
+            providerTypesImported.push(spec.local.name ?? spec.imported.name)
+          );
+      },
+
+      'Identifier[typeAnnotation.typeAnnotation.type="TSTypeReference"]': (
+        node: TSESTree.Identifier
+      ) => {
+        const typeName = (
+          node.typeAnnotation?.typeAnnotation as TSESTree.TSTypeReference
+        ).typeName;
+
+        if (
+          ASTUtils.isIdentifier(typeName) &&
+          providerTypesImported.includes(typeName.name)
+        ) {
+          const providerType = getProviderType(node);
+          if (providerType && providerType !== preferredType) {
+            context.report({
+              node,
+              messageId: 'providerTypeMismatch',
+              data: {
+                preferred: preferredType,
+              },
+            });
+          }
+        }
+      },
+    };
+  },
+});
+
+function getProviderType(node: TSESTree.Identifier): ProviderType | undefined {
+  const parent = node.parent;
+
+  if (ASTUtils.isVariableDeclarator(parent)) {
+    const init = parent.init;
+    let type: ProviderType | undefined;
+    if (init?.type === AST_NODE_TYPES.ObjectExpression) {
+      const properties = init.properties;
+      for (const property of properties) {
+        if (
+          property.type === AST_NODE_TYPES.Property &&
+          ASTUtils.isIdentifier(property.key) &&
+          property.key.name === 'useFactory'
+        ) {
+          type = 'factory';
+          break;
+        }
+
+        if (
+          property.type === AST_NODE_TYPES.Property &&
+          ASTUtils.isIdentifier(property.key) &&
+          property.key.name === 'useClass'
+        ) {
+          type = 'class';
+          break;
+        }
+
+        if (
+          property.type === AST_NODE_TYPES.Property &&
+          ASTUtils.isIdentifier(property.key) &&
+          property.key.name === 'useValue'
+        ) {
+          type = 'value';
+          break;
+        }
+
+        if (
+          property.type === AST_NODE_TYPES.Property &&
+          ASTUtils.isIdentifier(property.key) &&
+          property.key.name === 'useExisting'
+        ) {
+          type = 'existing';
+          break;
+        }
+      }
+    }
+
+    return type;
+  }
+}
+

tests/rules/enforce-custom-provider-type.rule.spec.ts

@@ -0,0 +1,137 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import enforceCustomProviderTypeRule from '../../src/rules/enforce-custom-provider-type.rule';
+
+// This test required changes to the tsconfig file to allow importing from the rule-tester package.
+// See https://github.com/typescript-eslint/typescript-eslint/issues/7284
+
+const ruleTester = new RuleTester({
+  parserOptions: {
+    project: './tsconfig.json',
+  },
+  parser: '@typescript-eslint/parser',
+  defaultFilenames: {
+    // We need to specify a filename that will be used by the rule parser.
+    // Since the test process starts at the root of the project, we need to point to the sub folder containing it.
+    ts: './tests/rules/file.ts',
+    tsx: '',
+  },
+});
+
+ruleTester.run('enforce-custom-provider-type', enforceCustomProviderTypeRule, {
+  valid: [
+    // Test for when the provider is of the preferred type
+    {
+      code: `
+      import { Provider } from '@nestjs/common';
+
+      const factoryProvider: Provider = {
+        provide: 'TOKEN',
+        useFactory: () => 'some-value'
+      }
+      `,
+      options: [
+        {
+          prefer: 'factory',
+        },
+      ],
+    },
+    // Test for when the Provider type is not imported from '@nestjs/common'
+    {
+      code: `
+      import { Provider } from 'some-other-package';
+      const customValueProvider: Provider = {
+        useValue: 'some-value',
+        provide: 'TOKEN'
+      }
+        `,
+      options: [
+        {
+          prefer: 'factory',
+        },
+      ],
+    },
+  ],
+  invalid: [
+    // Test for when the provider is not of the preferred type
+    {
+      code: `
+      import { Provider } from '@nestjs/common';
+      const customValueProvider: Provider = {
+        provide: 'TOKEN',
+        useValue: 'some-value' // ⚠️ provider is not of type "factory"
+      }
+      `,
+      options: [
+        {
+          prefer: 'factory',
+        },
+      ],
+      errors: [
+        {
+          messageId: 'providerTypeMismatch',
+        },
+      ],
+    },
+    {
+      code: `
+      import { Provider } from '@nestjs/common';
+      import { SomeClass } from './some-class';
+      const customValueProvider: Provider = {
+        provide: 'TOKEN',
+        useClass: SomeClass // ⚠️ provider is not of type "factory"
+      }
+      `,
+      options: [
+        {
+          prefer: 'factory',
+        },
+      ],
+      errors: [
+        {
+          messageId: 'providerTypeMismatch',
+        },
+      ],
+    },
+    {
+      code: `
+      import { Provider } from '@nestjs/common';
+      import { EXISTING_TOKEN } from './token';
+      const customValueProvider: Provider = {
+        provide: 'TOKEN',
+        useExisting: EXISTING_TOKEN // ⚠️ provider is not of type "factory"
+      }
+      `,
+      options: [
+        {
+          prefer: 'factory',
+        },
+      ],
+      errors: [
+        {
+          messageId: 'providerTypeMismatch',
+        },
+      ],
+    },
+    // Test for when the provider is not of the preferred type and was renamed
+    {
+      code: `
+      import { Provider as NestProvider } from '@nestjs/common';
+      import { EXISTING_TOKEN } from './token';
+      const customValueProvider: NestProvider = {
+        provide: 'TOKEN',
+        useExisting: EXISTING_TOKEN // ⚠️ provider is not of type "factory"
+      }
+      `,
+      options: [
+        {
+          prefer: 'factory',
+        },
+      ],
+      errors: [
+        {
+          messageId: 'providerTypeMismatch',
+        },
+      ],
+    },
+  ],
+});