eslint-plugin-stratified-design 0.7.0 → 0.8.0-beta

package/lib/helpers/{lowerLevelImports/4 layer.js → common.js}

@@ -29,8 +29,9 @@ const resolvePath = p.resolve;
 const parsePath = p.parse;
 
 /**
- * @param {any[]} array
- * @param {(item: any) => boolean} callback
+ * @template T
+ * @param {T[]} array
+ * @param {(item: T) => boolean} callback
  * @returns {number}
  */
 const findLastIndex = (array, callback) => {
@@ -49,6 +50,16 @@ const equal = (array1, array2) => {
   return array1.every((item, index) => item === array2[index]);
 };
 
+/**
+ * @template T
+ * @param {T[]} array
+ * @param {number} index
+ * @returns {T}
+ */
+const readArray = (array, index) => {
+  return index >= 0 ? array[index] : array[array.length + index];
+};
+
 module.exports = {
   toRelative,
   toSegments,
@@ -58,4 +69,5 @@ module.exports = {
   parsePath,
   findLastIndex,
   equal,
+  readArray,
 };

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

@@ -3,7 +3,7 @@ const { report: reportError } = require("./2 layer");
 const {
   isNodeModule,
   findLevel: findLayerLevel,
-  hasInterface: hasInterfaceBetween,
+  hasBarrier: hasBarrierBetween,
   removeAlias: removeAliasFromModuleSource,
 } = require("./3 layer");
 const {
@@ -12,7 +12,7 @@ const {
   toPath,
   resolvePath,
   parsePath,
-} = require("./4 layer");
+} = require("../common");
 
 const FINISHED = "finished";
 
@@ -191,10 +191,10 @@ const reportHasProperLevel = (
   filePath
 ) => {
   const findLevel = findLayerLevel(structure);
-  const hasInterface = hasInterfaceBetween(structure, fileLevel);
+  const hasBarrier = hasBarrierBetween(structure, fileLevel);
 
   /**
-   * @param {import('eslint').Rule.NodeParentExtension} node
+   * @param {import('../type').Node} node
    * @param {string} modulePath
    */
   return (node, modulePath) => {
@@ -222,7 +222,7 @@ const reportHasProperLevel = (
       return FINISHED;
     }
 
-    if (hasInterface(moduleLevel)) {
+    if (hasBarrier(moduleLevel)) {
       report("barrier");
       return FINISHED;
     }

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

@@ -1,15 +1,15 @@
 const { isNodeModule } = require("./3 layer");
-const { toRelative } = require("./4 layer");
+const { toRelative } = require("../common");
 
 /**
  * Report eslint error
- * @param {import('eslint').Rule.RuleContext} context
+ * @param {import('../type.js').Context} context
  * @param {string} rootDir
- * * @param {string} filePath
+ * @param {string} filePath
  */
 const report = (context, rootDir, filePath) => {
   /**
-   * @param {import('eslint').Rule.NodeParentExtension} node
+   * @param {import('../type').Node} node
    * @param {string} messageId
    * @param {string} modulePath
    */

package/lib/helpers/lowerLevelImports/3 layer.js

@@ -4,11 +4,36 @@ const {
   joinPath,
   resolvePath,
   toRelative,
-} = require("./4 layer");
+} = require("../common");
 
 /**
- * @param {*} options
+ * @typedef {{
+ *  structure: Array<
+ *    string | { name: string, barrier?: boolean, interface?: boolean, nodeModule?: boolean, isNodeModule?: boolean }
+ *  >,
+ *  root: string,
+ *  aliases: Record<string, string>,
+ *  exclude: string[],
+ *  include: string[],
+ *  useLevelNumber: boolean
+ *  isIndexHighest: boolean
+ * }} Options
+ */
+
+/**
+ * @typedef {{
+ *  name: string;
+ *  barrier?: boolean | undefined;
+ *  interface?: boolean | undefined;
+ *  nodeModule?: boolean | undefined;
+ *  isNodeModule?: boolean | undefined;
+ * }[]} Structure
+ */
+
+/**
+ * @param {Options} options
  * @param {string} rootDir
+ * @returns {Structure}
  */
 const createStructure = (options, rootDir) => {
   return options.structure.map((layer) => {
@@ -20,7 +45,7 @@ const createStructure = (options, rootDir) => {
 };
 
 /**
- * @param {*} options
+ * @param {Options} options
  */
 const createAliases = (options) => {
   return Object.keys(options.aliases)
@@ -63,7 +88,7 @@ const isNodeModule = (rootDir) => {
 
 /**
  * Find the layer level for a module
- * @param {{[string]: {name: string; nodeModule: boolean; barrier: boolean; isNodeModule: boolean, interface: boolean}}} structure
+ * @param {Structure} structure
  * @returns the level of the module with `path`
  */
 const findLevel = (structure) => {
@@ -83,25 +108,25 @@ const findLevel = (structure) => {
 
 /**
  * Check if there is an interface between file layer and module layer
- * @param {{[string]: {name: string; nodeModule: boolean; barrier: boolean; isNodeModule: boolean, interface: boolean}}} structure
+ * @param {Structure} structure
  * @param {number} fileLevel
  */
-const hasInterface = (structure, fileLevel) => {
+const hasBarrier = (structure, fileLevel) => {
   /**
    * @param {number} moduleLevel
    */
   return (moduleLevel) => {
-    const layerInterface = structure
+    const layerBarrier = structure
       .slice(fileLevel + 1, moduleLevel)
       .find((layer) => layer.barrier || layer.interface);
-    return Boolean(layerInterface);
+    return Boolean(layerBarrier);
   };
 };
 
 module.exports = {
   isNodeModule,
   findLevel,
-  hasInterface,
+  hasBarrier,
   createStructure,
   createAliases,
   removeAlias,

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

@@ -0,0 +1,86 @@
+"use strict";
+
+const {
+  resolvePath,
+  joinPath,
+  toSegments,
+  readArray,
+  findLastIndex,
+} = require("../common");
+const {
+  toStructure,
+  replaceAlias,
+  readRawStructure,
+  findLevel,
+  findLayerWithSimilarPath,
+} = require("./2 layer");
+
+/**
+ * @param {string} fileDir
+ */
+const createStructure = (fileDir) => {
+  const parentFileDir = joinPath(fileDir, "..");
+
+  const rawStructure = readRawStructure(fileDir);
+  const parentRawStructure = readRawStructure(parentFileDir);
+
+  const fileDirname = `${readArray(toSegments(fileDir), -1)}/`;
+  const theIndex = findLastIndex(parentRawStructure, (rawLayers) => {
+    return Boolean(
+      rawLayers.find((rawLayer) => {
+        if (typeof rawLayer === "string")
+          return `${rawLayer}/`.startsWith(fileDirname);
+        return `${rawLayer.name}/`.startsWith(fileDirname);
+      })
+    );
+  });
+
+  const structure = toStructure(rawStructure, fileDir);
+  const parentStructure = toStructure(parentRawStructure, parentFileDir);
+
+  for (let i = theIndex + 1; i <= parentRawStructure.length - 1; i++) {
+    structure.push(parentStructure[i]);
+  }
+
+  return structure;
+};
+
+/**
+ * @param {string} cwd
+ * @param {string} fileDir
+ * @param {import('./2 layer').Aliases} aliases
+ */
+const createModulePath = (cwd, fileDir, aliases) => {
+  /**
+   * @param {string} moduleSourceWithAlias
+   */
+  return (moduleSourceWithAlias) => {
+    const moduleSource = replaceAlias(
+      cwd,
+      fileDir,
+      aliases
+    )(moduleSourceWithAlias);
+    const isNodeModule = moduleSource.startsWith(".") === false;
+    return isNodeModule ? moduleSource : resolvePath(fileDir, moduleSource);
+  };
+};
+
+/**
+ * @param {import('./2 layer').Structure} structure
+ */
+const findLevelInChild = (structure) => {
+  /**
+   * @param {string} path
+   */
+  return (path) => {
+    const layer = findLayerWithSimilarPath(structure)(path);
+    if (!layer) return null;
+    const fileDir = layer.name;
+    const rawChildStructure = readRawStructure(fileDir);
+    const childStructure = toStructure(rawChildStructure, fileDir);
+    const childLevel = findLevel(childStructure)(path);
+    return childLevel !== null ? findLevel(structure)(fileDir) : null;
+  };
+};
+
+module.exports = { createStructure, createModulePath, findLevelInChild };

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

@@ -0,0 +1,156 @@
+"use strict";
+
+const { readFileSync } = require("fs");
+const {
+  resolvePath,
+  toRelative,
+  joinPath,
+  toSegments,
+  toPath,
+} = require("../common");
+
+/**
+ * @typedef {{
+ *  name: string;
+ *  barrier?: boolean;
+ *  nodeModule?: boolean;
+ * }} Layer
+ */
+
+/**
+ * @typedef {string|Layer} RawLayer
+ */
+
+/**
+ * @typedef {Layer[][]} Structure
+ */
+
+/**
+ * @typedef {RawLayer[][]} RawStructure
+ */
+
+/**
+ * @typedef {{alias: string, path: string}[]} Aliases
+ */
+
+/**
+ * @param {string} fileDir
+ * @returns {RawStructure}
+ */
+const readRawStructure = (fileDir) => {
+  try {
+    return JSON.parse(
+      readFileSync(resolvePath(fileDir, "./.stratified.json"), "utf-8")
+    );
+  } catch (err) {
+    return [];
+  }
+};
+
+/**
+ * @param {RawStructure} rawStructure
+ * @param {string} fileDir
+ * @return {Structure}
+ */
+const toStructure = (rawStructure, fileDir) => {
+  return rawStructure.map((rawLayers) => {
+    return rawLayers.map((rawLayer) => {
+      const layer =
+        typeof rawLayer === "string" ? { name: rawLayer } : rawLayer;
+      return layer.nodeModule
+        ? layer
+        : { ...layer, name: joinPath(fileDir, layer.name) };
+    });
+  });
+};
+
+/**
+ * @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] }));
+};
+
+/**
+ * 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);
+  };
+};
+
+/**
+ * Find the layer level for a module
+ * @param {Structure} structure
+ * @returns the level of the module with `path`
+ */
+const findLevel = (structure) => {
+  /**
+   * @param {string} path
+   */
+  return (path) => {
+    const level = structure.findIndex((layers) =>
+      Boolean(layers.find((layer) => layer.name === path))
+    );
+    return level >= 0 ? level : null;
+  };
+};
+
+/**
+ * @param {import('./2 layer').Structure} structure
+ */
+const findLayerWithSimilarPath = (structure) => {
+  /**
+   * @param {string} path
+   * @return {Layer | null}
+   */
+  return (path) => {
+    return (
+      toSegments(path).reduce((theLayer, _, index, segments) => {
+        if (theLayer) return theLayer;
+        const similarPath = toPath(segments.slice(0, segments.length - index));
+        /**
+         * @type {Layer}
+         */
+        return structure.reduce((foundLayer, layers) => {
+          if (foundLayer) return foundLayer;
+          return layers.find((layer) => layer.name === similarPath);
+        }, undefined);
+      }, undefined) || null
+    );
+  };
+};
+
+/**
+ * @param {string} cwd
+ */
+const isNotRegisteredNodeModule = (cwd) => {
+  /**
+   * @param {string} modulePath
+   */
+  return (modulePath) => modulePath.startsWith(cwd) === false;
+};
+
+module.exports = {
+  readRawStructure,
+  toStructure,
+  createAliases,
+  replaceAlias,
+  findLevel,
+  findLayerWithSimilarPath,
+  isNotRegisteredNodeModule,
+};

package/lib/helpers/stratifiedImports/index.js

@@ -0,0 +1,24 @@
+"use strict";
+
+const {
+  createStructure,
+  createModulePath,
+  findLevelInChild,
+} = require("./1 layer");
+const {
+  createAliases,
+  findLevel,
+  isNotRegisteredNodeModule,
+} = require("./2 layer");
+
+const { parseFileSource } = require("../lowerLevelImports");
+
+module.exports = {
+  createStructure,
+  createModulePath,
+  createAliases,
+  parseFileSource,
+  findLevel,
+  isNotRegisteredNodeModule,
+  findLevelInChild,
+};

package/lib/helpers/type.js

@@ -0,0 +1,8 @@
+/**
+ * @typedef {import('eslint').Rule.RuleContext} Context
+ * @typedef {import('eslint').Rule.Node} Node
+ * @typedef {import('eslint').AST.Token} Token
+ * @typedef {import('eslint').SourceCode} SourceCode
+ */
+
+module.exports = {};

package/lib/rules/lower-level-imports.js

@@ -117,15 +117,16 @@ module.exports = {
       include: ["**/*.{js,ts,jsx,tsx}"],
       aliases: {},
       useLevelNumber: false,
+      isIndexHighest: false,
       ...(context.options[0] || {}),
     };
 
-    const cwd = context.getCwd();
+    const cwd = context.cwd;
     const rootDir = createRootDir(cwd, options);
 
     const { fileDir, filePath, isExcludedFile } = parseFileSource(
       options,
-      context.getFilename()
+      context.filename
     );
 
     const structure = createStructure(options, rootDir);

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

@@ -35,17 +35,11 @@ const deriveLevel = (sourceCode, nodeOrToken) => {
 };
 
 /**
- *
+ * @param {SourceCode} sourceCode
  * @param {Node} node
  */
-const traceAncestor = (node) => {
-  let parent = node;
-  let nextParent = node.parent;
-  while (nextParent.type !== "Program") {
-    parent = parent.parent;
-    nextParent = parent.parent;
-  }
-  return parent;
+const traceAncestor = (sourceCode, node) => {
+  return sourceCode.getAncestors(node)[1];
 };
 
 /** @type {import('eslint').Rule.RuleModule} */
@@ -83,7 +77,7 @@ module.exports = {
       ...(context.options[0] || {}),
     };
 
-    const fileSource = path.resolve(context.getFilename());
+    const fileSource = path.resolve(context.filename);
 
     const isIncludedFile = options.include.find((pattern) =>
       minimatch(fileSource, pattern)
@@ -100,7 +94,7 @@ module.exports = {
      */
     const levels = {};
 
-    const sourceCode = context.getSourceCode();
+    const sourceCode = context.sourceCode;
 
     return {
       Program(node) {
@@ -127,7 +121,7 @@ module.exports = {
         const calleeLevel = levels[node.callee.name];
         if (calleeLevel === undefined) return;
         if (calleeLevel !== null) {
-          const ancestor = traceAncestor(node);
+          const ancestor = traceAncestor(sourceCode, node);
           const ancestorLevel = deriveLevel(sourceCode, ancestor);
           if (ancestorLevel !== null && ancestorLevel < calleeLevel) return;
         }

package/lib/rules/stratified-imports.js

@@ -0,0 +1,172 @@
+/**
+ * @fileoverview Require that lower level modules be imported (stratified-imports)
+ * @author Hodoug Joung
+ */
+
+"use strict";
+
+const { parsePath } = require("../helpers/common");
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const helper = require("../helpers/stratifiedImports");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    type: "problem",
+    fixable: "code",
+    schema: {
+      type: "array",
+      items: [
+        {
+          type: "object",
+          properties: {
+            aliases: {
+              type: "object",
+              patternProperties: {
+                ["^.+$"]: {
+                  type: "string",
+                  pattern: "^\\.{1,2}(/[^/]+)*/?$",
+                },
+              },
+              additionalProperties: false,
+            },
+            exclude: {
+              type: "array",
+              items: [{ type: "string" }],
+            },
+            include: {
+              type: "array",
+              items: [{ type: "string" }],
+            },
+          },
+          additionalProperties: false,
+        },
+      ],
+      additionalItems: false,
+    },
+    messages: {
+      "not-lower-level": "'{{module}}' is NOT LOWER level than '{{file}}'",
+      barrier:
+        "An ABSTRACT BARRIER prevents '{{file}}' from importing '{{module}}'",
+      "not-registered": "'{{file}}' does NOT registered at .stratified.json",
+    },
+  },
+  create(context) {
+    const options = {
+      exclude: ["**/*.{test,spec}.{js,ts,jsx,tsx}"],
+      include: ["**/*.{js,ts,jsx,tsx}"],
+      aliases: {},
+      ...(context.options[0] || {}),
+    };
+
+    const { fileDir, filePath, isExcludedFile } = helper.parseFileSource(
+      options,
+      context.filename
+    );
+
+    if (isExcludedFile) return {};
+
+    const structure = helper.createStructure(fileDir);
+
+    const fileLevel = helper.findLevel(structure)(filePath);
+
+    const createModulePath = helper.createModulePath(
+      context.cwd,
+      fileDir,
+      helper.createAliases(options.aliases)
+    );
+
+    const findLevel = helper.findLevel(structure);
+
+    const findLevelInChild = helper.findLevelInChild(structure);
+
+    const isNotRegisteredNodeModule = helper.isNotRegisteredNodeModule(
+      context.cwd
+    );
+
+    /**
+     * @param {number} moduleLevel
+     */
+    const hasBarrier = (moduleLevel) => {
+      const layerBarrier = structure
+        .slice(fileLevel + 1, moduleLevel)
+        .find((layers) => layers.find((layer) => layer.barrier));
+      return Boolean(layerBarrier);
+    };
+
+    /**
+     * @param {import('../helpers/type').Node} node
+     * @param {'not-lower-level'|'barrier'|'not-registered'} messageId
+     * @param {string | undefined} modulePath
+     */
+    const reportError = (node, messageId, modulePath) => {
+      context.report({
+        node,
+        messageId,
+        data: {
+          file: parsePath(filePath).name,
+          ...(modulePath ? { module: parsePath(modulePath).name } : {}),
+        },
+      });
+    };
+
+    /**
+     * @param {import('../helpers/type').Node} node
+     * @returns
+     */
+    const report = (node) => {
+      // TODO: invalid .stratified.json
+
+      if (fileLevel === null) {
+        reportError(node, "not-registered");
+        return;
+      }
+
+      const modulePath = createModulePath(node.source.value);
+      const moduleLevel = (() => {
+        const level = findLevel(modulePath);
+        return level !== null
+          ? level
+          : isNotRegisteredNodeModule(modulePath)
+          ? "notRegisteredNodeModule"
+          : findLevelInChild(modulePath);
+      })();
+
+      if (moduleLevel === "notRegisteredNodeModule") return;
+
+      if (moduleLevel === null) {
+        reportError(node, "not-lower-level", modulePath);
+        return;
+      }
+
+      if (hasBarrier(moduleLevel)) {
+        reportError(node, "barrier", modulePath);
+        return;
+      }
+
+      if (moduleLevel <= fileLevel) {
+        reportError(node, "not-lower-level", modulePath);
+        return;
+      }
+    };
+
+    return {
+      ImportDeclaration(node) {
+        report(node);
+      },
+      ExportNamedDeclaration(node) {
+        if (node.source) report(node);
+      },
+      ExportAllDeclaration(node) {
+        if (node.source) report(node);
+      },
+    };
+  },
+};

package/mocked/stratified-imports/.stratified.json

@@ -0,0 +1,12 @@
+[
+  ["layerA"],
+  ["layerB"],
+  [{ "name": "layerC", "barrier": true }],
+  ["layerD"],
+  [{ "name": "nodeModuleE", "nodeModule": "true" }],
+  ["layerF"],
+  ["layerG", "layerH"],
+  ["layerI"],
+  ["layerJ"],
+  ["layerK"]
+]

package/mocked/stratified-imports/layerB/.stratified.json

@@ -0,0 +1 @@
+[["layerBA"], ["layerBB"]]

package/mocked/stratified-imports/layerJ/.stratified.json

@@ -0,0 +1 @@
+[["entryJA", "entryJB"], ["layerJC"]]

package/package.json

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

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

@@ -0,0 +1,138 @@
+/**
+ * @fileoverview test for helpers/stratified-imports
+ * @author Hodoug Joung
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const assert = require("assert");
+const {
+  findLevel,
+  findLayerWithSimilarPath,
+  toStructure,
+  createAliases,
+  replaceAlias,
+} = require("../../../lib/helpers/stratifiedImports/2 layer");
+const {
+  createModulePath,
+} = require("../../../lib/helpers/stratifiedImports/1 layer");
+
+//------------------------------------------------------------------------------
+// Tests
+//------------------------------------------------------------------------------
+
+describe("helpers/stratified-imports", () => {
+  describe("toStructure()", () => {
+    const fileDir = "/src";
+    const testCases = [
+      { rawStructure: [["layer"]], structure: [[{ name: "/src/layer" }]] },
+      {
+        rawStructure: [[{ name: "layer" }]],
+        structure: [[{ name: "/src/layer" }]],
+      },
+      {
+        rawStructure: [[{ name: "layer", barrier: true }]],
+        structure: [[{ name: "/src/layer", barrier: true }]],
+      },
+    ];
+    testCases.forEach(({ rawStructure, structure }) => {
+      it(`${rawStructure} -> ${structure}`, () => {
+        assert.deepEqual(toStructure(rawStructure, fileDir), structure);
+      });
+    });
+  });
+
+  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(`${rawAliases} -> ${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 = [
+      { path: "/src/layerA", level: 0 },
+      { path: "/src/layerB", level: 1 },
+      { path: "/src/layerA/entry", level: null },
+    ];
+    testCases.forEach(({ path, level }) => {
+      it(`The level of ${path} is ${level}`, () => {
+        assert.equal(findLevel(structure)(path), level);
+      });
+    });
+  });
+
+  describe("findLayerWithSimilarPath()", () => {
+    const structure = [[{ name: "/src/layerA" }], [{ name: "/src/layerB" }]];
+    const testCases = [
+      { path: "/src/layerA", layer: structure[0][0] },
+      { path: "/src/layerB", layer: structure[1][0] },
+      { path: "/src/layerA/entry", layer: structure[0][0] },
+    ];
+    testCases.forEach(({ path, layer }) => {
+      it(`The level of ${path} is ${JSON.stringify(layer)}`, () => {
+        assert.equal(findLayerWithSimilarPath(structure)(path), layer);
+      });
+    });
+  });
+
+  describe("createModulePath()", () => {
+    const cwd = "/proj";
+    const fileDir = "/proj/src/layerA";
+    const aliases = [{ alias: "@/", path: "./src/" }];
+    const testCases = [
+      {
+        moduleSource: "@/layerA/layerAA",
+        modulePath: "/proj/src/layerA/layerAA",
+      },
+      {
+        moduleSource: "nodeModule",
+        modulePath: "nodeModule",
+      },
+    ];
+    testCases.forEach(({ moduleSource, modulePath }) => {
+      it(`${moduleSource} -> ${modulePath}`, () => {
+        assert.equal(
+          createModulePath(cwd, fileDir, aliases)(moduleSource),
+          modulePath
+        );
+      });
+    });
+  });
+});

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

@@ -0,0 +1,228 @@
+/**
+ * @fileoverview test for lower-level-imports
+ * @author Hodoug Joung
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const rule = require("../../../lib/rules/stratified-imports");
+const RuleTester = require("eslint").RuleTester;
+
+//------------------------------------------------------------------------------
+// Tests
+//------------------------------------------------------------------------------
+
+/*
+// .stratified.json
+[
+  ["layerA"],
+  ["layerB"],
+  [{ "name": "layerC", "barrier": true }],
+  ["layerD"],
+  [{ "name": "nodeModuleE", "nodeModule": "true" }],
+  ["layerF"],
+  ["layerG", "layerH"],
+  ["layerI"],
+  ["layerJ"],
+  ["layerK"]
+]
+
+// layerB/.stratified.json
+[
+  ["layerBA"],
+  ["layerBB"]
+]
+
+// layerJ/.stratified.json
+[
+  ["entryJA", "entryJB"],
+  ["layerJC"]
+]
+*/
+
+const ruleTester = new RuleTester({
+  parserOptions: { ecmaVersion: 2022, sourceType: "module" },
+});
+
+ruleTester.run("stratified-imports", rule, {
+  valid: [
+    {
+      code: "import { func } from './layerB'",
+      filename: "./mocked/stratified-imports/layerA.js",
+      options: [],
+    },
+    {
+      code: "import { func } from './layerC'",
+      filename: "./mocked/stratified-imports/layerA.js",
+      options: [],
+    },
+    {
+      code: "import { func } from 'notRegisteredNodeModule'",
+      filename: "./mocked/stratified-imports/layerA.js",
+      options: [],
+    },
+    {
+      code: "import { func } from 'nodeModuleE'",
+      filename: "./mocked/stratified-imports/layerD.js",
+      options: [],
+    },
+    {
+      code: "import { func } from './layerH'",
+      filename: "./mocked/stratified-imports/layerF.js",
+      options: [],
+    },
+    {
+      code: "import { func } from './layerI'",
+      filename: "./mocked/stratified-imports/layerH.js",
+      options: [],
+    },
+    {
+      code: "import { func } from './layerBB'",
+      filename: "./mocked/stratified-imports/layerB/layerBA.js",
+      options: [],
+    },
+    {
+      code: "import { func } from '../layerC'",
+      filename: "./mocked/stratified-imports/layerB/layerBA.js",
+      options: [],
+    },
+    {
+      code: "import { func } from './layerJC'",
+      filename: "./mocked/stratified-imports/layerJ/entryJA.js",
+      options: [],
+    },
+    {
+      code: "import { func } from './layerJC'",
+      filename: "./mocked/stratified-imports/layerJ/entryJB.js",
+      options: [],
+    },
+    {
+      code: "import { func } from '../layerK'",
+      filename: "./mocked/stratified-imports/layerJ/layerJC.js",
+      options: [],
+    },
+    {
+      code: "import { func } from '@/layerB'",
+      filename: "./mocked/stratified-imports/layerA.js",
+      options: [{ aliases: { "@/": "./mocked/stratified-imports/" } }],
+    },
+    {
+      code: "import { func } from './notRegisteredLayer'",
+      filename: "./mocked/stratified-imports/layerA.test.js",
+      options: [],
+    },
+    {
+      code: "import { func } from './notRegisteredLayer'",
+      filename: "./mocked/stratified-imports/layerA.js",
+      options: [{ include: ["**/*.ts"] }],
+    },
+    {
+      code: "import { func } from './notRegisteredLayer'",
+      filename: "./mocked/stratified-imports/layerA.js",
+      options: [{ exclude: ["**/*.js"] }],
+    },
+    {
+      code: "import { func } from './notRegisteredLayer'",
+      filename: "./mocked/stratified-imports/layerA.js",
+      options: [{ include: ["**/*.js"], exclude: ["**/layerA.js"] }],
+    },
+    {
+      code: "import { func } from './layerJ/entryJA'",
+      filename: "./mocked/stratified-imports/layerI.js",
+      options: [],
+    },
+  ],
+  invalid: [
+    {
+      code: "import { func } from './layerA'",
+      filename: "./mocked/stratified-imports/notRegisteredLayer.js",
+      options: [],
+      errors: [
+        {
+          messageId: "not-registered",
+          data: { file: "notRegisteredLayer" },
+        },
+      ],
+    },
+    {
+      code: "import { func } from './layerA'",
+      filename: "./mocked/stratified-imports/layerB.js",
+      options: [],
+      errors: [
+        {
+          messageId: "not-lower-level",
+          data: { module: "layerA", file: "layerB" },
+        },
+      ],
+    },
+    {
+      code: "import { func } from './layerD'",
+      filename: "./mocked/stratified-imports/layerB.js",
+      options: [],
+      errors: [
+        {
+          messageId: "barrier",
+          data: { module: "layerD", file: "layerB" },
+        },
+      ],
+    },
+    {
+      code: "import { func } from './layerBA'",
+      filename: "./mocked/stratified-imports/layerB/layerBB.js",
+      options: [],
+      errors: [
+        {
+          messageId: "not-lower-level",
+          data: { module: "layerBA", file: "layerBB" },
+        },
+      ],
+    },
+    {
+      code: "import { func } from '../layerA'",
+      filename: "./mocked/stratified-imports/layerB/layerBA.js",
+      options: [],
+      errors: [
+        {
+          messageId: "not-lower-level",
+          data: { module: "layerA", file: "layerBA" },
+        },
+      ],
+    },
+    {
+      code: "import { func } from './entryJA'",
+      filename: "./mocked/stratified-imports/layerJ/layerJC.js",
+      options: [],
+      errors: [
+        {
+          messageId: "not-lower-level",
+          data: { module: "entryJA", file: "layerJC" },
+        },
+      ],
+    },
+    {
+      code: "import { func } from '../layerI'",
+      filename: "./mocked/stratified-imports/layerJ/layerJC.js",
+      options: [],
+      errors: [
+        {
+          messageId: "not-lower-level",
+          data: { module: "layerI", file: "layerJC" },
+        },
+      ],
+    },
+    {
+      code: "import { func } from './layerJ/notRegisteredEntry'",
+      filename: "./mocked/stratified-imports/layerI.js",
+      options: [],
+      errors: [
+        {
+          messageId: "not-lower-level",
+          data: { module: "notRegisteredEntry", file: "layerI" },
+        },
+      ],
+    },
+  ],
+});