eslint-plugin-reliability 3.0.0

package/src/rules/error-handling/no-missing-error-context.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-error-context
+ * Detects thrown errors without context
+ *
+ * @see https://rules.sonarsource.com/javascript/RSPEC-1128/
+ */
+import type { TSESLint } from '@interlace/eslint-devkit';
+type MessageIds = 'missingErrorContext' | 'addErrorMessage' | 'addErrorStack' | 'useErrorClass';
+export interface Options {
+    /** Require error message. Default: true */
+    requireMessage?: boolean;
+    /** Require stack trace. Default: false */
+    requireStackTrace?: boolean;
+    /** Ignore in test files. Default: true */
+    ignoreInTests?: boolean;
+}
+type RuleOptions = [Options?];
+export declare const noMissingErrorContext: TSESLint.RuleModule<MessageIds, RuleOptions, unknown, TSESLint.RuleListener> & {
+    name: string;
+};
+export {};

package/src/rules/error-handling/no-missing-error-context.js

@@ -0,0 +1,183 @@
+"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.noMissingErrorContext = void 0;
+const eslint_devkit_1 = require("@interlace/eslint-devkit");
+const eslint_devkit_2 = require("@interlace/eslint-devkit");
+/**
+ * Check if error has a message
+ */
+function hasErrorMessage(node) {
+    if (!node.argument) {
+        return false;
+    }
+    // Check if it's a new Error() with message (includes TypeError, ReferenceError, etc.)
+    if (node.argument.type === 'NewExpression' &&
+        node.argument.callee.type === 'Identifier' &&
+        (node.argument.callee.name === 'Error' ||
+            node.argument.callee.name.endsWith('Error'))) {
+        // Check if first argument is a string (message)
+        if (node.argument.arguments.length > 0) {
+            const firstArg = node.argument.arguments[0];
+            if (firstArg.type === 'Literal' && typeof firstArg.value === 'string') {
+                return firstArg.value.length > 0;
+            }
+            if (firstArg.type === 'TemplateLiteral') {
+                return true;
+            }
+        }
+    }
+    // Check if it's a string literal
+    if (node.argument.type === 'Literal' &&
+        typeof node.argument.value === 'string') {
+        return node.argument.value.length > 0;
+    }
+    // Check if it's a template literal
+    if (node.argument.type === 'TemplateLiteral') {
+        return true;
+    }
+    return false;
+}
+/**
+ * Check if error is an Error instance (has stack trace)
+ */
+function hasErrorStack(node) {
+    if (!node.argument) {
+        return false;
+    }
+    // Check if it's a new Error() instance
+    if (node.argument.type === 'NewExpression' &&
+        node.argument.callee.type === 'Identifier') {
+        const calleeName = node.argument.callee.name;
+        // Error, TypeError, ReferenceError, etc. all have stack traces
+        if (calleeName === 'Error' || calleeName.endsWith('Error')) {
+            return true;
+        }
+    }
+    return false;
+}
+exports.noMissingErrorContext = (0, eslint_devkit_2.createRule)({
+    name: 'no-missing-error-context',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Detects thrown errors without context',
+        },
+        hasSuggestions: true,
+        messages: {
+            missingErrorContext: (0, eslint_devkit_1.formatLLMMessage)({
+                icon: eslint_devkit_1.MessageIcons.WARNING,
+                issueName: 'Missing error context',
+                description: 'Thrown error missing {{missing}}',
+                severity: 'MEDIUM',
+                fix: 'Add error message and use Error class for stack trace',
+                documentationLink: 'https://rules.sonarsource.com/javascript/RSPEC-1128/',
+            }),
+            addErrorMessage: (0, eslint_devkit_1.formatLLMMessage)({
+                icon: eslint_devkit_1.MessageIcons.INFO,
+                issueName: 'Add Error Message',
+                description: 'Add descriptive error message',
+                severity: 'LOW',
+                fix: 'throw new Error("descriptive message")',
+                documentationLink: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error',
+            }),
+            addErrorStack: (0, eslint_devkit_1.formatLLMMessage)({
+                icon: eslint_devkit_1.MessageIcons.INFO,
+                issueName: 'Use Error Class',
+                description: 'Use Error class for stack trace',
+                severity: 'LOW',
+                fix: 'throw new Error(message) instead of throw message',
+                documentationLink: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error',
+            }),
+            useErrorClass: (0, eslint_devkit_1.formatLLMMessage)({
+                icon: eslint_devkit_1.MessageIcons.INFO,
+                issueName: 'Use Specific Error',
+                description: 'Use specific error class',
+                severity: 'LOW',
+                fix: 'throw new TypeError("message") or throw new RangeError("message")',
+                documentationLink: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypeError',
+            }),
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    requireMessage: {
+                        type: 'boolean',
+                        default: true,
+                        description: 'Require error message',
+                    },
+                    requireStackTrace: {
+                        type: 'boolean',
+                        default: false,
+                        description: 'Require stack trace',
+                    },
+                    ignoreInTests: {
+                        type: 'boolean',
+                        default: true,
+                        description: 'Ignore in test files',
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [
+        {
+            requireMessage: true,
+            requireStackTrace: false,
+            ignoreInTests: true,
+        },
+    ],
+    create(context, [options = {}]) {
+        const { requireMessage = true, requireStackTrace = false, ignoreInTests = true, } = options || {};
+        const filename = context.getFilename();
+        const isTestFile = ignoreInTests && /\.(test|spec)\.(ts|tsx|js|jsx)$/.test(filename);
+        if (isTestFile) {
+            return {};
+        }
+        /**
+         * Check throw statements
+         */
+        function checkThrowStatement(node) {
+            const missing = [];
+            if (requireMessage && !hasErrorMessage(node)) {
+                missing.push('message');
+            }
+            if (requireStackTrace && !hasErrorStack(node)) {
+                missing.push('stack trace');
+            }
+            if (missing.length === 0) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: 'missingErrorContext',
+                data: {
+                    missing: missing.join(' and '),
+                },
+                suggest: [
+                    {
+                        messageId: 'addErrorMessage',
+                        fix: () => null, // Cannot auto-fix without context
+                    },
+                    {
+                        messageId: 'addErrorStack',
+                        fix: () => null,
+                    },
+                    {
+                        messageId: 'useErrorClass',
+                        fix: () => null,
+                    },
+                ],
+            });
+        }
+        return {
+            ThrowStatement: checkThrowStatement,
+        };
+    },
+});

