eslint-plugin-no-mistakes 0.25.0 → 0.26.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-no-mistakes",
-  "version": "0.25.0",
+  "version": "0.26.0",
   "description": "ESLint and Oxlint rules for deterministic no-mistakes code analysis",
   "license": "MIT",
   "repository": {

package/src/defaulted-props.js

@@ -193,7 +193,11 @@ function isFunctionParameterSource(node, context) {
 function findVariable(scope, name) {
   let variable = null;
   for (let current = scope; current && variable === null; current = current.upper) {
-    variable = current.variables.find((item) => item.name === name) || null;
+    if (current.set && typeof current.set.get === "function") {
+      variable = current.set.get(name) || null;
+    } else {
+      variable = current.variables.find((item) => item.name === name) || null;
+    }
   }
   return variable;
 }

package/src/index.js

@@ -4,6 +4,8 @@ const rules = {
   "await-array-methods": require("./rules/await-array-methods"),
   "nextjs-static-fetch-method": require("./rules/nextjs-static-fetch-method"),
   "nextjs-static-fetch-url": require("./rules/nextjs-static-fetch-url"),
+  "module-mock-boundary": require("./rules/module-mock-boundary"),
+  "module-mock-preserve-exports": require("./rules/module-mock-preserve-exports"),
   "nextjs-metadata-exports-location": require("./rules/nextjs-metadata-exports-location"),
   "nextjs-no-manual-script-tags": require("./rules/nextjs-no-manual-script-tags"),
   "no-delete-property": require("./rules/no-delete-property"),

package/src/rules/ast-pattern-names.js

@@ -0,0 +1,25 @@
+"use strict";
+
+function collectPatternNames(node, names = new Set()) {
+  if (!node) return names;
+  if (node.type === "Identifier") {
+    names.add(node.name);
+    return names;
+  }
+  const children =
+    node.type === "ObjectPattern"
+      ? node.properties.map((property) => property.value || property.argument)
+      : node.type === "ArrayPattern"
+        ? node.elements
+        : node.type === "RestElement"
+          ? [node.argument]
+          : node.type === "AssignmentPattern"
+            ? [node.left]
+            : [];
+  for (const child of children) collectPatternNames(child, names);
+  return names;
+}
+
+module.exports = {
+  collectPatternNames,
+};

package/src/rules/module-mock-baseline.js

@@ -0,0 +1,23 @@
+"use strict";
+
+const { repoRelativeFilename } = require("./module-mock-helpers");
+
+function baselineKey(filename, specifier) {
+  return JSON.stringify([repoRelativeFilename(filename), specifier]);
+}
+
+function baselineSet(entries = []) {
+  return new Set(entries.map(([file, specifier]) => JSON.stringify([file, specifier])));
+}
+
+function baselineMap(entries = []) {
+  return new Map(
+    entries.map(([file, specifier, count]) => [JSON.stringify([file, specifier]), count]),
+  );
+}
+
+module.exports = {
+  baselineKey,
+  baselineMap,
+  baselineSet,
+};

package/src/rules/module-mock-boundary.js

@@ -0,0 +1,206 @@
+"use strict";
+
+const { rule } = require("../helpers");
+const { baselineKey, baselineMap } = require("./module-mock-baseline");
+const { matchDirectMockCallApply } = require("./module-mock-call-apply");
+const { integrationAllows } = require("./module-mock-integration");
+const {
+  collectPatternNames,
+  importSpecifierName,
+  isFrameworkBinding,
+  isInternalSpecifier,
+  isModuleMockMemberCall,
+  memberPropertyName,
+  moduleMockSpecifierArgument,
+  pathAllowed,
+  propertyName,
+  repoRelativeFilename,
+} = require("./module-mock-helpers");
+
+const MODULE_MOCK_METHODS = new Set([
+  "doMock",
+  "importMock",
+  "mock",
+  "setMock",
+  "unstable_mockModule",
+]);
+
+function createBaselineTracker(filename, entries) {
+  const normalizedFilename = repoRelativeFilename(filename);
+  const baseline = baselineMap(entries);
+  const seen = new Map();
+  return {
+    allowed(specifier) {
+      const key = baselineKey(filename, specifier);
+      const count = (seen.get(key) ?? 0) + 1;
+      seen.set(key, count);
+      return count <= (baseline.get(key) ?? 0);
+    },
+    stale() {
+      const stale = [];
+      for (const [key, allowed] of baseline) {
+        const [file, specifier] = JSON.parse(key);
+        if (file !== normalizedFilename) continue;
+        const count = seen.get(key) ?? 0;
+        if (count < allowed) stale.push({ specifier, allowed, seen: count });
+      }
+      return stale;
+    },
+  };
+}
+
+function reportMessage(dynamic, specifier) {
+  if (dynamic) return "Module mock boundary requires literal specifiers.";
+  return `Module mock boundary does not allow mocking internal module "${specifier}".`;
+}
+
+function resolveVariable(node, context) {
+  let scope = context.sourceCode.getScope(node);
+  while (scope) {
+    const variable = scope.variables.find((candidate) => candidate.name === node.name);
+    if (variable) return variable;
+    scope = scope.upper;
+  }
+  return null;
+}
+
+module.exports = rule(
+  {
+    type: "problem",
+    docs: {
+      description: "enforce configured module mock boundaries",
+      recommended: false,
+    },
+    schema: [{ type: "object" }],
+    messages: {
+      boundary: "{{message}}",
+      stale: "{{message}}",
+    },
+  },
+  (context) => {
+    const options = context.options?.[0] ?? {};
+    const filename = context.filename;
+    const tracker = createBaselineTracker(filename, options.baseline);
+    const mockAliases = new Map();
+    if (!pathAllowed(filename, options)) return {};
+
+    function declareAlias(id, init) {
+      if (!id || !init) return;
+      if (id.type === "ObjectPattern" && isFrameworkBinding(init, context)) {
+        for (const property of id.properties) {
+          if (property.type !== "Property") continue;
+          const method = propertyName(property.key);
+          if (MODULE_MOCK_METHODS.has(method)) {
+            for (const name of collectPatternNames(property.value)) {
+              mockAliases.set(name, resolveVariable(property.value, context));
+            }
+          }
+        }
+        return;
+      }
+      if (
+        init.type === "MemberExpression" &&
+        memberPropertyName(init) &&
+        MODULE_MOCK_METHODS.has(memberPropertyName(init)) &&
+        isFrameworkBinding(init.object, context)
+      ) {
+        for (const name of collectPatternNames(id))
+          mockAliases.set(name, resolveVariable(id, context));
+      }
+    }
+
+    function isUnshadowedMockAlias(node) {
+      return (
+        node.type === "Identifier" && mockAliases.get(node.name) === resolveVariable(node, context)
+      );
+    }
+
+    function reportIfDisallowed(
+      node,
+      specifierNode = node.arguments[0],
+      factory = node.arguments[1],
+    ) {
+      const { dynamic, specifier } = moduleMockSpecifierArgument(specifierNode);
+      if (dynamic) {
+        if (options.requireLiteralSpecifiers === false) return;
+        context.report({ node, messageId: "boundary", data: { message: reportMessage(true) } });
+        return;
+      }
+      if (!specifier || !isInternalSpecifier(specifier, options)) return;
+      if (integrationAllows(specifier, factory, options)) return;
+      if (tracker.allowed(specifier)) return;
+      context.report({
+        node,
+        messageId: "boundary",
+        data: { message: reportMessage(false, specifier) },
+      });
+    }
+
+    return {
+      ImportDeclaration(node) {
+        if (node.source.value !== "vitest" && node.source.value !== "@jest/globals") return;
+        for (const specifier of node.specifiers) {
+          if (specifier.type !== "ImportSpecifier") continue;
+          if (MODULE_MOCK_METHODS.has(importSpecifierName(specifier))) {
+            mockAliases.set(specifier.local.name, resolveVariable(specifier.local, context));
+          }
+        }
+      },
+      VariableDeclarator(node) {
+        declareAlias(node.id, node.init);
+      },
+      AssignmentExpression(node) {
+        if (node.operator === "=") declareAlias(node.left, node.right);
+      },
+      CallExpression(node) {
+        const memberMock = isModuleMockMemberCall(node, context);
+        if (memberMock && MODULE_MOCK_METHODS.has(memberMock.method)) {
+          reportIfDisallowed(node);
+          return;
+        }
+        const directCall = matchDirectMockCallApply(node, context, MODULE_MOCK_METHODS);
+        if (directCall) {
+          reportIfDisallowed(node, directCall.specifierNode, directCall.factory);
+          return;
+        }
+        if (isUnshadowedMockAlias(node.callee)) {
+          reportIfDisallowed(node);
+          return;
+        }
+        if (
+          node.callee.type === "MemberExpression" &&
+          propertyName(node.callee.property) === "call" &&
+          node.callee.object.type === "Identifier" &&
+          isUnshadowedMockAlias(node.callee.object)
+        ) {
+          reportIfDisallowed(node, node.arguments[1], node.arguments[2]);
+          return;
+        }
+        if (
+          node.callee.type === "MemberExpression" &&
+          propertyName(node.callee.property) === "apply" &&
+          node.callee.object.type === "Identifier" &&
+          isUnshadowedMockAlias(node.callee.object)
+        ) {
+          const args = node.arguments[1];
+          reportIfDisallowed(
+            node,
+            args?.type === "ArrayExpression" ? args.elements[0] : undefined,
+            args?.type === "ArrayExpression" ? args.elements[1] : undefined,
+          );
+        }
+      },
+      "Program:exit"(node) {
+        for (const entry of tracker.stale()) {
+          context.report({
+            node,
+            messageId: "stale",
+            data: {
+              message: `Module mock boundary baseline for "${entry.specifier}" is stale; lower count from ${entry.allowed} to ${entry.seen}.`,
+            },
+          });
+        }
+      },
+    };
+  },
+);

package/src/rules/module-mock-call-apply.js

@@ -0,0 +1,25 @@
+"use strict";
+
+const { isModuleMockMemberCall, propertyName } = require("./module-mock-helpers");
+
+function matchDirectMockCallApply(node, context, methods) {
+  if (
+    node.callee.type !== "MemberExpression" ||
+    !["call", "apply"].includes(propertyName(node.callee.property)) ||
+    node.callee.object.type !== "MemberExpression"
+  ) {
+    return null;
+  }
+  const direct = isModuleMockMemberCall({ callee: node.callee.object }, context);
+  if (!direct || !methods.has(direct.method)) return null;
+  if (propertyName(node.callee.property) === "call") {
+    return { factory: node.arguments[2], specifierNode: node.arguments[1] };
+  }
+  const args = node.arguments[1];
+  return {
+    factory: args?.type === "ArrayExpression" ? args.elements[1] : undefined,
+    specifierNode: args?.type === "ArrayExpression" ? args.elements[0] : undefined,
+  };
+}
+
+module.exports = { matchDirectMockCallApply };

package/src/rules/module-mock-framework.js

@@ -0,0 +1,88 @@
+"use strict";
+
+const FRAMEWORK_MODULES = new Set(["vitest", "@jest/globals"]);
+
+function propertyName(node) {
+  if (!node) return null;
+  return node.type === "Literal" ? String(node.value) : node.name;
+}
+
+function memberPropertyName(node) {
+  if (!node?.computed) return propertyName(node?.property);
+  return node.property?.type === "Literal" ? String(node.property.value) : null;
+}
+
+function frameworkRequireModule(def) {
+  const init = def.node?.init;
+  const requireCall =
+    init?.type === "MemberExpression" && memberPropertyName(init) ? init.object : init;
+  if (
+    def.type === "Variable" &&
+    requireCall?.type === "CallExpression" &&
+    requireCall.callee.type === "Identifier" &&
+    requireCall.callee.name === "require" &&
+    FRAMEWORK_MODULES.has(requireCall.arguments[0]?.value)
+  ) {
+    return requireCall.arguments[0].value;
+  }
+  return null;
+}
+
+function frameworkBindingModule(node, context) {
+  if (node?.type === "MemberExpression" && !node.computed) {
+    const module = frameworkBindingModule(node.object, context);
+    const prop = propertyName(node.property);
+    if (module === "vitest" && prop === "vi") return module;
+    if (module === "@jest/globals" && prop === "jest") return module;
+    return null;
+  }
+  if (node?.type !== "Identifier") return null;
+  let scope = context.sourceCode.getScope(node);
+  while (scope) {
+    const variable = scope.variables.find((candidate) => candidate.name === node.name);
+    if (!variable) {
+      scope = scope.upper;
+      continue;
+    }
+    for (const def of variable.defs) {
+      const importModule = def.type === "ImportBinding" ? def.parent?.source?.value : null;
+      if (FRAMEWORK_MODULES.has(importModule) && frameworkImportMatches(def, importModule)) {
+        return importModule;
+      }
+      const requireModule = frameworkRequireModule(def);
+      if (requireModule) return requireModule;
+    }
+    if (variable.defs.length === 0 && node.name === "vi") return "vitest";
+    if (variable.defs.length === 0 && node.name === "jest") return "@jest/globals";
+    return null;
+  }
+  if (node.name === "vi") return "vitest";
+  if (node.name === "jest") return "@jest/globals";
+  return null;
+}
+
+function isFrameworkBinding(node, context) {
+  return Boolean(frameworkBindingModule(node, context));
+}
+
+function frameworkImportMatches(def, importModule) {
+  if (def.node?.type === "ImportNamespaceSpecifier") return true;
+  const imported = def.node?.imported;
+  const name = imported?.type === "Literal" ? String(imported.value) : imported?.name;
+  if (importModule === "vitest") return name === "vi";
+  return name === "jest";
+}
+
+function expressionName(node) {
+  if (node?.type === "Identifier") return node.name;
+  if (node?.type !== "MemberExpression" || node.computed) return null;
+  const object = expressionName(node.object);
+  const prop = propertyName(node.property);
+  return object && prop ? `${object}.${prop}` : null;
+}
+
+module.exports = {
+  expressionName,
+  frameworkBindingModule,
+  isFrameworkBinding,
+};

package/src/rules/module-mock-helpers.js

@@ -0,0 +1,158 @@
+"use strict";
+
+const { collectPatternNames } = require("./ast-pattern-names");
+const {
+  expressionName,
+  frameworkBindingModule,
+  isFrameworkBinding,
+} = require("./module-mock-framework");
+
+const MODULE_MOCK_METHODS = new Set([
+  "doMock",
+  "doUnmock",
+  "importMock",
+  "mock",
+  "setMock",
+  "unmock",
+  "unstable_mockModule",
+]);
+const PRESERVE_METHODS = new Set(["mock", "doMock", "unstable_mockModule"]);
+const DEFAULT_INTERNAL_SPECIFIERS = ["./**", "../**", "/**"];
+
+function propertyName(node) {
+  if (!node) return null;
+  return node.type === "Literal" ? String(node.value) : node.name;
+}
+
+function memberPropertyName(node) {
+  if (!node?.computed) return propertyName(node?.property);
+  return node.property?.type === "Literal" ? String(node.property.value) : null;
+}
+
+function literalString(node) {
+  if (!node) return null;
+  if (node.type === "Literal" && typeof node.value === "string") return node.value;
+  if (node.type === "TemplateLiteral" && node.expressions.length === 0) {
+    return node.quasis.map((quasi) => quasi.value.cooked ?? quasi.value.raw).join("");
+  }
+  return null;
+}
+
+function normalizeFilename(filename) {
+  return filename.replace(/\\/g, "/");
+}
+
+function repoRelativeFilename(filename) {
+  const cwd = normalizeFilename(process.cwd());
+  const normalized = normalizeFilename(filename);
+  return normalized.startsWith(`${cwd}/`) ? normalized.slice(cwd.length + 1) : normalized;
+}
+
+function globToRegExp(pattern) {
+  let source = "^";
+  for (let index = 0; index < pattern.length; index += 1) {
+    const ch = pattern[index];
+    const next = pattern[index + 1];
+    if (ch === "*" && next === "*") {
+      if (pattern[index + 2] === "/") {
+        source += "(?:.*/)?";
+        index += 2;
+      } else {
+        source += ".*";
+        index += 1;
+      }
+    } else if (ch === "*") {
+      source += "[^/]*";
+    } else if (ch === "?") {
+      source += "[^/]";
+    } else {
+      source += ch.replace(/[\\^$+?.()|[\]{}]/g, "\\$&");
+    }
+  }
+  source += "$";
+  return new RegExp(source);
+}
+
+function safeRegExp(source) {
+  try {
+    return new RegExp(source);
+  } catch {
+    return null;
+  }
+}
+
+function stringMatches(value, patterns) {
+  return patterns.some((pattern) => {
+    if (pattern.startsWith("/") && pattern.endsWith("/") && pattern.length > 2) {
+      const regex = safeRegExp(pattern.slice(1, -1));
+      return regex ? regex.test(value) : false;
+    }
+    return globToRegExp(pattern).test(value);
+  });
+}
+
+function pathAllowed(filename, options) {
+  const file = repoRelativeFilename(filename);
+  const include = options.includePathPatterns ?? [];
+  const exclude = options.excludePathPatterns ?? [];
+  return (include.length === 0 || stringMatches(file, include)) && !stringMatches(file, exclude);
+}
+
+function isInternalSpecifier(specifier, options) {
+  return stringMatches(specifier, options.internalSpecifiers ?? DEFAULT_INTERNAL_SPECIFIERS);
+}
+
+function moduleMockSpecifierArgument(node) {
+  const direct = literalString(node);
+  if (direct !== null) return { dynamic: false, specifier: direct };
+  if (node?.type === "ImportExpression") {
+    const specifier = literalString(node.source);
+    return specifier === null ? { dynamic: true } : { dynamic: false, specifier };
+  }
+  if (node?.type === "CallExpression" && node.callee.type === "Import") {
+    const specifier = literalString(node.arguments[0]);
+    return specifier === null ? { dynamic: true } : { dynamic: false, specifier };
+  }
+  return { dynamic: true };
+}
+
+function isModuleMockMemberCall(node, context) {
+  if (node.callee.type !== "MemberExpression") return false;
+  const method = memberPropertyName(node.callee);
+  if (!MODULE_MOCK_METHODS.has(method)) return false;
+  if (!isFrameworkBinding(node.callee.object, context)) return false;
+  return {
+    framework: frameworkBindingModule(node.callee.object, context),
+    method,
+    namespace: expressionName(node.callee.object),
+  };
+}
+
+function isPreserveMockCall(node, context) {
+  const mock = isModuleMockMemberCall(node, context);
+  return mock && PRESERVE_METHODS.has(mock.method) ? mock : false;
+}
+
+function importSpecifierName(specifier) {
+  const imported = specifier.imported;
+  if (!imported) return null;
+  return imported.type === "Literal" ? String(imported.value) : imported.name;
+}
+
+module.exports = {
+  collectPatternNames,
+  expressionName,
+  frameworkBindingModule,
+  importSpecifierName,
+  isFrameworkBinding,
+  isInternalSpecifier,
+  isModuleMockMemberCall,
+  memberPropertyName,
+  isPreserveMockCall,
+  literalString,
+  moduleMockSpecifierArgument,
+  pathAllowed,
+  propertyName,
+  repoRelativeFilename,
+  stringMatches,
+};