@adonisjs/eslint-plugin 1.0.1

package/dist/bin/test.js

@@ -0,0 +1,44 @@
+"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");
+const runner_1 = require("@japa/runner");
+/*
+|--------------------------------------------------------------------------
+| Configure tests
+|--------------------------------------------------------------------------
+|
+| The configure method accepts the configuration to configure the Japa
+| tests runner.
+|
+| The first method call "processCliArgs" process the command line arguments
+| and turns them into a config object. Using this method is not mandatory.
+|
+| Please consult japa.dev/runner-config for the config docs.
+*/
+(0, runner_1.configure)({
+    ...(0, runner_1.processCliArgs)(process.argv.slice(2)),
+    ...{
+        plugins: [(0, assert_1.assert)()],
+        reporters: [(0, spec_reporter_1.specReporter)()],
+        importer: (filePath) => Promise.resolve(`${filePath}`).then(s => require(s)),
+        files: ['tests/**/*.spec.ts'],
+    },
+});
+/*
+|--------------------------------------------------------------------------
+| Run tests
+|--------------------------------------------------------------------------
+|
+| The following "run" method is required to execute all the tests.
+|
+*/
+(0, runner_1.run)();

package/dist/src/index.js

@@ -0,0 +1,7 @@
+"use strict";
+const prefer_lazy_controller_import_1 = require("./rules/prefer_lazy_controller_import");
+module.exports = {
+    rules: {
+        'prefer-lazy-controller-import': prefer_lazy_controller_import_1.default,
+    },
+};

package/dist/src/rules/prefer_lazy_controller_import.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const utils_2 = require("../utils");
+const httpMethods = ['get', 'post', 'put', 'delete', 'patch'];
+exports.default = (0, utils_2.createEslintRule)({
+    name: 'prefer-lazy-controller-import',
+    defaultOptions: [],
+    meta: {
+        type: 'problem',
+        fixable: 'code',
+        docs: {
+            description: 'Prefer lazy controller import over eager import',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            preferLazyControllerImport: 'Prefer lazy controller import over eager import',
+        },
+    },
+    create: function (context) {
+        let importIdentifiers = [];
+        let routerIdentifier = '';
+        let importNodes = [];
+        function isRouteCallExpression(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 &&
+                httpMethods.includes(node.callee.property.name));
+        }
+        return {
+            /**
+             * Track all imported identifiers
+             * Also get the local name of the router 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/router') {
+                    if (node.specifiers[0] && node.specifiers[0].type === 'ImportDefaultSpecifier') {
+                        routerIdentifier = node.specifiers[0].local.name;
+                    }
+                }
+            },
+            /**
+             * 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);
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+});

package/dist/src/utils.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEslintRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+exports.createEslintRule = utils_1.ESLintUtils.RuleCreator((ruleName) => ruleName);

package/dist/tests/prefer_lazy_controller_import.spec.js

@@ -0,0 +1,47 @@
+"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_controller_import_1 = require("../src/rules/prefer_lazy_controller_import");
+const valids = [
+    `
+  import router from "@adonisjs/core/services/router"
+  const lazyController = () => import("./controller")
+
+  router.get("/", "HomeController.index")
+  router.get("/test", [lazyController, 'index'])
+  `,
+];
+const invalids = [
+    [
+        `
+    import router from "@adonisjs/core/services/router"
+    import HomeController from "./controller"
+
+    router.group(() => {
+      router.get("/", [HomeController, 'index'])
+    })
+    `,
+        `
+    import router from "@adonisjs/core/services/router"
+    const HomeController = () => import("./controller")
+
+    router.group(() => {
+      router.get("/", [HomeController, 'index'])
+    })
+    `,
+    ],
+];
+(0, runner_1.test)('Prefer lazy controller import', ({ assert }) => {
+    const ruleTester = new ts_eslint_1.RuleTester({
+        parser: require.resolve('@typescript-eslint/parser'),
+    });
+    ruleTester.run('prefer-lazy-controller-import', prefer_lazy_controller_import_1.default, {
+        valid: valids,
+        invalid: invalids.map((invalid) => ({
+            code: invalid[0],
+            output: invalid[1],
+            errors: [{ messageId: 'preferLazyControllerImport' }],
+        })),
+    });
+});

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@adonisjs/eslint-plugin",
+  "version": "1.0.1",
+  "description": "",
+  "files": [
+    "dist"
+  ],
+  "main": "dist/src/index.js",
+  "keywords": [],
+  "author": "Julien Ripouteau <julien@ripouteau.com>",
+  "license": "ISC",
+  "dependencies": {
+    "@typescript-eslint/utils": "^5.59.11"
+  },
+  "devDependencies": {
+    "@japa/assert": "^1.4.1",
+    "@japa/runner": "^2.5.1",
+    "@japa/spec-reporter": "^1.3.3",
+    "@types/node": "^20.3.1",
+    "@typescript-eslint/parser": "^5.59.11",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.1.3"
+  },
+  "scripts": {
+    "build": "tsc --outDir dist",
+    "quick:test": "ts-node bin/test.ts"
+  }
+}