eslint-plugin-fsd-paths-check 0.0.8 → 0.0.10

package/lib/helpers/isPathRelative.js

@@ -0,0 +1,7 @@
+function isPathRelative(path) {
+    return path === `.` || path.startsWith(`./`) || path.startsWith('../');
+}
+
+module.exports = {
+    isPathRelative
+}

package/lib/helpers/isSameModuleImport.js

@@ -0,0 +1,37 @@
+const { isPathRelative } = require("./isPathRelative");
+const path = require("path");
+
+function isSameModuleImport(from, to, fsdLayers) {
+    if(isPathRelative(to)) {
+        return false;
+    }
+
+    const toArray = to.split('/');
+    const toLayer = toArray[0];
+    const toSlice = toArray[1];
+
+    if(!toLayer || !toSlice || !fsdLayers[toLayer]) {
+        return false;
+    }
+
+    const fromNormalized = path.toNamespacedPath(from);
+    const fromProject = fromNormalized.split(`src/`)[1];
+
+    if(!fromProject) {
+        return false;
+    }
+
+    const fromArray = fromProject.split('/');
+    const fromLayer = fromArray[0];
+    const fromSlice = fromArray[1];
+
+    if(!fromLayer || !fromSlice || !fsdLayers[fromLayer]) {
+        return false;
+    }
+
+    return fromSlice === toSlice && fromLayer === toLayer;
+}
+
+module.exports = {
+    isSameModuleImport
+};

package/lib/rules/enforce-public-api-imports.js

@@ -0,0 +1,82 @@
+"use strict";
+
+const { isPathRelative } = require("../helpers/isPathRelative");
+const path = require("path");
+const {isSameModuleImport} = require("../helpers/isSameModuleImport");
+
+const fsdLayers = {
+  'entities': 'entities',
+  'features': 'features',
+  'widgets': 'widgets',
+  'pages': 'pages',
+}
+
+module.exports = {
+  meta: {
+    type: `suggestion`,
+    docs: {
+      description: "Rule to enforce other modules public api usage",
+      recommended: false,
+      url: null,
+    },
+    fixable: `code`,
+    schema: [{
+      type: `object`,
+      properties: {
+        alias: {
+          type: `string`,
+        }
+      }
+    }],
+    messages: {
+      useOthersModulesPublicApi: `When importing from other modules, public api should be used`,
+      doNotUseAbsolutePathInSameModuleImport: `When importing from the same module, absolute path should not be used`,
+    },
+  },
+
+  create(context) {
+    return {
+      ImportDeclaration(node) {
+        const alias = context.options[0]?.alias ?? ``;
+        const value = node.source.value;
+        const pathTo = alias ? value.replace(`${alias}`, ``) : value;
+        const currentFile = context.getFilename();
+
+        if(isPathRelative(pathTo)) {
+          return;
+        }
+
+        const segments = pathTo.split("/");
+        const layer = segments[0];
+
+        if(!fsdLayers[layer]) {
+          return;
+        }
+
+        const isImportNotFromPublicApi = segments.length > 2;
+        const isSameModule = isSameModuleImport(currentFile, pathTo, fsdLayers);
+
+        if (isImportNotFromPublicApi && !isSameModule) {
+          context.report({
+            node,
+            messageId: `useOthersModulesPublicApi`,
+            fix(fixer) {
+              const index = value.indexOf(segments[1]);
+              if (index === -1) return undefined;
+
+              const publicPathImport = value.substring(0, index + segments[1].length);
+
+              return fixer.replaceText(node.source, `'${publicPathImport}'`);
+            }
+          })
+        }
+        else if (isSameModule) {
+          context.report({
+            node,
+            messageId: `doNotUseAbsolutePathInSameModuleImport`
+          })
+        }
+      }
+    };
+  },
+};

package/lib/rules/enforce-relative-path-within-slice.js

@@ -1,6 +1,15 @@
 "use strict";
 
 const path = require("path");
