@adonisjs/eslint-plugin 1.1.2 → 1.1.3

package/README.md

@@ -0,0 +1,34 @@
+# `@adonisjs/eslint-plugin`
+
+ESLint plugin to enforce AdonisJS specific linting rules. Following is the list of available rules.
+
+- `prefer-lazy-controller-import`: Enforces and auto fixes standard HTTP controller imports inside the routes file to lazy imports. Lazy imports improves the application load time.
+- `prefer-lazy-listener-import`: Enforces and auto fixes standard event listener imports inside the events file to lazy imports. Lazy imports improves the application load time.
+
+## Installation
+
+Install the package as a development dependency from the npm packages registry.
+
+```bash
+npm i -D @adonisjs/eslint-plugin
+
+# For yarn lovers
+yarn add -D @adonisjs/eslint-plugin
+
+# For pnpm believers
+pnpm add -D @adonisjs/eslint-plugin
+```
+
+## Usage
+
+Add the following rule to your eslint config file.
+
+```js
+{
+  plugins: ['@adonisjs/eslint-plugin'],
+  rules: {
+    '@adonisjs/prefer-lazy-controller-import': 'error',
+    '@adonisjs/prefer-lazy-listener-import': 'error',
+  },
+}
+```

package/dist/bin/test.js

@@ -1,12 +1,4 @@
 "use strict";
