@blumintinc/eslint-plugin-blumint 1.14.0 → 1.16.0

package/lib/rules/dynamic-https-errors.js

@@ -3,18 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.dynamicHttpsErrors = void 0;
 const createRule_1 = require("../utils/createRule");
 const utils_1 = require("@typescript-eslint/utils");
-const isHttpsErrorCall = (callee) => {
-    if (callee.type === 'MemberExpression') {
-        return (callee.object.type === 'Identifier' &&
-            callee.object.name === 'https' &&
-            callee.property.type === 'Identifier' &&
-            callee.property.name === 'HttpsError');
-    }
-    else if (callee.type === 'Identifier') {
-        return callee.name === 'HttpsError';
-    }
-    return false;
-};
+const ASTHelpers_1 = require("../utils/ASTHelpers");
+const findPropertyByName = (properties, name) => properties.find((p) => p.type === utils_1.AST_NODE_TYPES.Property &&
+    !p.computed &&
+    ((p.key.type === utils_1.AST_NODE_TYPES.Identifier && p.key.name === name) ||
+        (p.key.type === utils_1.AST_NODE_TYPES.Literal && p.key.value === name)));
 exports.dynamicHttpsErrors = (0, createRule_1.createRule)({
     name: 'dynamic-https-errors',
     meta: {
@@ -27,57 +20,134 @@ exports.dynamicHttpsErrors = (0, createRule_1.createRule)({
         messages: {
             dynamicHttpsErrors: 'The HttpsError message (second argument) must stay static. Template expressions here change the hashed message and explode the number of error ids for the same failure. Keep this argument constant and move interpolated values into the third "details" argument so monitoring groups the error while still capturing request context.',
             missingThirdArgument: 'HttpsError calls must include a third "details" argument. The message (second argument) is hashed into a stable identifier, so omitting details leaves errors hard to debug and encourages packing variables into the hashed message. Provide a third argument with the request-specific context (object or string) to keep identifiers stable and diagnostics useful.',
+            missingDetailsProperty: 'HttpsError calls must include a "details" property. The message is hashed into a stable identifier, so omitting details leaves errors hard to debug and encourages packing variables into the hashed message. Provide a details property with the request-specific context (object or string) to keep identifiers stable and diagnostics useful.',
+            missingDetailsDueToSpread: 'HttpsError calls must include a "details" property. This call uses an object spread, which prevents static verification that "details" is present. Ensure the spread object contains "details" or provide it explicitly to keep identifiers stable and diagnostics useful.',
+            unexpectedExtraArgumentForObjectCall: 'Object-based HttpsError calls must have exactly one argument containing code, message, and details properties. Remove extra arguments or use the positional signature (code, message, details).',
         },
     },
     defaultOptions: [],
     create(context) {
-        const checkForHttpsError = (node) => {
-            const callee = node.callee;
-            if (isHttpsErrorCall(callee)) {
-                // Check for missing third argument
-                if (node.arguments.length < 3) {
+        // Only string concatenation with "+" can be static; all other operators
+        // are treated as dynamic to avoid hashing non-literal message content.
+        const isDynamicBinaryExpression = (expression) => {
+            if (expression.operator !== '+')
+                return true;
+            const isStaticLiteral = (expr) => {
+                const inner = ASTHelpers_1.ASTHelpers.unwrapTSAssertions(expr);
+                return (inner.type === utils_1.AST_NODE_TYPES.Literal &&
+                    typeof inner.value === 'string');
+            };
+            const isSafe = (expr) => {
+                if (expr.type === utils_1.AST_NODE_TYPES.PrivateIdentifier) {
+                    return false;
+                }
+                const inner = ASTHelpers_1.ASTHelpers.unwrapTSAssertions(expr);
+                if (inner.type === utils_1.AST_NODE_TYPES.BinaryExpression) {
+                    return !isDynamicBinaryExpression(inner);
+                }
+                return isStaticLiteral(inner);
+            };
+            return !(isSafe(expression.left) && isSafe(expression.right));
+        };
+        /**
+         * Determines if a node should be validated for staticness.
+         *
+         * Pragmatic Exception: Identifier, MemberExpression, and ChainExpression nodes
+         * (e.g., `props.message`, `props?.message`, `ERROR_MSG`) are excluded from
+         * staticness validation. While they can be dynamic and may affect message
+         * stability, they are permitted to support common React/props patterns and
+         * constants, preserving developer ergonomics as an intentional trade-off.
+         */
+        const shouldValidateForStaticness = (node) => {
+            return (node.type !== utils_1.AST_NODE_TYPES.Identifier &&
+                node.type !== utils_1.AST_NODE_TYPES.MemberExpression &&
+                node.type !== utils_1.AST_NODE_TYPES.ChainExpression &&
+                node.type !== utils_1.AST_NODE_TYPES.SpreadElement &&
+                // Explicitly exclude patterns and other non-Expression nodes that can appear in Property.value
+                node.type !== utils_1.AST_NODE_TYPES.ArrayPattern &&
+                node.type !== utils_1.AST_NODE_TYPES.AssignmentPattern &&
+                node.type !== utils_1.AST_NODE_TYPES.ObjectPattern &&
+                node.type !== utils_1.AST_NODE_TYPES.RestElement &&
+                node.type !== utils_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression);
+        };
+        /**
+         * Checks if the message node is static.
+         *
+         * A message is considered static if it's a Literal (string), a TemplateLiteral with no expressions,
+         * or a BinaryExpression (string concatenation with '+') where all parts are static.
+         *
+         * This function reports `dynamicHttpsErrors` for all other expression types (CallExpression,
+         * ConditionalExpression, etc.) that reach it, except for those explicitly excluded by
+         * `shouldValidateForStaticness`.
+         */
+        const checkMessageIsStatic = (messageNode) => {
+            const currentNode = ASTHelpers_1.ASTHelpers.unwrapTSAssertions(messageNode);
+            if (currentNode.type === utils_1.AST_NODE_TYPES.Literal) {
+                return;
+            }
+            if (currentNode.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
+                currentNode.expressions.length === 0) {
+                return;
+            }
+            if (currentNode.type === utils_1.AST_NODE_TYPES.BinaryExpression) {
+                if (isDynamicBinaryExpression(currentNode)) {
                     context.report({
-                        node,
-                        messageId: 'missingThirdArgument',
+                        node: messageNode,
+                        messageId: 'dynamicHttpsErrors',
                     });
                 }
-                // Check for dynamic content in second argument (existing functionality)
-                const secondArg = node.arguments[1];
-                if (!secondArg)
-                    return;
-                if (secondArg.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
-                    secondArg.expressions.length > 0) {
+                return;
+            }
+            // Catch-all for other dynamic forms (CallExpression, ConditionalExpression, etc.)
+            context.report({
+                node: messageNode,
+                messageId: 'dynamicHttpsErrors',
+            });
+        };
+        const checkForHttpsError = (node) => {
+            const callee = node.callee;
+            if (!ASTHelpers_1.ASTHelpers.isHttpsErrorCall(callee))
+                return;
+            // Signature 1: Object-based constructor (HttpsErrorProps)
+            if (node.arguments.length >= 1 &&
+                node.arguments[0].type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                if (node.arguments.length > 1) {
                     context.report({
-                        node: secondArg,
-                        messageId: 'dynamicHttpsErrors',
+                        node,
+                        messageId: 'unexpectedExtraArgumentForObjectCall',
                     });
                     return;
                 }
-                // Only string concatenation with "+" can be static; all other operators
-                // are treated as dynamic to avoid hashing non-literal message content.
-                const isDynamicBinaryExpression = (expression) => {
-                    if (expression.operator !== '+')
-                        return true;
-                    const isStaticLiteral = (expr) => expr.type === utils_1.AST_NODE_TYPES.Literal &&
-                        typeof expr.value === 'string';
-                    const isSafe = (expr) => {
-                        if (expr.type === utils_1.AST_NODE_TYPES.PrivateIdentifier) {
-                            return false;
-                        }
-                        if (expr.type === utils_1.AST_NODE_TYPES.BinaryExpression) {
-                            return !isDynamicBinaryExpression(expr);
-                        }
-                        return isStaticLiteral(expr);
-                    };
-                    return !(isSafe(expression.left) && isSafe(expression.right));
-                };
-                if (secondArg.type === utils_1.AST_NODE_TYPES.BinaryExpression &&
-                    isDynamicBinaryExpression(secondArg)) {
+                const props = node.arguments[0];
+                const messageProperty = findPropertyByName(props.properties, 'message');
+                const detailsProperty = findPropertyByName(props.properties, 'details');
+                if (!detailsProperty) {
+                    const hasSpread = props.properties.some((p) => p.type === utils_1.AST_NODE_TYPES.SpreadElement);
                     context.report({
-                        node: secondArg,
-                        messageId: 'dynamicHttpsErrors',
+                        node,
+                        messageId: hasSpread
+                            ? 'missingDetailsDueToSpread'
+                            : 'missingDetailsProperty',
                     });
                 }
+                if (messageProperty &&
+                    shouldValidateForStaticness(messageProperty.value)) {
+                    checkMessageIsStatic(messageProperty.value);
+                }
+                return;
+            }
+            // Signature 2: Positional arguments (code, message, details)
+            // Check for missing third argument
+            if (node.arguments.length < 3) {
+                context.report({
+                    node,
+                    messageId: 'missingThirdArgument',
+                });
+            }
+            // Check for dynamic content in second argument
+            const secondArg = node.arguments[1];
+            if (secondArg && shouldValidateForStaticness(secondArg)) {
+                checkMessageIsStatic(secondArg);
             }
         };
         return {

package/lib/rules/enforce-boolean-naming-prefixes.d.ts

@@ -3,6 +3,7 @@ type Options = [
     {
         prefixes?: string[];
         ignoreOverriddenGetters?: boolean;
+        enforceForPropertySignatures?: boolean;
     }
 ];
 export declare const enforceBooleanNamingPrefixes: TSESLint.RuleModule<"missingBooleanPrefix", Options, TSESLint.RuleListener>;