eslint-plugin-maintainability 3.0.0

package/src/rules/error-handling/error-message.js

@@ -0,0 +1,146 @@
+"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.errorMessage = void 0;
+const eslint_devkit_1 = require("@interlace/eslint-devkit");
+const eslint_devkit_2 = require("@interlace/eslint-devkit");
+exports.errorMessage = (0, eslint_devkit_1.createRule)({
+    name: 'error-message',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce providing a message when creating built-in Error objects for better debugging',
+        },
+        hasSuggestions: true,
+        messages: {
+            missingErrorMessage: (0, eslint_devkit_2.formatLLMMessage)({
+                icon: eslint_devkit_2.MessageIcons.INFO,
+                issueName: 'Missing Error Message',
+                description: 'Error constructor called without message parameter',
+                severity: 'HIGH',
+                fix: 'Add descriptive error message: new Error("description")',
+                documentationLink: 'https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/error-message.md',
+            }),
+            addErrorMessage: (0, eslint_devkit_2.formatLLMMessage)({
+                icon: eslint_devkit_2.MessageIcons.WARNING,
+                issueName: 'Add Error Message',
+                description: 'Add descriptive error message to constructor',
+                severity: 'HIGH',
+                fix: 'Add descriptive error message: new Error("description")',
+                documentationLink: 'https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/error-message.md',
+            }),
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    allowEmptyCatch: {
+                        type: 'boolean',
+                        default: false,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [{ allowEmptyCatch: false }],
+    create(context) {
+        const [options] = context.options;
+        const { allowEmptyCatch = false } = options || {};
+        // Built-in Error constructors that should have messages
+        const errorConstructors = new Set([
+            'Error',
+            'TypeError',
+            'ReferenceError',
+            'SyntaxError',
+            'RangeError',
+            'EvalError',
+            'URIError',
+        ]);
+        function isErrorConstructor(name) {
+            return errorConstructors.has(name);
+        }
+        function hasMessageArgument(node) {
+            // Check if there are arguments
+            if (!node.arguments || node.arguments.length === 0) {
+                return false;
+            }
+            // Check if first argument is a non-empty string or expression
+            const firstArg = node.arguments[0];
+            if (firstArg.type === 'Literal') {
+                // Allow non-empty strings
+                return (typeof firstArg.value === 'string' && firstArg.value.trim().length > 0);
+            }
+            // Allow any expression (variable, function call, etc.) as it might be dynamic
+            return true;
+        }
+        function isInCatchClause(node) {
+            let current = node;
+            while (current) {
+                if (current.type === 'CatchClause') {
+                    return true;
+                }
+                current = current.parent;
+            }
+            return false;
+        }
+        function checkErrorCreation(node) {
+            let constructorName = null;
+            if (node.type === 'NewExpression') {
+                // new Error(...)
+                if (node.callee.type === 'Identifier') {
+                    constructorName = node.callee.name;
+                }
+            }
+            else if (node.type === 'CallExpression') {
+                // Error(...) - function call style
+                if (node.callee.type === 'Identifier') {
+                    constructorName = node.callee.name;
+                }
+            }
+            if (!constructorName || !isErrorConstructor(constructorName)) {
+                return;
+            }
+            // Allow empty catch if option is enabled
+            if (allowEmptyCatch && isInCatchClause(node)) {
+                return;
+            }
+            // Check if message is provided
+            if (!hasMessageArgument(node)) {
+                context.report({
+                    node,
+                    messageId: 'missingErrorMessage',
+                    data: {
+                        constructor: constructorName,
+                    },
+                    suggest: [
+                        {
+                            messageId: 'addErrorMessage',
+                            data: { constructor: constructorName },
+                            fix(fixer) {
+                                if (node.arguments.length === 0) {
+                                    // No arguments: replace the empty parentheses with ("Error message")
+                                    const parenStart = node.callee.range[1];
+                                    const parenEnd = node.range[1];
+                                    return fixer.replaceTextRange([parenStart, parenEnd], '("Error message")');
+                                }
+                                else {
+                                    // Has arguments: replace the first argument with "Error message"
+                                    return fixer.replaceText(node.arguments[0], '"Error message"');
+                                }
+                            },
+                        },
+                    ],
+                });
+            }
+        }
+        return {
+            NewExpression: checkErrorCreation,
+            CallExpression: checkErrorCreation,
+        };
+    },
+});

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 {};