@sun-asterisk/sunlint 1.3.2 → 1.3.3

package/rules/common/C048_no_bypass_architectural_layers/symbol-based-analyzer.js

@@ -0,0 +1,235 @@
+/**
+ * C048 Symbol-based Analyzer - Advanced Do not bypass architectural layers (controller/service/repository)
+ * Purpose: Use AST + Symbol Resolution to clear layered architecture, ensuring logic and data flow are well-structured and maintainable.
+ */
+
+// c048-symbol-analyzer.js
+const path = require("path");
+const { SyntaxKind } = require("ts-morph");
+
+class C048SymbolBasedAnalyzer {
+  constructor(semanticEngine = null) {
+    this.ruleId = "C048";
+    this.ruleName =
+      "Error bypass architectural layers (controller/service/repository) (Symbol-Based)";
+    this.semanticEngine = semanticEngine;
+    this.verbose = false;
+
+    this.layers = {
+      controller: "controller",
+      service: "service",
+      repository: "repository",
+      other: "other",
+    };
+
+    this.dirHints = {
+      controller: [/^controllers?$/i, /controller/i],
+      service: [/^services?$/i, /service/i],
+      repository: [/^repositories?$/i, /repository/i, /repos?$/i],
+    };
+
+    this.classSuffix = {
+      controller: /Controller$/,
+      service: /Service$/,
+      repository: /Repository$/,
+    };
+
+    // 🔧 FIX: arrays, not strings
+    this.forbiddenImports = {
+      controller: ["repository"], // Controllers must not import repositories
+      service: ["controller"], // Services must not import controllers
+    };
+  }
+
+  async initialize(semanticEngine = null) {
+    if (semanticEngine) {
+      this.semanticEngine = semanticEngine;
+    }
+    this.verbose = semanticEngine?.verbose || false;
+    if (process.env.SUNLINT_DEBUG) {
+      console.log(
+        `🔧 [C048 Symbol-Based] Analyzer initialized, verbose: ${this.verbose}`
+      );
+    }
+  }
+
+  async analyzeFileBasic(filePath, options = {}) {
+    return await this.analyzeFileWithSymbols(filePath, options);
+  }
+
+  async analyzeFileWithSymbols(filePath, options = {}) {
+    const violations = [];
+    const verbose = options.verbose || this.verbose;
+
+    if (!this.semanticEngine?.project) {
+      if (verbose) {
+        console.warn(
+          "[C048 Symbol-Based] No semantic engine available, skipping analysis"
+        );
+      }
+      return violations;
+    }
+
+    try {
+      const sourceFile = this.semanticEngine.project.getSourceFile(filePath);
+      if (!sourceFile) return violations;
+
+      const fileLayer = this.inferLayer(sourceFile);
+      if (verbose) {
+        console.log(`🔍 Analyzing ${filePath} → layer = ${fileLayer}`);
+      }
+
+      if (
+        ![this.layers.controller, this.layers.service].includes(fileLayer)
+      ) {
+        return violations;
+      }
+
+      const forbidden = new Set(this.forbiddenImports[fileLayer] || []);
+
+      // 1) Import-based violations
+      for (const imp of sourceFile.getImportDeclarations()) {
+        const targetLayer = this.getImportedTargetLayer(imp);
+        if (verbose) {
+          console.log(
+            `   import ${imp.getModuleSpecifierValue()} → layer ${targetLayer}`
+          );
+        }
+        if (!targetLayer) continue;
+        if (forbidden.has(targetLayer)) {
+          violations.push({
+            ruleId: this.ruleId,
+            severity: "warning",
+            message:
+              fileLayer === this.layers.controller
+                ? "Controllers should not import Repositories. Depend on a Service instead."
+                : "Services should not import Controllers. Keep presentation layer out of service logic.",
+            source: this.ruleId,
+            file: filePath,
+            line: imp.getStartLineNumber(),
+            column: imp.getStart() - imp.getStartLinePos(),
+            description: `[SYMBOL-BASED] Bypassing architectural layers detected: ${fileLayer} importing ${targetLayer}`,
+            suggestion: "Refactor to use appropriate layer dependencies",
+            category: "Architecture",
+          });
+        }
+      }
+
+      // 2) new XRepository() / new XController()
+      const badSuffix =
+        fileLayer === this.layers.controller
+          ? this.classSuffix.repository
+          : this.classSuffix.controller;
+
+      sourceFile.forEachDescendant((node) => {
+        if (node.getKind() === SyntaxKind.NewExpression) {
+          const expr = node;
+          const exprText = expr.getExpression().getText();
+          if (badSuffix.test(exprText)) {
+            violations.push({
+              ruleId: this.ruleId,
+              severity: "warning",
+              message:
+                fileLayer === this.layers.controller
+                  ? "Controllers should not instantiate Repositories directly. Call a Service."
+                  : "Services should not instantiate Controllers.",
+              source: this.ruleId,
+              file: filePath,
+              line: expr.getStartLineNumber(),
+              column: expr.getStart() - expr.getStartLinePos(),
+              description: `[SYMBOL-BASED] Bypassing architectural layers detected: ${fileLayer} instantiating ${exprText}`,
+              suggestion: "Refactor to use appropriate layer dependencies",
+              category: "Architecture",
+            });
+          }
+        }
+      });
+
+      // 3) property/param types referring to forbidden classes
+      sourceFile.forEachDescendant((node) => {
+        if (
+          node.getKind() === SyntaxKind.PropertyDeclaration ||
+          node.getKind() === SyntaxKind.Parameter ||
+          node.getKind() === SyntaxKind.VariableDeclaration
+        ) {
+          const typeNode = node.getTypeNode?.();
+          if (!typeNode) return;
+          const t = typeNode.getText();
+          if (badSuffix.test(t)) {
+            violations.push({
+              ruleId: this.ruleId,
+              severity: "warning",
+              message:
+                fileLayer === this.layers.controller
+                  ? "Controllers should not hold Repository-typed members. Inject a Service instead."
+                  : "Services should not reference Controller types.",
+              source: this.ruleId,
+              file: filePath,
+              line: node.getStartLineNumber(),
+              column: node.getStart() - node.getStartLinePos(),
+              description: `[SYMBOL-BASED] Bypassing architectural layers detected: ${fileLayer} using ${t} type`,
+              suggestion: "Refactor to use appropriate layer dependencies",
+              category: "Architecture",
+            });
+          }
+        }
+      });
+
+      if (verbose) {
+        console.log(
+          `🔍 [C048 Symbol-Based] Total violations found: ${violations.length}`
+        );
+      }
+
+      return violations;
+    } catch (error) {
+      if (verbose) {
+        console.warn(
+          `[C048 Symbol-Based] Analysis failed for ${filePath}:`,
+          error.message
+        );
+      }
+      return violations;
+    }
+  }
+
+  inferLayerFromPath(filePath) {
+    const parts = filePath.split(path.sep);
+    for (const seg of parts) {
+      for (const [layer, patterns] of Object.entries(this.dirHints)) {
+        if (patterns.some((re) => re.test(seg))) return layer;
+      }
+    }
+    const base = path.basename(filePath, path.extname(filePath));
+    for (const [layer, re] of Object.entries(this.classSuffix)) {
+      if (re.test(base)) return layer;
+    }
+    return this.layers.other;
+  }
+
+  inferLayerFromClasses(sourceFile) {
+    const classes = sourceFile.getClasses();
+    for (const cls of classes) {
+      const name = cls.getName() || "";
+      for (const [layer, re] of Object.entries(this.classSuffix)) {
+        if (re.test(name)) return layer;
+      }
+    }
+    return null;
+  }
+
+  inferLayer(sourceFile) {
+    return (
+      this.inferLayerFromClasses(sourceFile) ||
+      this.inferLayerFromPath(sourceFile.getFilePath())
+    );
+  }
+
+  getImportedTargetLayer(imp) {
+    const target = imp.getModuleSpecifierSourceFile();
+    if (!target) return null;
+    return this.inferLayer(target);
+  }
+}
+
+module.exports = C048SymbolBasedAnalyzer;

