eslint-plugin-no-mistakes 0.26.0 → 0.28.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-no-mistakes",
-  "version": "0.26.0",
+  "version": "0.28.0",
   "description": "ESLint and Oxlint rules for deterministic no-mistakes code analysis",
   "license": "MIT",
   "repository": {
@@ -21,10 +21,10 @@
     "test": "vitest run --coverage"
   },
   "devDependencies": {
-    "@typescript-eslint/parser": "^8.60.1",
-    "@vitest/coverage-v8": "^4.1.8",
-    "eslint": "^10.4.1",
-    "oxlint": "^1.69.0",
+    "@typescript-eslint/parser": "^8.61.1",
+    "@vitest/coverage-v8": "^4.1.9",
+    "eslint": "^10.5.0",
+    "oxlint": "^1.71.0",
     "vitest": "^4.1.6"
   },
   "peerDependencies": {

package/src/index.js

@@ -1,6 +1,8 @@
 "use strict";
 
 const rules = {
+  "async-call-disposition": require("./rules/async-call-disposition"),
+  "async-try-catch-return-await": require("./rules/async-try-catch-return-await"),
   "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"),
@@ -8,6 +10,7 @@ const rules = {
   "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-global-fetch-outside-helper": require("./rules/no-global-fetch-outside-helper"),
   "no-delete-property": require("./rules/no-delete-property"),
   "no-import-only-test-files": require("./rules/no-import-only-test-files"),
   "no-placeholder-never-type-exports": require("./rules/no-placeholder-never-type-exports"),
@@ -27,10 +30,12 @@ const rules = {
   "playwright-unique": require("./rules/playwright-unique"),
   "react-no-nullish-react-node": require("./rules/react-no-nullish-react-node"),
   "react-no-use-promise-resolve": require("./rules/react-no-use-promise-resolve"),
+  "server-require-nullable-fetch-wrapper": require("./rules/server-require-nullable-fetch-wrapper"),
   "test-no-error-message-matching": require("./rules/test-no-error-message-matching"),
   "test-no-shared-state": require("./rules/test-no-shared-state"),
   "ts-no-export-renaming": require("./rules/ts-no-export-renaming"),
   "ts-no-function-aliases": require("./rules/ts-no-function-aliases"),
+  "ts-preserve-null-option-defaults": require("./rules/ts-preserve-null-option-defaults"),
   "vitest-mock-test-file-naming": require("./rules/vitest-mock-test-file-naming"),
 };
 

package/src/returned-jsx.js

@@ -98,18 +98,22 @@ function visitNode(node, callback) {
 
 function childNodes(node) {
   const children = [];
-  for (const [key, value] of Object.entries(node)) {
+  for (const key in node) {
     if (key === "parent" || key === "tokens" || key === "comments") {
       continue;
     }
-    if (Array.isArray(value)) {
-      for (const child of value) {
-        if (isAstNode(child)) {
-          children.push(child);
+    if (Object.prototype.hasOwnProperty.call(node, key)) {
+      const value = node[key];
+      if (Array.isArray(value)) {
+        for (let i = 0; i < value.length; i++) {
+          const child = value[i];
+          if (isAstNode(child)) {
+            children.push(child);
+          }
         }
+      } else if (isAstNode(value)) {
+        children.push(value);
       }
-    } else if (isAstNode(value)) {
-      children.push(value);
     }
   }
   return children;

package/src/rules/async-ast.js

@@ -0,0 +1,90 @@
+"use strict";
+
+const transparentExpressionTypes = new Set([
+  "ChainExpression",
+  "TSNonNullExpression",
+  "TSAsExpression",
+  "TSTypeAssertion",
+  "TSSatisfiesExpression",
+]);
+
+function isFunction(node) {
+  return (
+    node?.type === "ArrowFunctionExpression" ||
+    node?.type === "FunctionDeclaration" ||
+    node?.type === "FunctionExpression"
+  );
+}
+
+function findContainingFunction(node) {
+  let current = node.parent;
+  while (current) {
+    if (isFunction(current)) return current;
+    current = current.parent;
+  }
+}
+
+function isTransparentExpression(node) {
+  return transparentExpressionTypes.has(node?.type);
+}
+
+function unwrapExpression(node) {
+  let current = node;
+  while (isTransparentExpression(current)) current = current.expression;
+  return current;
+}
+
+function unwrapTransparentParent(node) {
+  let current = node;
+  while (isTransparentExpression(current.parent)) current = current.parent;
+  return current;
+}
+
+function visitorKeys(context, node) {
+  return context.sourceCode.visitorKeys[node.type] || [];
+}
+
+function traverse(context, node, visit, root = node) {
+  if (!node) return;
+  if (node !== root && isFunction(node)) return;
+  visit(node);
+  for (const key of visitorKeys(context, node)) {
+    const value = node[key];
+    if (Array.isArray(value)) {
+      for (const child of value) {
+        if (child?.type) traverse(context, child, visit, root);
+      }
+    } else if (value?.type) {
+      traverse(context, value, visit, root);
+    }
+  }
+}
+
+function isUnconditionalBeforeReturn(node, block) {
+  let current = node;
+  while (current && current !== block) {
+    const parent = current.parent;
+    if (!parent || parent.type === "IfStatement" || parent.type.endsWith("Expression")) {
+      return false;
+    }
+    if (
+      parent.type.endsWith("Statement") &&
+      parent.type !== "ExpressionStatement" &&
+      parent.type !== "BlockStatement"
+    ) {
+      return false;
+    }
+    current = parent;
+  }
+  return current === block;
+}
+
+module.exports = {
+  findContainingFunction,
+  isFunction,
+  isTransparentExpression,
+  isUnconditionalBeforeReturn,
+  traverse,
+  unwrapExpression,
+  unwrapTransparentParent,
+};

package/src/rules/async-call-disposition.js

@@ -0,0 +1,203 @@
+"use strict";
+
+const { rule } = require("../helpers");
+const {
+  findContainingFunction,
+  isFunction,
+  isTransparentExpression,
+  unwrapTransparentParent,
+} = require("./async-ast");
+const { targetOptionsSchema } = require("./async-schema");
+const { createTargetMatcher, memberPropertyName } = require("./async-targets");
+
+function isPromiseAllCall(node) {
+  return (
+    node?.type === "CallExpression" &&
+    node.callee.type === "MemberExpression" &&
+    !node.callee.computed &&
+    node.callee.object.type === "Identifier" &&
+    node.callee.object.name === "Promise" &&
+    memberPropertyName(node.callee) === "all"
+  );
+}
+
+function directlyDisposed(node) {
+  const expression = unwrapTransparentParent(node);
+  const parent = expression.parent;
+  if (parent?.type === "ReturnStatement") {
+    const fn = findContainingFunction(parent);
+    return !isCallArgument(fn);
+  }
+  if (parent?.type === "ArrowFunctionExpression" && parent.body === expression) {
+    if (isCallCallee(parent)) return directlyDisposed(parent.parent);
+    return !isCallArgument(parent);
+  }
+  return (
+    parent?.type === "AwaitExpression" ||
+    (parent?.type === "UnaryExpression" && parent.operator === "void")
+  );
+}
+
+function isCallArgument(node) {
+  return Boolean(node?.parent?.type === "CallExpression" && node.parent.arguments.includes(node));
+}
+
+function isCallCallee(node) {
+  return node?.parent?.type === "CallExpression" && node.parent.callee === node;
+}
+
+function isPromiseAllIterable(node, promiseAll) {
+  return promiseAll.arguments[0] === node && (node.type === "ArrayExpression" || isMapCall(node));
+}
+
+function isMapCall(node) {
+  return (
+    node?.type === "CallExpression" &&
+    node.callee.type === "MemberExpression" &&
+    memberPropertyName(node.callee) === "map"
+  );
+}
+
+function isMapCallback(fn) {
+  const call = fn.parent;
+  return isMapCall(call) && call.arguments.includes(fn);
+}
+
+function expressionReturnedFromCallback(node, fn) {
+  let current = node;
+  let returnStatement = null;
+  while (current && current !== fn) {
+    if (current.parent === fn && fn.body === current && fn.body.type !== "BlockStatement") {
+      return true;
+    }
+    if (current.parent?.type === "ReturnStatement") {
+      returnStatement = current.parent;
+    }
+    current = current.parent;
+  }
+  return Boolean(returnStatement);
+}
+
+function canReachPromiseAll(node, promiseAll) {
+  let current = node;
+  while (current && current !== promiseAll) {
+    const parent = current.parent;
+    if (isTransparentExpression(parent)) {
+      current = parent;
+      continue;
+    }
+    if (parent?.type === "MemberExpression") return false;
+    if (parent === promiseAll) return isPromiseAllIterable(current, promiseAll);
+    if (isFunction(parent)) {
+      if (!expressionReturnedFromCallback(node, parent) || !isMapCallback(parent)) {
+        return false;
+      }
+      current = parent.parent;
+      continue;
+    }
+    if (parent?.type === "ArrayExpression") {
+      if (parent.parent !== promiseAll || promiseAll.arguments[0] !== parent) return false;
+      current = parent;
+      continue;
+    }
+    if (parent?.type === "ObjectExpression") return false;
+    if (
+      parent?.type === "CallExpression" &&
+      parent !== promiseAll &&
+      parent.arguments.includes(current)
+    ) {
+      return false;
+    }
+    current = parent;
+  }
+  return current === promiseAll;
+}
+
+function observedExpression(node) {
+  let current = node;
+  while (current.parent) {
+    const parent = current.parent;
+    if (isTransparentExpression(parent)) {
+      current = parent;
+      continue;
+    }
+    if (
+      parent.type === "MemberExpression" &&
+      parent.object === current &&
+      parent.parent?.type === "CallExpression" &&
+      parent.parent.callee === parent
+    ) {
+      current = parent;
+      continue;
+    }
+    if (parent.type === "CallExpression" && parent.callee === current) {
+      current = parent;
+      continue;
+    }
+    break;
+  }
+  return current;
+}
+
+function promiseAllDisposed(node) {
+  let current = node.parent;
+  while (current) {
+    if (isPromiseAllCall(current) && canReachPromiseAll(node, current)) {
+      return (
+        directlyDisposed(current) ||
+        directlyDisposed(observedExpression(current)) ||
+        promiseAllDisposed(current)
+      );
+    }
+    current = current.parent;
+  }
+  return false;
+}
+
+function isDisposed(node) {
+  const observed = observedExpression(node);
+  return directlyDisposed(node) || directlyDisposed(observed) || promiseAllDisposed(node);
+}
+
+module.exports = rule(
+  {
+    type: "problem",
+    docs: {
+      description: "require explicit async disposition for configured async calls",
+      recommended: false,
+    },
+    hasSuggestions: true,
+    schema: targetOptionsSchema,
+    messages: {
+      disposition:
+        "Handle this async promise explicitly with await, return, Promise.all(...), or void.",
+      markVoid: "Prefix the call with void to mark this promise as intentionally floating.",
+    },
+  },
+  (context) => {
+    const matcher = createTargetMatcher(context);
+    if (!matcher.hasTargets) return {};
+
+    return {
+      ...matcher.visitors,
+      CallExpression(node) {
+        if (!matcher.isTargetCall(node) || isDisposed(node)) return;
+        context.report({
+          node,
+          messageId: "disposition",
+          suggest:
+            node.parent?.type === "ExpressionStatement"
+              ? [
+                  {
+                    messageId: "markVoid",
+                    fix(fixer) {
+                      return fixer.insertTextBefore(node, "void ");
+                    },
+                  },
+                ]
+              : [],
+        });
+      },
+    };
+  },
+);

package/src/rules/async-schema.js

@@ -0,0 +1,28 @@
+"use strict";
+
+function optionsSchema(propertyName) {
+  return [
+    {
+      type: "object",
+      properties: {
+        [propertyName]: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              sourceSpecifierPatterns: { type: "array", items: { type: "string" } },
+              calleeNamePatterns: { type: "array", items: { type: "string" } },
+            },
+            additionalProperties: false,
+          },
+        },
+      },
+      additionalProperties: false,
+    },
+  ];
+}
+
+const handlerOptionsSchema = optionsSchema("handlers");
+const targetOptionsSchema = optionsSchema("targets");
+
+module.exports = { handlerOptionsSchema, targetOptionsSchema };

package/src/rules/async-targets.js

@@ -0,0 +1,200 @@
+"use strict";
+
+const { unwrapExpression } = require("./async-ast");
+const { propertyName } = require("./module-mock-helpers");
+
+function safeRegExp(source) {
+  try {
+    return new RegExp(source);
+  } catch {
+    return null;
+  }
+}
+
+function patternToRegExp(pattern) {
+  if (pattern.startsWith("/") && pattern.endsWith("/") && pattern.length > 2) {
+    return safeRegExp(pattern.slice(1, -1));
+  }
+  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, "\\$&");
+    }
+  }
+  return safeRegExp(`${source}$`);
+}
+
+function compileTargets(options, optionKey) {
+  return (options[optionKey] || [])
+    .map((target) => ({
+      sourceSpecifierPatterns: (target.sourceSpecifierPatterns || [])
+        .map(patternToRegExp)
+        .filter(Boolean),
+      calleeNamePatterns: (target.calleeNamePatterns || []).map(patternToRegExp).filter(Boolean),
+    }))
+    .filter(
+      (target) => target.sourceSpecifierPatterns.length > 0 && target.calleeNamePatterns.length > 0,
+    );
+}
+
+function matchesAny(value, patterns) {
+  return typeof value === "string" && patterns.some((pattern) => pattern.test(value));
+}
+
+function targetMatches(targets, source, calleeName) {
+  return targets.some(
+    (target) =>
+      matchesAny(source, target.sourceSpecifierPatterns) &&
+      matchesAny(calleeName, target.calleeNamePatterns),
+  );
+}
+
+function findVariable(scope, name) {
+  while (scope) {
+    const variable = scope.variables.find((candidate) => candidate.name === name);
+    if (variable) return variable;
+    scope = scope.upper;
+  }
+  return null;
+}
+
+function resolveVariable(node, context) {
+  return findVariable(context.sourceCode.getScope(node), node.name);
+}
+
+function importSpecifierName(specifier) {
+  const imported = specifier.imported;
+  return imported.type === "Literal" ? String(imported.value) : imported.name;
+}
+
+function requireSource(node) {
+  const expression = unwrapExpression(node);
+  return expression?.type === "CallExpression" &&
+    expression.callee.type === "Identifier" &&
+    expression.callee.name === "require" &&
+    typeof expression.arguments[0]?.value === "string"
+    ? expression.arguments[0].value
+    : null;
+}
+
+function bindingIdentifier(node) {
+  if (node?.type === "Identifier") return node;
+  return node?.type === "AssignmentPattern" && node.left.type === "Identifier" ? node.left : null;
+}
+
+function memberPropertyName(node) {
+  if (!node.computed) return propertyName(node.property);
+  return node.property?.type === "Literal" ? String(node.property.value) : null;
+}
+
+function createTargetMatcher(context, optionKey = "targets") {
+  const targets = compileTargets(context.options?.[0] || {}, optionKey);
+  const sourceSpecifierPatterns = targets.flatMap((target) => target.sourceSpecifierPatterns);
+  const directBindings = new Map();
+  const namespaceBindings = new Map();
+
+  function recordDirect(id, source, calleeName) {
+    if (id?.type !== "Identifier" || !targetMatches(targets, source, calleeName)) return;
+    const variable = resolveVariable(id, context);
+    if (variable) directBindings.set(variable, { source, calleeName });
+  }
+
+  function recordNamespace(id, source) {
+    if (id.type !== "Identifier" || !matchesAny(source, sourceSpecifierPatterns)) {
+      return;
+    }
+    const variable = resolveVariable(id, context);
+    if (variable) namespaceBindings.set(variable, source);
+  }
+
+  function recordRequireDeclarator(node) {
+    const source = requireSource(node.init);
+    if (!source) return;
+    if (node.id.type === "Identifier") {
+      recordNamespace(node.id, source);
+      recordDirect(node.id, source, node.id.name);
+      return;
+    }
+    if (node.id.type === "ObjectPattern") {
+      for (const property of node.id.properties) {
+        if (property.type !== "Property") continue;
+        recordDirect(bindingIdentifier(property.value), source, propertyName(property.key));
+      }
+    }
+  }
+
+  function recordProgramRequires(node) {
+    for (const statement of node.body) {
+      const declarations =
+        statement.type === "VariableDeclaration"
+          ? statement.declarations
+          : statement.type === "ExportNamedDeclaration" &&
+              statement.declaration?.type === "VariableDeclaration"
+            ? statement.declaration.declarations
+            : [];
+      for (const declaration of declarations) recordRequireDeclarator(declaration);
+    }
+  }
+
+  function isDirectTarget(node) {
+    if (node.type !== "Identifier") return false;
+    const variable = resolveVariable(node, context);
+    return Boolean(variable && directBindings.has(variable));
+  }
+
+  function isNamespaceTarget(node) {
+    if (node.type !== "MemberExpression") return false;
+    const name = memberPropertyName(node);
+    if (!name) return false;
+    const source =
+      requireSource(node.object) ||
+      (node.object.type === "Identifier"
+        ? namespaceBindings.get(resolveVariable(node.object, context))
+        : null);
+    return Boolean(source && targetMatches(targets, source, name));
+  }
+
+  return {
+    hasTargets: targets.length > 0,
+    isTargetCall(node) {
+      return isDirectTarget(node.callee) || isNamespaceTarget(node.callee);
+    },
+    visitors: {
+      Program: recordProgramRequires,
+      ImportDeclaration(node) {
+        const source = node.source.value;
+        for (const specifier of node.specifiers) {
+          if (specifier.type === "ImportNamespaceSpecifier") {
+            recordNamespace(specifier.local, source);
+          } else if (specifier.type === "ImportDefaultSpecifier") {
+            recordDirect(specifier.local, source, specifier.local.name);
+          } else if (specifier.type === "ImportSpecifier") {
+            recordDirect(specifier.local, source, importSpecifierName(specifier));
+          }
+        }
+      },
+      VariableDeclarator(node) {
+        recordRequireDeclarator(node);
+      },
+    },
+  };
+}
+
+module.exports = {
+  createTargetMatcher,
+  memberPropertyName,
+};