@sun-asterisk/sunlint 1.3.33 → 1.3.35

package/engines/arch-detect/rules/layered/l005-layer-separation.js

@@ -0,0 +1,215 @@
+"use strict";
+/**
+ * L005: Layer Separation Verified
+ * Xác nhận các layer được tách biệt trong folder structure
+ */
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.L005LayerSeparation = void 0;
+const enums_1 = require("../../types/enums");
+const base_rule_1 = require("../base-rule");
+const rule_registry_1 = require("../rule-registry");
+const rule = (0, base_rule_1.createRule)('L005', 'Layer Separation Verified', 'Xác nhận các layer được tách biệt trong folder structure', enums_1.RuleCategory.STRUCTURE, 0.1, [enums_1.PatternType.LAYERED], {}, {
+    requires: ['L001', 'L002', 'L003', 'L004'],
+    tags: ['layered', 'structure', 'separation'],
+});
+let L005LayerSeparation = (() => {
+    let _classDecorators = [(0, rule_registry_1.RegisterRule)(rule)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = base_rule_1.BaseRule;
+    var L005LayerSeparation = _classThis = class extends _classSuper {
+        constructor() {
+            super(...arguments);
+            this.rule = rule;
+        }
+        async customDetection(context) {
+            const matches = [];
+            const violations = [];
+            // Classify files into layers
+            const layers = this.classifyFilesIntoLayers(context.files);
+            // Check 1: Count distinct layer folders
+            const distinctLayers = new Set(layers.map((l) => l.type)).size;
+            matches.push({
+                type: enums_1.MatchType.FOLDER,
+                path: '',
+                matchedPattern: `${distinctLayers} distinct layers detected`,
+            });
+            // Check 2: Verify layers are in different folders
+            const layerFolders = new Map();
+            for (const layer of layers) {
+                if (!layerFolders.has(layer.type)) {
+                    layerFolders.set(layer.type, new Set());
+                }
+                layerFolders.get(layer.type).add(layer.folder);
+            }
+            // Check for proper separation
+            let separationIssues = 0;
+            const folderList = Array.from(layerFolders.values());
+            for (let i = 0; i < folderList.length; i++) {
+                for (let j = i + 1; j < folderList.length; j++) {
+                    const overlap = Array.from(folderList[i]).filter((f) => folderList[j].has(f));
+                    if (overlap.length > 0) {
+                        separationIssues++;
+                        violations.push({
+                            type: 'layer_mixing',
+                            severity: enums_1.Severity.WARNING,
+                            path: overlap[0],
+                            message: 'Multiple layer types found in same folder',
+                            suggestion: 'Consider separating layers into different folders',
+                        });
+                    }
+                }
+            }
+            // Check 3: No mixed files (controller + repository logic)
+            const mixedFiles = await this.detectMixedFiles(context);
+            for (const file of mixedFiles.slice(0, 3)) {
+                violations.push({
+                    type: 'mixed_responsibility',
+                    severity: enums_1.Severity.WARNING,
+                    path: file,
+                    message: 'File contains multiple layer responsibilities',
+                    suggestion: 'Split into separate files for each layer',
+                });
+            }
+            // Calculate score
+            let score = 0;
+            if (distinctLayers >= 4)
+                score = 1;
+            else if (distinctLayers === 3)
+                score = 0.8;
+            else if (distinctLayers === 2)
+                score = 0.5;
+            else
+                score = 0;
+            // Reduce score for issues
+            score -= separationIssues * 0.1;
+            score -= mixedFiles.length * 0.05;
+            score = Math.max(0, score);
+            return { matches, violations, score };
+        }
+        classifyFilesIntoLayers(files) {
+            const layers = [];
+            const layerPatterns = [
+                {
+                    type: 'presentation',
+                    folderPatterns: [/controllers?/i, /handlers?/i, /api/i, /endpoints?/i, /routes?/i],
+                    filePatterns: [/controller/i, /handler/i, /endpoint/i],
+                },
+                {
+                    type: 'business',
+                    folderPatterns: [/services?/i, /business/i, /usecases?/i, /application/i, /managers?/i],
+                    filePatterns: [/service/i, /usecase/i, /manager/i, /business/i],
+                },
+                {
+                    type: 'data',
+                    folderPatterns: [/repositories?/i, /repository/i, /daos?/i, /persistence/i, /gateways?/i],
+                    filePatterns: [/repository/i, /dao/i, /gateway/i, /datasource/i],
+                },
+                {
+                    type: 'model',
+                    folderPatterns: [/models?/i, /entities?/i, /domain/i, /dtos?/i],
+                    filePatterns: [/entity/i, /model/i, /dto/i],
+                },
+            ];
+            for (const file of files) {
+                if (file.isTest || file.isConfig)
+                    continue;
+                for (const layer of layerPatterns) {
+                    const folderMatch = layer.folderPatterns.some((p) => p.test(file.relativePath));
+                    const fileMatch = layer.filePatterns.some((p) => p.test(file.fileName));
+                    if (folderMatch || fileMatch) {
+                        const folder = file.relativePath.split('/').slice(0, -1).join('/') || '.';
+                        layers.push({
+                            type: layer.type,
+                            folder,
+                            files: [file],
+                        });
+                        break;
+                    }
+                }
+            }
+            return layers;
+        }
+        async detectMixedFiles(context) {
+            const mixedFiles = [];
+            const sourceFiles = context.files
+                .filter((f) => !f.isTest && !f.isConfig && f.language)
+                .slice(0, 30);
+            const layerIndicators = {
+                presentation: [/@Controller\b/, /@Get\(/, /@Post\(/, /router\.(get|post)/],
+                data: [/@Repository\b/, /DbContext/, /\.query\(/, /\.find\(/],
+            };
+            for (const file of sourceFiles) {
+                try {
+                    const content = await context.helpers.readFile(file.absolutePath);
+                    const hasPresentation = layerIndicators.presentation.some((p) => p.test(content));
+                    const hasData = layerIndicators.data.some((p) => p.test(content));
+                    if (hasPresentation && hasData) {
+                        mixedFiles.push(file.relativePath);
+                    }
+                }
+                catch {
+                    // Skip unreadable files
+                }
+            }
+            return mixedFiles;
+        }
+        getMetadata(context, matches) {
+            return {
+                ...super.getMetadata(context, matches),
+                layerCount: matches.length > 0 ? parseInt(matches[0].matchedPattern?.split(' ')[0] || '0', 10) : 0,
+            };
+        }
+    };
+    __setFunctionName(_classThis, "L005LayerSeparation");
+    (() => {
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        L005LayerSeparation = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return L005LayerSeparation = _classThis;
+})();
+exports.L005LayerSeparation = L005LayerSeparation;
+exports.default = L005LayerSeparation;
+//# sourceMappingURL=l005-layer-separation.js.map

package/engines/arch-detect/rules/layered/l006-dependency-direction.js

@@ -0,0 +1,221 @@
+"use strict";
+/**
+ * L006: Dependency Direction Correct
+ * Xác nhận dependency flow đúng hướng (top-down)
+ */
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.L006DependencyDirection = void 0;
+const enums_1 = require("../../types/enums");
+const base_rule_1 = require("../base-rule");
+const rule_registry_1 = require("../rule-registry");
+const rule = (0, base_rule_1.createRule)('L006', 'Dependency Direction Correct', 'Xác nhận dependency flow đúng hướng (Controller → Service → Repository → Entity)', enums_1.RuleCategory.STRUCTURE, 0.09, [enums_1.PatternType.LAYERED], {}, {
+    requires: ['L001', 'L002', 'L003'],
+    tags: ['layered', 'dependency', 'architecture'],
+});
+const LAYER_ORDER = ['presentation', 'business', 'data', 'model'];
+let L006DependencyDirection = (() => {
+    let _classDecorators = [(0, rule_registry_1.RegisterRule)(rule)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = base_rule_1.BaseRule;
+    var L006DependencyDirection = _classThis = class extends _classSuper {
+        constructor() {
+            super(...arguments);
+            this.rule = rule;
+        }
+        async customDetection(context) {
+            const matches = [];
+            const violations = [];
+            // Analyze dependencies
+            const dependencies = await this.analyzeDependencies(context);
+            let validDeps = 0;
+            let invalidDeps = 0;
+            for (const dep of dependencies) {
+                if (this.isValidDependency(dep.fromLayer, dep.toLayer)) {
+                    validDeps++;
+                    if (matches.length < 5) {
+                        matches.push({
+                            type: enums_1.MatchType.CODE,
+                            path: dep.fromFile,
+                            matchedPattern: `Valid: ${dep.fromLayer} → ${dep.toLayer}`,
+                        });
+                    }
+                }
+                else {
+                    invalidDeps++;
+                    violations.push({
+                        type: 'invalid_dependency',
+                        severity: enums_1.Severity.WARNING,
+                        path: dep.fromFile,
+                        line: dep.line,
+                        message: `Invalid dependency: ${dep.fromLayer} → ${dep.toLayer}`,
+                        suggestion: `${dep.toLayer} layer should not be imported by ${dep.fromLayer} layer`,
+                    });
+                }
+            }
+            // Calculate score
+            let score = 1;
+            const totalDeps = validDeps + invalidDeps;
+            if (totalDeps > 0) {
+                if (invalidDeps === 0)
+                    score = 1;
+                else if (invalidDeps <= 2)
+                    score = 0.6;
+                else if (invalidDeps <= 5)
+                    score = 0.3;
+                else
+                    score = 0;
+            }
+            matches.push({
+                type: enums_1.MatchType.CODE,
+                path: '',
+                matchedPattern: `${validDeps} valid, ${invalidDeps} invalid dependencies`,
+            });
+            return { matches, violations, score };
+        }
+        async analyzeDependencies(context) {
+            const dependencies = [];
+            const sourceFiles = context.files
+                .filter((f) => !f.isTest && !f.isConfig && f.language)
+                .slice(0, 50);
+            const importPatterns = [
+                /import\s+.*\s+from\s+['"]([^'"]+)['"]/g,
+                /import\s+['"]([^'"]+)['"]/g,
+                /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+                /from\s+([a-zA-Z_][a-zA-Z0-9_]*)\s+import/g,
+                /using\s+([a-zA-Z_.]+);/g,
+            ];
+            for (const file of sourceFiles) {
+                const fromLayer = this.classifyFileLayer(file);
+                if (!fromLayer)
+                    continue;
+                try {
+                    const content = await context.helpers.readFile(file.absolutePath);
+                    const lines = content.split('\n');
+                    for (let i = 0; i < lines.length; i++) {
+                        const line = lines[i];
+                        for (const pattern of importPatterns) {
+                            pattern.lastIndex = 0; // Reset regex
+                            let match;
+                            while ((match = pattern.exec(line)) !== null) {
+                                const importPath = match[1];
+                                const toLayer = this.classifyImportLayer(importPath);
+                                if (toLayer) {
+                                    dependencies.push({
+                                        fromFile: file.relativePath,
+                                        fromLayer,
+                                        toFile: importPath,
+                                        toLayer,
+                                        line: i + 1,
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // Skip unreadable files
+                }
+            }
+            return dependencies;
+        }
+        classifyFileLayer(file) {
+            const path = file.relativePath.toLowerCase();
+            const name = file.fileName.toLowerCase();
+            if (/controller|handler|endpoint|api/.test(path) || /controller|handler/.test(name)) {
+                return 'presentation';
+            }
+            if (/service|business|usecase|manager|application/.test(path) ||
+                /service|usecase|manager/.test(name)) {
+                return 'business';
+            }
+            if (/repository|dao|persistence|gateway|data/.test(path) ||
+                /repository|dao|gateway/.test(name)) {
+                return 'data';
+            }
+            if (/model|entity|domain|dto/.test(path) || /entity|model|dto/.test(name)) {
+                return 'model';
+            }
+            return null;
+        }
+        classifyImportLayer(importPath) {
+            const path = importPath.toLowerCase();
+            if (/controller|handler|endpoint/.test(path))
+                return 'presentation';
+            if (/service|business|usecase|manager/.test(path))
+                return 'business';
+            if (/repository|dao|persistence|gateway/.test(path))
+                return 'data';
+            if (/model|entity|domain|dto/.test(path))
+                return 'model';
+            return null;
+        }
+        isValidDependency(from, to) {
+            const fromIndex = LAYER_ORDER.indexOf(from);
+            const toIndex = LAYER_ORDER.indexOf(to);
+            // Valid: from higher layer (lower index) to lower layer (higher index)
+            // Also valid: same layer or model layer can be used by any layer
+            return fromIndex <= toIndex || to === 'model';
+        }
+        getMetadata(context, matches) {
+            const statsMatch = matches.find((m) => m.matchedPattern?.includes('valid,'));
+            const stats = statsMatch?.matchedPattern?.split(', ') || [];
+            return {
+                ...super.getMetadata(context, matches),
+                validDependencies: parseInt(stats[0]?.split(' ')[0] || '0', 10),
+                invalidDependencies: parseInt(stats[1]?.split(' ')[0] || '0', 10),
+            };
+        }
+    };
+    __setFunctionName(_classThis, "L006DependencyDirection");
+    (() => {
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        L006DependencyDirection = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return L006DependencyDirection = _classThis;
+})();
+exports.L006DependencyDirection = L006DependencyDirection;
+exports.default = L006DependencyDirection;
+//# sourceMappingURL=l006-dependency-direction.js.map