package/rules/common/C052_parsing_or_data_transformation/analyzer.js

@@ -0,0 +1,180 @@
+/**
+ * C052 Main Analyzer - Parsing or data transformation logic must be separated from controllers
+ * Primary: Enforce separation of concerns — controllers should only handle requests and delegate processing, improving testability, maintainability, and reuse.
+ * Fallback: Regex-based for all other cases
+ */
+
+const C052SymbolBasedAnalyzer = require('./symbol-based-analyzer');
+
+class C052Analyzer {
+  constructor(options = {}) {
+    if (process.env.SUNLINT_DEBUG) {
+      console.log(`🔧 [C052] Constructor called with options:`, !!options);
+      console.log(`🔧 [C052] Options type:`, typeof options, Object.keys(options || {}));
+    }
+
+    this.ruleId = 'C052';
+    this.ruleName = 'Parsing or data transformation logic must be separated from controllers';
+    this.description = 'Enforce separation of concerns — controllers should only handle requests and delegate processing, improving testability, maintainability, and reuse.';
+    this.semanticEngine = options.semanticEngine || null;
+    this.verbose = options.verbose || false;
+
+    // Configuration
+    this.config = {
+      useSymbolBased: true,      // Primary approach
+      fallbackToRegex: false,     // Only when symbol fails completely
+      symbolBasedOnly: false     // Can be set to true for pure mode
+    };
+
+    // Initialize both analyzers
+    try {
+      this.symbolAnalyzer = new C052SymbolBasedAnalyzer(this.semanticEngine);
+      if (process.env.SUNLINT_DEBUG) {
+        console.log(`🔧 [C052] Symbol analyzer created successfully`);
+      }
+    } catch (error) {
+      console.error(`🔧 [C052] Error creating symbol analyzer:`, error);
+    }
+  }
+
+  /**
+   * Initialize with semantic engine
+   */
+  async initialize(semanticEngine = null) {
+    if (semanticEngine) {
+      this.semanticEngine = semanticEngine;
+    }
+    this.verbose = semanticEngine?.verbose || false;
+
+    // Initialize both analyzers
+    await this.symbolAnalyzer.initialize(semanticEngine);
+
+    // Ensure verbose flag is propagated
+    this.symbolAnalyzer.verbose = this.verbose;
+
+    if (this.verbose) {
+      console.log(`🔧 [C052 Hybrid] Analyzer initialized - verbose: ${this.verbose}`);
+    }
+  }
+
+  async analyze(files, language, options = {}) {
+    if (process.env.SUNLINT_DEBUG) {
+      console.log(`🔧 [C052] analyze() method called with ${files.length} files, language: ${language}`);
+    }
+
+    const violations = [];
+
+    for (const filePath of files) {
+      try {
+        if (process.env.SUNLINT_DEBUG) {
+          console.log(`🔧 [C052] Processing file: ${filePath}`);
+        }
+
+        const fileViolations = await this.analyzeFile(filePath, options);
+        violations.push(...fileViolations);
+
+        if (process.env.SUNLINT_DEBUG) {
+          console.log(`🔧 [C052] File ${filePath}: Found ${fileViolations.length} violations`);
+        }
+      } catch (error) {
+        console.warn(`❌ [C052] Analysis failed for ${filePath}:`, error.message);
+      }
+    }
+
+    if (process.env.SUNLINT_DEBUG) {
+      console.log(`🔧 [C052] Total violations found: ${violations.length}`);
+    }
+
+    return violations;
+  }
+
+  async analyzeFile(filePath, options = {}) {
+    if (process.env.SUNLINT_DEBUG) {
+      console.log(`🔧 [C052] analyzeFile() called for: ${filePath}`);
+    }
+
+    // 1. Try Symbol-based analysis first (primary)
+    if (this.config.useSymbolBased &&
+        this.semanticEngine?.project &&
+        this.semanticEngine?.initialized) {
+      try {
+        if (process.env.SUNLINT_DEBUG) {
+          console.log(`🔧 [C052] Trying symbol-based analysis...`);
+        }
+        const sourceFile = this.semanticEngine.project.getSourceFile(filePath);
+        if (sourceFile) {
+          if (process.env.SUNLINT_DEBUG) {
+            console.log(`🔧 [C052] Source file found, analyzing with symbol-based...`);
+          }
+          const violations = await this.symbolAnalyzer.analyzeFileWithSymbols(filePath, { ...options, verbose: options.verbose });
+
+          // Mark violations with analysis strategy
+          violations.forEach(v => v.analysisStrategy = 'symbol-based');
+
+          if (process.env.SUNLINT_DEBUG) {
+            console.log(`✅ [C052] Symbol-based analysis: ${violations.length} violations`);
+          }
+          return violations; // Return even if 0 violations - symbol analysis completed successfully
+        } else {
+          if (process.env.SUNLINT_DEBUG) {
+            console.log(`⚠️ [C052] Source file not found in project`);
+          }
+        }
+      } catch (error) {
+        console.warn(`⚠️ [C052] Symbol analysis failed: ${error.message}`);
+        // Continue to fallback
+      }
+    } else {
+      if (process.env.SUNLINT_DEBUG) {
+        console.log(`🔄 [C052] Symbol analysis conditions check:`);
+        console.log(`  - useSymbolBased: ${this.config.useSymbolBased}`);
+        console.log(`  - semanticEngine: ${!!this.semanticEngine}`);
+        console.log(`  - semanticEngine.project: ${!!this.semanticEngine?.project}`);
+        console.log(`  - semanticEngine.initialized: ${this.semanticEngine?.initialized}`);
+        console.log(`🔄 [C052] Symbol analysis unavailable, using regex fallback`);
+      }
+    }
+
+    if (options?.verbose) {
+      console.log(`🔧 [C052] No analysis methods succeeded, returning empty`);
+    }
+    return [];
+  }
+
+  async analyzeFileBasic(filePath, options = {}) {
+    console.log(`🔧 [C052] analyzeFileBasic() called for: ${filePath}`);
+    console.log(`🔧 [C052] semanticEngine exists: ${!!this.semanticEngine}`);
+    console.log(`🔧 [C052] symbolAnalyzer exists: ${!!this.symbolAnalyzer}`);
+
+    try {
+      // Try symbol-based analysis first
+      if (this.semanticEngine?.isSymbolEngineReady?.() &&
+          this.semanticEngine.project) {
+
+        if (this.verbose) {
+          console.log(`🔍 [C052] Using symbol-based analysis for ${filePath}`);
+        }
+
+        const violations = await this.symbolAnalyzer.analyzeFileBasic(filePath, options);
+        return violations;
+      }
+    } catch (error) {
+      if (this.verbose) {
+        console.warn(`⚠️ [C052] Symbol analysis failed: ${error.message}`);
+      }
+    }
+  }
+
+  /**
+   * Methods for compatibility with different engine invocation patterns
+   */
+  async analyzeFileWithSymbols(filePath, options = {}) {
+    return this.analyzeFile(filePath, options);
+  }
+
+  async analyzeWithSemantics(filePath, options = {}) {
+    return this.analyzeFile(filePath, options);
+  }
+}
+
+module.exports = C052Analyzer;

