@blumintinc/eslint-plugin-blumint 1.13.0 → 1.15.0

package/lib/rules/require-hooks-default-params.js

@@ -14,7 +14,7 @@ exports.requireHooksDefaultParams = (0, createRule_1.createRule)({
         fixable: 'code',
         schema: [],
         messages: {
-            requireDefaultParams: 'React hooks with all optional parameters should default to an empty object',
+            requireDefaultParams: 'Hook "{{hookName}}" accepts an options object where every property is optional, but the parameter is not defaulted. When callers omit the argument the hook receives undefined, so destructuring or property access throws even though the fields are optional. Default the parameter to an empty object (e.g., "({ option } = {})") so the hook stays safe to call with no arguments.',
         },
     },
     defaultOptions: [],
@@ -81,8 +81,10 @@ exports.requireHooksDefaultParams = (0, createRule_1.createRule)({
             'ArrowFunctionExpression, FunctionDeclaration'(node) {
                 // Check if it's a hook function
                 let isHook = false;
+                let hookName;
                 if (node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration) {
-                    isHook = node.id ? isHookName(node.id.name) : false;
+                    hookName = node.id?.name;
+                    isHook = hookName ? isHookName(hookName) : false;
                 }
                 else {
                     const parent = node.parent;
@@ -90,12 +92,14 @@ exports.requireHooksDefaultParams = (0, createRule_1.createRule)({
                         parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
                         parent.id &&
                         parent.id.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        hookName = parent.id.name;
                         isHook = isHookName(parent.id.name);
                     }
                 }
                 if (!isHook) {
                     return;
                 }
+                const messageData = { hookName: hookName ?? 'this hook' };
                 // Check if it has exactly one parameter
                 if (node.params.length !== 1) {
                     return;
@@ -121,10 +125,9 @@ exports.requireHooksDefaultParams = (0, createRule_1.createRule)({
                                         context.report({
                                             node: param,
                                             messageId: 'requireDefaultParams',
+                                            data: messageData,
                                             fix(fixer) {
-                                                const paramText = context
-                                                    .getSourceCode()
-                                                    .getText(param);
+                                                const paramText = context.sourceCode.getText(param);
                                                 return fixer.replaceText(param, `${paramText} = {}`);
                                             },
                                         });
@@ -140,10 +143,9 @@ exports.requireHooksDefaultParams = (0, createRule_1.createRule)({
                                         context.report({
                                             node: param,
                                             messageId: 'requireDefaultParams',
+                                            data: messageData,
                                             fix(fixer) {
-                                                const paramText = context
-                                                    .getSourceCode()
-                                                    .getText(param);
+                                                const paramText = context.sourceCode.getText(param);
                                                 return fixer.replaceText(param, `${paramText} = {}`);
                                             },
                                         });
@@ -152,7 +154,7 @@ exports.requireHooksDefaultParams = (0, createRule_1.createRule)({
                             }
                             else {
                                 // If we can't find the type definition, check if it's defined in the same file
-                                const program = context.getSourceCode().ast;
+                                const program = context.sourceCode.ast;
                                 const typeDefinitions = program.body.filter((node) => {
                                     if (node.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration ||
                                         node.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) {
@@ -172,10 +174,9 @@ exports.requireHooksDefaultParams = (0, createRule_1.createRule)({
                                             context.report({
                                                 node: param,
                                                 messageId: 'requireDefaultParams',
+                                                data: messageData,
                                                 fix(fixer) {
-                                                    const paramText = context
-                                                        .getSourceCode()
-                                                        .getText(param);
+                                                    const paramText = context.sourceCode.getText(param);
                                                     return fixer.replaceText(param, `${paramText} = {}`);
                                                 },
                                             });
@@ -191,10 +192,9 @@ exports.requireHooksDefaultParams = (0, createRule_1.createRule)({
                                             context.report({
                                                 node: param,
                                                 messageId: 'requireDefaultParams',
+                                                data: messageData,
                                                 fix(fixer) {
-                                                    const paramText = context
-                                                        .getSourceCode()
-                                                        .getText(param);
+                                                    const paramText = context.sourceCode.getText(param);
                                                     return fixer.replaceText(param, `${paramText} = {}`);
                                                 },
                                             });
@@ -214,8 +214,9 @@ exports.requireHooksDefaultParams = (0, createRule_1.createRule)({
                             context.report({
                                 node: param,
                                 messageId: 'requireDefaultParams',
+                                data: messageData,
                                 fix(fixer) {
-                                    const paramText = context.getSourceCode().getText(param);
+                                    const paramText = context.sourceCode.getText(param);
                                     return fixer.replaceText(param, `${paramText} = {}`);
                                 },
                             });

package/lib/rules/require-https-error-cause.d.ts

@@ -0,0 +1,4 @@
+import { TSESLint } from '@typescript-eslint/utils';
+type MessageIds = 'missingCause' | 'causeNotCatchBinding' | 'missingCatchBinding';
+export declare const requireHttpsErrorCause: TSESLint.RuleModule<MessageIds, [], TSESLint.RuleListener>;
+export {};

package/lib/rules/require-https-error-cause.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireHttpsErrorCause = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
+const createRule_1 = require("../utils/createRule");
+const isHttpsErrorCallee = (callee) => {
+    if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return callee.name === 'HttpsError';
+    }
+    if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+        return (callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+            callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+            callee.property.name === 'HttpsError');
+    }
+    return false;
+};
+const findVariableInScopeChain = (scope, name) => {
+    let currentScope = scope;
+    while (currentScope) {
+        const variable = currentScope.variables.find((item) => item.name === name);
+        if (variable) {
+            return variable;
+        }
+        currentScope = currentScope.upper;
+    }
+    return null;
+};
+exports.requireHttpsErrorCause = (0, createRule_1.createRule)({
+    name: 'require-https-error-cause',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Ensure HttpsError calls inside catch blocks pass the caught error as the fourth "cause" argument to preserve stack traces for monitoring.',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            missingCause: 'HttpsError inside a catch block must pass the caught error as the fourth "cause" argument. Without the original error, the stack is lost and monitoring fingerprints degrade. Add {{catchName}} as the cause argument after the optional details parameter.',
+            causeNotCatchBinding: 'The fourth HttpsError argument should be the catch binding {{catchName}} so the original error stack is preserved for monitoring. Pass the catch variable instead of {{actual}}.',
+            missingCatchBinding: 'HttpsError inside a catch block needs a named catch binding so the original error can be forwarded as the fourth "cause" argument. Bind the error value (e.g., `catch (error)`) and pass that variable as the cause to keep the upstream stack trace.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const sourceCode = context.sourceCode ?? context.getSourceCode();
+        const catchStack = [];
+        const reportMissingCause = (node, catchName) => {
+            context.report({
+                node,
+                messageId: 'missingCause',
+                data: {
+                    catchName,
+                },
+            });
+        };
+        const reportWrongCause = (node, catchName, actual) => {
+            context.report({
+                node,
+                messageId: 'causeNotCatchBinding',
+                data: {
+                    catchName,
+                    actual,
+                },
+            });
+        };
+        const isCatchBindingReference = (identifier, frame) => {
+            if (!frame.paramName || identifier.name !== frame.paramName) {
+                return false;
+            }
+            const variable = findVariableInScopeChain(ASTHelpers_1.ASTHelpers.getScope(context, identifier), identifier.name);
+            return (variable?.defs.some((definition) => definition.type === 'CatchClause' && definition.node === frame.node) ?? false);
+        };
+        const validateHttpsError = (node) => {
+            if (!catchStack.length) {
+                return;
+            }
+            if (!isHttpsErrorCallee(node.callee)) {
+                return;
+            }
+            const activeCatch = catchStack[catchStack.length - 1];
+            if (!activeCatch.paramName) {
+                context.report({
+                    node,
+                    messageId: 'missingCatchBinding',
+                });
+                return;
+            }
+            const catchName = activeCatch.paramName;
+            // HttpsError accepts both positional and object-based constructors. This signature
+            // is supported for compatibility with HttpsError overloads, ensuring the rule
+            // can validate the 'cause' property within a settings object to preserve
+            // error chaining for better diagnostics.
+            if (node.arguments.length === 1 &&
+                node.arguments[0].type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                const settingsObj = node.arguments[0];
+                const causeProp = settingsObj.properties.find((prop) => prop.type === utils_1.AST_NODE_TYPES.Property &&
+                    !prop.computed &&
+                    ((prop.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        prop.key.name === 'cause') ||
+                        (prop.key.type === utils_1.AST_NODE_TYPES.Literal &&
+                            prop.key.value === 'cause')));
+                if (!causeProp) {
+                    reportMissingCause(node, catchName);
+                    return;
+                }
+                const causeValue = causeProp.value;
+                if (causeValue.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                    reportWrongCause(causeValue, catchName, sourceCode.getText(causeValue));
+                    return;
+                }
+                if (!isCatchBindingReference(causeValue, activeCatch)) {
+                    reportWrongCause(causeValue, catchName, sourceCode.getText(causeValue));
+                }
+                return;
+            }
+            if (node.arguments.length < 4) {
+                reportMissingCause(node, catchName);
+                return;
+            }
+            const causeArg = node.arguments[3];
+            if (!causeArg || causeArg.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                reportWrongCause(causeArg ?? node, catchName, causeArg
+                    ? sourceCode.getText(causeArg)
+                    : 'the missing cause argument');
+                return;
+            }
+            if (!isCatchBindingReference(causeArg, activeCatch)) {
+                reportWrongCause(causeArg, catchName, sourceCode.getText(causeArg));
+            }
+        };
+        return {
+            CatchClause(node) {
+                if (node.param?.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    catchStack.push({ paramName: node.param.name, node });
+                    return;
+                }
+                // Destructured catch params (e.g., `catch ({ message })`) do not bind the
+                // full error object, so they cannot be forwarded as the HttpsError cause.
+                // Users should bind the error value (e.g., `catch (error)`) before rethrowing.
+                catchStack.push({ paramName: null, node });
+            },
+            'CatchClause:exit'() {
+                catchStack.pop();
+            },
+            NewExpression(node) {
+                validateHttpsError(node);
+            },
+            CallExpression(node) {
+                validateHttpsError(node);
+            },
+        };
+    },
+});
+//# sourceMappingURL=require-https-error-cause.js.map

package/lib/rules/require-https-error.js

@@ -11,8 +11,8 @@ module.exports = (0, createRule_1.createRule)({
         },
         schema: [],
         messages: {
-            useHttpsError: 'Use HttpsError instead of throw new Error in functions/src directory',
-            useProprietaryHttpsError: 'Use our proprietary HttpsError instead of firebase-admin HttpsError',
+            useHttpsError: 'Throwing "{{constructorName}}" in Cloud Functions returns a generic 500 and drops the structured status code clients rely on. Throw the proprietary HttpsError instead so responses include the correct status, sanitized message, and logging context.',
+            useProprietaryHttpsError: '{{reference}} comes from {{source}} and bypasses our proprietary HttpsError wrapper, so responses skip standardized status codes, logging, and client-safe payloads. Import and throw HttpsError from @our-company/errors to keep errors consistent.',
         },
     },
     defaultOptions: [],
@@ -22,12 +22,20 @@ module.exports = (0, createRule_1.createRule)({
         if (!filename.includes('functions/src')) {
             return {};
         }
-        let httpsIdentifier = null;
-        let httpsErrorIdentifier = null;
+        const httpsIdentifiers = new Map();
+        const httpsErrorIdentifiers = new Map();
+        const reportProprietary = (node, data) => context.report({
+            node,
+            messageId: 'useProprietaryHttpsError',
+            data,
+        });
         return {
             ImportDeclaration(node) {
                 if (node.source.value === 'firebase-admin' ||
                     node.source.value === 'firebase-admin/lib/https-error') {
+                    const sourceModule = String(node.source.value);
+                    // Report imports immediately so the forbidden dependency is blocked even
+                    // when unused; throw sites below also report to cover runtime usage.
                     // Check for direct HttpsError import
                     const httpsErrorSpecifier = node.specifiers.find((spec) => spec.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
                         spec.imported.name === 'HttpsError');
@@ -35,17 +43,19 @@ module.exports = (0, createRule_1.createRule)({
                     const httpsSpecifier = node.specifiers.find((spec) => spec.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
                         spec.imported.name === 'https');
                     if (httpsErrorSpecifier && 'local' in httpsErrorSpecifier) {
-                        httpsErrorIdentifier = httpsErrorSpecifier.local.name;
-                        context.report({
-                            node,
-                            messageId: 'useProprietaryHttpsError',
+                        const localName = httpsErrorSpecifier.local.name;
+                        httpsErrorIdentifiers.set(localName, sourceModule);
+                        reportProprietary(node, {
+                            reference: localName,
+                            source: sourceModule,
                         });
                     }
                     if (httpsSpecifier && 'local' in httpsSpecifier) {
-                        httpsIdentifier = httpsSpecifier.local.name;
-                        context.report({
-                            node,
-                            messageId: 'useProprietaryHttpsError',
+                        const localName = httpsSpecifier.local.name;
+                        httpsIdentifiers.set(localName, sourceModule);
+                        reportProprietary(node, {
+                            reference: `${localName}.HttpsError`,
+                            source: sourceModule,
                         });
                     }
                 }
@@ -65,22 +75,34 @@ module.exports = (0, createRule_1.createRule)({
                     context.report({
                         node,
                         messageId: 'useHttpsError',
+                        data: {
+                            constructorName: callee.name,
+                        },
                     });
                     return;
                 }
                 // Check for firebase-admin HttpsError usage
-                const isFirebaseHttpsError = callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
                     callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    callee.object.name === httpsIdentifier &&
                     callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    callee.property.name === 'HttpsError';
-                const isDirectHttpsError = callee.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    callee.name === httpsErrorIdentifier;
-                if (isFirebaseHttpsError || isDirectHttpsError) {
-                    context.report({
-                        node,
-                        messageId: 'useProprietaryHttpsError',
+                    callee.property.name === 'HttpsError') {
+                    const objectName = callee.object.name;
+                    const source = httpsIdentifiers.get(objectName);
+                    if (!source) {
+                        return;
+                    }
+                    reportProprietary(node, {
+                        reference: `${objectName}.HttpsError`,
+                        source,
                     });
+                    return;
+                }
+                if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    const source = httpsErrorIdentifiers.get(callee.name);
+                    if (!source) {
+                        return;
+                    }
+                    reportProprietary(node, { reference: callee.name, source });
                 }
             },
         };

package/lib/rules/require-image-optimized.js

@@ -32,7 +32,7 @@ module.exports = (0, createRule_1.createRule)({
         const options = context.options[0] || {
             componentPath: 'src/components/image/ImageOptimized',
         };
-        const sourceCode = context.getSourceCode();
+        const sourceCode = context.sourceCode;
         return {
             // Handle JSX img elements
             JSXElement(node) {

package/lib/rules/require-memo.js

@@ -8,21 +8,25 @@ const ASTHelpers_1 = require("../utils/ASTHelpers");
 const isComponentExplicitlyUnmemoized = (componentName) => componentName.toLowerCase().includes('unmemoized');
 function isFunction(node) {
     return (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
-        node.type === utils_1.AST_NODE_TYPES.FunctionExpression);
+        node.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+        node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration);
 }
-function isHigherOrderFunctionReturningJSX(node) {
+function isHigherOrderFunctionReturningJSX(node, context) {
     if (isFunction(node)) {
-        // Check if function takes another function as an argument
-        const hasFunctionParam = 'params' in node && node.params.some(isFunction);
         if (node.body && node.body.type === 'BlockStatement') {
             for (const statement of node.body.body) {
                 if (statement.type === 'ReturnStatement' && statement.argument) {
-                    const returnsJSX = ASTHelpers_1.ASTHelpers.returnsJSX(statement.argument);
+                    const returnsJSX = ASTHelpers_1.ASTHelpers.returnsJSX(statement.argument, context);
                     const returnsFunction = isFunction(statement.argument);
-                    return (hasFunctionParam || returnsFunction) && returnsJSX;
+                    return returnsFunction && returnsJSX;
                 }
             }
         }
+        else if (node.body && isFunction(node.body)) {
+            // Shorthand arrow HOC: (Comp) => (props) => <Comp {...props} />
+            // Here node.body is the inner function; check if it returns JSX.
+            return ASTHelpers_1.ASTHelpers.returnsJSX(node.body, context);
+        }
     }
     return false;
 }
@@ -52,14 +56,15 @@ function checkFunction(context, node) {
     if (!fileName.endsWith('.tsx')) {
         return;
     }
-    if (isHigherOrderFunctionReturningJSX(node)) {
+    if (isHigherOrderFunctionReturningJSX(node, context)) {
         return;
     }
     const parentNode = node.parent;
     if (node.parent.type === 'CallExpression') {
         return;
     }
-    if (ASTHelpers_1.ASTHelpers.returnsJSX(node.body) && ASTHelpers_1.ASTHelpers.hasParameters(node)) {
+    if (ASTHelpers_1.ASTHelpers.returnsJSX(node.body, context) &&
+        ASTHelpers_1.ASTHelpers.hasParameters(node)) {
         const results = [
             isUnmemoizedArrowFunction,
             isUnmemoizedFunctionComponent,
@@ -79,7 +84,10 @@ function checkFunction(context, node) {
                 },
                 fix: results[2] || results[1]
                     ? function fix(fixer) {
-                        const sourceCode = context.getSourceCode();
+                        if (node.async || node.generator) {
+                            return null;
+                        }
+                        const sourceCode = context.sourceCode;
                         let importFix = null;
                         // Search for memo import statement
                         const importDeclarations = sourceCode.ast.body.filter((node) => node.type === 'ImportDeclaration');
@@ -118,7 +126,7 @@ function checkFunction(context, node) {
                         const functionNameReplacement = `function ${node.id.name}Unmemoized`;
                         const fixes = [
                             fixer.replaceTextRange(functionKeywordRange, functionKeywordReplacement),
-                            fixer.insertTextAfterRange([node.range[1], node.range[1]], ')'),
+                            fixer.insertTextAfterRange([node.range[1], node.range[1]], ');'),
                             fixer.replaceTextRange([node.id.range[0] - 1, node.id.range[1]], functionNameReplacement),
                         ];
                         if (importFix) {

package/lib/rules/require-memoize-jsx-returners.d.ts

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