@antithrow/eslint-plugin 1.1.0 → 1.2.0

package/README.md

@@ -1,7 +1,7 @@
 <div align="center">
 	<h1>@antithrow/eslint-plugin</h1>
 	<p>
-		ESLint rules for <a href="https://github.com/jack-weilage/antithrow">antithrow</a> Result types
+		ESLint rules for <a href="https://github.com/antithrow/antithrow">antithrow</a> Result types
 	</p>
 
 ![NPM Version](https://img.shields.io/npm/v/@antithrow/eslint-plugin)
@@ -40,6 +40,7 @@ export default [
       "@antithrow": antithrow,
     },
     rules: {
+      "@antithrow/no-throwing-call": "warn",
       "@antithrow/no-unsafe-unwrap": "warn",
       "@antithrow/no-unused-result": "error",
     },
@@ -51,5 +52,6 @@ export default [
 
 | Rule | Description | Recommended |
 | --- | --- | --- |
+| [`no-throwing-call`](./docs/rules/no-throwing-call.md) | Disallow calls to throwing built-in APIs with `@antithrow/std` replacements | `warn` |
 | [`no-unsafe-unwrap`](./docs/rules/no-unsafe-unwrap.md) | Disallow `unwrap`/`expect` APIs on antithrow `Result` values | `warn` |
 | [`no-unused-result`](./docs/rules/no-unused-result.md) | Require `Result` and `ResultAsync` values to be used | `error` |

package/dist/create-rule.js

@@ -1,2 +1,2 @@
 import { ESLintUtils } from "@typescript-eslint/utils";
-export const createRule = ESLintUtils.RuleCreator((name) => `https://github.com/jack-weilage/antithrow/blob/main/packages/eslint-plugin/docs/rules/${name}.md`);
+export const createRule = ESLintUtils.RuleCreator((name) => `https://github.com/antithrow/antithrow/blob/main/packages/eslint-plugin/docs/rules/${name}.md`);

package/dist/index.js

@@ -1,11 +1,12 @@
 import packageJson from "../package.json" with { type: "json" };
-import { noUnsafeUnwrap, noUnusedResult } from "./rules/index.js";
+import { noThrowingCall, noUnsafeUnwrap, noUnusedResult } from "./rules/index.js";
 const plugin = {
     meta: {
         name: packageJson.name,
         version: packageJson.version,
     },
     rules: {
+        "no-throwing-call": noThrowingCall,
         "no-unsafe-unwrap": noUnsafeUnwrap,
         "no-unused-result": noUnusedResult,
     },
@@ -18,6 +19,7 @@ plugin.configs = {
             "@antithrow": plugin,
         },
         rules: {
+            "@antithrow/no-throwing-call": "warn",
             "@antithrow/no-unsafe-unwrap": "warn",
             "@antithrow/no-unused-result": "error",
         },

package/dist/rules/index.d.ts

@@ -1,2 +1,3 @@
+export { noThrowingCall } from "./no-throwing-call.js";
 export { noUnsafeUnwrap } from "./no-unsafe-unwrap.js";
 export { noUnusedResult } from "./no-unused-result.js";

package/dist/rules/index.js

@@ -1,2 +1,3 @@
+export { noThrowingCall } from "./no-throwing-call.js";
 export { noUnsafeUnwrap } from "./no-unsafe-unwrap.js";
 export { noUnusedResult } from "./no-unused-result.js";

package/dist/rules/no-throwing-call.d.ts

@@ -0,0 +1,9 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+/** @lintignore */
+export declare const MessageId: {
+    readonly THROWING_CALL: "throwingCall";
+};
+export type MessageId = (typeof MessageId)[keyof typeof MessageId];
+export declare const noThrowingCall: ESLintUtils.RuleModule<"throwingCall", [], import("../create-rule.js").AntithrowPluginDocs, ESLintUtils.RuleListener> & {
+    name: string;
+};

package/dist/rules/no-throwing-call.js

@@ -0,0 +1,172 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+import ts from "typescript";
+import { createRule } from "../create-rule.js";
+/** @lintignore */
+export const MessageId = {
+    THROWING_CALL: "throwingCall",
+};
+const GLOBAL_FUNCTIONS = new Set([
+    "fetch",
+    "atob",
+    "btoa",
+    "structuredClone",
+    "decodeURI",
+    "decodeURIComponent",
+    "encodeURI",
+    "encodeURIComponent",
+]);
+const JSON_METHODS = new Set(["parse", "stringify"]);
+const RESPONSE_BODY_METHODS = new Set(["json", "text", "arrayBuffer", "blob", "formData"]);
+const GLOBAL_OBJECTS = new Set(["globalThis", "window", "self"]);
+const NULLISH_TYPE_FLAGS = ts.TypeFlags.Null | ts.TypeFlags.Undefined | ts.TypeFlags.Void;
+/**
+ * Extracts the property name from a `MemberExpression` when it can be
+ * statically determined. Handles `obj.prop`, `obj["prop"]`, and
+ * `` obj[`prop`] `` (template literals with no interpolations).
+ * Returns `null` for dynamic access like `obj[variable]`.
+ */
+function getStaticMemberName(node) {
+    if (!node.computed && node.property.type === "Identifier") {
+        return node.property.name;
+    }
+    if (node.computed &&
+        node.property.type === "Literal" &&
+        typeof node.property.value === "string") {
+        return node.property.value;
+    }
+    if (node.computed &&
+        node.property.type === "TemplateLiteral" &&
+        node.property.expressions.length === 0) {
+        const [quasi] = node.property.quasis;
+        return quasi?.value.cooked ?? null;
+    }
+    return null;
+}
+function isImplicitGlobal(name, scope) {
+    let current = scope;
+    while (current) {
+        const variable = current.set.get(name);
+        if (variable) {
+            return variable.defs.length === 0;
+        }
+        current = current.upper;
+    }
+    return true;
+}
+function isImplicitGlobalObject(node, scope) {
+    return GLOBAL_OBJECTS.has(node.name) && isImplicitGlobal(node.name, scope);
+}
+function containsGlobalResponseType(type, globalResponseType, checker) {
+    if (type.isUnionOrIntersection()) {
+        return type.types.some((member) => containsGlobalResponseType(member, globalResponseType, checker));
+    }
+    const flags = type.getFlags();
+    if (flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Never | NULLISH_TYPE_FLAGS)) {
+        return false;
+    }
+    if (checker.isTypeAssignableTo(type, globalResponseType)) {
+        return true;
+    }
+    const constraint = checker.getBaseConstraintOfType(type);
+    if (constraint && constraint !== type) {
+        return containsGlobalResponseType(constraint, globalResponseType, checker);
+    }
+    return false;
+}
+export const noThrowingCall = createRule({
+    name: "no-throwing-call",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow calls to known throwing built-in APIs that have @antithrow/std replacements.",
+            recommended: true,
+            requiresTypeChecking: true,
+        },
+        messages: {
+            [MessageId.THROWING_CALL]: "`{{ api }}` can throw. A non-throwing wrapper is available from `@antithrow/std`.",
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        const services = ESLintUtils.getParserServices(context);
+        const checker = services.program.getTypeChecker();
+        const globalResponseSymbol = checker.resolveName("Response", undefined, ts.SymbolFlags.Type, false);
+        const globalResponseType = globalResponseSymbol
+            ? checker.getDeclaredTypeOfSymbol(globalResponseSymbol)
+            : null;
+        return {
+            CallExpression(node) {
+                const callee = node.callee;
+                // fetch(), atob(), etc.
+                if (callee.type === "Identifier" && GLOBAL_FUNCTIONS.has(callee.name)) {
+                    const scope = context.sourceCode.getScope(callee);
+                    if (isImplicitGlobal(callee.name, scope)) {
+                        context.report({
+                            node,
+                            messageId: MessageId.THROWING_CALL,
+                            data: { api: callee.name },
+                        });
+                    }
+                    return;
+                }
+                if (callee.type !== "MemberExpression") {
+                    return;
+                }
+                const methodName = getStaticMemberName(callee);
+                if (!methodName) {
+                    return;
+                }
+                // globalThis.fetch(), window.atob(), self.structuredClone(), etc.
+                if (GLOBAL_FUNCTIONS.has(methodName) &&
+                    callee.object.type === "Identifier" &&
+                    isImplicitGlobalObject(callee.object, context.sourceCode.getScope(callee.object))) {
+                    context.report({
+                        node,
+                        messageId: MessageId.THROWING_CALL,
+                        data: { api: methodName },
+                    });
+                    return;
+                }
+                // JSON.parse(), JSON.stringify()
+                if (JSON_METHODS.has(methodName) &&
+                    callee.object.type === "Identifier" &&
+                    callee.object.name === "JSON") {
+                    const scope = context.sourceCode.getScope(callee.object);
+                    if (isImplicitGlobal("JSON", scope)) {
+                        context.report({
+                            node,
+                            messageId: MessageId.THROWING_CALL,
+                            data: { api: `JSON.${methodName}` },
+                        });
+                    }
+                    return;
+                }
+                // globalThis.JSON.parse(), window.JSON.stringify(), etc.
+                if (JSON_METHODS.has(methodName) &&
+                    callee.object.type === "MemberExpression" &&
+                    getStaticMemberName(callee.object) === "JSON" &&
+                    callee.object.object.type === "Identifier" &&
+                    isImplicitGlobalObject(callee.object.object, context.sourceCode.getScope(callee.object.object))) {
+                    context.report({
+                        node,
+                        messageId: MessageId.THROWING_CALL,
+                        data: { api: `JSON.${methodName}` },
+                    });
+                    return;
+                }
+                if (RESPONSE_BODY_METHODS.has(methodName) && globalResponseType) {
+                    const tsNode = services.esTreeNodeToTSNodeMap.get(callee.object);
+                    const type = checker.getTypeAtLocation(tsNode);
+                    if (containsGlobalResponseType(type, globalResponseType, checker)) {
+                        context.report({
+                            node,
+                            messageId: MessageId.THROWING_CALL,
+                            data: { api: `response.${methodName}` },
+                        });
+                    }
+                }
+            },
+        };
+    },
+});

package/package.json

@@ -1,12 +1,12 @@
 {
 	"name": "@antithrow/eslint-plugin",
-	"version": "1.1.0",
+	"version": "1.2.0",
 	"description": "ESLint plugin for antithrow Result types",
 	"license": "MIT",
 	"author": "Jack Weilage",
 	"repository": {
 		"type": "git",
-		"url": "git+https://github.com/jack-weilage/antithrow.git",
+		"url": "git+https://github.com/antithrow/antithrow.git",
 		"directory": "packages/eslint-plugin"
 	},
 	"keywords": [