package/rules/common/C052_parsing_or_data_transformation/config.json

@@ -0,0 +1,50 @@
+{
+  "id": "C052",
+  "name": "C052_C052_parsing_or_data_transformation",
+  "category": "architecture",
+  "description": "C052 - Parsing or data transformation logic must be separated from controllers",
+  "severity": "warning",
+  "enabled": true,
+  "semantic": {
+    "enabled": true,
+    "priority": "high",
+    "fallback": "heuristic"
+  },
+  "patterns": {
+    "include": [
+      "**/*.js",
+      "**/*.ts",
+      "**/*.jsx",
+      "**/*.tsx"
+    ],
+    "exclude": [
+      "**/*.test.*",
+      "**/*.spec.*",
+      "**/*.mock.*",
+      "**/test/**",
+      "**/tests/**",
+      "**/spec/**"
+    ]
+  },
+  "options": {
+    "strictMode": false,
+    "allowedDbMethods": [],
+    "repositoryPatterns": [
+      "*Repository*",
+      "*Repo*",
+      "*DAO*",
+      "*Store*"
+    ],
+    "servicePatterns": [
+      "*Service*",
+      "*UseCase*",
+      "*Handler*",
+      "*Manager*"
+    ],
+    "complexityThreshold": {
+      "methodLength": 200,
+      "cyclomaticComplexity": 5,
+      "nestedDepth": 3
+    }
+  }
+}

