eslint-plugin-reliability 3.0.0

package/src/rules/error-handling/no-unhandled-promise.js

@@ -0,0 +1,351 @@
+"use strict";
+/**
+ * Copyright (c) 2025 Ofri Peretz
+ * Licensed under the MIT License. Use of this source code is governed by the
+ * MIT license that can be found in the LICENSE file.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noUnhandledPromise = void 0;
+const eslint_devkit_1 = require("@interlace/eslint-devkit");
+const eslint_devkit_2 = require("@interlace/eslint-devkit");
+/**
+ * Check if a node is a Promise-like expression
+ * For now, we check all CallExpressions since we can't statically determine
+ * which functions return promises. The isPromiseHandled function will filter out
+ * non-promise calls that are inside handled promise chains.
+ */
+function isPromiseExpression(node) {
+    // Function calls that might return promises
+    if (node.type === 'CallExpression') {
+        return true;
+    }
+    // Await expressions (already handled)
+    if (node.type === 'AwaitExpression') {
+        return false; // Already handled
+    }
+    return false;
+}
+/**
+ * Check if a CallExpression is inside a promise chain callback
+ */
+function isInsidePromiseCallback(node) {
+    let current = node;
+    let depth = 0;
+    const maxDepth = 10;
+    while (current && depth < maxDepth) {
+        const parent = current
+            .parent;
+        if (!parent)
+            break;
+        // Check if we're inside an arrow function or function expression
+        if (parent.type === 'ArrowFunctionExpression' ||
+            parent.type === 'FunctionExpression') {
+            // Check if this function is an argument to a promise method (.then, .catch, .finally)
+            const funcParent = parent
+                .parent;
+            if (funcParent &&
+                funcParent.type === 'CallExpression' &&
+                funcParent.callee &&
+                funcParent.callee.type === 'MemberExpression') {
+                const memberExpr = funcParent.callee;
+                if (memberExpr.property.type === 'Identifier') {
+                    const methodName = memberExpr.property.name;
+                    if (methodName === 'then' ||
+                        methodName === 'catch' ||
+                        methodName === 'finally') {
+                        // We're inside a promise chain callback
+                        return true;
+                    }
+                }
+            }
+        }
+        current = parent;
+        depth++;
+    }
+    return false;
+}
+/**
+ * Check if promise is handled (has .catch, .then, or is in try/catch)
+ */
+function isPromiseHandled(node) {
+    // For identifiers, check if they're used in a promise chain
+    if (node.type === 'Identifier') {
+        const parent = node.parent;
+        if (parent &&
+            parent.type === 'MemberExpression' &&
+            parent.object === node) {
+            if (parent.property.type === 'Identifier') {
+                const methodName = parent.property.name;
+                if (methodName === 'catch' ||
+                    methodName === 'then' ||
+                    methodName === 'finally') {
+                    // Check if this MemberExpression is used as a callee (called)
+                    const memberParent = parent.parent;
+                    if (memberParent &&
+                        memberParent.type === 'CallExpression' &&
+                        memberParent.callee === parent) {
+                        // Promise is handled by .then(), .catch(), or .finally()
+                        return true;
+                    }
+                }
+            }
+        }
+    }
+    // For CallExpressions, traverse up the AST to find if this promise is part of a handled chain
+    let current = node;
+    let depth = 0;
+    const maxDepth = 10;
+    while (current && depth < maxDepth) {
+        const parent = current
+            .parent;
+        if (!parent)
+            break;
+        // Check if parent is a MemberExpression with .catch/.then/.finally
+        if (parent.type === 'MemberExpression' && parent.object === current) {
+            if (parent.property.type === 'Identifier') {
+                const methodName = parent.property.name;
+                if (methodName === 'catch' ||
+                    methodName === 'then' ||
+                    methodName === 'finally') {
+                    // Check if this MemberExpression is used as a callee (called)
+                    const memberParent = parent.parent;
+                    if (memberParent &&
+                        memberParent.type === 'CallExpression' &&
+                        memberParent.callee === parent) {
+                        // Promise is handled by .then(), .catch(), or .finally()
+                        return true;
+                    }
+                }
+            }
+        }
+        // Check if in try/catch block
+        if (parent.type === 'TryStatement') {
+            return true;
+        }
+        // Check if in await expression
+        if (parent.type === 'AwaitExpression') {
+            return true;
+        }
+        current = parent;
+        depth++;
+    }
+    return false;
+}
+exports.noUnhandledPromise = (0, eslint_devkit_2.createRule)({
+    name: 'no-unhandled-promise',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Detects unhandled Promise rejections',
+        },
+        hasSuggestions: true,
+        messages: {
+            unhandledPromise: (0, eslint_devkit_1.formatLLMMessage)({
+                icon: eslint_devkit_1.MessageIcons.WARNING,
+                issueName: 'Unhandled promise',
+                cwe: 'CWE-1024',
+                description: 'Unhandled Promise rejection detected',
+                severity: 'HIGH',
+                fix: 'Add .catch() handler or use try/catch with await',
+                documentationLink: 'https://rules.sonarsource.com/javascript/RSPEC-4635/',
+            }),
+            addCatch: (0, eslint_devkit_1.formatLLMMessage)({
+                icon: eslint_devkit_1.MessageIcons.INFO,
+                issueName: 'Add catch handler',
+                description: 'Add .catch() handler to promise',
+                severity: 'LOW',
+                fix: 'promise.catch(error => console.error(error))',
+                documentationLink: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/catch',
+            }),
+            useTryCatch: (0, eslint_devkit_1.formatLLMMessage)({
+                icon: eslint_devkit_1.MessageIcons.INFO,
+                issueName: 'Use try/catch',
+                description: 'Use try/catch with await',
+                severity: 'LOW',
+                fix: 'try { await promise; } catch (error) { handle(error); }',
+                documentationLink: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/try...catch',
+            }),
+            useAwait: (0, eslint_devkit_1.formatLLMMessage)({
+                icon: eslint_devkit_1.MessageIcons.INFO,
+                issueName: 'Use await',
+                description: 'Use await to handle promise',
+                severity: 'LOW',
+                fix: 'await promise;',
+                documentationLink: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/await',
+            }),
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    ignoreInTests: {
+                        type: 'boolean',
+                        default: true,
+                        description: 'Ignore promises in test files',
+                    },
+                    ignoreVoidExpressions: {
+                        type: 'boolean',
+                        default: false,
+                        description: 'Ignore promises in void expressions',
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [
+        {
+            ignoreInTests: true,
+            ignoreVoidExpressions: false,
+        },
+    ],
+    create(context, [options = {}]) {
+        const { ignoreInTests = true, ignoreVoidExpressions = false } = options || {};
+        const filename = context.getFilename();
+        const isTestFile = ignoreInTests && /\.(test|spec)\.(ts|tsx|js|jsx)$/.test(filename);
+        if (isTestFile) {
+            return {};
+        }
+        // const sourceCode = context.sourceCode || context.sourceCode; // Not used
+        /**
+         * Check call expressions for unhandled promises
+         */
+        function checkCallExpression(node) {
+            // Skip CallExpressions that are inside promise chain callbacks
+            if (isInsidePromiseCallback(node)) {
+                return;
+            }
+            // Skip calls to promise methods (.then, .catch, .finally) as they are handled by definition
+            // But only if they have meaningful callbacks
+            if (node.callee.type === 'MemberExpression' &&
+                node.callee.property.type === 'Identifier') {
+                const methodName = node.callee.property.name;
+                if (methodName === 'then' ||
+                    methodName === 'catch' ||
+                    methodName === 'finally') {
+                    // Check if the callback is empty or meaningless
+                    if (node.arguments.length > 0 &&
+                        node.arguments[0].type === 'ArrowFunctionExpression') {
+                        const callback = node.arguments[0];
+                        if (callback.body.type === 'BlockStatement' &&
+                            callback.body.body.length === 0) {
+                            // Empty callback - don't skip, this should be flagged
+                        }
+                        else {
+                            return; // Has meaningful callback, skip
+                        }
+                    }
+                    else {
+                        return; // Not an arrow function callback, assume it's handled
+                    }
+                }
+            }
+            // Check if it's a promise-returning function
+            if (!isPromiseExpression(node)) {
+                return;
+            }
+            // Check if it's already handled
+            if (isPromiseHandled(node)) {
+                return;
+            }
+            // Check if it's in a void expression
+            if (ignoreVoidExpressions) {
+                const parent = node
+                    .parent;
+                if (parent &&
+                    parent.type === 'UnaryExpression' &&
+                    parent.operator === 'void') {
+                    return;
+                }
+            }
+            // Skip if this CallExpression is an argument to another CallExpression
+            // (e.g., console.log(fetch(url)) - we don't want to flag fetch(url) here)
+            const parent = node
+                .parent;
+            if (parent && parent.type === 'CallExpression') {
+                // Only skip if it's not part of a promise chain
+                // If it's the object of a MemberExpression with .then/.catch/.finally, it's a promise
+                const grandParent = parent.parent;
+                if (!(grandParent &&
+                    grandParent.type === 'MemberExpression' &&
+                    grandParent.object === parent &&
+                    grandParent.property.type === 'Identifier' &&
+                    (grandParent.property.name === 'then' ||
+                        grandParent.property.name === 'catch' ||
+                        grandParent.property.name === 'finally'))) {
+                    return;
+                }
+            }
+            context.report({
+                node,
+                messageId: 'unhandledPromise',
+                suggest: [
+                    {
+                        messageId: 'addCatch',
+                        fix: () => null, // Cannot auto-fix without context
+                    },
+                    {
+                        messageId: 'useTryCatch',
+                        fix: () => null,
+                    },
+                    {
+                        messageId: 'useAwait',
+                        fix: () => null,
+                    },
+                ],
+            });
+        }
+        /**
+         * Check identifier expressions for unhandled promises
+         * Note: Currently unused, keeping for future implementation
+         */
+        /*
+        function checkIdentifier(node: TSESTree.Identifier) {
+          // Skip identifiers that are inside promise chain callbacks
+          if (isInsidePromiseCallback({ type: 'CallExpression', callee: node, arguments: [], optional: false } as TSESTree.CallExpression)) {
+            return;
+          }
+    
+          // Check if it's a promise-like identifier
+          if (!isPromiseExpression(node)) {
+            return;
+          }
+    
+          // Check if it's already handled
+          if (isPromiseHandled(node)) {
+            return;
+          }
+    
+          // Check if it's in a void expression
+          if (ignoreVoidExpressions) {
+            const parent = (node as TSESTree.Node & { parent?: TSESTree.Node }).parent;
+            if (parent && parent.type === 'UnaryExpression' && parent.operator === 'void') {
+              return;
+            }
+          }
+    
+          context.report({
+            node,
+            messageId: 'unhandledPromise',
+            suggest: [
+              {
+                messageId: 'addCatch',
+                fix: () => null,
+              },
+              {
+                messageId: 'useTryCatch',
+                fix: () => null,
+              },
+              {
+                messageId: 'useAwait',
+                fix: () => null,
+              },
+            ],
+          });
+        }
+        */
+        return {
+            CallExpression: checkCallExpression,
+        };
+    },
+});

package/src/rules/reliability/no-await-in-loop.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) 2025 Ofri Peretz
+ * Licensed under the MIT License. Use of this source code is governed by the
+ * MIT license that can be found in the LICENSE file.
+ */
+/**
+ * ESLint Rule: no-await-in-loop
+ * Disallow await inside loops without considering concurrency implications (unicorn-inspired)
+ */
+import type { TSESLint } from '@interlace/eslint-devkit';
+type MessageIds = 'awaitInLoop' | 'suggestPromiseAll' | 'suggestConcurrent' | 'considerSequential' | 'asyncLoopPattern';
+export interface Options {
+    /** Allow await in for-of loops */
+    allowForOf?: boolean;
+    /** Allow await in while loops */
+    allowWhile?: boolean;
+    /** Check for potential concurrent execution opportunities */
+    checkConcurrency?: boolean;
+}
+type RuleOptions = [Options?];
+export declare const noAwaitInLoop: TSESLint.RuleModule<MessageIds, RuleOptions, unknown, TSESLint.RuleListener> & {
+    name: string;
+};
+export {};

