@adonisjs/eslint-plugin 2.0.1 → 2.1.0

package/README.md

@@ -106,6 +106,85 @@ const SendVerificationEmail = () => import('#listeners/send_verification_email')
 emitter.on('user:created', [SendVerificationEmail, 'handle'])
 ```
 
+## `prefer-adonisjs-inertia-link`
+
+> [!NOTE]
+> This rule is for AdonisJS 7+ projects using `@adonisjs/inertia` v4+.
+
+The `@adonisjs/prefer-adonisjs-inertia-link` rule warns when you import the `Link` component from `@inertiajs/react` or `@inertiajs/vue3` instead of using the typesafe version from `@adonisjs/inertia`.
+
+```ts
+// ❌ Warning: Prefer importing Link from @adonisjs/inertia/react for typesafe routing
+import { Link } from '@inertiajs/react'
+```
+
+```ts
+// ✅ Correct
+import { Link } from '@adonisjs/inertia/react'
+```
+
+## `no-backend-import-in-frontend`
+
+The `@adonisjs/no-backend-import-in-frontend` rule prevents importing backend code in your frontend files located in the `inertia/` directory.
+
+The rule detects both:
+
+- **Subpath imports** (`#models/user`) - automatically reads your `package.json` imports field
+- **Relative imports** (`../../app/models/user`) - checks if the resolved path is outside `inertia/`
+
+```ts
+// inertia/pages/users.tsx
+
+// ❌ Error: Importing backend code in frontend files is not allowed
+import User from '#models/user'
+import { UserService } from '../../app/services/user_service'
+```
+
+```ts
+// inertia/pages/users.tsx
+
+// ✅ Correct - type-only imports are allowed
+import type { User } from '#models/user'
+import type { UserService } from '../../app/services/user_service'
+
+// ✅ Correct - imports pointing to inertia/ are allowed
+import { Button } from '#components/button' // if #components/* -> ./inertia/components/*
+import { utils } from '../utils'
+```
+
+### Sharing code between frontend and backend
+
+If you have shared code (e.g., enums, constants, utility types) in your backend that you want to import in your frontend, you can use the `allowed` option to whitelist specific paths:
+
+```ts
+// eslint.config.js
+export default [
+  {
+    rules: {
+      '@adonisjs/no-backend-import-in-frontend': [
+        'error',
+        {
+          allowed: [
+            '#shared/*', // allows #shared/enums, #shared/constants, etc.
+            '#shared/**', // allows #shared/utils/helpers (deep nested)
+            '#enums', // exact match
+          ],
+        },
+      ],
+    },
+  },
+]
+```
+
+The `allowed` option uses [micromatch](https://github.com/micromatch/micromatch) for glob pattern matching.
+
+```ts
+// inertia/pages/users.tsx
+
+// ✅ Correct - #shared/* is in the allowed list
+import { UserStatus } from '#shared/enums'
+```
+
 <div align="center">
   <sub>Built with ❤︎ by <a href="https://github.com/Julien-R44">Julien Ripouteau</a> and <a href="https://github.com/thetutlage">Harminder Virk</a>
 </div>

package/build/index.d.ts

@@ -6,6 +6,14 @@ declare const _default: {
         'prefer-lazy-listener-import': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferLazyListenerImport", [], {
             description: string;
         }, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        'prefer-adonisjs-inertia-link': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferAdonisInertiaLink", [], {
+            description: string;
+        }, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        'no-backend-import-in-frontend': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noBackendImport", [{
+            allowed?: string[];
+        }], {
+            description: string;
+        }, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     };
 };
 export default _default;

package/build/index.js

@@ -151,11 +151,144 @@ var prefer_lazy_controller_import_default = createEslintRule({
   }
 });
 
