@sun-asterisk/sunlint 1.0.5

package/eslint-integration/eslint-plugin-custom/t002-interface-prefix-i.js

@@ -0,0 +1,42 @@
+/**
+ * Custom ESLint rule for: T002 – Interface names should start with 'I'
+ * Rule ID: custom/t002
+ * Purpose: Enforce consistent interface naming convention by requiring the 'I' prefix
+ */
+
+"use strict";
+
+module.exports = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Interface names should start with 'I'",
+      recommended: false
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      interfacePrefix: "Interface name '{{name}}' should start with 'I'"
+    }
+  },
+
+  create(context) {
+    return {
+      TSInterfaceDeclaration(node) {
+        const interfaceName = node.id.name;
+        if (!interfaceName.startsWith("I")) {
+          context.report({
+            node: node.id,
+            messageId: "interfacePrefix",
+            data: {
+              name: interfaceName,
+            },
+            fix(fixer) {
+              return fixer.replaceText(node.id, `I${interfaceName}`);
+            },
+          });
+        }
+      },
+    };
+  },
+};

package/eslint-integration/eslint-plugin-custom/t003-ts-ignore-reason.js

@@ -0,0 +1,48 @@
+/**
+ * Custom ESLint rule for: T003 – Avoid using @ts-ignore without a justification
+ * Rule ID: custom/t003
+ * Purpose: Ensure @ts-ignore comments include a reason to maintain code quality and documentation
+ */
+
+"use strict";
+
+module.exports = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Avoid using @ts-ignore without a justification",
+      recommended: false
+    },
+    fixable: null,
+    schema: [],
+    messages: {
+      tsIgnoreReason: "Please provide a reason for using @ts-ignore"
+    }
+  },
+
+  create(context) {
+    return {
+      Program() {
+        const sourceCode = context.getSourceCode();
+        const comments = sourceCode.getAllComments();
+
+        comments.forEach((comment) => {
+          if (comment.type === "Line" && comment.value.includes("@ts-ignore")) {
+            // Check if there's a justification after @ts-ignore
+            const hasJustification = comment.value
+              .replace("@ts-ignore", "")
+              .trim()
+              .length > 0;
+
+            if (!hasJustification) {
+              context.report({
+                node: comment,
+                messageId: "tsIgnoreReason",
+              });
+            }
+          }
+        });
+      },
+    };
+  },
+};

package/eslint-integration/eslint-plugin-custom/t004-interface-public-only.js