package/src/rules/error-handling/no-silent-errors.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-silent-errors
+ * Detects empty catch blocks
+ *
+ * @see https://rules.sonarsource.com/javascript/RSPEC-1186/
+ */
+import type { TSESLint } from '@interlace/eslint-devkit';
+type MessageIds = 'silentError' | 'addErrorLogging' | 'addErrorHandling' | 'rethrowError';
+export interface Options {
+    /** Allow empty catch if comment explains why. Default: false */
+    allowWithComment?: boolean;
+    /** Ignore in test files. Default: true */
+    ignoreInTests?: boolean;
+}
+type RuleOptions = [Options?];
+export declare const noSilentErrors: TSESLint.RuleModule<MessageIds, RuleOptions, unknown, TSESLint.RuleListener> & {
+    name: string;
+};
+export {};

package/src/rules/error-handling/no-silent-errors.js

@@ -0,0 +1,178 @@
+"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.noSilentErrors = void 0;
+const eslint_devkit_1 = require("@interlace/eslint-devkit");
+const eslint_devkit_2 = require("@interlace/eslint-devkit");
+/**
+ * Check if catch block is empty or only has comments
+ */
+function isEmptyCatchBlock(catchClause) {
+    const body = catchClause.body;
+    /* v8 ignore next 3 -- defensive: catch clause body is always BlockStatement in valid JS */
+    if (!body || body.type !== 'BlockStatement') {
+        return true;
+    }
+    // Check if body only has comments or is empty
+    const statements = body.body;
+    if (statements.length === 0) {
+        return true;
+    }
+    // Check if all statements are just comments (not possible in AST, but check for empty statements)
+    const nonEmptyStatements = statements.filter((stmt) => stmt.type !== 'EmptyStatement');
+    return nonEmptyStatements.length === 0;
+}
+/**
+ * Check if catch block has a comment explaining why it's empty
+ */
+function hasExplanatoryComment(catchClause, sourceCode) {
+    // Check for comments before the catch clause
+    const comments = sourceCode.getAllComments();
+    const catchStart = catchClause.loc?.start;
+    /* v8 ignore next 3 -- defensive: catch clause always has location, and no comments = no match */
+    if (!catchStart || !comments.length) {
+        return false;
+    }
+    // Look for explanatory comments near the catch clause
+    const explanatoryPatterns = [
+        /intentional/i,
+        /expected/i,
+        /ignore/i,
+        /silent/i,
+        /noop/i,
+        /no-op/i,
+        /by design/i,
+        /known issue/i,
+        /legacy/i,
+        /third.?party/i,
+        /framework/i,
+        /library/i,
+        /not implemented/i,
+        /todo/i,
+        /fixme/i,
+    ];
+    // Check comments before the catch clause (within 2 lines)
+    for (const comment of comments) {
+        if (comment.loc && catchStart.line - comment.loc.end.line <= 2) {
+            const commentText = comment.value.toLowerCase();
+            if (explanatoryPatterns.some((pattern) => pattern.test(commentText))) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+exports.noSilentErrors = (0, eslint_devkit_2.createRule)({
+    name: 'no-silent-errors',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Detects empty catch blocks',
+        },
+        hasSuggestions: true,
+        messages: {
+            silentError: (0, eslint_devkit_1.formatLLMMessage)({
+                icon: eslint_devkit_1.MessageIcons.WARNING,
+                issueName: 'Silent error',
+                description: 'Empty catch block detected - errors are silently ignored',
+                severity: 'MEDIUM',
+                fix: 'Add error logging or handling in catch block',
+                documentationLink: 'https://rules.sonarsource.com/javascript/RSPEC-1186/',
+            }),
+            addErrorLogging: (0, eslint_devkit_1.formatLLMMessage)({
+                icon: eslint_devkit_1.MessageIcons.INFO,
+                issueName: 'Add Error Logging',
+                description: 'Add error logging to catch block',
+                severity: 'LOW',
+                fix: 'catch (error) { console.error(error); }',
+                documentationLink: 'https://rules.sonarsource.com/javascript/RSPEC-1186/',
+            }),
+            addErrorHandling: (0, eslint_devkit_1.formatLLMMessage)({
+                icon: eslint_devkit_1.MessageIcons.INFO,
+                issueName: 'Add Error Handling',
+                description: 'Add error handling to catch block',
+                severity: 'LOW',
+                fix: 'catch (error) { handleError(error); }',
+                documentationLink: 'https://rules.sonarsource.com/javascript/RSPEC-1186/',
+            }),
+            rethrowError: (0, eslint_devkit_1.formatLLMMessage)({
+                icon: eslint_devkit_1.MessageIcons.INFO,
+                issueName: 'Rethrow Error',
+                description: 'Rethrow error if needed',
+                severity: 'LOW',
+                fix: 'catch (error) { throw new CustomError(error); }',
+                documentationLink: 'https://rules.sonarsource.com/javascript/RSPEC-1186/',
+            }),
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    allowWithComment: {
+                        type: 'boolean',
+                        default: false,
+                        description: 'Allow empty catch if comment explains why',
+                    },
+                    ignoreInTests: {
+                        type: 'boolean',
+                        default: true,
+                        description: 'Ignore in test files',
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [
+        {
+            allowWithComment: false,
+            ignoreInTests: true,
+        },
+    ],
+    create(context, [options = {}]) {
+        const { allowWithComment = false, ignoreInTests = true } = 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;
+        /**
+         * Check catch clauses
+         */
+        function checkCatchClause(node) {
+            if (!isEmptyCatchBlock(node)) {
+                return;
+            }
+            // Check if comment explains why it's empty
+            if (allowWithComment && hasExplanatoryComment(node, sourceCode)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: 'silentError',
+                suggest: [
+                    {
+                        messageId: 'addErrorLogging',
+                        fix: () => null, // Cannot auto-fix without context
+                    },
+                    {
+                        messageId: 'addErrorHandling',
+                        fix: () => null,
+                    },
+                    {
+                        messageId: 'rethrowError',
+                        fix: () => null,
+                    },
+                ],
+            });
+        }
+        return {
+            CatchClause: checkCatchClause,
+        };
+    },
+});

package/src/rules/error-handling/no-unhandled-promise.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-unhandled-promise
+ * Detects unhandled Promise rejections
+ * CWE-1024: Comparison of Classes by Name
+ *
+ * @see https://cwe.mitre.org/data/definitions/1024.html
+ * @see https://rules.sonarsource.com/javascript/RSPEC-4635/
+ */
+import type { TSESLint } from '@interlace/eslint-devkit';
+type MessageIds = 'unhandledPromise' | 'addCatch' | 'useTryCatch' | 'useAwait';
+export interface Options {
+    /** Ignore promises in test files. Default: true */
+    ignoreInTests?: boolean;
+    /** Ignore promises in void expressions. Default: false */
+    ignoreVoidExpressions?: boolean;
+}
+type RuleOptions = [Options?];
+export declare const noUnhandledPromise: TSESLint.RuleModule<MessageIds, RuleOptions, unknown, TSESLint.RuleListener> & {
+    name: string;
+};
+export {};