@sun-asterisk/sunlint 1.0.7 → 1.1.4

package/integrations/eslint/plugin/rules/common/c029-catch-block-logging.js

@@ -0,0 +1,115 @@
+/**
+ * Custom ESLint rule for: C029 – Every `catch` block must log the error cause
+ * Rule ID: custom/c029
+ * Goal: Catching errors without logging/rethrowing can hide bugs
+ * 
+ * NOTE: This ESLint rule provides basic catch block validation.
+ * For enhanced analysis with context validation and multi-level severity,
+ * use SunLint C029 which offers superior detection capabilities.
+ */
+
+module.exports = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Every `catch` block must log the error cause (C029)",
+      recommended: true,
+      url: "https://coding-standards.sun.com/rules/c029"
+    },
+    schema: [],
+    messages: {
+      silentCatch: "Catch block must log error or rethrow - silent error handling hides bugs (C029)",
+      emptyCatch: "Empty catch block - error is silently ignored (C029)"
+    }
+  },
+  create(context) {
+    return {
+      CatchClause(node) {
+        const body = node.body && node.body.body;
+        
+        // Check for empty catch blocks
+        if (!Array.isArray(body) || body.length === 0) {
+          context.report({
+            node,
+            messageId: "emptyCatch"
+          });
+          return;
+        }
+
+        const hasLogOrThrow = body.some(stmt => {
+          // Check for throw statements
+          if (stmt.type === "ThrowStatement") {
+            return true;
+          }
+
+          // Check for test assertions (Jest patterns)
+          if (stmt.type === "ExpressionStatement" &&
+              stmt.expression.type === "CallExpression" &&
+              stmt.expression.callee &&
+              stmt.expression.callee.name === "expect") {
+            return true;
+          }
+
+          // Check for Redux thunk error handling patterns
+          if (stmt.type === "VariableDeclaration" &&
+              stmt.declarations.some(decl => 
+                decl.init && 
+                decl.init.type === "CallExpression" &&
+                decl.init.callee &&
+                decl.init.callee.name === "handleAxiosError")) {
+            return true;
+          }
+
+          // Check for return rejectWithValue
+          if (stmt.type === "ReturnStatement" &&
+              stmt.argument &&
+              stmt.argument.type === "CallExpression" &&
+              stmt.argument.callee &&
+              stmt.argument.callee.name === "rejectWithValue") {
+            return true;
+          }
+
+          // Check for dispatch calls (Redux patterns)
+          if (stmt.type === "ExpressionStatement" &&
+              stmt.expression.type === "CallExpression" &&
+              stmt.expression.callee &&
+              stmt.expression.callee.name === "dispatch") {
+            return true;
+          }
+
+          // Check for console.log, console.error, console.warn
+          if (stmt.type === "ExpressionStatement" &&
+              stmt.expression.type === "CallExpression" &&
+              stmt.expression.callee &&
+              stmt.expression.callee.type === "MemberExpression" &&
+              stmt.expression.callee.object.name === "console" &&
+              (stmt.expression.callee.property.name === "log" ||
+               stmt.expression.callee.property.name === "error" ||
+               stmt.expression.callee.property.name === "warn")) {
+            return true;
+          }
+
+          // Check for custom logger calls (logger.error, log.error, etc.)
+          if (stmt.type === "ExpressionStatement" &&
+              stmt.expression.type === "CallExpression" &&
+              stmt.expression.callee &&
+              stmt.expression.callee.type === "MemberExpression" &&
+              (stmt.expression.callee.property.name === "error" ||
+               stmt.expression.callee.property.name === "warn" ||
+               stmt.expression.callee.property.name === "log")) {
+            return true;
+          }
+
+          return false;
+        });
+
+        if (!hasLogOrThrow) {
+          context.report({
+            node,
+            messageId: "silentCatch"
+          });
+        }
+      }
+    };
+  }
+};

package/integrations/eslint/plugin/rules/common/c030-use-custom-error-classes.js