@@ -0,0 +1,160 @@
+/**
+ * Custom ESLint rule for: T004 – Interface chỉ nên chứa public method
+ * Rule ID: custom/t004
+ * Purpose: Interface là hợp đồng, không được có logic private/internal
+ */
+
+"use strict";
+
+module.exports = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Interface chỉ nên chứa public method",
+      category: "TypeScript",
+      recommended: true,
+    },
+    fixable: null,
+    schema: [],
+    messages: {
+      interfacePrivateMethod: "Interface không được chứa private method '{{methodName}}'. Interface là hợp đồng public, hãy chuyển logic private sang class implementation.",
+      interfaceProtectedMethod: "Interface không được chứa protected method '{{methodName}}'. Interface là hợp đồng public, hãy chuyển logic protected sang class implementation.",
+      interfacePrivateProperty: "Interface không được chứa private property '{{propertyName}}'. Interface là hợp đồng public, hãy chuyển property private sang class implementation.",
+      interfaceProtectedProperty: "Interface không được chứa protected property '{{propertyName}}'. Interface là hợp đồng public, hãy chuyển property protected sang class implementation.",
+      interfaceImplementation: "Interface không được chứa implementation logic trong method '{{methodName}}'. Interface chỉ định nghĩa hợp đồng, không có implementation.",
+      interfacePrivateNamingMethod: "Interface method '{{methodName}}' có tên gợi ý private (bắt đầu với _). Interface chỉ nên chứa public contract, hãy remove hoặc chuyển sang class implementation.",
+      interfacePrivateNamingProperty: "Interface property '{{propertyName}}' có tên gợi ý private (bắt đầu với _). Interface chỉ nên chứa public contract, hãy remove hoặc chuyển sang class implementation.",
+      interfaceImplementationDetails: "Interface method '{{methodName}}' leak implementation details. Interface nên abstract, không expose chi tiết implementation như SQL, cache, connection handling.",
+      interfaceInternalState: "Interface property '{{propertyName}}' expose internal state management. Interface nên chỉ define public contract, không expose internal resources.",
+    },
+  },
+
+  create(context) {
+    // Helper function to check if a name suggests private/internal usage
+    function isPrivateNaming(name) {
+      return name && (name.startsWith('_') || name.startsWith('__'));
+    }
+    
+    // Helper function to check if method name suggests implementation details
+    function isImplementationDetail(name) {
+      const implementationKeywords = [
+        'buildSql', 'executeRaw', 'handleConnection', 'logQuery', 'log',
+        'buildQuery', 'executeQuery', 'handleRetry', 'handleError',
+        'internal', 'cache', 'pool', 'connection', 'retry', 'performance'
+      ];
+      
+      return name && implementationKeywords.some(keyword => 
+        name.toLowerCase().includes(keyword.toLowerCase())
+      );
+    }
+    
+    // Helper function to check if property suggests internal state
+    function isInternalState(name) {
+      const internalStateKeywords = [
+        'pool', 'cache', 'connection', 'internal', 'secret', 'config',
+        'state', 'buffer', 'queue', 'stack', 'heap'
+      ];
+      
+      return name && internalStateKeywords.some(keyword => 
+        name.toLowerCase().includes(keyword.toLowerCase())
+      );
+    }
+    
+    return {
+      TSInterfaceDeclaration(node) {
+        // Kiểm tra từng member trong interface
+        node.body.body.forEach(member => {
+          // Kiểm tra method signature
+          if (member.type === 'TSMethodSignature') {
+            const methodName = member.key.name || member.key.value;
+            
+            // Kiểm tra accessibility modifiers (for completeness, though TS doesn't allow this)
+            if (member.accessibility === 'private') {
+              context.report({
+                node: member,
+                messageId: "interfacePrivateMethod",
+                data: { methodName }
+              });
+            }
+            
+            if (member.accessibility === 'protected') {
+              context.report({
+                node: member,
+                messageId: "interfaceProtectedMethod",
+                data: { methodName }
+              });
+            }
+            
+            // Kiểm tra tên method có gợi ý private không
+            if (isPrivateNaming(methodName)) {
+              context.report({
+                node: member,
+                messageId: "interfacePrivateNamingMethod",
+                data: { methodName }
+              });
+            }
+            
+            // Kiểm tra method có leak implementation details không
+            if (isImplementationDetail(methodName)) {
+              context.report({
+                node: member,
+                messageId: "interfaceImplementationDetails",
+                data: { methodName }
+              });
+            }
+          }
+          
+          // Kiểm tra property signature
+          if (member.type === 'TSPropertySignature') {
+            const propertyName = member.key.name || member.key.value;
+            
+            // Kiểm tra accessibility modifiers
+            if (member.accessibility === 'private') {
+              context.report({
+                node: member,
+                messageId: "interfacePrivateProperty",
+                data: { propertyName }
+              });
+            }
+            
+            if (member.accessibility === 'protected') {
+              context.report({
+                node: member,
+                messageId: "interfaceProtectedProperty",
+                data: { propertyName }
+              });
+            }
+            
+            // Kiểm tra tên property có gợi ý private không
+            if (isPrivateNaming(propertyName)) {
+              context.report({
+                node: member,
+                messageId: "interfacePrivateNamingProperty",
+                data: { propertyName }
+              });
+            }
+            
+            // Kiểm tra property có expose internal state không
+            if (isInternalState(propertyName)) {
+              context.report({
+                node: member,
+                messageId: "interfaceInternalState",
+                data: { propertyName }
+              });
+            }
+          }
+          
+          // Kiểm tra nếu có implementation trong interface (thường không xảy ra trong TS, nhưng để đảm bảo)
+          if (member.type === 'MethodDefinition' && member.value && member.value.body) {
+            const methodName = member.key.name || member.key.value;
+            context.report({
+              node: member,
+              messageId: "interfaceImplementation",
+              data: { methodName }
+            });
+          }
+        });
+      }
+    };
+  },
+};

