@blumintinc/eslint-plugin-blumint 1.12.6 → 1.14.0

package/lib/rules/no-overridable-method-calls-in-constructor.js

@@ -0,0 +1,272 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noOverridableMethodCallsInConstructor = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const getMethodName_1 = require("../utils/getMethodName");
+exports.noOverridableMethodCallsInConstructor = (0, createRule_1.createRule)({
+    name: 'no-overridable-method-calls-in-constructor',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow calling overridable methods in constructors to prevent unexpected behavior',
+            recommended: 'error',
+        },
+        fixable: undefined,
+        schema: [],
+        messages: {
+            noOverridableMethodCallsInConstructor: 'What\'s wrong: Constructor calls overridable or abstract {{target}} member "{{methodName}}". \u2192 Why it matters: This executes subclass overrides before the subclass constructor finishes initializing its fields, which can read undefined state or run side effects on a partially constructed instance. \u2192 How to fix: Move the call to a post-construction initializer, or make "{{methodName}}" private or static so construction never executes overridable code.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const sourceCode = context.getSourceCode();
+        /**
+         * Checks if a method is overridable (not private and not static)
+         */
+        function isOverridableMethod(node) {
+            // Private methods are not overridable
+            if (node.accessibility === 'private') {
+                return false;
+            }
+            // ES private methods (#foo) are non-overridable
+            if (node.key.type === utils_1.AST_NODE_TYPES.PrivateIdentifier) {
+                return false;
+            }
+            // Static methods are not overridable in the same way as instance methods
+            if (node.static) {
+                return false;
+            }
+            return true;
+        }
+        /**
+         * Checks if a method is abstract
+         */
+        function isAbstractMethod(node) {
+            return node.abstract === true;
+        }
+        /**
+         * Collects all method names from a class, categorized by whether they are overridable
+         */
+        function collectMethodNames(classNode) {
+            const overridableMethods = new Set();
+            const abstractMethods = new Set();
+            for (const member of classNode.body.body) {
+                if (member.type === utils_1.AST_NODE_TYPES.MethodDefinition) {
+                    const methodName = getMethodNameFromDefinition(member);
+                    if (methodName) {
+                        if (isAbstractMethod(member)) {
+                            abstractMethods.add(methodName);
+                        }
+                        else if (isOverridableMethod(member)) {
+                            overridableMethods.add(methodName);
+                        }
+                    }
+                }
+                else if (member.type === utils_1.AST_NODE_TYPES.TSAbstractMethodDefinition) {
+                    const methodName = getMethodNameFromDefinition(member);
+                    if (methodName) {
+                        abstractMethods.add(methodName);
+                    }
+                }
+            }
+            return { overridableMethods, abstractMethods };
+        }
+        /**
+         * Gets the method name from a method definition
+         */
+        function getMethodNameFromDefinition(method) {
+            const name = (0, getMethodName_1.getMethodName)(method, sourceCode, {
+                computedFallbackToText: false,
+            });
+            return name || null; // Computed property names are not handled
+        }
+        /**
+         * Checks if a call expression is calling a method on 'this' or 'super'
+         */
+        function isThisOrSuperMethodCall(node) {
+            if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                !node.callee.computed // Ignore computed properties like this[methodName]()
+            ) {
+                const object = node.callee.object;
+                const property = node.callee.property;
+                // Check if it's a call on 'this'
+                if (object.type === utils_1.AST_NODE_TYPES.ThisExpression &&
+                    property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    return {
+                        isMethodCall: true,
+                        methodName: property.name,
+                        isSuper: false,
+                    };
+                }
+                // Check if it's a call on 'super'
+                if (object.type === utils_1.AST_NODE_TYPES.Super &&
+                    property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    return {
+                        isMethodCall: true,
+                        methodName: property.name,
+                        isSuper: true,
+                    };
+                }
+                // Check for method chaining: this.method().anotherMethod()
+                // In this case, object is a CallExpression
+                if (object.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                    const nestedCall = isThisOrSuperMethodCall(object);
+                    if (nestedCall.isMethodCall) {
+                        return nestedCall; // Return the nested method call info
+                    }
+                }
+            }
+            return { isMethodCall: false, methodName: null, isSuper: false };
+        }
+        /**
+         * Checks if a member expression is accessing a property on 'this' or 'super'
+         */
+        function isThisOrSuperPropertyAccess(node) {
+            if (!node.computed) {
+                // Ignore computed properties like this[propertyName]
+                const object = node.object;
+                const property = node.property;
+                // Check if it's access on 'this'
+                if (object.type === utils_1.AST_NODE_TYPES.ThisExpression &&
+                    property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    // Skip 'constructor' property as it's not an overridable method
+                    if (property.name === 'constructor') {
+                        return {
+                            isPropertyAccess: false,
+                            propertyName: null,
+                            isSuper: false,
+                        };
+                    }
+                    return {
+                        isPropertyAccess: true,
+                        propertyName: property.name,
+                        isSuper: false,
+                    };
+                }
+                // Check if it's access on 'super'
+                if (object.type === utils_1.AST_NODE_TYPES.Super &&
+                    property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    return {
+                        isPropertyAccess: true,
+                        propertyName: property.name,
+                        isSuper: true,
+                    };
+                }
+            }
+            return { isPropertyAccess: false, propertyName: null, isSuper: false };
+        }
+        return {
+            // Process class declarations and expressions
+            'ClassDeclaration, ClassExpression'(node) {
+                const { overridableMethods, abstractMethods } = collectMethodNames(node);
+                // Find the constructor method
+                const ctorMethod = node.body.body.find((member) => member.type === utils_1.AST_NODE_TYPES.MethodDefinition &&
+                    member.kind === 'constructor');
+                if (!ctorMethod || !ctorMethod.value.body) {
+                    return; // No constructor or constructor has no body
+                }
+                // Function to recursively check for method calls in the constructor
+                function checkForMethodCalls(bodyNode) {
+                    if (!bodyNode || typeof bodyNode !== 'object') {
+                        return;
+                    }
+                    // Check for method calls
+                    if (bodyNode.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                        const { isMethodCall, methodName, isSuper } = isThisOrSuperMethodCall(bodyNode);
+                        if (isMethodCall && methodName) {
+                            // Abstract methods are always a problem when called from constructor
+                            // This includes super calls to abstract methods
+                            if (abstractMethods.has(methodName)) {
+                                context.report({
+                                    node: bodyNode,
+                                    messageId: 'noOverridableMethodCallsInConstructor',
+                                    data: {
+                                        methodName,
+                                        target: isSuper ? 'super' : 'this',
+                                    },
+                                });
+                            }
+                            // Overridable methods are a problem when called on 'this'
+                            else if (overridableMethods.has(methodName) && !isSuper) {
+                                context.report({
+                                    node: bodyNode,
+                                    messageId: 'noOverridableMethodCallsInConstructor',
+                                    data: {
+                                        methodName,
+                                        target: 'this',
+                                    },
+                                });
+                            }
+                        }
+                    }
+                    // Check for property access (getters/setters) - only if not part of a call expression
+                    else if (bodyNode.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                        // Check if this MemberExpression is the callee of a CallExpression
+                        // If so, skip it as it will be handled by the CallExpression check
+                        const parent = bodyNode.parent;
+                        if (parent &&
+                            parent.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                            parent.callee === bodyNode) {
+                            return; // Skip this MemberExpression as it's part of a method call
+                        }
+                        const { isPropertyAccess, propertyName, isSuper } = isThisOrSuperPropertyAccess(bodyNode);
+                        if (isPropertyAccess && propertyName) {
+                            // Abstract methods are always a problem when accessed from constructor
+                            if (abstractMethods.has(propertyName)) {
+                                context.report({
+                                    node: bodyNode,
+                                    messageId: 'noOverridableMethodCallsInConstructor',
+                                    data: {
+                                        methodName: propertyName,
+                                        target: isSuper ? 'super' : 'this',
+                                    },
+                                });
+                            }
+                            // Overridable methods are a problem when accessed on 'this'
+                            else if (overridableMethods.has(propertyName) && !isSuper) {
+                                context.report({
+                                    node: bodyNode,
+                                    messageId: 'noOverridableMethodCallsInConstructor',
+                                    data: {
+                                        methodName: propertyName,
+                                        target: 'this',
+                                    },
+                                });
+                            }
+                        }
+                    }
+                    // Avoid circular references by not checking 'parent' property
+                    const keysToSkip = new Set(['parent', 'loc', 'range']);
+                    // Don't traverse into function expressions or arrow functions as they create new scopes
+                    if (bodyNode.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+                        bodyNode.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                        bodyNode.type === utils_1.AST_NODE_TYPES.FunctionDeclaration) {
+                        return;
+                    }
+                    // Recursively check all child nodes
+                    for (const key in bodyNode) {
+                        if (keysToSkip.has(key))
+                            continue;
+                        const child = bodyNode[key];
+                        if (child && typeof child === 'object') {
+                            if ('type' in child) {
+                                checkForMethodCalls(child);
+                            }
+                            else if (Array.isArray(child)) {
+                                child.forEach((item) => {
+                                    if (item && typeof item === 'object' && 'type' in item) {
+                                        checkForMethodCalls(item);
+                                    }
+                                });
+                            }
+                        }
+                    }
+                }
+                // Start checking from the constructor body
+                checkForMethodCalls(ctorMethod.value.body);
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-overridable-method-calls-in-constructor.js.map

package/lib/rules/no-passthrough-getters.d.ts

@@ -0,0 +1,4 @@
+import { TSESTree } from '@typescript-eslint/utils';
+export declare const noPassthroughGetters: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"noPassthroughGetter", never[], {
+    MethodDefinition(node: TSESTree.MethodDefinition): void;
+}>;

package/lib/rules/no-passthrough-getters.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noPassthroughGetters = void 0;
+const createRule_1 = require("../utils/createRule");
+const utils_1 = require("@typescript-eslint/utils");
+const getMethodName_1 = require("../utils/getMethodName");
+const COMPLEX_EXPRESSION_TYPES = new Set([
+    utils_1.AST_NODE_TYPES.CallExpression,
+    utils_1.AST_NODE_TYPES.TemplateLiteral,
+    utils_1.AST_NODE_TYPES.NewExpression,
+    utils_1.AST_NODE_TYPES.BinaryExpression,
+    utils_1.AST_NODE_TYPES.ArrayExpression,
+    utils_1.AST_NODE_TYPES.ObjectExpression,
+]);
+exports.noPassthroughGetters = (0, createRule_1.createRule)({
+    create(context) {
+        const sourceCode = context.getSourceCode();
+        return {
+            // Target getter methods in classes
+            MethodDefinition(node) {
+                // Only check getter methods
+                if (node.kind !== 'get') {
+                    return;
+                }
+                // Skip if the getter has decorators (like @Memoize)
+                if (node.decorators && node.decorators.length > 0) {
+                    return;
+                }
+                const methodBody = node.value.body;
+                if (!methodBody) {
+                    return;
+                }
+                // Check if the getter body is a simple return statement
+                if (methodBody.body.length === 1 &&
+                    methodBody.body[0].type === 'ReturnStatement') {
+                    const returnStatement = methodBody
+                        .body[0];
+                    // Skip if there's no return argument
+                    if (!returnStatement.argument) {
+                        return;
+                    }
+                    // Skip if the return statement uses super
+                    if (containsSuper(returnStatement.argument)) {
+                        return;
+                    }
+                    // Skip if the return statement includes type assertions or casting
+                    if (hasTypeAssertion(returnStatement.argument)) {
+                        return;
+                    }
+                    // Skip if the return statement includes null/undefined handling
+                    if (hasNullUndefinedHandling(returnStatement.argument)) {
+                        return;
+                    }
+                    // Skip if the return statement includes computed property access or function calls
+                    if (hasComputedPropertyOrFunctionCall(returnStatement.argument)) {
+                        return;
+                    }
+                    // Check if the return statement is accessing a property from a constructor parameter
+                    if (isConstructorParameterPropertyAccess(returnStatement.argument)) {
+                        const getterName = (0, getMethodName_1.getMethodName)(node, sourceCode, {
+                            computedFallbackToText: false,
+                        }) || 'getter';
+                        const propertyPath = getMemberPath(returnStatement.argument) ??
+                            'nested property on a constructor-injected object';
+                        context.report({
+                            node,
+                            messageId: 'noPassthroughGetter',
+                            data: {
+                                getterName,
+                                propertyPath,
+                            },
+                        });
+                    }
+                }
+            },
+        };
+        /**
+         * Check if the node is a simple property access from a constructor parameter
+         * like this.settings.property or this.settings['property'] or this.settings.nested.deep.property
+         */
+        function isConstructorParameterPropertyAccess(node) {
+            // Check for member expressions like this.settings.property
+            if (node.type === 'MemberExpression') {
+                return isConstructorParameterAccess(node);
+            }
+            return false;
+        }
+        /**
+         * Check if the node is accessing a property from a constructor parameter
+         * Patterns to match: this.constructorParam.property, this.constructorParam['property'], this.constructorParam.nested.deep.property
+         * Patterns to NOT match: this.property, SomeClass.property, this.methodCall()
+         */
+        function isConstructorParameterAccess(node) {
+            let current = node.object;
+            let depth = 0;
+            // Walk up member expressions until we reach a base
+            while (current && current.type === 'MemberExpression') {
+                depth += 1;
+                current = current.object;
+            }
+            // Require at least one nesting and a base of `this`
+            return depth >= 1 && current?.type === 'ThisExpression';
+        }
+        /**
+         * Check if the node contains a reference to super
+         */
+        function containsSuper(node) {
+            let current = node;
+            while (current && current.type === 'MemberExpression') {
+                if (current.object.type === 'Super') {
+                    return true;
+                }
+                current = current.object;
+            }
+            return false;
+        }
+        function getMemberPath(node) {
+            if (node.type === 'ThisExpression') {
+                return 'this';
+            }
+            if (node.type === 'Identifier') {
+                return node.name;
+            }
+            if (node.type !== 'MemberExpression') {
+                return null;
+            }
+            const objectPath = getMemberPath(node.object);
+            if (!objectPath) {
+                return null;
+            }
+            if (node.computed && node.property.type === 'Literal') {
+                const literalValue = typeof node.property.value === 'string'
+                    ? JSON.stringify(node.property.value)
+                    : String(node.property.value);
+                return `${objectPath}[${literalValue}]`;
+            }
+            if (node.property.type === 'Identifier') {
+                return `${objectPath}.${node.property.name}`;
+            }
+            return null;
+        }
+        /**
+         * Check if the node has a type assertion or casting
+         */
+        function hasTypeAssertion(node) {
+            if (node.type === 'TSAsExpression' || node.type === 'TSTypeAssertion') {
+                return true;
+            }
+            if (node.type === 'MemberExpression') {
+                return hasTypeAssertion(node.object);
+            }
+            return false;
+        }
+        /**
+         * Check if the node handles null/undefined values
+         */
+        function hasNullUndefinedHandling(node) {
+            // Check for logical expressions like this.settings.property || []
+            if (node.type === 'LogicalExpression') {
+                return true;
+            }
+            // Check for conditional expressions like this.settings.property ? this.settings.property : []
+            if (node.type === 'ConditionalExpression') {
+                return true;
+            }
+            // Check for optional chaining like this.settings?.property
+            if (node.type === 'MemberExpression' && node.optional) {
+                return true;
+            }
+            // The nullish coalescing check is already covered by the LogicalExpression check above
+            return false;
+        }
+        /**
+         * Check if the node includes computed property access or function calls
+         */
+        function hasComputedPropertyOrFunctionCall(node) {
+            if (COMPLEX_EXPRESSION_TYPES.has(node.type)) {
+                return true;
+            }
+            // Check for member expressions with computed properties like this.settings[key]
+            if (node.type === 'MemberExpression') {
+                // If the property is computed with a dynamic expression (not a literal), it's not a simple property access
+                if (node.computed && node.property.type !== 'Literal') {
+                    return true;
+                }
+                // Recursively check the object part
+                return hasComputedPropertyOrFunctionCall(node.object);
+            }
+            return false;
+        }
+    },
+    name: 'no-passthrough-getters',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Avoid getter methods that only re-expose nested properties on constructor-injected objects without adding behavior',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            noPassthroughGetter: 'Getter "{{getterName}}" only forwards nested property "{{propertyPath}}" from an object provided via the constructor. This indirection hides the real source of state and expands the class API without adding behavior. Read the constructor-injected object directly or add logic that justifies a getter (validation, memoization, fallback).',
+        },
+    },
+    defaultOptions: [],
+});
+//# sourceMappingURL=no-passthrough-getters.js.map

package/lib/rules/no-redundant-annotation-assertion.d.ts

@@ -0,0 +1,2 @@
+import { TSESLint } from '@typescript-eslint/utils';
+export declare const noRedundantAnnotationAssertion: TSESLint.RuleModule<"redundantAnnotationAndAssertion", [], TSESLint.RuleListener>;