@@ -0,0 +1,294 @@
+/**
+ * Custom ESLint rule for: C030 – Dùng custom error class thay vì dùng lỗi hệ thống trực tiếp
+ * Rule ID: custom/c030
+ * Purpose: Enforce using custom error classes instead of generic Error class for better error handling and categorization
+ */
+
+const c030Rule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Use custom error classes instead of generic Error class",
+      recommended: true
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          allowGenericInTests: {
+            type: "boolean",
+            description: "Whether to allow generic Error in test files (default: true)"
+          },
+          allowedBuiltinErrors: {
+            type: "array",
+            items: { type: "string" },
+            description: "Built-in error types that are allowed (e.g., TypeError, RangeError)"
+          },
+          customErrorClasses: {
+            type: "array",
+            items: { type: "string" },
+            description: "Custom error class names that are recommended"
+          },
+          allowRethrow: {
+            type: "boolean",
+            description: "Whether to allow rethrowing caught errors (default: true)"
+          },
+          strictMode: {
+            type: "boolean",
+            description: "Enable strict mode - only custom errors allowed (default: false)"
+          },
+          requireErrorCode: {
+            type: "boolean",
+            description: "Require custom errors to have error codes (default: true)"
+          },
+          requireStatusCode: {
+            type: "boolean",
+            description: "Require custom errors for HTTP to have status codes (default: false)"
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      useCustomError: "Use custom error class instead of generic 'Error'. Consider using specific error types like ValidationError, NotFoundError, BusinessRuleError, etc. Vietnamese: 'Dùng custom error class thay vì Error generic'",
+      useSpecificBuiltin: "Consider using a more specific built-in error type like TypeError, RangeError, or a custom error class. Vietnamese: 'Cân nhắc dùng built-in error cụ thể hơn hoặc custom error class'",
+      missingErrorCode: "Custom error class should include an error code property. Vietnamese: 'Custom error class nên có thuộc tính error code'",
+      missingStatusCode: "HTTP-related error class should include a status code property. Vietnamese: 'Error class liên quan HTTP nên có thuộc tính status code'",
+      preferCustomError: "Prefer custom error classes for better error categorization and handling. Vietnamese: 'Ưu tiên custom error classes để phân loại và xử lý lỗi tốt hơn'"
+    },
+    fixable: null
+  },
+
+  create(context) {
+    const options = context.options[0] || {};
+
+    // Default configuration
+    const allowGenericInTests = options.allowGenericInTests !== false;
+    const allowedBuiltinErrors = new Set(options.allowedBuiltinErrors || [
+      'TypeError', 'RangeError', 'SyntaxError', 'ReferenceError', 'URIError', 'EvalError'
+    ]);
+    const customErrorClasses = new Set(options.customErrorClasses || [
+      'ValidationError', 'NotFoundError', 'BusinessRuleError', 'BusinessError',
+      'ExternalServiceError', 'AuthenticationError', 'AuthorizationError',
+      'NetworkError', 'DatabaseError', 'ConfigurationError', 'TimeoutError'
+    ]);
+    const allowRethrow = options.allowRethrow !== false;
+    const strictMode = options.strictMode || false;
+    const requireErrorCode = options.requireErrorCode !== false;
+    const requireStatusCode = options.requireStatusCode || false;
+
+    const sourceCode = context.getSourceCode();
+    const filename = context.getFilename();
+
+    function isTestFile() {
+      if (!allowGenericInTests) return false;
+
+      const testPatterns = ['.test.', '.spec.', '__tests__', '/test/', '/tests/', '.e2e.', '.stories.'];
+      return testPatterns.some(pattern => filename.includes(pattern));
+    }
+
+    function isRethrowStatement(node) {
+      if (!allowRethrow) return false;
+
+      // Check if throwing a caught error parameter
+      if (node.argument && node.argument.type === 'Identifier') {
+        // Look for catch clauses in parent scopes
+        let parent = node.parent;
+        while (parent) {
+          if (parent.type === 'CatchClause' && 
+              parent.param && 
+              parent.param.name === node.argument.name) {
+            return true;
+          }
+          parent = parent.parent;
+        }
+      }
+
+      return false;
+    }
+
+    function getErrorClassName(node) {
+      if (!node.argument) return null;
+
+      if (node.argument.type === 'NewExpression' && node.argument.callee) {
+        if (node.argument.callee.type === 'Identifier') {
+          return node.argument.callee.name;
+        }
+        if (node.argument.callee.type === 'MemberExpression' && 
+            node.argument.callee.property && 
+            node.argument.callee.property.type === 'Identifier') {
+          return node.argument.callee.property.name;
+        }
+      }
+
+      return null;
+    }
+
+    function isCustomErrorClass(className) {
+      if (!className) return false;
+
+      // Check if it's a known custom error class
+      if (customErrorClasses.has(className)) return true;
+
+      // Check if it follows custom error naming patterns
+      const customErrorPatterns = [
+        /Error$/,           // Ends with 'Error'
+        /Exception$/,       // Ends with 'Exception'
+        /Failure$/,         // Ends with 'Failure'
+        /Fault$/           // Ends with 'Fault'
+      ];
+
+      return customErrorPatterns.some(pattern => 
+        pattern.test(className) && 
+        !allowedBuiltinErrors.has(className) && 
+        className !== 'Error'
+      );
+    }
+
+    function checkErrorClassDefinition(node) {
+      // Check if custom error class has required properties
+      if (node.type === 'ClassDeclaration' && 
+          node.id && 
+          isCustomErrorClass(node.id.name)) {
+
+        const className = node.id.name;
+        const classBody = node.body.body;
+
+        if (requireErrorCode) {
+          const hasErrorCode = classBody.some(member => {
+            if (member.type === 'PropertyDefinition' || member.type === 'ClassProperty') {
+              return member.key && member.key.name === 'code';
+            }
+            if (member.type === 'MethodDefinition' && member.kind === 'constructor') {
+              // Check if constructor sets error code
+              const constructorBody = member.value.body.body;
+              return constructorBody.some(stmt => {
+                if (stmt.type === 'ExpressionStatement' && 
+                    stmt.expression.type === 'AssignmentExpression' &&
+                    stmt.expression.left.type === 'MemberExpression' &&
+                    stmt.expression.left.property.name === 'code') {
+                  return true;
+                }
+                return false;
+              });
+            }
+            return false;
+          });
+
+          if (!hasErrorCode) {
+            context.report({
+              node: node.id,
+              messageId: "missingErrorCode"
+            });
+          }
+        }
+
+        if (requireStatusCode && /http|api|web|service/i.test(className.toLowerCase())) {
+          const hasStatusCode = classBody.some(member => {
+            if (member.type === 'PropertyDefinition' || member.type === 'ClassProperty') {
+              return member.key && (member.key.name === 'statusCode' || member.key.name === 'status');
+            }
+            if (member.type === 'MethodDefinition' && member.kind === 'constructor') {
+              // Check if constructor sets status code
+              const constructorBody = member.value.body.body;
+              return constructorBody.some(stmt => {
+                if (stmt.type === 'ExpressionStatement' && 
+                    stmt.expression.type === 'AssignmentExpression' &&
+                    stmt.expression.left.type === 'MemberExpression' &&
+                    (stmt.expression.left.property.name === 'statusCode' || 
+                     stmt.expression.left.property.name === 'status')) {
+                  return true;
+                }
+                return false;
+              });
+            }
+            return false;
+          });
+
+          if (!hasStatusCode) {
+            context.report({
+              node: node.id,
+              messageId: "missingStatusCode"
+            });
+          }
+        }
+      }
+    }
+
+    return {
+      ThrowStatement(node) {
+        // Skip test files if allowed
+        if (isTestFile()) return;
+
+        // Skip rethrow statements if allowed
+        if (isRethrowStatement(node)) return;
+
+        const errorClassName = getErrorClassName(node);
+
+        // Check for generic Error usage
+        if (errorClassName === 'Error') {
+          context.report({
+            node: node.argument,
+            messageId: "useCustomError"
+          });
+          return;
+        }
+
+        // In strict mode, only custom errors are allowed
+        if (strictMode && errorClassName) {
+          if (!isCustomErrorClass(errorClassName) && !allowedBuiltinErrors.has(errorClassName)) {
+            context.report({
+              node: node.argument,
+              messageId: "preferCustomError"
+            });
+          }
+        }
+
+        // Check for other built-in errors that could be more specific
+        if (allowedBuiltinErrors.has(errorClassName) && !strictMode) {
+          // Only suggest if it's a generic built-in error
+          if (['TypeError', 'RangeError'].includes(errorClassName)) {
+            context.report({
+              node: node.argument,
+              messageId: "useSpecificBuiltin"
+            });
+          }
+        }
+      },
+
+      ClassDeclaration(node) {
+        checkErrorClassDefinition(node);
+      },
+
+      // Check for Promise.reject with generic Error
+      'CallExpression[callee.type="MemberExpression"][callee.object.name="Promise"][callee.property.name="reject"]'(node) {
+        if (isTestFile()) return;
+
+        const arg = node.arguments[0];
+        if (arg && arg.type === 'NewExpression' && 
+            arg.callee && arg.callee.name === 'Error') {
+          context.report({
+            node: arg,
+            messageId: "useCustomError"
+          });
+        }
+      },
+
+      // Check for async function error throwing
+      'AwaitExpression > CallExpression[callee.type="MemberExpression"][callee.property.name="reject"]'(node) {
+        if (isTestFile()) return;
+
+        const arg = node.arguments[0];
+        if (arg && arg.type === 'NewExpression' && 
+            arg.callee && arg.callee.name === 'Error') {
+          context.report({
+            node: arg,
+            messageId: "useCustomError"
+          });
+        }
+      }
+    };
+  }
+};
+
+module.exports = c030Rule;