package/eslint-integration/eslint-plugin-custom/t007-no-fn-in-constructor.js

@@ -0,0 +1,52 @@
+/**
+ * Custom ESLint rule for: T007 – Avoid declaring functions inside constructors or class bodies
+ * Rule ID: custom/t007
+ * Purpose: Prevent function declarations inside constructors and class bodies to maintain clean code structure
+ */
+
+module.exports = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Avoid declaring functions inside constructors or class bodies",
+      recommended: false
+    },
+    schema: [],
+    messages: {
+      noFunctionInConstructor: "Avoid declaring functions inside class constructors.",
+      noFunctionInClassBody: "Avoid declaring nested functions inside class body."
+    }
+  },
+  create(context) {
+    return {
+      MethodDefinition(node) {
+        if (node.kind === "constructor" && node.value && node.value.body && node.value.body.body) {
+          const constructorBody = node.value.body.body;
+          constructorBody.forEach(element => {
+            if (element.type === "FunctionDeclaration" || element.type === "FunctionExpression") {
+              context.report({
+                node: element,
+                messageId: "noFunctionInConstructor"
+              });
+            }
+          });
+        }
+      },
+      ClassBody(node) {
+        node.body.forEach(element => {
+          if (element.type === "MethodDefinition" && element.value && element.value.body && element.value.body.body) {
+            const methodBody = element.value.body.body;
+            methodBody.forEach(subNode => {
+              if (subNode.type === "FunctionDeclaration") {
+                context.report({
+                  node: subNode,
+                  messageId: "noFunctionInClassBody"
+                });
+              }
+            });
+          }
+        });
+      }
+    };
+  }
+};

package/eslint-integration/eslint-plugin-custom/t011-no-real-time-dependency.js

