@sun-asterisk/sunlint 1.0.7 → 1.1.4

package/integrations/eslint/plugin/rules/common/c047-no-duplicate-retry-logic.js

@@ -0,0 +1,239 @@
+/**
+ * Custom ESLint rule for: C047 – Logic retry không được viết lặp lại nhiều nơi
+ * Rule ID: custom/c047
+ * Purpose: Detect duplicate retry logic patterns and enforce centralized retry utilities
+ */
+
+module.exports = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Logic retry không được viết lặp lại nhiều nơi - use centralized retry utility instead",
+      recommended: false
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          maxRetryPatterns: {
+            type: "number",
+            minimum: 1,
+            default: 2,
+            description: "Maximum number of retry patterns allowed before suggesting centralization"
+          },
+          allowedRetryUtils: {
+            type: "array",
+            items: { type: "string" },
+            default: ["RetryUtil", "retryWithBackoff", "withRetry"],
+            description: "Names of allowed centralized retry utilities"
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      duplicateRetryLogic: "Duplicate retry logic detected ({{count}} occurrences). Consider using a centralized retry utility like RetryUtil.withRetry()",
+      inlineRetryLogic: "Inline retry logic found. Consider using a centralized retry utility for consistency and maintainability.",
+      suggestRetryUtil: "Use centralized retry utility instead of custom retry logic."
+    }
+  },
+  create(context) {
+    const options = context.options[0] || {};
+    const maxRetryPatterns = options.maxRetryPatterns || 2;
+    const allowedRetryUtils = options.allowedRetryUtils || ["RetryUtil", "retryWithBackoff", "withRetry"];
+    
+    const retryPatterns = [];
+    const sourceCode = context.getSourceCode();
+
+    /**
+     * Check if a node represents a retry pattern
+     */
+    function isRetryPattern(node) {
+      // Pattern 1: for/while loop with try-catch for retry
+      if ((node.type === "ForStatement" || node.type === "WhileStatement") && 
+          node.body && node.body.type === "BlockStatement") {
+        const hasRetryLogic = node.body.body.some(stmt => 
+          stmt.type === "TryStatement" || 
+          (stmt.type === "IfStatement" && hasRetryCondition(stmt))
+        );
+        return hasRetryLogic;
+      }
+
+      // Pattern 2: do-while with try-catch
+      if (node.type === "DoWhileStatement" && 
+          node.body && node.body.type === "BlockStatement") {
+        return node.body.body.some(stmt => stmt.type === "TryStatement");
+      }
+
+      // Pattern 3: recursive function with retry logic
+      if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression") {
+        return hasRecursiveRetryPattern(node);
+      }
+
+      return false;
+    }
+
+    /**
+     * Check if statement has retry-related conditions
+     */
+    function hasRetryCondition(ifStmt) {
+      if (!ifStmt.test) return false;
+      
+      const testText = sourceCode.getText(ifStmt.test).toLowerCase();
+      return testText.includes('retry') || 
+             testText.includes('attempt') || 
+             testText.includes('tries') ||
+             testText.includes('maxretries') ||
+             testText.includes('maxattempts');
+    }
+
+    /**
+     * Check if function has recursive retry pattern
+     */
+    function hasRecursiveRetryPattern(funcNode) {
+      if (!funcNode.body || !funcNode.body.body) return false;
+      
+      const funcName = funcNode.id ? funcNode.id.name : null;
+      if (!funcName) return false;
+
+      // Look for recursive calls with retry logic
+      const hasRecursiveCall = funcNode.body.body.some(stmt => {
+        if (stmt.type === "TryStatement" && stmt.handler) {
+          // Check if catch block has recursive call
+          return containsRecursiveCall(stmt.handler.body, funcName);
+        }
+        return false;
+      });
+
+      return hasRecursiveCall;
+    }
+
+    /**
+     * Check if block contains recursive call to the function
+     */
+    function containsRecursiveCall(block, funcName) {
+      if (!block || !block.body) return false;
+      
+      return block.body.some(stmt => {
+        if (stmt.type === "ReturnStatement" && stmt.argument) {
+          return containsCallExpression(stmt.argument, funcName);
+        }
+        if (stmt.type === "ExpressionStatement") {
+          return containsCallExpression(stmt.expression, funcName);
+        }
+        return false;
+      });
+    }
+
+    /**
+     * Check if expression contains call to specific function
+     */
+    function containsCallExpression(expr, funcName) {
+      if (expr.type === "CallExpression" && 
+          expr.callee && expr.callee.name === funcName) {
+        return true;
+      }
+      
+      if (expr.type === "AwaitExpression" && expr.argument) {
+        return containsCallExpression(expr.argument, funcName);
+      }
+      
+      return false;
+    }
+
+    /**
+     * Check if node uses allowed retry utilities
+     */
+    function usesAllowedRetryUtil(node) {
+      const nodeText = sourceCode.getText(node);
+      return allowedRetryUtils.some(utilName => nodeText.includes(utilName));
+    }
+
+    /**
+     * Get hash for retry pattern to detect duplicates
+     */
+    function getRetryPatternHash(node) {
+      let text = sourceCode.getText(node);
+      // Normalize text for comparison (remove variable names, whitespace)
+      text = text
+        .replace(/\b[a-zA-Z_$][a-zA-Z0-9_$]*\b/g, 'VAR') // Replace identifiers
+        .replace(/\s+/g, ' ') // Normalize whitespace
+        .replace(/\/\*.*?\*\//g, '') // Remove block comments
+        .replace(/\/\/.*$/gm, ''); // Remove line comments
+      return text;
+    }
+
+    return {
+      // Check for retry patterns in various constructs
+      "ForStatement, WhileStatement, DoWhileStatement"(node) {
+        if (isRetryPattern(node) && !usesAllowedRetryUtil(node)) {
+          const hash = getRetryPatternHash(node);
+          const existing = retryPatterns.find(p => p.hash === hash);
+          
+          if (existing) {
+            existing.count++;
+            existing.nodes.push(node);
+          } else {
+            retryPatterns.push({
+              hash,
+              count: 1,
+              nodes: [node],
+              type: node.type
+            });
+          }
+        }
+      },
+
+      "FunctionDeclaration, FunctionExpression"(node) {
+        if (isRetryPattern(node) && !usesAllowedRetryUtil(node)) {
+          context.report({
+            node,
+            messageId: "inlineRetryLogic"
+          });
+        }
+      },
+
+      // Check for inline setTimeout/setInterval retry patterns
+      "CallExpression"(node) {
+        if (node.callee && 
+            (node.callee.name === "setTimeout" || node.callee.name === "setInterval")) {
+          const parent = node.parent;
+          // Check if this setTimeout is part of retry logic
+          if (parent && parent.type === "ExpressionStatement") {
+            let current = parent.parent;
+            while (current) {
+              if (current.type === "TryStatement" || 
+                  (current.type === "IfStatement" && hasRetryCondition(current))) {
+                if (!usesAllowedRetryUtil(current)) {
+                  context.report({
+                    node: current,
+                    messageId: "inlineRetryLogic"
+                  });
+                }
+                break;
+              }
+              current = current.parent;
+            }
+          }
+        }
+      },
+
+      // Report duplicates at end of program
+      "Program:exit"() {
+        retryPatterns.forEach(pattern => {
+          if (pattern.count >= maxRetryPatterns) {
+            pattern.nodes.forEach(node => {
+              context.report({
+                node,
+                messageId: "duplicateRetryLogic",
+                data: {
+                  count: pattern.count
+                }
+              });
+            });
+          }
+        });
+      }
+    };
+  }
+};