+const { isSameModuleImport } = require("../helpers/isSameModuleImport");
+
+const fsdLayers = {
+  'shared': 'shared',
+  'entities': 'entities',
+  'features': 'features',
+  'widgets': 'widgets',
+  'pages': 'pages',
+}
 
 module.exports = {
   meta: {
@@ -11,16 +20,14 @@ module.exports = {
       url: null, // URL to the documentation page for this rule
     },
     fixable: `code`,
-    schema: [
-      {
+    schema: [{
         type: `object`,
         properties: {
           alias: {
             type: `string`,
           }
         }
-      }
-    ],
+      }],
     messages: {
       useRelativePathWithinSlice: `Imports within the slice should be relative`
     },
@@ -44,7 +51,7 @@ const importExportDeclaration = (context) => (node) => {
   const pathTo = alias ? value.replace(`${alias}`, ``) : value;
   const currentFile = context.getFilename();
 
-  if(shouldBeRelative(currentFile, pathTo)) {
+  if(isSameModuleImport(currentFile, pathTo, fsdLayers)) {
     context.report({
       node,
       messageId: `useRelativePathWithinSlice`,
@@ -60,51 +67,8 @@ const importExportDeclaration = (context) => (node) => {
   }
 }
 
-const fsdLayers = {
-  'shared': 'shared',
-  'entities': 'entities',
-  'features': 'features',
-  'widgets': 'widgets',
-  'pages': 'pages',
-}
-
-function isPathRelative(path) {
-  return path === `.` || path.startsWith(`./`) || path.startsWith('../');
-}
-
 function getProjectPath(fullPath) {
   const fromNormalized = path.toNamespacedPath(fullPath);
 
   return fromNormalized.split(`src/`)[1];
 }
-
-function shouldBeRelative(from, to) {
-  if(isPathRelative(to)) {
-    return false;
-  }
-
-  const toArray = to.split('/');
-  const toLayer = toArray[0];
-  const toSlice = toArray[1];
-
-  if(!toLayer || !toSlice || !fsdLayers[toLayer]) {
-    return false;
-  }
-
-  const fromNormalized = path.toNamespacedPath(from);
-  const fromProject = fromNormalized.split(`src/`)[1];
-
-  if(!fromProject) {
-    return false;
-  }
-
-  const fromArray = fromProject.split('/');
-  const fromLayer = fromArray[0];
-  const fromSlice = fromArray[1];
-
-  if(!fromLayer || !fromSlice || !fsdLayers[fromLayer]) {
-    return false;
-  }
-
-  return fromSlice === toSlice && fromLayer === toLayer;
-}

package/lib/rules/forbid-imports-from-upper-slices.js

@@ -0,0 +1,109 @@
+"use strict";
+
+const path = require("path");
+const {isPathRelative} = require("../helpers/isPathRelative");
+const micromatch = require("micromatch");
+
+const fsdLayers = {
+  'shared': 'shared',
+  'entities': 'entities',
+  'features': 'features',
+  'widgets': 'widgets',
+  'pages': 'pages',
+  'app': 'app'
+}
+
+const allowedLayerImports = {
+  app: ['pages', 'widgets', 'features', 'entities', 'shared'],
+  pages: ['widgets', 'features', 'entities', 'shared'],
+  widgets: ['features', 'entities', 'shared'],
+  features: ['entities', 'shared'],
+  entities: ['entities', 'shared'],
+  shared: ['shared'],
+}
+
+module.exports = {
+  meta: {
+    type: `suggestion`,
+    docs: {
+      description: "Rule, which forbids imports from upper fsd slices",
+      recommended: false,
+      url: null,
+    },
+    fixable: null,
+    schema: [
+      {
+        type: `object`,
+        properties: {
+          alias: {
+            type: `string`,
+          },
+          ignoreImportPatterns: {
+            type: `array`,
+          }
+        }
+      }
+    ],
+    messages: {
+      doNotImportFromUpperFSDLayers: `Imports from upper FSD layers are prohibited`
+    },
+  },
+
+  create(context) {
+    return {
+      ImportDeclaration: importExportDeclaration(context),
+      ExportNamedDeclaration: importExportDeclaration(context),
+    };
+  },
+};
+
+const importExportDeclaration = (context) => (node) => {
+  const { alias = '', ignoreImportPatterns = [] } = context.options[0] ?? {};
+
+  const getCurrentFileLayer = (currentFilePath) => {
+    const normalizedPath = path.toNamespacedPath(currentFilePath);
+    const projectPath = normalizedPath?.split('src')[1];
+    const segments = projectPath.split('/');
+
+    return segments?.[1];
+  }
+
+  const getImportLayer = (value) => {
+    const importPath = alias ? value.replace(alias, '') : value;
+    const segments = importPath?.split('/');
+
+    return segments?.[0];
+  }
+
+  if(!node.source) {
+    return;
+  }
+
+  const currentFilePath = context.getFilename();
+  const importPath = node.source.value;
+  const currentFileLayer = getCurrentFileLayer(currentFilePath);
+  const importLayer = getImportLayer(importPath);
+
+  if(isPathRelative(importPath)) {
+    return;
+  }
+
+  if(!fsdLayers[importLayer] || !fsdLayers[currentFileLayer]) {
+    return;
+  }
+
+  const isIgnored = ignoreImportPatterns.some((pattern) => {
+    return micromatch.isMatch(importPath, pattern);
+  })
+
+  if(isIgnored) {
+    return;
+  }
+
+  if(!allowedLayerImports[currentFileLayer].includes(importLayer)) {
+    context.report({
+      node,
+      messageId: `doNotImportFromUpperFSDLayers`
+    })
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-fsd-paths-check",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "description": "Plugin to check feature sliced design paths correctness",
   "keywords": [
     "eslint",
@@ -22,11 +22,12 @@
     "update:eslint-docs": "eslint-doc-generator"
   },
   "dependencies": {
+    "micromatch": "^4.0.8",
     "requireindex": "^1.2.0"
   },
   "devDependencies": {
-    "eslint": "^8.26.0",
     "@eslint/js": "^8.26.0",
+    "eslint": "^8.26.0",
     "eslint-doc-generator": "^2.0.0",
     "eslint-plugin-eslint-plugin": "^6.0.0",
     "eslint-plugin-n": "^17.0.0",