@@ -0,0 +1,175 @@
+/**
+ * Custom ESLint rule for: T011 – Test không nên phụ thuộc vào thời gian thực
+ * Rule ID: custom/t011
+ * Purpose: Detect real-time dependencies in tests like setTimeout, delay, sleep, etc.
+ */
+
+module.exports = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Test không nên phụ thuộc vào thời gian thực (No real-time dependencies in tests)",
+      isRecommended: true
+    },
+    schema: [],
+    messages: {
+      noRealTimeDelay: "Test should not depend on real-time delays. Use mocks, stubs, or deterministic approaches instead of '{{method}}'.",
+      noDateNow: "Test should not depend on current timestamp. Use mock time or inject clock instead of 'Date.now()' or 'new Date()'.",
+      noSetTimeout: "Test should not use setTimeout/setInterval for delays. Use mock timers or deterministic test patterns.",
+      noThreadSleep: "Test should not use Thread.sleep() or similar blocking delays. Use mock objects or callbacks."
+    }
+  },
+  create(context) {
+    
+    const TEST_FUNCTIONS = ["test", "it", "beforeEach", "beforeAll", "afterEach", "afterAll"];
+    const DESCRIBE_FUNCTIONS = ["describe", "context", "suite"];
+    const PROBLEMATIC_TIMERS = ["setTimeout", "setInterval", "setImmediate", "delay", "sleep", "wait", "pause"];
+    
+    // Check if current context is inside a test function
+    function isInTestContext(node) {
+      let parent = node.parent;
+      while (parent) {
+        if (parent.type === "CallExpression" && isTestOrDescribeFunction(parent)) {
+          return true;
+        }
+        parent = parent.parent;
+      }
+      return false;
+    }
+
+    function isTestOrDescribeFunction(node) {
+      if (!node || !node.callee) {
+        return false;
+      }
+
+      if (node.type === "CallExpression") {
+        const allTestFunctions = [...TEST_FUNCTIONS, ...DESCRIBE_FUNCTIONS];
+        
+        // Handle direct calls
+        if (node.callee.type === "Identifier") {
+          return allTestFunctions.includes(node.callee.name);
+        }
+        
+        // Handle member expression calls like test.skip, describe.only
+        if (node.callee.type === "MemberExpression" &&
+            node.callee.object.type === "Identifier") {
+          const baseName = node.callee.object.name;
+          return allTestFunctions.includes(baseName);
+        }
+      }
+
+      return false;
+    }
+
+    function checkProblematicMethod(node, methodName, messageId = "noSetTimeout") {
+      if (PROBLEMATIC_TIMERS.includes(methodName)) {
+        context.report({
+          node,
+          messageId,
+          data: { method: methodName }
+        });
+      }
+    }
+
+    return {
+      // Detect setTimeout, setInterval calls
+      CallExpression(node) {
+        if (!isInTestContext(node)) {
+          return;
+        }
+
+        const callee = node.callee;
+        
+        // Direct function calls
+        if (callee.type === "Identifier") {
+          checkProblematicMethod(node, callee.name);
+        }
+        
+        // Member expression calls
+        if (callee.type === "MemberExpression" && callee.property && callee.property.type === "Identifier") {
+          checkProblematicMethod(node, callee.property.name);
+        }
+
+        // Promise-based delays
+        if (callee.type === "Identifier" && callee.name === "Promise" && 
+            node.arguments.length > 0 && node.arguments[0].type === "ArrowFunctionExpression") {
+          const promiseBody = node.arguments[0].body;
+          if (promiseBody && promiseBody.type === "CallExpression" && 
+              promiseBody.callee && promiseBody.callee.name === "setTimeout") {
+            context.report({
+              node,
+              messageId: "noRealTimeDelay",
+              data: { method: "Promise + setTimeout" }
+            });
+          }
+        }
+      },
+
+      // Detect Date.now(), new Date() without parameters
+      NewExpression(node) {
+        if (!isInTestContext(node)) {
+          return;
+        }
+
+        if (node.callee.type === "Identifier" && node.callee.name === "Date" && node.arguments.length === 0) {
+          context.report({
+            node,
+            messageId: "noDateNow"
+          });
+        }
+      },
+
+      // Detect Date.now() calls
+      MemberExpression(node) {
+        if (!isInTestContext(node)) {
+          return;
+        }
+
+        if (node.object.type === "Identifier" && 
+            node.object.name === "Date" && 
+            node.property.type === "Identifier" && 
+            node.property.name === "now") {
+          context.report({
+            node,
+            messageId: "noDateNow"
+          });
+        }
+      },
+
+      // Detect await expressions with timing-based patterns
+      AwaitExpression(node) {
+        if (!isInTestContext(node)) {
+          return;
+        }
+
+        const argument = node.argument;
+        
+        // await new Promise(resolve => setTimeout(...))
+        if (argument.type === "NewExpression" && 
+            argument.callee.type === "Identifier" && 
+            argument.callee.name === "Promise") {
+          context.report({
+            node,
+            messageId: "noRealTimeDelay",
+            data: { method: "await Promise + delay" }
+          });
+        }
+
+        // await sleep(), await delay(), etc.
+        if (argument.type === "CallExpression" && 
+            argument.callee.type === "Identifier") {
+          const methodName = argument.callee.name;
+          const problematicAsyncMethods = ["sleep", "delay", "wait", "pause"];
+          
+          if (problematicAsyncMethods.includes(methodName)) {
+            context.report({
+              node,
+              messageId: "noRealTimeDelay",
+              data: { method: `await ${methodName}` }
+            });
+          }
+        }
+      }
+    };
+  }
+};

package/eslint-integration/eslint-plugin-custom/t019-no-empty-type.js