package/integrations/eslint/plugin/rules/common/c072-one-assert-per-test.js

@@ -0,0 +1,184 @@
+/**
+ * Custom ESLint rule for: C072 – Each test should assert only one behavior (Single Assert Rule)
+ * Rule ID: custom/c072
+ * Purpose: A test case should only have one main behavior to test (one expect statement)
+ */
+
+module.exports = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Each test should assert only one behavior (Single Assert Rule)",
+      recommended: false
+    },
+    schema: [],
+    messages: {
+      tooMany: "Test contains too many expect statements ({{count}}). Each test should have only one main behavior to verify."
+    }
+  },
+  create(context) {
+    function isTestFunction(node) {
+      // Safety check for node structure
+      if (!node || !node.callee) {
+        return false;
+      }
+
+      // Check for test/it calls
+      if (node.type === "CallExpression") {
+        // Handle direct test/it calls
+        if (node.callee.type === "Identifier") {
+          return ["test", "it"].includes(node.callee.name);
+        }
+        
+        // Handle imported test/it calls
+        if (node.callee.type === "MemberExpression" &&
+            node.callee.object.type === "Identifier" &&
+            ["test", "it"].includes(node.callee.property.name)) {
+          return true;
+        }
+      }
+
+      return false;
+    }
+
+    function isDescribeBlock(node) {
+      if (!node || !node.callee) {
+        return false;
+      }
+
+      if (node.type === "CallExpression") {
+        // Handle direct describe calls
+        if (node.callee.type === "Identifier") {
+          return node.callee.name === "describe";
+        }
+        
+        // Handle imported describe calls
+        if (node.callee.type === "MemberExpression" &&
+            node.callee.object.type === "Identifier" &&
+            node.callee.property.name === "describe") {
+          return true;
+        }
+      }
+
+      return false;
+    }
+
+    function isSetupOrTeardown(node) {
+      if (!node || !node.callee) {
+        return false;
+      }
+
+      if (node.type === "CallExpression") {
+        const name = node.callee.type === "Identifier" 
+          ? node.callee.name 
+          : node.callee.type === "MemberExpression" 
+            ? node.callee.property.name 
+            : null;
+
+        return ["beforeEach", "afterEach", "beforeAll", "afterAll"].includes(name);
+      }
+
+      return false;
+    }
+
+    function countExpectCalls(body) {
+      let count = 0;
+
+      function traverse(node) {
+        // Safety check to ensure node exists and has type property
+        if (!node || typeof node !== 'object' || !node.type) {
+          return;
+        }
+
+        // Check if this node is an expect call
+        if (
+          node.type === "CallExpression" &&
+          node.callee &&
+          node.callee.type === "Identifier" &&
+          node.callee.name === "expect"
+        ) {
+          count++;
+        }
+
+        // Safely traverse child nodes, but don't go into nested test functions
+        for (const key in node) {
+          if (key === 'parent' || key === 'range' || key === 'loc') {
+            continue; // Skip circular references and metadata
+          }
+          
+          const child = node[key];
+          if (Array.isArray(child)) {
+            child.forEach(item => {
+              if (item && typeof item === 'object' && item.type) {
+                // Don't traverse into nested test functions
+                if (!(item.type === "CallExpression" && isTestFunction(item))) {
+                  traverse(item);
+                }
+              }
+            });
+          } else if (child && typeof child === 'object' && child.type) {
+            // Don't traverse into nested test functions
+            if (!(child.type === "CallExpression" && isTestFunction(child))) {
+              traverse(child);
+            }
+          }
+        }
+      }
+
+      traverse(body);
+      return count;
+    }
+
+    return {
+      CallExpression(node) {
+        // Only check test/it function calls
+        if (!isTestFunction(node)) {
+          return;
+        }
+
+        // Ensure we have the required arguments (name and callback)
+        if (!node.arguments || node.arguments.length < 2) {
+          return;
+        }
+
+        const testCallback = node.arguments[1];
+        
+        // Check if the second argument is a function (test body)
+        if (
+          !testCallback ||
+          (testCallback.type !== "FunctionExpression" && 
+           testCallback.type !== "ArrowFunctionExpression")
+        ) {
+          return;
+        }
+
+        // Get the function body
+        const fnBody = testCallback.body;
+        if (!fnBody) {
+          return;
+        }
+
+        // Handle both block statements and expression bodies
+        let bodyToCheck = fnBody;
+        if (testCallback.type === "ArrowFunctionExpression" && fnBody.type !== "BlockStatement") {
+          // For arrow functions with expression bodies, wrap in a virtual block
+          bodyToCheck = { type: "BlockStatement", body: [{ type: "ExpressionStatement", expression: fnBody }] };
+        }
+
+        // Count expect calls in the test body
+        const expectCount = countExpectCalls(bodyToCheck);
+        
+        // Report if more than one expect statement
+        if (expectCount > 1) {
+          context.report({
+            node,
+            messageId: "tooMany",
+            data: {
+              count: expectCount
+            }
+          });
+        }
+      }
+    };
+  }
+};