package/rules/common/C052_parsing_or_data_transformation/symbol-based-analyzer.js

@@ -0,0 +1,132 @@
+/**
+ * C052 Symbol-based Analyzer - Advanced Parsing or data transformation logic must be separated from controllers
+ * Purpose: Use AST + Symbol controllers should only handle requests and delegate processing, improving testability, maintainability, and reuse.
+ */
+
+// c052-symbol-analyzer.js
+const { SyntaxKind } = require("ts-morph");
+
+class C052SymbolBasedAnalyzer {
+  constructor(semanticEngine = null) {
+    this.ruleId = "C052";
+    this.ruleName =
+      "Error bypass architectural layers (controller/service/repository) (Symbol-Based)";
+    this.semanticEngine = semanticEngine;
+    this.verbose = false;
+  }
+
+  async initialize(semanticEngine = null) {
+    if (semanticEngine) {
+      this.semanticEngine = semanticEngine;
+    }
+    this.verbose = semanticEngine?.verbose || false;
+    if (process.env.SUNLINT_DEBUG) {
+      console.log(
+        `🔧 [C052 Symbol-Based] Analyzer initialized, verbose: ${this.verbose}`
+      );
+    }
+  }
+
+  async analyzeFileBasic(filePath, options = {}) {
+    return await this.analyzeFileWithSymbols(filePath, options);
+  }
+
+  async analyzeFileWithSymbols(filePath, options = {}) {
+    const violations = [];
+    const verbose = options.verbose || this.verbose;
+
+    if (!this.semanticEngine?.project) {
+      if (verbose) {
+        console.warn(
+          "[C052 Symbol-Based] No semantic engine available, skipping analysis"
+        );
+      }
+      return violations;
+    }
+
+    // Only check controller files
+    if (!filePath.toLowerCase().includes('controller')) {
+      return violations;
+    }
+
+
+    try {
+      const sourceFile = this.semanticEngine.project.getSourceFile(filePath);
+      if (!sourceFile) return violations;
+
+      sourceFile.forEachDescendant((node) => {
+        // Check suspicious call expressions
+        if (node.getKind() === SyntaxKind.CallExpression) {
+          const expression = node.getExpression();
+          const exprText = expression.getText();
+
+          // Known suspicious functions
+          const suspicious = [
+            "parseInt",
+            "parseFloat",
+            "JSON.parse",
+            "JSON.stringify",
+            "toLowerCase",
+            "toUpperCase",
+            "trim",
+            "toISOString",
+          ];
+
+          for (const s of suspicious) {
+            if (exprText.includes(s)) {
+              violations.push({
+                ruleId: this.ruleId,
+                severity: "warning",
+                message: `Controller should not perform data parsing or transformation directly (uses ${s}).`,
+                source: this.ruleId,
+                file: filePath,
+                line: node.getStartLineNumber(),
+                column: node.getStart() - node.getStartLinePos(),
+                description: `[SYMBOL-BASED] Data parsing/transformation detected in controller (calls ${s})`,
+                suggestion: "Refactor to delegate parsing/transformation to a service",
+                category: "maintainability",
+              });
+            }
+          }
+        }
+
+        // Check if new Date(...) used
+        if (node.getKind() === SyntaxKind.NewExpression) {
+          const exp = node.getExpression();
+          if (exp && exp.getText() === "Date") {
+            violations.push({
+              ruleId: this.ruleId,
+              severity: "warning",
+              message: `Controller should not perform data parsing or transformation directly (uses new Date()).`,
+              source: this.ruleId,
+              file: filePath,
+              line: node.getStartLineNumber(),
+              column: node.getStart() - node.getStartLinePos(),
+              description: `[SYMBOL-BASED] Data parsing/transformation detected in controller (uses new Date())`,
+              suggestion: "Refactor to delegate parsing/transformation to a service",
+              category: "maintainability",
+            });
+          }
+        }
+      });
+
+      if (verbose) {
+        console.log(
+          `🔍 [C052 Symbol-Based] Total violations found: ${violations.length}`
+        );
+      }
+
+      return violations;
+    } catch (error) {
+      if (verbose) {
+        console.warn(
+          `[C052 Symbol-Based] Analysis failed for ${filePath}:`,
+          error.message
+        );
+      }
+      return violations;
+    }
+  }
+}
+
+module.exports = C052SymbolBasedAnalyzer;

package/rules/index.js

@@ -61,6 +61,8 @@ const commonRules = {
     C031: loadRule('common', 'C031_validation_separation'),
     C041: loadRule('common', 'C041_no_sensitive_hardcode'),
     C042: loadRule('common', 'C042_boolean_name_prefix'),
+    C048: loadRule('common', 'C048_no_bypass_architectural_layers'),
+    C052: loadRule('common', 'C052_parsing_or_data_transformation'),
     C047: loadRule('common', 'C047_no_duplicate_retry_logic'),
 };