@blumintinc/eslint-plugin-blumint 0.1.17 → 0.1.19

package/docs/rules/dynamic-https-errors.md

@@ -0,0 +1,23 @@
+# Dynamic elements of errors should be in the 'details' field (`@blumintinc/blumint/dynamic-https-errors`)
+
+⚠️ This rule _warns_ in the ✅ `recommended` config.
+
+<!-- end auto-generated rule header -->
+
+This rule warns against the use of template literals in the `message` field of the `HttpsError` constructor, and suggests their use in the `details` field instead.
+
+## Rule Details
+
+Examples of **incorrect** code for this rule:
+
+```typescript
+throw new https.HttpsError('foo', `Error: ${bar}`, 'baz');
+throw new HttpsError('foo', `Error: ${bar}`, 'baz');
+```
+
+Examples of **correct** code for this rule:
+
+```typescript
+throw new https.HttpsError('foo', 'bar', 'baz');
+throw new https.HttpsError('foo', 'bar', `Details: ${baz}`);
+```

package/lib/index.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const array_methods_this_context_1 = require("./rules/array-methods-this-context");
+const dynamic_https_errors_1 = require("./rules/dynamic-https-errors");
 const export_if_in_doubt_1 = require("./rules/export-if-in-doubt");
 const extract_global_constants_1 = require("./rules/extract-global-constants");
 const generic_starts_with_t_1 = require("./rules/generic-starts-with-t");
@@ -17,7 +18,7 @@ const require_memo_1 = require("./rules/require-memo");
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '0.1.17',
+        version: '0.1.19',
     },
     parseOptions: {
         ecmaVersion: 2020,
@@ -27,6 +28,7 @@ module.exports = {
             plugins: ['@blumintinc/blumint'],
             rules: {
                 '@blumintinc/blumint/array-methods-this-context': 'warn',
+                '@blumintinc/blumint/dynamic-https-errors': 'warn',
                 // '@blumintinc/blumint/export-if-in-doubt': 'warn',
                 // '@blumintinc/blumint/extract-global-constants': 'warn',
                 '@blumintinc/blumint/generic-starts-with-t': 'warn',
@@ -45,6 +47,7 @@ module.exports = {
     },
     rules: {
         'array-methods-this-context': array_methods_this_context_1.arrayMethodsThisContext,
+        'dynamic-https-errors': dynamic_https_errors_1.dynamicHttpsErrors,
         'export-if-in-doubt': export_if_in_doubt_1.exportIfInDoubt,
         'extract-global-constants': extract_global_constants_1.extractGlobalConstants,
         'generic-starts-with-t': generic_starts_with_t_1.genericStartsWithT,

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

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dynamicHttpsErrors = void 0;
+/* eslint-disable @blumintinc/blumint/extract-global-constants */
+const createRule_1 = require("../utils/createRule");
+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;
+};
+exports.dynamicHttpsErrors = (0, createRule_1.createRule)({
+    name: 'dynamic-https-errors',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Dynamic error details should only be in the third argument of the HttpsError constructor. The second argument is hashed to produce a unique id.',
+            recommended: 'warn',
+        },
+        schema: [],
+        messages: {
+            dynamicHttpsErrors: 'Found dynamic error details in the "message" field. Move any dynamic details third argument.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const checkForHttpsError = (node) => {
+            const callee = node.callee;
+            if (isHttpsErrorCall(callee)) {
+                const secondArg = node.arguments[1];
+                if (secondArg && secondArg.type === 'TemplateLiteral') {
+                    if (secondArg.expressions.length > 0) {
+                        context.report({
+                            node: secondArg,
+                            messageId: 'dynamicHttpsErrors',
+                        });
+                    }
+                }
+            }
+        };
+        return {
+            NewExpression(node) {
+                return checkForHttpsError(node);
+            },
+            CallExpression(node) {
+                return checkForHttpsError(node);
+            },
+        };
+    },
+});
+//# sourceMappingURL=dynamic-https-errors.js.map

package/lib/rules/require-memo.js

@@ -1,31 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.requireMemo = void 0;
+const utils_1 = require("@typescript-eslint/utils");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
 const isComponentExplicitlyUnmemoized = (componentName) => componentName.toLowerCase().includes('unmemoized');
-function isMemoCallExpression(node) {
-    if (node.type !== 'CallExpression')
-        return false;
-    if (node.callee.type === 'MemberExpression') {
-        const { callee: { object, property }, } = node;
-        if (object.type === 'Identifier' &&
-            property.type === 'Identifier' &&
-            object.name === 'React' &&
-            property.name === 'memo') {
-            return true;
-        }
-    }
-    else if (node.callee.type === 'Identifier' && node.callee.name === 'memo') {
-        return true;
-    }
-    return false;
+function isFunction(node) {
+    return (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+        node.type === utils_1.AST_NODE_TYPES.FunctionExpression);
 }
 function isHigherOrderFunctionReturningJSX(node) {
-    if (node.type === 'ArrowFunctionExpression' ||
-        node.type === 'FunctionExpression') {
-        if (node.body.type === 'ArrowFunctionExpression' ||
-            node.body.type === 'FunctionExpression') {
-            return ASTHelpers_1.ASTHelpers.returnsJSX(node.body.body);
+    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 returnsFunction = isFunction(statement.argument);
+                    return (hasFunctionParam || returnsFunction) && returnsJSX;
+                }
+            }
         }
     }
     return false;
@@ -36,15 +30,19 @@ function checkFunction(context, node) {
         return;
     }
     if (isHigherOrderFunctionReturningJSX(node)) {
+        console.log('Found HOF');
         return;
     }
-    let currentNode = node.parent;
-    while (currentNode.type === 'CallExpression') {
-        if (isMemoCallExpression(currentNode)) {
-            return;
-        }
-        currentNode = currentNode.parent;
+    const currentNode = node.parent;
+    if (node.parent.type === 'CallExpression') {
+        return;
     }
+    // while (currentNode.type === 'CallExpression') {
+    //   if (isMemoCallExpression(currentNode) || true) {
+    //     return;
+    //   }
+    //   currentNode = currentNode.parent;
+    // }
     if (ASTHelpers_1.ASTHelpers.returnsJSX(node.body) && ASTHelpers_1.ASTHelpers.hasParameters(node)) {
         if (currentNode.type === 'VariableDeclarator' &&
             currentNode.id.type === 'Identifier' &&

package/lib/utils/ASTHelpers.js

@@ -153,8 +153,20 @@ class ASTHelpers {
                         statement.argument?.type === 'JSXFragment')) {
                     return true;
                 }
+                // Handle conditional returns
+                if (statement.type === 'ReturnStatement' &&
+                    statement.argument?.type === 'ConditionalExpression') {
+                    const conditionalExpr = statement.argument;
+                    if (ASTHelpers.returnsJSX(conditionalExpr.consequent) ||
+                        ASTHelpers.returnsJSX(conditionalExpr.alternate)) {
+                        return true;
+                    }
+                }
             }
         }
+        if (node.type === 'ConditionalExpression') {
+            return (this.returnsJSX(node.consequent) || this.returnsJSX(node.alternate));
+        }
         return false;
     }
     static hasParameters(node) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blumintinc/eslint-plugin-blumint",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "description": "Custom eslint rules for use at BluMint",
   "keywords": [
     "eslint",