-/*
- * @adonisjs/mail
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 const assert_1 = require("@japa/assert");
 const spec_reporter_1 = require("@japa/spec-reporter");

package/dist/src/rules/prefer_lazy_controller_import.js

@@ -10,12 +10,12 @@ exports.default = (0, utils_2.createEslintRule)({
         type: 'problem',
         fixable: 'code',
         docs: {
-            description: 'Prefer lazy controller import over eager import',
+            description: 'Prefer lazy controller import over standard import',
             recommended: 'error',
         },
         schema: [],
         messages: {
-            preferLazyControllerImport: 'Prefer lazy controller import over eager import',
+            preferLazyControllerImport: 'Replace standard import with lazy controller import',
         },
     },
     create: function (context) {
@@ -47,29 +47,37 @@ exports.default = (0, utils_2.createEslintRule)({
                     }
                 }
             },
-            /**
-             * Check if we are calling router.get() or any other http method
-             */
             CallExpression(node) {
-                if (isRouteCallExpression(node, routerIdentifier)) {
-                    const secondArgument = node.arguments[1];
-                    if (secondArgument.type !== utils_1.AST_NODE_TYPES.ArrayExpression) {
-                        return;
-                    }
-                    for (const element of secondArgument.elements) {
-                        if (element.type !== 'Identifier' || !importIdentifiers.includes(element.name)) {
-                            continue;
-                        }
-                        context.report({
-                            node: importNodes[element.name],
-                            messageId: 'preferLazyControllerImport',
-                            fix(fixer) {
-                                const importPath = importNodes[element.name].source.raw;
-                                const newImportDeclaration = `const ${element.name} = () => import(${importPath})`;
-                                return fixer.replaceText(importNodes[element.name], newImportDeclaration);
-                            },
-                        });
+                /**
+                 * Check if we are calling router.get() or any other http method
+                 */
+                if (!isRouteCallExpression(node, routerIdentifier)) {
+                    return;
+                }
+                /**
+                 * Ensure the second argument is an array
+                 */
+                const secondArgument = node.arguments[1];
+                if (secondArgument.type !== utils_1.AST_NODE_TYPES.ArrayExpression) {
+                    return;
+                }
+                for (const element of secondArgument.elements) {
+                    /**
+                     * If we are dealing with an Identifier that was imported
+                     * through a standard import, then report it as an error
+                     */
+                    if (element.type !== 'Identifier' || !importIdentifiers.includes(element.name)) {
+                        continue;
                     }
+                    context.report({
+                        node: importNodes[element.name],
+                        messageId: 'preferLazyControllerImport',
+                        fix(fixer) {
+                            const importPath = importNodes[element.name].source.raw;
+                            const newImportDeclaration = `const ${element.name} = () => import(${importPath})`;
+                            return fixer.replaceText(importNodes[element.name], newImportDeclaration);
+                        },
+                    });
                 }
             },
         };

package/dist/src/rules/prefer_lazy_listener_import.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const utils_2 = require("../utils");
+exports.default = (0, utils_2.createEslintRule)({
+    name: 'prefer-lazy-listener-import',
+    defaultOptions: [],
+    meta: {
+        type: 'problem',
+        fixable: 'code',
+        docs: {
+            description: 'Prefer lazy listener import over standard import',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            preferLazyListenerImport: 'Replace standard import with lazy listener import',
+        },
+    },
+    create: function (context) {
+        let importIdentifiers = [];
+        let emitterIdentifier = '';
+        let importNodes = [];
+        function isEmitterOnCallExpression(node, routerIdentifier) {
+            return (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                node.callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                node.callee.object.name === routerIdentifier &&
+                node.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                node.callee.property.name === 'on');
+        }
+        return {
+            /**
+             * Track all imported identifiers
+             * Also get the local name of the emitter import
+             */
+            ImportDeclaration(node) {
+                for (const specifier of node.specifiers) {
+                    if (specifier.type === 'ImportDefaultSpecifier' || specifier.type === 'ImportSpecifier') {
+                        importIdentifiers.push(specifier.local.name);
+                        importNodes[specifier.local.name] = node;
+                    }
+                }
+                if (node.source.value === '@adonisjs/core/services/emitter') {
+                    if (node.specifiers[0] && node.specifiers[0].type === 'ImportDefaultSpecifier') {
+                        emitterIdentifier = node.specifiers[0].local.name;
+                    }
+                }
+            },
+            CallExpression(node) {
+                /**
+                 * Check if we are calling emitter.on()
+                 */
+                if (!isEmitterOnCallExpression(node, emitterIdentifier)) {
+                    return;
+                }
+                /**
+                 * Ensure the second argument is an array
+                 */
+                const secondArgument = node.arguments[1];
+                if (secondArgument.type !== utils_1.AST_NODE_TYPES.ArrayExpression) {
+                    return;
+                }
+                for (const element of secondArgument.elements) {
+                    /**
+                     * If we are dealing with an Identifier that was imported
+                     * through a standard import, then report it as an error
+                     */
+                    if (element.type !== 'Identifier' || !importIdentifiers.includes(element.name)) {
+                        continue;
+                    }
+                    context.report({
+                        node: importNodes[element.name],
+                        messageId: 'preferLazyListenerImport',
+                        fix(fixer) {
+                            const importPath = importNodes[element.name].source.raw;
+                            const newImportDeclaration = `const ${element.name} = () => import(${importPath})`;
+                            return fixer.replaceText(importNodes[element.name], newImportDeclaration);
+                        },
+                    });
+                }
+            },
+        };
+    },
+});

package/dist/tests/prefer_lazy_controller_import.spec.js

@@ -10,6 +10,15 @@ const valids = [
 
   router.get("/", "HomeController.index")
   router.get("/test", [lazyController, 'index'])
+  `,
+    `
+  import router from "@adonisjs/core/services/router"
+  import middleware from '#start/middleware'
+
+  const lazyController = () => import("./controller")
+
+  router.get("/", "HomeController.index").middleware(middleware.auth())
+  router.get("/test", [lazyController, 'index']).middleware(middleware.auth())
   `,
 ];
 const invalids = [

package/dist/tests/prefer_lazy_listener_import.spec.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const runner_1 = require("@japa/runner");
+const ts_eslint_1 = require("@typescript-eslint/utils/dist/ts-eslint");
+const prefer_lazy_listener_import_1 = require("../src/rules/prefer_lazy_listener_import");
+const valids = [
+    `
+  import emitter from '@adonisjs/core/services/emitter'
+  const SendVerificationEmail = () => import('#listeners/send_verification_email')
+
+  emitter.on('user:registered', [SendVerificationEmail, 'handle'])
+  `,
+];
+const invalids = [
+    [
+        `
+    import emitter from '@adonisjs/core/services/emitter'
+    import SendVerificationEmail from '#listeners/send_verification_email'
+
+    emitter.on('user:registered', [SendVerificationEmail, 'handle'])
+    `,
+        `
+    import emitter from '@adonisjs/core/services/emitter'
+    const SendVerificationEmail = () => import('#listeners/send_verification_email')
+
+    emitter.on('user:registered', [SendVerificationEmail, 'handle'])
+    `,
+    ],
+];
+(0, runner_1.test)('Prefer lazy event listener import', ({ assert }) => {
+    const ruleTester = new ts_eslint_1.RuleTester({
+        parser: require.resolve('@typescript-eslint/parser'),
+    });
+    ruleTester.run('prefer-lazy-listener-import', prefer_lazy_listener_import_1.default, {
+        valid: valids,
+        invalid: invalids.map((invalid) => ({
+            code: invalid[0],
+            output: invalid[1],
+            errors: [{ messageId: 'preferLazyListenerImport' }],
+        })),
+    });
+});

package/package.json

@@ -1,14 +1,25 @@
 {
   "name": "@adonisjs/eslint-plugin",
-  "version": "1.1.2",
-  "description": "",
+  "version": "1.1.3",
+  "description": "ESLint plugin to enforce AdonisJS app specific linting rules",
   "files": [
     "dist"
   ],
   "main": "dist/src/index.js",
-  "keywords": [],
+  "exports": {
+    ".": "./dist/src/index.js"
+  },
+  "keywords": [
+    "eslint",
+    "adonisjs",
+    "eslint-plugin"
+  ],
   "author": "Julien Ripouteau <julien@ripouteau.com>",
-  "license": "ISC",
+  "contributors": [
+    "virk",
+    "adonisjs"
+  ],
+  "license": "MIT",
   "dependencies": {
     "@typescript-eslint/utils": "^5.59.11"
   },
@@ -23,6 +34,7 @@
   },
   "scripts": {
     "build": "tsc --outDir dist",
+    "test": "ts-node bin/test.ts",
     "quick:test": "ts-node bin/test.ts"
   }
 }