package/integrations/eslint/plugin/rules/common/c035-no-empty-catch.js

@@ -0,0 +1,162 @@
+/**
+ * Custom ESLint rule for: C035 – No empty catch blocks (without error handling or logging)
+ * Rule ID: custom/c035
+ * Purpose: Prevent silently swallowing errors in catch blocks without logging or handling them
+ * Note: Primarily intended for backend code. Frontend may handle errors through UI.
+ */
+
+module.exports = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "No empty catch blocks (without error handling or logging)",
+      recommended: true
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          allowFrontend: {
+            type: "boolean",
+            default: true
+          },
+          allowIgnoredParams: {
+            type: "boolean", 
+            default: true
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      emptyCatch: "Empty catch blocks are not allowed. Errors should be logged or handled explicitly.",
+      emptyCatchBackend: "Backend code must log errors in catch blocks. Consider using console.error(), logger, or proper error handling."
+    }
+  },
+  create(context) {
+    const options = context.options[0] || {};
+    const allowFrontend = options.allowFrontend !== false;
+    const allowIgnoredParams = options.allowIgnoredParams !== false;
+    
+    function isBackendFile(filename) {
+      // Heuristics to determine if it's a backend file
+      const backendPatterns = [
+        /server/i, /backend/i, /api/i, /service/i, 
+        /controller/i, /model/i, /dao/i, /repository/i,
+        /middleware/i, /route/i, /endpoint/i
+      ];
+      
+      return backendPatterns.some(pattern => pattern.test(filename));
+    }
+    
+    function isFrontendFile(filename) {
+      // Heuristics to determine if it's a frontend file  
+      const frontendPatterns = [
+        /component/i, /page/i, /screen/i, /view/i,
+        /ui/i, /frontend/i, /client/i, /app/i,
+        /hook/i, /context/i, /store/i, /reducer/i
+      ];
+      
+      return frontendPatterns.some(pattern => pattern.test(filename));
+    }
+    
+    function isIntentionallyIgnored(param) {
+      if (!param || !param.name) return false;
+      
+      const ignoredPatterns = [
+        'ignored', '_', '__', 'unused', 'ignore', 
+        '_error', '_err', '_e', 'ignored_error'
+      ];
+      
+      const paramName = param.name.toLowerCase();
+      return ignoredPatterns.some(pattern => 
+        paramName === pattern || paramName.includes('ignored')
+      );
+    }
+    
+    function hasFrontendErrorHandling(body) {
+      // Check for common frontend error handling patterns
+      const bodyText = context.getSourceCode().getText(body);
+      const frontendPatterns = [
+        /show.*error/i, /display.*error/i, /toast/i, /alert/i,
+        /notification/i, /modal/i, /snackbar/i, /message/i,
+        /set.*error/i, /error.*state/i, /ui.*error/i
+      ];
+      
+      return frontendPatterns.some(pattern => pattern.test(bodyText));
+    }
+
+    return {
+      CatchClause(node) {
+        const filename = context.getFilename();
+        const body = node.body && node.body.body;
+        const param = node.param;
+        
+        // Allow intentionally ignored parameters
+        if (allowIgnoredParams && isIntentionallyIgnored(param)) {
+          return;
+        }
+        
+        // Check if catch block is empty
+        if (!Array.isArray(body) || body.length === 0) {
+          const isBackend = isBackendFile(filename);
+          const isFrontend = isFrontendFile(filename);
+          
+          // For backend files, always report
+          if (isBackend) {
+            context.report({
+              node,
+              messageId: "emptyCatchBackend"
+            });
+            return;
+          }
+          
+          // For frontend files, be more lenient if option is set
+          if (isFrontend && allowFrontend) {
+            return; // Allow empty catch in frontend
+          }
+          
+          // Default behavior for unclassified files
+          context.report({
+            node,
+            messageId: "emptyCatch"
+          });
+          return;
+        }
+        
+        // Check for proper error handling in non-empty blocks
+        const hasLogging = body.some(statement => {
+          const text = context.getSourceCode().getText(statement);
+          return /console\.(error|warn|log)|logger\.|log\(|throw\s/i.test(text);
+        });
+        
+        const isBackend = isBackendFile(filename);
+        const isFrontend = isFrontendFile(filename);
+        
+        // Backend should have logging or re-throwing
+        if (isBackend && !hasLogging) {
+          // Check if there's at least some error handling
+          const hasAnyHandling = body.some(statement => {
+            const text = context.getSourceCode().getText(statement);
+            return /error|err|exception|fail/i.test(text);
+          });
+          
+          if (!hasAnyHandling) {
+            context.report({
+              node,
+              messageId: "emptyCatchBackend"
+            });
+          }
+        }
+        
+        // Frontend can handle through UI
+        if (isFrontend && allowFrontend) {
+          const hasFrontendHandling = hasFrontendErrorHandling(node.body);
+          if (hasLogging || hasFrontendHandling) {
+            return; // OK for frontend
+          }
+        }
+      }
+    };
+  }
+};

