Merge pull request #1 from nartc/feat/custom-destroy-service-name

feat: add way to customize Destroy service name

Author: phhien203

README.md

@@ -10,6 +10,8 @@ This is a repository containing custom ESLint rules for Angular projects
 
 ## Usage
 
+### `destroy-service-provider`
+
 Edit your eslint config file as follow
 
 ```json

package.json

@@ -33,6 +33,7 @@
     "@types/estree": "0.0.51",
     "@types/node": "16.11.33",
     "@typescript-eslint/parser": "5.21.0",
+    "@typescript-eslint/utils": "5.31.0",
     "eslint": "8.15.0",
     "husky": "7.0.4",
     "jest": "28.1.0",

src/index.ts

@@ -1,7 +1,7 @@
-import destroyServiceProvider from "./rules/destroy-service-provider";
+import * as destroyServiceProviderRule from "./rules/destroy-service-provider";
 
 export = {
   rules: {
-    "destroy-service-provider": destroyServiceProvider,
+    [destroyServiceProviderRule.ruleName]: destroyServiceProviderRule.rule,
   },
 };

src/rules/destroy-service-provider.test.ts

@@ -1,10 +1,8 @@
-import { RuleTester } from "eslint";
+import { ESLintUtils } from "@typescript-eslint/utils";
+import { rule } from "./destroy-service-provider";
 
-import rule from "./destroy-service-provider";
-
-const tester = new RuleTester({
-  parser: require.resolve("@typescript-eslint/parser"),
-  parserOptions: { ecmaVersion: 2015 },
+const tester = new ESLintUtils.RuleTester({
+  parser: "@typescript-eslint/parser",
 });
 
 tester.run("destroy-service-provider", rule, {
@@ -88,8 +86,10 @@ tester.run("destroy-service-provider", rule, {
         }`,
       errors: [
         {
-          message:
-            "Please provide DestroyService in Component class providers.",
+          messageId: "missing",
+          data: {
+            className: "Component",
+          },
         },
       ],
     },
@@ -105,8 +105,30 @@ tester.run("destroy-service-provider", rule, {
         }`,
       errors: [
         {
-          message:
-            "Please provide DestroyService in Directive class providers.",
+          messageId: "missing",
+          data: {
+            className: "Directive",
+          },
+        },
+      ],
+    },
+    {
+      code: `
+        @Directive({
+          selector: 'my-directive',
+        })
+        export class MyDirective implements OnInit {
+          constructor(
+            private destroy$: Destroy,
+          ) {}
+        }`,
+      options: [{ destroyServiceName: "Destroy" }],
+      errors: [
+        {
+          messageId: "missing",
+          data: {
+            className: "Directive",
+          },
         },
       ],
     },

src/rules/destroy-service-provider.ts

@@ -1,26 +1,53 @@
-import { Rule } from "eslint";
+import {
+  CallExpression,
+  ClassDeclaration,
+  Decorator,
+  MethodDefinition,
+  ObjectExpression,
+  Property,
+} from "@typescript-eslint/types/dist/generated/ast-spec";
+import { ESLintUtils } from "@typescript-eslint/utils";
+import { repositoryUrl } from "../utils";
 
-const rule: Rule.RuleModule = {
-  create: context => {
+export const ruleName = "destroy-service-provider";
+
+type MessageIds = "missing";
+
+type Options = [
+  {
+    /**
+     * @default DestroyService
+     */
+    destroyServiceName?: string;
+  },
+];
+
+const createRule = ESLintUtils.RuleCreator(name => `${repositoryUrl}#${name}`);
+
+export const rule = createRule<Options, MessageIds>({
+  create(context, [options]) {
     return {
       "ClassDeclaration > Decorator[expression.callee.name=/^(Component|Directive)$/]":
-        (node: any) => {
+        (node: Decorator) => {
+          const nodeExpression = node.expression as CallExpression;
           const isDecoratorEmpty =
-            !node.expression.arguments.length ||
-            !node.expression.arguments[0].properties.length;
+            !nodeExpression.arguments.length ||
+            !(nodeExpression.arguments[0] as ObjectExpression).properties
+              .length;
 
           if (isDecoratorEmpty) {
             return;
           }
 
           // whether component has providers decorator property
-          const providersProperty =
-            node.expression.arguments[0].properties.find((property: any) => {
-              return (
-                property.key.type === "Identifier" &&
-                property.key.name === "providers"
-              );
-            });
+          const providersProperty = (
+            nodeExpression.arguments[0] as ObjectExpression
+          ).properties.find((property: any) => {
+            return (
+              property.key.type === "Identifier" &&
+              property.key.name === "providers"
+            );
+          }) as Property;
 
           let providerValuesHasDestroyService: boolean = false;
 
@@ -31,7 +58,10 @@ const rule: Rule.RuleModule = {
           ) {
             providerValuesHasDestroyService =
               !!providersProperty.value.elements.find((e: any) => {
-                return e.type === "Identifier" && e.name === "DestroyService";
+                return (
+                  e.type === "Identifier" &&
+                  e.name === options.destroyServiceName
+                );
               });
           }
 
@@ -40,17 +70,18 @@ const rule: Rule.RuleModule = {
             (providersProperty && !providerValuesHasDestroyService)
           ) {
             // get constructor
-            const classDeclaration = node.parent;
+            const classDeclaration = (node as any).parent as ClassDeclaration;
             const classElements = classDeclaration.body.body;
-            const classConstructor = classElements.find((e: any) => {
+            const classConstructor = classElements.find(e => {
               return e.type === "MethodDefinition" && e.kind === "constructor";
             });
 
             let hasDestroy;
 
             if (classConstructor) {
               // find DestroyService
-              const params: any[] = classConstructor.value.params;
+              const params: any[] = (classConstructor as MethodDefinition).value
+                .params;
               hasDestroy = params.find(param => {
                 return (
                   param.type === "TSParameterProperty" &&
@@ -60,21 +91,48 @@ const rule: Rule.RuleModule = {
                   param.parameter.typeAnnotation.typeAnnotation.typeName
                     .type === "Identifier" &&
                   param.parameter.typeAnnotation.typeAnnotation.typeName
-                    .name === "DestroyService"
+                    .name === options.destroyServiceName
                 );
               });
             }
 
             if (hasDestroy) {
               context.report({
                 loc: hasDestroy.loc,
-                message: `Please provide DestroyService in ${node.expression.callee.name} class providers.`,
+                messageId: "missing",
+                data: {
+                  className: (nodeExpression as any).callee.name,
+                },
               });
             }
           }
         },
     };
   },
-};
-
-export = rule;
+  name: ruleName,
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Destroy service should be provided in Component/Directive providers/viewProviders array.",
+      recommended: "error",
+    },
+    messages: {
+      missing:
+        "Please provide DestroyService in {{className}} class providers.",
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          destroyServiceName: {
+            type: "string",
+            default: "DestroyService",
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+  },
+  defaultOptions: [{ destroyServiceName: "DestroyService" }],
+});

src/utils.ts

@@ -0,0 +1,3 @@
+const packageJson = require('../package.json');
+
+export const repositoryUrl = packageJson.repository;