@@ -0,0 +1,95 @@
+/**
+ * Custom ESLint rule for: T019 – Disallow empty type definitions
+ * Rule ID: custom/t019
+ * Purpose: Prevent empty type definitions and suggest more specific types
+ */
+
+"use strict";
+
+module.exports = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow empty type definitions",
+      category: "TypeScript",
+      recommended: true,
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      emptyType: "Empty type definition is not allowed. Add at least one property or use a more specific type.",
+    },
+  },
+
+  create(context) {
+    // Helper function to get a more specific type suggestion based on the name
+    function getSuggestedType(name) {
+      const lowerName = name.toLowerCase();
+      
+      // Suggest more specific types based on common naming patterns
+      if (lowerName.includes("config") || lowerName.includes("options")) {
+        return "Record<string, unknown>";
+      }
+      if (lowerName.includes("props")) {
+        return "Record<string, React.ReactNode>";
+      }
+      if (lowerName.includes("state")) {
+        return "Record<string, unknown>";
+      }
+      if (lowerName.includes("params")) {
+        return "Record<string, string | number | boolean>";
+      }
+      if (lowerName.includes("result") || lowerName.includes("response")) {
+        return "Record<string, unknown>";
+      }
+      if (lowerName.includes("event") || lowerName.includes("handler")) {
+        return "(...args: unknown[]) => void";
+      }
+      if (lowerName.includes("callback") || lowerName.includes("fn")) {
+        return "(...args: unknown[]) => unknown";
+      }
+      if (lowerName.includes("data") || lowerName.includes("item")) {
+        return "Record<string, unknown>";
+      }
+      
+      // Default suggestion
+      return "Record<string, unknown>";
+    }
+
+    return {
+      TSInterfaceDeclaration(node) {
+        if (node.body.body.length === 0) {
+          const suggestedType = getSuggestedType(node.id.name);
+          context.report({
+            node: node.body,
+            messageId: "emptyType",
+            fix(fixer) {
+              return fixer.replaceText(
+                node,
+                `type ${node.id.name} = ${suggestedType};`
+              );
+            },
+          });
+        }
+      },
+      TSTypeAliasDeclaration(node) {
+        if (
+          node.typeAnnotation.type === "TSTypeLiteral" &&
+          node.typeAnnotation.members.length === 0
+        ) {
+          const suggestedType = getSuggestedType(node.id.name);
+          context.report({
+            node: node.typeAnnotation,
+            messageId: "emptyType",
+            fix(fixer) {
+              return fixer.replaceText(
+                node.typeAnnotation,
+                suggestedType
+              );
+            },
+          });
+        }
+      },
+    };
+  },
+};

package/eslint-integration/eslint-plugin-custom/t025-no-nested-union-tuple.js

@@ -0,0 +1,48 @@
+/**
+ * Custom ESLint rule for: T025 – Avoid deeply nested union or tuple types
+ * Rule ID: custom/t025
+ * Purpose: Prevent complex nested union or tuple types to maintain type readability and simplicity
+ */
+
+module.exports = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Avoid deeply nested union or tuple types",
+      recommended: false
+    },
+    schema: [],
+    messages: {
+      nestedUnion: "Avoid nested union types.",
+      nestedTuple: "Avoid nested tuple types."
+    }
+  },
+  create(context) {
+    function checkNestedTypes(node) {
+      if (node.type === 'TSUnionType') {
+        const nested = node.types.some(t => t.type === 'TSUnionType' || t.type === 'TSTupleType');
+        if (nested) {
+          context.report({
+            node,
+            messageId: "nestedUnion"
+          });
+        }
+      }
+
+      if (node.type === 'TSTupleType') {
+        const nested = node.elementTypes.some(t => t.type === 'TSTupleType' || t.type === 'TSUnionType');
+        if (nested) {
+          context.report({
+            node,
+            messageId: "nestedTuple"
+          });
+        }
+      }
+    }
+
+    return {
+      TSUnionType: checkNestedTypes,
+      TSTupleType: checkNestedTypes
+    };
+  }
+};