package/src/rules/reliability/no-await-in-loop.js

@@ -0,0 +1,234 @@
+"use strict";
+/**
+ * Copyright (c) 2025 Ofri Peretz
+ * Licensed under the MIT License. Use of this source code is governed by the
+ * MIT license that can be found in the LICENSE file.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noAwaitInLoop = void 0;
+const eslint_devkit_1 = require("@interlace/eslint-devkit");
+const eslint_devkit_2 = require("@interlace/eslint-devkit");
+exports.noAwaitInLoop = (0, eslint_devkit_1.createRule)({
+    name: 'no-await-in-loop',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow await inside loops and suggest appropriate concurrency patterns',
+        },
+        hasSuggestions: false,
+        messages: {
+            awaitInLoop: (0, eslint_devkit_2.formatLLMMessage)({
+                icon: eslint_devkit_2.MessageIcons.WARNING,
+                issueName: 'Sequential Async Loop',
+                description: 'Await in loop forces sequential execution',
+                severity: 'MEDIUM',
+                fix: 'Consider Promise.all() for concurrent execution or extract async logic',
+                documentationLink: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function',
+            }),
+            suggestPromiseAll: (0, eslint_devkit_2.formatLLMMessage)({
+                icon: eslint_devkit_2.MessageIcons.INFO,
+                issueName: 'Use Promise.all',
+                description: 'Concurrent execution of independent operations',
+                severity: 'LOW',
+                fix: 'Promise.all(items.map(async (item) => await process(item)))',
+                documentationLink: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/all',
+            }),
+            suggestConcurrent: (0, eslint_devkit_2.formatLLMMessage)({
+                icon: eslint_devkit_2.MessageIcons.INFO,
+                issueName: 'Use Promise.allSettled',
+                description: 'Concurrent execution with error handling',
+                severity: 'LOW',
+                fix: 'Promise.allSettled(items.map(async (item) => await process(item)))',
+                documentationLink: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/allSettled',
+            }),
+            considerSequential: (0, eslint_devkit_2.formatLLMMessage)({
+                icon: eslint_devkit_2.MessageIcons.INFO,
+                issueName: 'Sequential Control',
+                description: 'Operations require sequential execution',
+                severity: 'LOW',
+                fix: 'Add concurrency control or extract to async function',
+                documentationLink: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function',
+            }),
+            asyncLoopPattern: (0, eslint_devkit_2.formatLLMMessage)({
+                icon: eslint_devkit_2.MessageIcons.INFO,
+                issueName: 'Async Loop Pattern',
+                description: 'Use controlled concurrency library',
+                severity: 'LOW',
+                fix: 'Consider p-map, p-series, or similar for controlled concurrency',
+                documentationLink: 'https://github.com/sindresorhus/p-map',
+            }),
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    allowForOf: {
+                        type: 'boolean',
+                        default: false,
+                    },
+                    allowWhile: {
+                        type: 'boolean',
+                        default: false,
+                    },
+                    checkConcurrency: {
+                        type: 'boolean',
+                        default: true,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [{ allowForOf: false, allowWhile: false, checkConcurrency: true }],
+    create(context) {
+        const [options] = context.options;
+        const { allowForOf = false, allowWhile = false } = options || {};
+        function analyzeLoop(node, loopType) {
+            // Skip allowed loop types
+            if ((loopType === 'ForOfStatement' && allowForOf) ||
+                (loopType === 'WhileStatement' && allowWhile)) {
+                return;
+            }
+            // Find await expressions within the loop
+            const awaitExpressions = [];
+            // Properties to skip to avoid circular references
+            const skipProperties = new Set(['parent', 'tokens', 'comments', 'loc', 'range']);
+            function findAwaits(currentNode) {
+                if (currentNode.type === 'AwaitExpression') {
+                    awaitExpressions.push(currentNode);
+                }
+                // Don't traverse into nested functions (different scope)
+                if (currentNode.type !== 'FunctionDeclaration' &&
+                    currentNode.type !== 'FunctionExpression' &&
+                    currentNode.type !== 'ArrowFunctionExpression') {
+                    for (const key in currentNode) {
+                        if (skipProperties.has(key))
+                            continue;
+                        const child = currentNode[key];
+                        if (Array.isArray(child)) {
+                            child.forEach(item => {
+                                if (item && typeof item === 'object' && 'type' in item) {
+                                    findAwaits(item);
+                                }
+                            });
+                        }
+                        else if (child && typeof child === 'object' && 'type' in child) {
+                            findAwaits(child);
+                        }
+                    }
+                }
+            }
+            findAwaits(node);
+            if (awaitExpressions.length > 0) {
+                // Analyze the loop context to determine the best suggestion
+                const loopContext = analyzeLoopContext(node, loopType);
+                for (const awaitExpr of awaitExpressions) {
+                    context.report({
+                        node: awaitExpr,
+                        messageId: 'awaitInLoop',
+                        data: {
+                            loopType: loopContext.loopType,
+                            operations: loopContext.operationCount,
+                            suggestion: getSuggestion(loopContext),
+                            performance: loopContext.estimatedPerformance,
+                        },
+                    });
+                }
+            }
+        }
+        function analyzeLoopContext(node, loopType) {
+            const context = {
+                loopType,
+                operationCount: 1,
+                hasDependencies: false,
+                isSequential: true,
+                hasSideEffects: false,
+                estimatedPerformance: 'unknown',
+                operations: [],
+                node,
+            };
+            // Properties to skip to avoid circular references
+            const skipProps = new Set(['parent', 'tokens', 'comments', 'loc', 'range']);
+            // Analyze what operations are being performed in the loop
+            function analyzeOperations(currentNode) {
+                if (currentNode.type === 'CallExpression') {
+                    if (currentNode.callee.type === 'Identifier') {
+                        context.operations.push(currentNode.callee.name);
+                    }
+                    else if (currentNode.callee.type === 'MemberExpression' &&
+                        currentNode.callee.property.type === 'Identifier') {
+                        context.operations.push(currentNode.callee.property.name);
+                    }
+                }
+                // Check for dependencies between iterations
+                if (currentNode.type === 'AssignmentExpression' ||
+                    currentNode.type === 'UpdateExpression') {
+                    context.hasDependencies = true;
+                }
+                // Check for side effects that might require sequential execution
+                if (currentNode.type === 'CallExpression' &&
+                    (context.operations.includes('push') ||
+                        context.operations.includes('splice') ||
+                        context.operations.includes('delete'))) {
+                    context.hasSideEffects = true;
+                }
+                // Count operations
+                if (currentNode.type === 'AwaitExpression') {
+                    context.operationCount++;
+                }
+                // Recursively analyze
+                for (const key in currentNode) {
+                    if (skipProps.has(key))
+                        continue;
+                    const child = currentNode[key];
+                    if (Array.isArray(child)) {
+                        child.forEach(item => {
+                            if (item && typeof item === 'object' && 'type' in item) {
+                                analyzeOperations(item);
+                            }
+                        });
+                    }
+                    else if (child && typeof child === 'object' && 'type' in child) {
+                        analyzeOperations(child);
+                    }
+                }
+            }
+            analyzeOperations(node);
+            // Determine if operations can be concurrent
+            if (context.hasDependencies || context.hasSideEffects) {
+                context.isSequential = true;
+                context.estimatedPerformance = `sequential (${context.operationCount} operations)`;
+            }
+            else {
+                context.isSequential = false;
+                context.estimatedPerformance = `potential ${context.operationCount}x speedup with concurrency`;
+            }
+            return context;
+        }
+        function getSuggestion(context) {
+            if (context.isSequential) {
+                return 'operations may need to be sequential - consider if concurrency is safe';
+            }
+            else {
+                return 'operations appear independent - consider Promise.all() for concurrency';
+            }
+        }
+        return {
+            ForStatement(node) {
+                analyzeLoop(node, 'ForStatement');
+            },
+            ForInStatement(node) {
+                analyzeLoop(node, 'ForInStatement');
+            },
+            ForOfStatement(node) {
+                analyzeLoop(node, 'ForOfStatement');
+            },
+            WhileStatement(node) {
+                analyzeLoop(node, 'WhileStatement');
+            },
+            DoWhileStatement(node) {
+                analyzeLoop(node, 'DoWhileStatement');
+            },
+        };
+    },
+});

package/src/rules/reliability/no-missing-null-checks.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) 2025 Ofri Peretz
+ * Licensed under the MIT License. Use of this source code is governed by the
+ * MIT license that can be found in the LICENSE file.
+ */
+/**
+ * ESLint Rule: no-missing-null-checks
+ * Detects potential null pointer dereferences
+ * CWE-476: NULL Pointer Dereference
+ *
+ * @see https://cwe.mitre.org/data/definitions/476.html
+ * @see https://rules.sonarsource.com/javascript/RSPEC-2259/
+ */
+import type { TSESLint } from '@interlace/eslint-devkit';
+type MessageIds = 'missingNullCheck' | 'useOptionalChaining' | 'useNullishCoalescing' | 'addExplicitCheck';
+export interface Options {
+    /** Ignore in test files. Default: true */
+    ignoreInTests?: boolean;
+    /** Require explicit null checks. Default: false */
+    requireExplicitChecks?: boolean;
+}
+type RuleOptions = [Options?];
+export declare const noMissingNullChecks: TSESLint.RuleModule<MessageIds, RuleOptions, unknown, TSESLint.RuleListener> & {
+    name: string;
+};
+export {};