package/integrations/eslint/plugin/rules/common/c075-explicit-function-return-types.js

@@ -0,0 +1,168 @@
+/**
+ * Custom ESLint rule for: C075 – Functions must have explicit return type declarations
+ * Rule ID: sunlint/c075
+ * Purpose: Enforce explicit return type annotations for all functions to improve type safety
+ */
+
+module.exports = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Functions must have explicit return type declarations",
+      recommended: true,
+      category: "TypeScript"
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          allowExpressions: {
+            type: "boolean",
+            default: false
+          },
+          allowTypedFunctionExpressions: {
+            type: "boolean", 
+            default: true
+          },
+          allowHigherOrderFunctions: {
+            type: "boolean",
+            default: true
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      missingReturnType: "Function '{{name}}' is missing explicit return type annotation. Consider adding ': ReturnType'",
+      missingReturnTypeArrow: "Arrow function is missing explicit return type annotation. Consider adding ': ReturnType'",
+      missingReturnTypeMethod: "Method '{{name}}' is missing explicit return type annotation. Consider adding ': ReturnType'"
+    }
+  },
+  create(context) {
+    const options = context.options[0] || {};
+    const allowExpressions = options.allowExpressions || false;
+    const allowTypedFunctionExpressions = options.allowTypedFunctionExpressions || true;
+    const allowHigherOrderFunctions = options.allowHigherOrderFunctions || true;
+
+    function isTypedFunctionExpression(node) {
+      const parent = node.parent;
+      if (!parent) return false;
+
+      // Variable declaration with type annotation
+      if (parent.type === "VariableDeclarator" && parent.id && parent.id.typeAnnotation) {
+        return true;
+      }
+
+      // Property with type annotation  
+      if (parent.type === "Property" && parent.typeAnnotation) {
+        return true;
+      }
+
+      // Assignment to typed variable
+      if (parent.type === "AssignmentExpression" && parent.left && parent.left.typeAnnotation) {
+        return true;
+      }
+
+      return false;
+    }
+
+    function isHigherOrderFunction(node) {
+      // Check if function returns another function
+      if (node.body && node.body.type === "BlockStatement") {
+        // Simple heuristic: look for return statements that return functions
+        return node.body.body.some(stmt => {
+          if (stmt.type === "ReturnStatement" && stmt.argument) {
+            return stmt.argument.type === "FunctionExpression" || 
+                   stmt.argument.type === "ArrowFunctionExpression";
+          }
+          return false;
+        });
+      }
+      
+      // Arrow function directly returning function
+      if (node.body && 
+          (node.body.type === "FunctionExpression" || node.body.type === "ArrowFunctionExpression")) {
+        return true;
+      }
+
+      return false;
+    }
+
+    function hasReturnTypeAnnotation(node) {
+      return node.returnType !== null && node.returnType !== undefined;
+    }
+
+    function checkFunction(node) {
+      // Skip if return type is already present
+      if (hasReturnTypeAnnotation(node)) {
+        return;
+      }
+
+      // Skip if this is a typed function expression and allowed
+      if (allowTypedFunctionExpressions && isTypedFunctionExpression(node)) {
+        return;
+      }
+
+      // Skip if this is a higher-order function and allowed
+      if (allowHigherOrderFunctions && isHigherOrderFunction(node)) {
+        return;
+      }
+
+      // Skip constructors
+      if (node.parent && node.parent.type === "MethodDefinition" && node.parent.kind === "constructor") {
+        return;
+      }
+
+      // Skip getters/setters (they have implicit return types)
+      if (node.parent && node.parent.type === "MethodDefinition" && 
+          (node.parent.kind === "get" || node.parent.kind === "set")) {
+        return;
+      }
+
+      // Get function name for better error messages
+      let functionName = "anonymous";
+      if (node.id && node.id.name) {
+        functionName = node.id.name;
+      } else if (node.parent && node.parent.type === "VariableDeclarator" && node.parent.id) {
+        functionName = node.parent.id.name;
+      } else if (node.parent && node.parent.type === "Property" && node.parent.key) {
+        functionName = node.parent.key.name || node.parent.key.value;
+      } else if (node.parent && node.parent.type === "MethodDefinition" && node.parent.key) {
+        functionName = node.parent.key.name;
+      }
+
+      // Report the violation
+      const messageId = node.type === "ArrowFunctionExpression" ? "missingReturnTypeArrow" :
+                       node.parent && node.parent.type === "MethodDefinition" ? "missingReturnTypeMethod" :
+                       "missingReturnType";
+
+      context.report({
+        node,
+        messageId,
+        data: { name: functionName }
+      });
+    }
+
+    return {
+      FunctionDeclaration(node) {
+        checkFunction(node);
+      },
+      FunctionExpression(node) {
+        // Skip if expressions are allowed and this is a simple expression
+        if (allowExpressions && node.parent && 
+            (node.parent.type === "CallExpression" || node.parent.type === "ArrayExpression")) {
+          return;
+        }
+        checkFunction(node);
+      },
+      ArrowFunctionExpression(node) {
+        // Skip if expressions are allowed and this is a simple expression
+        if (allowExpressions && node.parent && 
+            (node.parent.type === "CallExpression" || node.parent.type === "ArrayExpression")) {
+          return;
+        }
+        checkFunction(node);
+      }
+    };
+  }
+};