@blumintinc/eslint-plugin-blumint 1.13.0 → 1.14.0

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

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireHttpsErrorCause = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+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.getSourceCode();
+        const catchStack = [];
+        // ESLint 9 moves getScope onto sourceCode; ESLint 8 exposes context.getScope().
+        // This shim keeps the rule compatible until the codebase drops ESLint 8 support.
+        const getScopeForNode = (node) => {
+            const sourceCodeWithScope = sourceCode;
+            if (typeof sourceCodeWithScope.getScope === 'function') {
+                return sourceCodeWithScope.getScope(node);
+            }
+            return context.getScope();
+        };
+        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(getScopeForNode(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;
+            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

@@ -79,7 +79,7 @@ function checkFunction(context, node) {
                 },
                 fix: results[2] || results[1]
                     ? function fix(fixer) {
-                        const sourceCode = context.getSourceCode();
+                        const sourceCode = context.sourceCode;
                         let importFix = null;
                         // Search for memo import statement
                         const importDeclarations = sourceCode.ast.body.filter((node) => node.type === 'ImportDeclaration');

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;