+// src/rules/prefer_adonisjs_inertia_link.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES3 } from "@typescript-eslint/utils";
+var INERTIA_PACKAGES = ["@inertiajs/react", "@inertiajs/vue3"];
+var prefer_adonisjs_inertia_link_default = createEslintRule({
+  name: "prefer-adonisjs-inertia-link",
+  defaultOptions: [],
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Prefer the typesafe @adonisjs/inertia Link component over the @inertiajs Link component"
+    },
+    schema: [],
+    messages: {
+      preferAdonisInertiaLink: "Prefer importing Link from @adonisjs/inertia/{{ framework }} for typesafe routing instead of {{ source }}"
+    }
+  },
+  create: function(context) {
+    return {
+      ImportDeclaration(node) {
+        const source = node.source.value;
+        if (!INERTIA_PACKAGES.includes(source)) return;
+        const hasLinkImport = node.specifiers.some((specifier) => {
+          if (specifier.type !== AST_NODE_TYPES3.ImportSpecifier) return false;
+          return specifier.imported.type === AST_NODE_TYPES3.Identifier && specifier.imported.name === "Link";
+        });
+        if (!hasLinkImport) return;
+        const framework = source === "@inertiajs/react" ? "react" : "vue";
+        context.report({
+          node,
+          messageId: "preferAdonisInertiaLink",
+          data: { framework, source }
+        });
+      }
+    };
+  }
+});
+
+// src/rules/no_backend_import_in_frontend.ts
+import micromatch from "micromatch";
+import { dirname, resolve } from "path";
+import { readPackageUpSync } from "read-package-up";
+var packageCache = /* @__PURE__ */ new Map();
+function getSubpathImports(filename) {
+  const cwd = dirname(filename);
+  if (packageCache.has(cwd)) return packageCache.get(cwd).imports;
+  const result = readPackageUpSync({ cwd, normalize: false });
+  if (!result) {
+    packageCache.set(cwd, { imports: null });
+    return null;
+  }
+  const imports = result.packageJson.imports ?? null;
+  packageCache.set(cwd, { imports });
+  return imports;
+}
+function resolveImportTarget(target) {
+  if (typeof target === "string") return [target];
+  if (Array.isArray(target)) return target;
+  if (typeof target === "object") return Object.values(target).flatMap(resolveImportTarget);
+  return [];
+}
+function subpathResolvesToFrontend(options) {
+  const { importPath, subpathImports } = options;
+  for (const [pattern, target] of Object.entries(subpathImports)) {
+    const patternBase = pattern.replace("/*", "").replace("*", "");
+    const importBase = importPath.replace("/*", "").replace("*", "");
+    if (importPath === pattern || importBase.startsWith(patternBase)) {
+      const resolvedPaths = resolveImportTarget(target);
+      const isFrontend = resolvedPaths.some((resolved) => {
+        return resolved.startsWith("./inertia/") || resolved.startsWith("inertia/");
+      });
+      if (isFrontend) return true;
+    }
+  }
+  return false;
+}
+function relativePathResolvesToFrontend(options) {
+  const { importPath, filename } = options;
+  const absolutePath = resolve(dirname(filename), importPath);
+  return /[\\/]inertia[\\/]/.test(absolutePath);
+}
+var no_backend_import_in_frontend_default = createEslintRule({
+  name: "no-backend-import-in-frontend",
+  defaultOptions: [{ allowed: [] }],
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow importing backend code in frontend (Inertia) files"
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          allowed: {
+            type: "array",
+            items: { type: "string" },
+            description: 'List of allowed import paths or glob patterns (e.g. "#shared/*", "#enums")'
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      noBackendImport: 'Importing backend code "{{ importPath }}" in frontend files is not allowed. Use `import type` for type-only imports, or add the path to the `allowed` option.'
+    }
+  },
+  create: function(context, options) {
+    const filename = context.filename;
+    const allowed = options[0]?.allowed ?? [];
+    const isInInertiaFolder = /[\\/]inertia[\\/]/.test(filename);
+    if (!isInInertiaFolder) return {};
+    const subpathImports = getSubpathImports(filename);
+    return {
+      ImportDeclaration(node) {
+        const importPath = node.source.value;
+        if (node.importKind === "type") return;
+        if (allowed.length > 0 && micromatch.isMatch(importPath, allowed)) return;
+        if (importPath.startsWith("#")) {
+          if (!subpathImports) return;
+          if (subpathResolvesToFrontend({ importPath, subpathImports })) return;
+          context.report({ node, messageId: "noBackendImport", data: { importPath } });
+          return;
+        }
+        if (importPath.startsWith(".")) {
+          if (relativePathResolvesToFrontend({ importPath, filename })) return;
+          context.report({ node, messageId: "noBackendImport", data: { importPath } });
+        }
+      }
+    };
+  }
+});
+
 // index.ts
 var index_default = {
   rules: {
     "prefer-lazy-controller-import": prefer_lazy_controller_import_default,
-    "prefer-lazy-listener-import": prefer_lazy_listener_import_default
+    "prefer-lazy-listener-import": prefer_lazy_listener_import_default,
+    "prefer-adonisjs-inertia-link": prefer_adonisjs_inertia_link_default,
+    "no-backend-import-in-frontend": no_backend_import_in_frontend_default
   }
 };
 export {

package/build/src/rules/no_backend_import_in_frontend.d.ts

@@ -0,0 +1,12 @@
+type Options = [{
+    allowed?: string[];
+}];
+/**
+ * ESLint rule to prevent importing backend code in frontend files.
+ * Only applies to files in the `inertia/` directory.
+ * Automatically detects frontend subpath imports by reading the package.json imports field.
+ */
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"noBackendImport", Options, {
+    description: string;
+}, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;

package/build/src/rules/prefer_adonisjs_inertia_link.d.ts

@@ -0,0 +1,8 @@
+/**
+ * ESLint rule to prefer the typesafe AdonisJS Inertia Link component
+ * over the non-typesafe Inertia.js Link component
+ */
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferAdonisInertiaLink", [], {
+    description: string;
+}, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@adonisjs/eslint-plugin",
   "description": "ESLint plugin to enforce AdonisJS app specific linting rules",
-  "version": "2.0.1",
+  "version": "2.1.0",
   "engines": {
     "node": ">=20.6.0"
   },
@@ -38,6 +38,7 @@
     "@release-it/conventional-changelog": "^10.0.1",
     "@stylistic/eslint-plugin-ts": "^4.4.1",
     "@swc/core": "^1.13.3",
+    "@types/micromatch": "^4.0.10",
     "@types/node": "^24.2.0",
     "@typescript-eslint/rule-tester": "^8.39.0",
     "c8": "^10.1.3",
@@ -57,7 +58,9 @@
     "eslint": "^9.9.1"
   },
   "dependencies": {
-    "@typescript-eslint/utils": "^8.39.0"
+    "@typescript-eslint/utils": "^8.39.0",
+    "micromatch": "^4.0.8",
+    "read-package-up": "^12.0.0"
   },
   "homepage": "https://github.com/adonisjs/eslint-plugin-adonisjs#readme",
   "repository": {