package/integrations/eslint/plugin/rules/common/c041-no-config-inline.js

@@ -0,0 +1,122 @@
+/**
+ * Custom ESLint rule for: C041 – No Hardcoded Sensitive Information
+ * Rule ID: custom/c041
+ * Purpose: Detect hardcoded sensitive information while avoiding false positives in UI/component contexts
+ */
+
+module.exports = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "No hardcoded sensitive information",
+      recommended: false
+    },
+    schema: [],
+    messages: {
+      inlineConfig: "Potential hardcoded sensitive information detected. Move sensitive values to environment variables or secure config files."
+    }
+  },
+  create(context) {
+    function isConfigOrUIContext(line) {
+      const lowerLine = line.toLowerCase();
+      
+      // UI/Component contexts - likely false positives
+      const uiContexts = [
+        'inputtype', 'type:', 'type =', 'inputtype=',
+        'routes =', 'route:', 'path:', 'routes:', 
+        'import {', 'export {', 'from ', 'import ',
+        'interface', 'type ', 'enum ',
+        'props:', 'defaultprops',
+        'schema', 'validator',
+        'hook', 'use', 'const use', 'import.*use',
+        // React/UI specific
+        'textinput', 'input ', 'field ', 'form',
+        'component', 'page', 'screen', 'modal',
+        // Route/navigation specific  
+        'navigation', 'route', 'path', 'url:', 'route:',
+        'setuppassword', 'resetpassword', 'forgotpassword',
+        'changepassword', 'confirmpassword'
+      ];
+      
+      return uiContexts.some(context => lowerLine.includes(context));
+    }
+    
+    function isFalsePositive(value, sourceCode) {
+      const lowerValue = value.toLowerCase();
+      
+      // Global false positive indicators
+      const globalFalsePositives = [
+        'test', 'mock', 'example', 'demo', 'sample', 'placeholder', 'dummy', 'fake',
+        'xmlns', 'namespace', 'schema', 'w3.org', 'google.com', 'googleapis.com',
+        'error', 'message', 'missing', 'invalid', 'failed', 'localhost', '127.0.0.1'
+      ];
+      
+      // Check global false positives
+      if (globalFalsePositives.some(pattern => lowerValue.includes(pattern))) {
+        return true;
+      }
+      
+      // Check if line context suggests UI/component usage
+      if (isConfigOrUIContext(sourceCode)) {
+        return true;
+      }
+      
+      return false;
+    }
+
+    const sensitivePatterns = [
+      { pattern: /password/i, minLength: 4 },
+      { pattern: /secret/i, minLength: 6 },
+      { pattern: /api[_-]?key/i, minLength: 10 },
+      { pattern: /auth[_-]?token/i, minLength: 16 },
+      { pattern: /access[_-]?token/i, minLength: 16 },
+      { pattern: /(mongodb|mysql|postgres|redis):\/\//i, minLength: 10 }
+    ];
+
+    function reportIfSensitive(node) {
+      const sourceCode = context.getSourceCode();
+      const lineText = sourceCode.lines[node.loc.start.line - 1];
+      
+      if (typeof node.value !== "string" || node.value.length < 4) return;
+      
+      // Skip if it's in a UI/component context
+      if (isFalsePositive(node.value, lineText)) {
+        return;
+      }
+      
+      // Check against sensitive patterns - both variable name and value
+      const lowerLine = lineText.toLowerCase();
+      const lowerValue = node.value.toLowerCase();
+      
+      for (const { pattern, minLength } of sensitivePatterns) {
+        // Check if pattern matches variable name OR value
+        const matchesValue = pattern.test(node.value) && node.value.length >= minLength;
+        const matchesLine = pattern.test(lineText) && node.value.length >= minLength;
+        
+        if (matchesValue || matchesLine) {
+          context.report({
+            node,
+            messageId: "inlineConfig"
+          });
+          break;
+        }
+      }
+    }
+
+    return {
+      Literal(node) {
+        reportIfSensitive(node);
+      },
+      TemplateLiteral(node) {
+        if (node.quasis.length === 1) {
+          // Create a mock node for template literal value
+          const mockNode = {
+            ...node,
+            value: node.quasis[0].value.raw
+          };
+          reportIfSensitive(mockNode);
+        }
+      }
+    };
+  }
+};