@sun-asterisk/sunlint 1.0.6 → 1.0.7

package/eslint-integration/eslint-plugin-custom/c030-use-custom-error-classes.js

@@ -1,294 +0,0 @@
-/**
- * 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/eslint-integration/eslint-plugin-custom/c034-no-implicit-return.js

@@ -1,34 +0,0 @@
-/**
- * Custom ESLint rule for: C034 – Do not use implicit return in arrow functions
- * Rule ID: custom/c034
- * Goal: Avoid using arrow functions with implicit return as they can be hard to read, use explicit return with braces
- */
-
-module.exports = {
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Do not use implicit return in arrow functions",
-      recommended: false
-    },
-    schema: [],
-    messages: {
-      implicitReturn: "Do not use implicit return. Use explicit return with {{ braces }}."
-    }
-  },
-  create(context) {
-    return {
-      ArrowFunctionExpression(node) {
-        if (node.body && node.body.type !== "BlockStatement") {
-          context.report({
-            node,
-            messageId: "implicitReturn",
-            data: {
-              braces: "{ ... }"
-            }
-          });
-        }
-      }
-    };
-  }
-};

package/eslint-integration/eslint-plugin-custom/c035-no-empty-catch.js

@@ -1,32 +0,0 @@
-/**
- * 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
- */
-
-module.exports = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "No empty catch blocks (without error handling or logging)",
-      recommended: true
-    },
-    schema: [],
-    messages: {
-      emptyCatch: "Empty catch blocks are not allowed. Errors should be logged or handled explicitly."
-    }
-  },
-  create(context) {
-    return {
-      CatchClause(node) {
-        const body = node.body && node.body.body;
-        if (Array.isArray(body) && body.length === 0) {
-          context.report({
-            node,
-            messageId: "emptyCatch"
-          });
-        }
-      }
-    };
-  }
-};

package/eslint-integration/eslint-plugin-custom/c041-no-config-inline.js

@@ -1,64 +0,0 @@
-/**
- * Custom ESLint rule for: C041 – Do not hardcode constants scattered throughout logic
- * Rule ID: custom/c041
- * Purpose: Enforce centralized configuration management by preventing scattered constant declarations
- */
-
-module.exports = {
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Do not hardcode constants scattered throughout logic",
-      recommended: false
-    },
-    schema: [],
-    messages: {
-      inlineConfig: "Do not hardcode configuration values. Move them to a centralized config file."
-    }
-  },
-  create(context) {
-    const suspiciousPatterns = [
-      /password/i,
-      /secret/i,
-      /api[_-]?key/i,
-      /auth[_-]?token/i,
-      /access[_-]?token/i,
-      /localhost/i,
-      /127\.0\.0\.1/,
-      /http:\/\//i,
-      /https:\/\//i,
-      /db[_-]?(url|uri|name|conn)/i,
-      /conn(ect)?ion[_-]?string/i
-    ];
-
-    function reportIfHardcoded(node, value) {
-      if (typeof value !== "string") return;
-      for (const pattern of suspiciousPatterns) {
-        if (pattern.test(value)) {
-          context.report({
-            node,
-            messageId: "inlineConfig",
-            data: { value }
-          });
-          break;
-        }
-      }
-    }
-
-    return {
-      Literal(node) {
-        if (typeof node.value === "string") {
-          reportIfHardcoded(node, node.value);
-        }
-      },
-      TemplateLiteral(node) {
-        if (
-          node.quasis.length === 1 &&
-          typeof node.quasis[0].value.raw === "string"
-        ) {
-          reportIfHardcoded(node, node.quasis[0].value.raw);
-        }
-      }
-    };
-  }
-};