eslint-plugin-stratified-design 0.8.0-beta.3 → 0.9.0-beta

package/docs/rules/lower-level-imports.md

@@ -125,6 +125,17 @@ The default is as follows:
 }
 ```
 
+Imported modules can be excluded from the rule (`lower-level-imports`) using the `excludeImports` option:
+
+```json
+{
+  "stratified-design/lower-level-imports": [
+    "error",
+    { "excludeImports": ["**/*.css"] }
+  ]
+}
+```
+
 ## Rule Details
 
 If a file structure is as follows:

package/docs/rules/no-disallowed-imports.md

@@ -0,0 +1,90 @@
+# Allow or disallow importing specified modules (no-disallowed-imports)
+
+In certain cases, it is necessary to restrict the importation of specific modules. For instance:
+
+- In a stratified design approach, higher-level modules should not be imported into lower-level modules.
+- There may be situations where global variables should only be writable within a specific context.
+
+## Options
+
+To control module imports, use the `imports` option:
+
+```json
+{
+  "stratified-design/no-disallowed-imports": [
+    "error",
+    {
+      "imports": [
+        {
+          "import": { "member": ["foo"], "from": "**/src/fileA" },
+          "allow": ["**/src/some-dir/*.js"]
+        },
+        {
+          "import": { "member": ["foo", "bar"], "from": "**/src/fileB" },
+          "disallow": ["**/src/not-allowed-file.js"]
+        },
+        {
+          "import": { "member": ["baz"], "from": "**/src/fileC" },
+          "allow": ["**/src/some-dir/*.js"],
+          "disallow": ["**/src/not-allowed-file.js"]
+        }
+      ]
+    }
+  ]
+}
+```
+
+If an imported module uses an alias, you can register the alias with the `aliases` option:
+
+```json
+{
+  "stratified-design/no-disallowed-imports": [
+    "error",
+    {
+      "aliases": { "@/": "./src/" }
+    }
+  ]
+}
+```
+
+## Rule Details
+
+Examples of **incorrect** code for this rule:
+
+```js
+// "stratified-design/no-disallowed-imports": [
+//   "error",
+//   {
+//     "imports": [
+//       {
+//         "import": { "member": ["foo"], "from": "**/src/fileA" },
+//         "allow": ["**/src/**/fileB.js"],
+//         "disallow": ["**/src/**/fileC.*"]
+//       }
+//     ]
+//   }
+// ]
+
+// ./src/fileC.js
+import { foo } from "./fileA";
+```
+
+Examples of **correct** code for this rule:
+
+```js
+// "stratified-design/no-disallowed-imports": [
+//   "error",
+//   {
+//     "imports": [
+//       {
+//         "import": { "member": ["foo"], "from": "**/src/fileA" },
+//         "allow": ["**/src/**/fileB.js"],
+//         "disallow": ["**/src/**/fileC.*"]
+//       }
+//     ]
+//   }
+// ]
+
+// ./src/fileB.js
+import { foo } from "./fileA";
+```

package/docs/rules/stratified-imports.md

@@ -68,7 +68,7 @@ You can register the files to which the rule (`stratified-imports`) should apply
 
 ```json
 {
-  "stratified-design/lower-level-imports": [
+  "stratified-design/stratified-imports": [
     "error",
     { "include": ["**/*.js"], "exclude": ["**/*.test.js"] }
   ]
@@ -84,6 +84,17 @@ The default configuration is as follows:
 }
 ```
 
+Imported modules can be excluded from the rule (`stratified-imports`) using the `excludeImports` option:
+
+```json
+{
+  "stratified-design/stratified-imports": [
+    "error",
+    { "excludeImports": ["**/*.css"] }
+  ]
+}
+```
+
 ## Rule Details
 
 Consider the following folder structure:

package/lib/helpers/common.js

@@ -1,5 +1,9 @@
 const p = require("path");
 
+/**
+ * @typedef {{alias: string, path: string}[]} Aliases
+ */
+
 // @level 2
 /**
  * @param {string} from
@@ -81,6 +85,37 @@ const reducedPaths = (path) => {
   }, []);
 };
 
+// @level 1
+/**
+ * @param {Record<string, string>} rawAliases
+ * @returns {Aliases}
+ */
+const createAliases = (rawAliases) => {
+  return Object.keys(rawAliases)
+    .sort((a, b) => b.length - a.length)
+    .map((alias) => ({ alias, path: rawAliases[alias] }));
+};
+
+// @level 1
+/**
+ * Replace an alias into the corresponding path
+ * @param {string} cwd
+ * @param {string} fileDir
+ * @param {Aliases} aliases
+ */
+const replaceAlias = (cwd, fileDir, aliases) => {
+  /**
+   * @param {string} moduleSource
+   */
+  return (moduleSource) => {
+    const { alias, path } =
+      aliases.find(({ alias }) => moduleSource.startsWith(alias)) || {};
+    if (!alias) return moduleSource;
+    const modulePath = resolvePath(cwd, moduleSource.replace(alias, path));
+    return toRelative(fileDir, modulePath);
+  };
+};
+
 module.exports = {
   toRelative,
   toSegments,
@@ -92,4 +127,6 @@ module.exports = {
   equal,
   readArray,
   reducedPaths,
+  createAliases,
+  replaceAlias,
 };

package/lib/helpers/noDisallowedImports.js

@@ -0,0 +1,38 @@
+"use strict";
+
+const { replaceAlias, resolvePath, parsePath } = require("./common");
+
+/**
+ * @param {string} contextFileSource
+ */
+const parseFileSource = (contextFileSource) => {
+  const fileSource = resolvePath(contextFileSource);
+  const parsedFileSource = parsePath(fileSource);
+  const fileDir = resolvePath(parsedFileSource.dir);
+  return { fileDir, fileSource };
+};
+
+/**
+ * @param {string} cwd
+ * @param {string} fileDir
+ * @param {import("./common").Aliases} aliases
+ */
+const createModulePath = (cwd, fileDir, aliases) => {
+  /**
+   * @param {string} moduleSourceWithAlias
+   */
+  return (moduleSourceWithAlias) => {
+    const moduleSource = replaceAlias(
+      cwd,
+      fileDir,
+      aliases
+    )(moduleSourceWithAlias);
+    const isNodeModule = moduleSource.startsWith(".") === false;
+    const modulePath = isNodeModule
+      ? moduleSource
+      : resolvePath(fileDir, moduleSource);
+    return modulePath;
+  };
+};
+
+module.exports = { parseFileSource, createModulePath };

package/lib/helpers/stratifiedImports/1 layer.js

@@ -1,9 +1,13 @@
 "use strict";
 
 const { minimatch } = require("minimatch");
-const { resolvePath, reducedPaths, parsePath } = require("../common");
 const {
+  resolvePath,
+  reducedPaths,
+  parsePath,
   replaceAlias,
+} = require("../common");
+const {
   findLevel,
   findLayerWithReducedPath,
   readStructure,
@@ -56,7 +60,7 @@ const parseFileSource = (options, contextFileSource) => {
  * @param {string} cwd
  * @param {string[]} excludeImports
  * @param {string} fileDir
- * @param {import('./2 layer').Aliases} aliases
+ * @param {import("../common").Aliases} aliases
  */
 const createModulePath = (cwd, excludeImports, fileDir, aliases) => {
   /**

package/lib/helpers/stratifiedImports/2 layer.js

@@ -29,10 +29,6 @@ const {
  * @typedef {RawLayer[][]} RawStructure
  */
 
-/**
- * @typedef {{alias: string, path: string}[]} Aliases
- */
-
 // @level 2
 /**
  * @param {string} fileDir
@@ -105,37 +101,6 @@ const toStructure = (rawStructure, fileDir) => {
   });
 };
 
-// @level 2
-/**
- * @param {Record<string, string>} rawAliases
- * @returns {Aliases}
- */
-const createAliases = (rawAliases) => {
-  return Object.keys(rawAliases)
-    .sort((a, b) => b.length - a.length)
-    .map((alias) => ({ alias, path: rawAliases[alias] }));
-};
-
-// @level 2
-/**
- * Replace an alias into the corresponding path
- * @param {string} cwd
- * @param {string} fileDir
- * @param {Aliases} aliases
- */
-const replaceAlias = (cwd, fileDir, aliases) => {
-  /**
-   * @param {string} moduleSource
-   */
-  return (moduleSource) => {
-    const { alias, path } =
-      aliases.find(({ alias }) => moduleSource.startsWith(alias)) || {};
-    if (!alias) return moduleSource;
-    const modulePath = resolvePath(cwd, moduleSource.replace(alias, path));
-    return toRelative(fileDir, modulePath);
-  };
-};
-
 // @level 2
 /**
  * Find the layer level for a module
@@ -238,8 +203,6 @@ const readStructure = (dir) => {
 module.exports = {
   readRawStructure,
   toStructure,
-  createAliases,
-  replaceAlias,
   findLevel,
   findLayerWithReducedPath,
   isNotRegisteredNodeModule,

package/lib/rules/no-disallowed-imports.js

@@ -0,0 +1,180 @@
+/**
+ * @fileoverview ...
+ * @author Hodoug Joung
+ */
+"use strict";
+
+const { minimatch } = require("minimatch");
+const helpers = require("../helpers/noDisallowedImports");
+const { createAliases } = require("../helpers/common");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/**
+ * @typedef {import('eslint').Rule.Node} Node
+ * @typedef {import('eslint').AST.Token} Token
+ * @typedef {import('eslint').SourceCode} SourceCode
+ * @typedef {{
+ *  import: { member: string[], from: string },
+ *  allow: string[],
+ *  disallow: string[],
+ * }} ImportPath
+ * @typedef {{
+ *  imports: ImportPath[],
+ *  aliases: Record<string, string>
+ * }} Options
+ */
+
+const DEFAULT = "default";
+
+const importSchema = {
+  type: "object",
+  properties: {
+    import: {
+      type: "object",
+      properties: {
+        member: {
+          type: "array",
+          items: [{ type: "string" }], // 'default' means default specifier
+        },
+        from: { type: "string" },
+      },
+      required: ["member", "from"],
+      additionalProperties: false,
+    },
+    allow: {
+      type: "array",
+      items: [{ type: "string" }],
+    },
+    disallow: {
+      type: "array",
+      items: [{ type: "string" }],
+    },
+  },
+  required: ["import"],
+  additionalProperties: false,
+};
+
+const aliasesSchema = {
+  type: "object",
+  patternProperties: {
+    ["^.+$"]: {
+      type: "string",
+      pattern: "^\\.{1,2}(/[^/]+)*/?$",
+    },
+  },
+  additionalProperties: false,
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    type: "problem",
+    fixable: "code",
+    schema: {
+      type: "array",
+      items: [
+        {
+          type: "object",
+          properties: {
+            imports: {
+              type: "array",
+              items: [importSchema],
+            },
+            aliases: aliasesSchema,
+          },
+          required: ["imports"],
+          additionalProperties: false,
+        },
+      ],
+      additionalItems: false,
+    },
+    messages: {
+      "no-disallowed-imports": "'{{member}}' should NOT be imported",
+    },
+  },
+  create(context) {
+    /**
+     * @type {Options}
+     */
+    const options = {
+      imports: [],
+      aliases: {},
+      ...(context.options[0] || {}),
+    };
+    const { fileDir, fileSource } = helpers.parseFileSource(context.filename);
+    const createModulePath = helpers.createModulePath(
+      context.cwd,
+      fileDir,
+      createAliases(options.aliases)
+    );
+    return {
+      ImportDeclaration(node) {
+        const modulePath = createModulePath(node.source.value);
+        /**
+         * @param {[string | undefined, ImportPath | undefined]} param0
+         * @param {ImportPath} importSpec
+         */
+        const searchTheImportPath = (
+          [theMember, theImportSpec],
+          importSpec
+        ) => {
+          if (theMember && theImportSpec) {
+            return [theMember, theImportSpec];
+          }
+
+          // const { member, from } = importSpec.import;
+
+          const importedSpecifiers = node.specifiers.map((specifier) => {
+            if (specifier.type === "ImportSpecifier")
+              return specifier.imported.name;
+            if (specifier.type === "ImportDefaultSpecifier") return DEFAULT;
+            return "";
+          });
+
+          const member = importSpec.import.member.find((specifier) =>
+            importedSpecifiers.some((sp) => sp === specifier)
+          );
+
+          if (member && minimatch(modulePath, importSpec.import.from)) {
+            if (member === DEFAULT) {
+              return [
+                node.specifiers.find(
+                  ({ type }) => type === "ImportDefaultSpecifier"
+                ).local.name,
+                importSpec,
+              ];
+            }
+            return [member, importSpec];
+          }
+
+          return [undefined, undefined];
+        };
+
+        const [theMember, theImportSpec] = options.imports.reduce(
+          searchTheImportPath,
+          [undefined, undefined]
+        );
+        if (!theMember || !theImportSpec) return;
+
+        const { allow, disallow } = theImportSpec;
+        const isAllowed =
+          (allow
+            ? Boolean(allow.find((pattern) => minimatch(fileSource, pattern)))
+            : true) &&
+          (disallow
+            ? !disallow.find((pattern) => minimatch(fileSource, pattern))
+            : true);
+        if (isAllowed) return;
+
+        context.report({
+          node,
+          messageId: "no-disallowed-imports",
+          data: { member: theMember },
+        });
+      },
+    };
+  },
+};

package/lib/rules/no-same-level-funcs.js

@@ -11,6 +11,8 @@ const path = require("path");
 // Rule Definition
 //------------------------------------------------------------------------------
 
+// FIXME: const Body = styled.div``; const Body2 = styled(Body)`` (TaggedTemplateExpression)
+
 /**
  * @typedef {import('eslint').Rule.Node} Node
  * @typedef {import('eslint').AST.Token} Token

package/lib/rules/stratified-imports.js

@@ -5,11 +5,11 @@
 
 "use strict";
 
-const { parsePath } = require("../helpers/common");
 //------------------------------------------------------------------------------
 // Requirements
 //------------------------------------------------------------------------------
 
+const { parsePath, createAliases } = require("../helpers/common");
 const helper = require("../helpers/stratifiedImports");
 
 //------------------------------------------------------------------------------
@@ -87,7 +87,7 @@ module.exports = {
       context.cwd,
       options.excludeImports,
       fileDir,
-      helper.createAliases(options.aliases)
+      createAliases(options.aliases)
     );
 
     const isInChildren = helper.isInChildren(fileDir);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-stratified-design",
-  "version": "0.8.0-beta.3",
+  "version": "0.9.0-beta",
   "description": "ESlint rules for stratified design",
   "keywords": [
     "eslint",

package/tests/lib/helpers/common.js

@@ -0,0 +1,57 @@
+/**
+ * @fileoverview test for helpers/common.js
+ * @author Hodoug Joung
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const assert = require("assert");
+const { createAliases, replaceAlias } = require("../../../lib/helpers/common");
+
+//------------------------------------------------------------------------------
+// Tests
+//------------------------------------------------------------------------------
+
+describe("helpers/common", () => {
+  describe("createAliases()", () => {
+    const testCases = [
+      {
+        rawAliases: { "@/": "./src/" },
+        aliases: [{ alias: "@/", path: "./src/" }],
+      },
+      {
+        rawAliases: { "@/": "./src/", "@layer/": "./src/layer/" },
+        aliases: [
+          { alias: "@layer/", path: "./src/layer/" },
+          { alias: "@/", path: "./src/" },
+        ],
+      },
+    ];
+    testCases.forEach(({ rawAliases, aliases }) => {
+      it(`${JSON.stringify(rawAliases)} -> ${JSON.stringify(aliases)}`, () => {
+        assert.deepEqual(createAliases(rawAliases), aliases);
+      });
+    });
+  });
+
+  describe("replaceAlias()", () => {
+    const cwd = "/proj";
+    const fileDir = "/proj/src/layerA";
+    const aliases = [{ alias: "@/", path: "./src/" }];
+    const testCases = [
+      { moduleSource: "@/layerA/layerAA", relPath: "./layerAA" },
+      { moduleSource: "nodeModule", relPath: "nodeModule" },
+    ];
+    testCases.forEach(({ moduleSource, relPath }) => {
+      it(`${moduleSource} -> ${relPath}`, () => {
+        assert.equal(
+          replaceAlias(cwd, fileDir, aliases)(moduleSource),
+          relPath
+        );
+      });
+    });
+  });
+});

package/tests/lib/helpers/stratified-imports.js

@@ -13,8 +13,6 @@ const {
   findLevel,
   findLayerWithReducedPath,
   toStructure,
-  createAliases,
-  replaceAlias,
   validateRawStructure,
   isInParent,
   isInChildren,
@@ -52,45 +50,6 @@ describe("helpers/stratified-imports", () => {
     });
   });
 
-  describe("createAliases()", () => {
-    const testCases = [
-      {
-        rawAliases: { "@/": "./src/" },
-        aliases: [{ alias: "@/", path: "./src/" }],
-      },
-      {
-        rawAliases: { "@/": "./src/", "@layer/": "./src/layer/" },
-        aliases: [
-          { alias: "@layer/", path: "./src/layer/" },
-          { alias: "@/", path: "./src/" },
-        ],
-      },
-    ];
-    testCases.forEach(({ rawAliases, aliases }) => {
-      it(`${JSON.stringify(rawAliases)} -> ${JSON.stringify(aliases)}`, () => {
-        assert.deepEqual(createAliases(rawAliases), aliases);
-      });
-    });
-  });
-
-  describe("replaceAlias()", () => {
-    const cwd = "/proj";
-    const fileDir = "/proj/src/layerA";
-    const aliases = [{ alias: "@/", path: "./src/" }];
-    const testCases = [
-      { moduleSource: "@/layerA/layerAA", relPath: "./layerAA" },
-      { moduleSource: "nodeModule", relPath: "nodeModule" },
-    ];
-    testCases.forEach(({ moduleSource, relPath }) => {
-      it(`${moduleSource} -> ${relPath}`, () => {
-        assert.equal(
-          replaceAlias(cwd, fileDir, aliases)(moduleSource),
-          relPath
-        );
-      });
-    });
-  });
-
   describe("findLevel()", () => {
     const structure = [[{ name: "/src/layerA" }], [{ name: "/src/layerB" }]];
     const testCases = [

package/tests/lib/rules/no-disallowed-imports.js

@@ -0,0 +1,184 @@
+/**
+ * @fileoverview Allow or disallow importing specified modules
+ * @author Hodoug Joung
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const rule = require("../../../lib/rules/no-disallowed-imports");
+const RuleTester = require("eslint").RuleTester;
+
+//------------------------------------------------------------------------------
+// Tests
+//------------------------------------------------------------------------------
+
+const ruleTester = new RuleTester({
+  parserOptions: {
+    ecmaVersion: 2022,
+    sourceType: "module",
+    ecmaFeatures: {
+      jsx: true,
+    },
+  },
+});
+
+ruleTester.run("no-disallowed-imports", rule, {
+  valid: [
+    {
+      code: "import { foo } from './fileA'",
+      filename: "./src/fileB.js",
+      options: [],
+    },
+    {
+      code: "import { foo } from './fileA'",
+      filename: "./src/fileB.js",
+      options: [
+        {
+          imports: [{ import: { member: ["foo"], from: "**/src/fileA" } }],
+        },
+      ],
+    },
+    {
+      code: "import { foo } from './fileA'",
+      filename: "./src/fileB.js",
+      options: [
+        {
+          imports: [
+            {
+              import: { member: ["baz"], from: "**/src/fileC" },
+              allow: ["**/src/**/*.js"],
+            },
+            {
+              import: { member: ["foo", "bar"], from: "**/src/fileA" },
+              allow: ["**/src/**/*.js"],
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: "import { foo } from './fileA'",
+      filename: "./src/fileB.js",
+      options: [
+        {
+          imports: [
+            {
+              import: { member: ["foo", "bar"], from: "**/src/fileA" },
+              disallow: ["**/src/**/*.test.js"],
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: "import { foo } from './fileA'",
+      filename: "./src/fileB.js",
+      options: [
+        {
+          imports: [
+            {
+              import: { member: ["foo", "bar"], from: "**/src/fileA" },
+              allow: ["**/src/**/*.js"],
+              disallow: ["**/src/**/*.test.js"],
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: "import { foo } from '@/fileA'",
+      filename: "./src/fileB.js",
+      options: [
+        {
+          imports: [
+            {
+              import: { member: ["foo"], from: "**/src/fileA" },
+              allow: ["**/src/**/*.js"],
+            },
+          ],
+          aliases: { "@/": "./src/" },
+        },
+      ],
+    },
+    {
+      code: "import foo from './fileA'",
+      filename: "./src/fileB.js",
+      options: [
+        {
+          imports: [
+            {
+              import: { member: ["default"], from: "**/src/fileA" },
+              allow: ["**/src/**/*.js"],
+            },
+          ],
+        },
+      ],
+    },
+  ],
+  invalid: [
+    {
+      code: "import { foo } from './fileA'",
+      filename: "./src/fileB.js",
+      options: [
+        {
+          imports: [
+            {
+              import: { member: ["foo"], from: "**/src/fileA" },
+              allow: ["**/src/**/*.test.js"],
+            },
+          ],
+        },
+      ],
+      errors: [{ messageId: "no-disallowed-imports", data: { member: "foo" } }],
+    },
+    {
+      code: "import { foo } from './fileA'",
+      filename: "./src/fileB.js",
+      options: [
+        {
+          imports: [
+            {
+              import: { member: ["foo"], from: "**/src/fileA" },
+              disallow: ["**/src/**/*.js"],
+            },
+          ],
+        },
+      ],
+      errors: [{ messageId: "no-disallowed-imports", data: { member: "foo" } }],
+    },
+    {
+      code: "import { foo } from './fileA'",
+      filename: "./src/fileB.js",
+      options: [
+        {
+          imports: [
+            {
+              import: { member: ["foo"], from: "**/src/fileA" },
+              allow: ["**/src/**/*.js"],
+              disallow: ["**/src/**/fileB.*"],
+            },
+          ],
+        },
+      ],
+      errors: [{ messageId: "no-disallowed-imports", data: { member: "foo" } }],
+    },
+    {
+      code: "import foo from './fileA'",
+      filename: "./src/fileB.js",
+      options: [
+        {
+          imports: [
+            {
+              import: { member: ["default"], from: "**/src/fileA" },
+              disallow: ["**/src/**/*.js"],
+            },
+          ],
+        },
+      ],
+      errors: [{ messageId: "no-disallowed-imports", data: { member: "foo" } }],
+    },
+  ],
+});