@devstroupe/devkit-cli 1.0.0

package/dist/migrations/sort-entities.d.ts

@@ -0,0 +1,2 @@
+import { IDevkitEntityConfig } from '@devstroupe/devkit-core';
+export declare function sortEntitiesForMigrations(entities: IDevkitEntityConfig[]): IDevkitEntityConfig[];

package/dist/migrations/sort-entities.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortEntitiesForMigrations = sortEntitiesForMigrations;
+const relationships_1 = require("../templates/shared/relationships");
+function migrationDependencies(entity) {
+    return (0, relationships_1.getRelationships)(entity.properties ?? [])
+        .filter((relationship) => relationship.kind !== 'one-to-many')
+        .map((relationship) => relationship.target);
+}
+function sortEntitiesForMigrations(entities) {
+    const byName = new Map(entities.map((entity) => [entity.name, entity]));
+    const visiting = new Set();
+    const visited = new Set();
+    const ordered = [];
+    const visit = (entity) => {
+        if (visited.has(entity.name) || visiting.has(entity.name))
+            return;
+        visiting.add(entity.name);
+        migrationDependencies(entity).forEach((dependency) => {
+            const target = byName.get(dependency);
+            if (target)
+                visit(target);
+        });
+        visiting.delete(entity.name);
+        visited.add(entity.name);
+        ordered.push(entity);
+    };
+    entities.forEach(visit);
+    return ordered;
+}

package/dist/rules/linter-rules.d.ts

@@ -0,0 +1,12 @@
+export interface LintViolation {
+    file: string;
+    line: number;
+    rule: string;
+    severity: 'error' | 'warn';
+    message: string;
+}
+export interface LintResult {
+    violations: LintViolation[];
+    filesScanned: number;
+}
+export declare function runLinter(projectRoot: string, config: any): LintResult;

package/dist/rules/linter-rules.js

@@ -0,0 +1,338 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runLinter = runLinter;
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+// Helper para ler arquivos recursivamente com filtros de extensão
+function getFilesRecursively(dir, extensions) {
+    let results = [];
+    if (!fs.existsSync(dir))
+        return results;
+    const list = fs.readdirSync(dir);
+    for (const file of list) {
+        const filePath = path.join(dir, file);
+        const stat = fs.statSync(filePath);
+        if (stat && stat.isDirectory()) {
+            const baseName = path.basename(filePath);
+            // Ignorar diretórios comuns de build/dependência
+            if (baseName !== 'node_modules' &&
+                baseName !== 'dist' &&
+                baseName !== '.git' &&
+                baseName !== '.angular' &&
+                baseName !== 'coverage') {
+                results = results.concat(getFilesRecursively(filePath, extensions));
+            }
+        }
+        else {
+            const ext = path.extname(file);
+            if (extensions.includes(ext)) {
+                results.push(filePath);
+            }
+        }
+    }
+    return results;
+}
+function runLinter(projectRoot, config) {
+    const violations = [];
+    let filesScanned = 0;
+    // Carrega configurações de regras (padrão: error para quase tudo, warn para imports de arquitetura)
+    const rulesConfig = config.rules || {};
+    const getRuleSeverity = (ruleName, defaultSeverity) => {
+        return rulesConfig[ruleName] !== undefined ? rulesConfig[ruleName] : defaultSeverity;
+    };
+    const severityNoPolling = getRuleSeverity('no-polling-in-frontend', 'error');
+    const severityForcePagination = getRuleSeverity('force-pagination-in-backend', 'error');
+    const severityStandardQueries = getRuleSeverity('use-standard-devkit-queries', 'error');
+    const severityCleanArch = getRuleSeverity('clean-architecture-imports', 'warn');
+    const severitySynchronize = getRuleSeverity('disable-typeorm-synchronize', 'error');
+    const severitySpartanRadius = getRuleSeverity('no-custom-spartan-radius', 'error');
+    const backendRoot = path.resolve(projectRoot, config.backendPath || './backend');
+    const frontendRoot = path.resolve(projectRoot, config.frontendPath || './frontend');
+    // --- 1. Auditando o Backend (NestJS) ---
+    if (fs.existsSync(backendRoot)) {
+        const backendFiles = getFilesRecursively(backendRoot, ['.ts']);
+        filesScanned += backendFiles.length;
+        for (const file of backendFiles) {
+            const content = fs.readFileSync(file, 'utf-8');
+            const lines = content.split('\n');
+            const relativePath = path.relative(projectRoot, file);
+            if (severitySynchronize !== 'off') {
+                lines.forEach((line, index) => {
+                    if (/\bsynchronize\s*:\s*true\b/.test(line)) {
+                        violations.push({
+                            file: relativePath,
+                            line: index + 1,
+                            rule: 'disable-typeorm-synchronize',
+                            severity: severitySynchronize,
+                            message: 'Use migrations TypeORM e mantenha "synchronize: false" para evitar alterações automáticas no schema.'
+                        });
+                    }
+                });
+            }
+            // Regra: clean-architecture-imports
+            // Impede que arquivos sob subdiretórios de domínio importem infra/controllers
+            if (severityCleanArch !== 'off' && (file.includes('/domain/') || file.includes('/entities/'))) {
+                lines.forEach((line, index) => {
+                    const trimmed = line.trim();
+                    if (trimmed.startsWith('//') || trimmed.startsWith('*') || trimmed.startsWith('/*'))
+                        return;
+                    // Import contendo infra, controller, module ou similar
+                    if (/import\s+.*\s+from\s+['"].*(?:\/infra\/|\/controllers\/|\/modules\/|\.controller|\.module).*['"]/i.test(line)) {
+                        violations.push({
+                            file: relativePath,
+                            line: index + 1,
+                            rule: 'clean-architecture-imports',
+                            severity: severityCleanArch,
+                            message: 'Camada de Domínio/Entidade não deve importar classes da camada de Infraestrutura, Controladores ou Módulos.'
+                        });
+                    }
+                });
+            }
+            // Regra: force-pagination-in-backend
+            // Garante que repositórios/controllers evitem .find() brutas ou .getMany() brutas
+            if (severityForcePagination !== 'off') {
+                const hasRepositoryOrController = file.endsWith('.repository.ts') || file.endsWith('.controller.ts') || file.endsWith('.service.ts');
+                if (hasRepositoryOrController) {
+                    lines.forEach((line, index) => {
+                        const trimmed = line.trim();
+                        if (trimmed.startsWith('//') || trimmed.startsWith('*') || trimmed.startsWith('/*'))
+                            return;
+                        // .find() sem argumentos ou sem filtros limitados, ou getMany() direto no queryBuilder sem skip/take/limit/take
+                        if (/\.find\(\s*(?:\{\s*\})?\s*\)/.test(line)) {
+                            violations.push({
+                                file: relativePath,
+                                line: index + 1,
+                                rule: 'force-pagination-in-backend',
+                                severity: severityForcePagination,
+                                message: 'Evite usar consultas brutas de tabela cheia ".find()". Prefira a paginação padrão do repositório ("findMany").'
+                            });
+                        }
+                        if (/\.getMany\(\)/.test(line) && !content.includes('.take(') && !content.includes('.limit(')) {
+                            violations.push({
+                                file: relativePath,
+                                line: index + 1,
+                                rule: 'force-pagination-in-backend',
+                                severity: severityForcePagination,
+                                message: 'Evite chamar ".getMany()" no QueryBuilder sem especificar limites de paginação (".take" ou ".limit").'
+                            });
+                        }
+                    });
+                }
+            }
+            // Regra: use-standard-devkit-queries (Backend)
+            if (severityStandardQueries !== 'off') {
+                // Controllers devem herdar de BaseCrudController
+                if (file.endsWith('.controller.ts') && !file.endsWith('auth.controller.ts') && content.includes('@Controller') && !content.includes('extends BaseCrudController')) {
+                    violations.push({
+                        file: relativePath,
+                        line: 1,
+                        rule: 'use-standard-devkit-queries',
+                        severity: severityStandardQueries,
+                        message: 'Controllers de CRUD devem herdar de "BaseCrudController" para garantir consistência e herança de comportamento.'
+                    });
+                }
+                // Repositories devem herdar de BaseRepository
+                if (file.endsWith('.repository.ts') && content.includes('@Injectable') && !content.includes('extends BaseRepository')) {
+                    violations.push({
+                        file: relativePath,
+                        line: 1,
+                        rule: 'use-standard-devkit-queries',
+                        severity: severityStandardQueries,
+                        message: 'Repositories devem herdar de "BaseRepository" para garantir paginação e parsing de filtros consistentes.'
+                    });
+                }
+            }
+        }
+    }
+    // --- 2. Auditando o Frontend (Angular) ---
+    if (fs.existsSync(frontendRoot)) {
+        const frontendFiles = getFilesRecursively(frontendRoot, ['.ts', '.html', '.css', '.scss']);
+        filesScanned += frontendFiles.length;
+        for (const file of frontendFiles) {
+            const relativePath = path.relative(projectRoot, file);
+            const normalizedPath = relativePath.replace(/\\/g, '/');
+            const content = fs.readFileSync(file, 'utf-8');
+            const lines = content.split('\n');
+            if (severitySpartanRadius !== 'off' && normalizedPath.includes('shared/components/devkit/')) {
+                lines.forEach((line, index) => {
+                    const definesRadiusToken = /--radius(?:-[\w-]+)?\s*:/.test(line);
+                    const radiusDeclaration = line.match(/border-radius\s*:\s*([^;]+)/);
+                    const radiusValue = radiusDeclaration?.[1]?.trim();
+                    const usesOfficialTokenOrSemanticCircle = !radiusValue ||
+                        /^var\(--radius(?:-[\w-]+)?\)$/.test(radiusValue) ||
+                        radiusValue === '9999px' ||
+                        radiusValue === '50%';
+                    if (definesRadiusToken || !usesOfficialTokenOrSemanticCircle) {
+                        violations.push({
+                            file: relativePath,
+                            line: index + 1,
+                            rule: 'no-custom-spartan-radius',
+                            severity: severitySpartanRadius,
+                            message: 'Wrappers DevKit não devem definir radius próprio. Use o primitive ou token oficial gerado pelo Spartan.'
+                        });
+                    }
+                });
+            }
+            // Ignorar wrappers locais nas demais regras e primitives Helm gerados pelo Spartan.
+            if (normalizedPath.includes('shared/components/devkit/') ||
+                normalizedPath.includes('frontend/libs/ui/')) {
+                continue;
+            }
+            // Auditoria de arquivos TypeScript do Frontend
+            if (file.endsWith('.ts')) {
+                const importsRxjs = content.includes('rxjs');
+                // Regra: no-polling-in-frontend
+                if (severityNoPolling !== 'off') {
+                    lines.forEach((line, index) => {
+                        const trimmed = line.trim();
+                        if (trimmed.startsWith('//') || trimmed.startsWith('*') || trimmed.startsWith('/*'))
+                            return;
+                        // Busca setInterval, interval( ou timer( com período)
+                        if (/\bsetInterval\s*\(/.test(line)) {
+                            violations.push({
+                                file: relativePath,
+                                line: index + 1,
+                                rule: 'no-polling-in-frontend',
+                                severity: severityNoPolling,
+                                message: 'Não faça polling contínuo no frontend usando "setInterval". Utilize WebSockets ou disparos reativos.'
+                            });
+                        }
+                        if (/\binterval\s*\(/.test(line) && (importsRxjs || line.includes('rxjs'))) {
+                            violations.push({
+                                file: relativePath,
+                                line: index + 1,
+                                rule: 'no-polling-in-frontend',
+                                severity: severityNoPolling,
+                                message: 'Não utilize o operador "interval" do RxJS para criar loops infinitos de polling.'
+                            });
+                        }
+                        if (/\btimer\s*\(\s*\d+\s*,\s*\d+\s*\)/.test(line)) {
+                            violations.push({
+                                file: relativePath,
+                                line: index + 1,
+                                rule: 'no-polling-in-frontend',
+                                severity: severityNoPolling,
+                                message: 'Não utilize o operador "timer" com período de re-execução para loops de polling.'
+                            });
+                        }
+                    });
+                }
+                // Regra: use-standard-devkit-queries (Frontend Component)
+                if (severityStandardQueries !== 'off' && file.endsWith('-list.component.ts')) {
+                    if (!content.includes('extends BaseListPage')) {
+                        violations.push({
+                            file: relativePath,
+                            line: 1,
+                            rule: 'use-standard-devkit-queries',
+                            severity: severityStandardQueries,
+                            message: 'Componentes de listagem devem herdar de "BaseListPage" para garantir sincronização de filtros com a URL.'
+                        });
+                    }
+                }
+                // Regra: use-standard-devkit-queries (Frontend CRUD Service)
+                if (severityStandardQueries !== 'off' && file.endsWith('.service.ts') && !file.endsWith('base.service.ts')) {
+                    const looksLikeCrudService = /\blist\s*\(/.test(content) &&
+                        /\bcreate\s*\(/.test(content) &&
+                        /\bupdate\s*\(/.test(content) &&
+                        /\bdelete\s*\(/.test(content);
+                    if (looksLikeCrudService && !content.includes('extends BaseService')) {
+                        violations.push({
+                            file: relativePath,
+                            line: 1,
+                            rule: 'use-standard-devkit-queries',
+                            severity: severityStandardQueries,
+                            message: 'Serviços CRUD do frontend devem herdar de "BaseService" para padronizar endpoints, paginação e operações de CRUD.'
+                        });
+                    }
+                }
+                // Regra: force-separate-template-and-styles
+                const severitySeparate = getRuleSeverity('force-separate-template-and-styles', 'error');
+                if (severitySeparate !== 'off') {
+                    lines.forEach((line, index) => {
+                        const trimmed = line.trim();
+                        if (trimmed.startsWith('//') || trimmed.startsWith('*') || trimmed.startsWith('/*'))
+                            return;
+                        if (/\btemplate\s*:\s*[`'"]/.test(line)) {
+                            violations.push({
+                                file: relativePath,
+                                line: index + 1,
+                                rule: 'force-separate-template-and-styles',
+                                severity: severitySeparate,
+                                message: 'Evite declarar template embutido (inline) no arquivo .ts. Utilize um arquivo HTML externo ("templateUrl").'
+                            });
+                        }
+                        if (/\bstyles\s*:\s*\[/.test(line)) {
+                            violations.push({
+                                file: relativePath,
+                                line: index + 1,
+                                rule: 'force-separate-template-and-styles',
+                                severity: severitySeparate,
+                                message: 'Evite declarar estilos embutidos (inline) no arquivo .ts. Utilize um arquivo CSS/SCSS externo ("styleUrls" ou "styleUrl").'
+                            });
+                        }
+                    });
+                }
+            }
+            // Auditoria de templates HTML de Listas no Frontend
+            if (file.endsWith('-list.component.html')) {
+                if (severityStandardQueries !== 'off') {
+                    const hasTable = content.includes('<devkit-table') || content.includes('devkit-table');
+                    const hasCardList = content.includes('<devkit-card-list') || content.includes('devkit-card-list');
+                    const hasSimpleList = content.includes('<devkit-simple-list') || content.includes('devkit-simple-list');
+                    if (!hasTable && !hasCardList && !hasSimpleList) {
+                        violations.push({
+                            file: relativePath,
+                            line: 1,
+                            rule: 'use-standard-devkit-queries',
+                            severity: severityStandardQueries,
+                            message: 'Telas de listagem devem utilizar um componente de exibição padrão do design system ("<devkit-table>", "<devkit-card-list>" ou "<devkit-simple-list>").'
+                        });
+                    }
+                    if (!content.includes('<devkit-filter') && !content.includes('devkit-filter')) {
+                        violations.push({
+                            file: relativePath,
+                            line: 1,
+                            rule: 'use-standard-devkit-queries',
+                            severity: severityStandardQueries,
+                            message: 'Telas de listagem devem utilizar o componente de filtros padrão "<devkit-filter>".'
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return { violations, filesScanned };
+}

package/dist/rules/linter-rules.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/rules/linter-rules.test.js

@@ -0,0 +1,214 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const assert = __importStar(require("node:assert"));
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const linter_rules_1 = require("./linter-rules");
+const sandboxDir = path.resolve(__dirname, 'test-sandbox');
+function setupSandbox() {
+    fs.ensureDirSync(sandboxDir);
+    fs.ensureDirSync(path.join(sandboxDir, 'backend/src/modules/cabin/controllers'));
+    fs.ensureDirSync(path.join(sandboxDir, 'backend/src/modules/cabin/entities'));
+    fs.ensureDirSync(path.join(sandboxDir, 'backend/src/modules/cabin/repositories'));
+    fs.ensureDirSync(path.join(sandboxDir, 'frontend/src/app/modules/cabin/list'));
+    fs.ensureDirSync(path.join(sandboxDir, 'frontend/src/app/services'));
+}
+function teardownSandbox() {
+    fs.removeSync(sandboxDir);
+}
+(0, node_test_1.test)('runLinter should detect all rules violations', () => {
+    setupSandbox();
+    // 1. Violando clean-architecture-imports e use-standard-devkit-queries no Backend
+    fs.writeFileSync(path.join(sandboxDir, 'backend/src/modules/cabin/entities/cabin.entity.ts'), `import { Controller } from '@nestjs/common';
+     import { CabinController } from '../controllers/cabin.controller'; // VIOLAÇÃO Clean Arch
+     export class CabinEntity {}`, 'utf-8');
+    fs.writeFileSync(path.join(sandboxDir, 'backend/src/modules/cabin/controllers/cabin.controller.ts'), `import { Controller } from '@nestjs/common';
+     @Controller('cabin')
+     export class CabinController {} // VIOLAÇÃO use-standard-devkit-queries (não estende BaseCrudController)`, 'utf-8');
+    // 2. Violando no-polling-in-frontend e force-separate-template-and-styles no Frontend
+    fs.writeFileSync(path.join(sandboxDir, 'frontend/src/app/modules/cabin/list/cabin-list.component.ts'), `import { Component } from '@angular/core';
+     import { interval } from 'rxjs'; // Para regra de polling
+     @Component({
+       selector: 'app-cabin-list',
+       template: '<div>Inline</div>', // VIOLAÇÃO force-separate-template-and-styles
+       styles: ['h1 { color: red; }'] // VIOLAÇÃO force-separate-template-and-styles
+     })
+     export class CabinListComponent {
+       constructor() {
+         setInterval(() => {}, 1000); // VIOLAÇÃO no-polling-in-frontend
+         interval(5000).subscribe(); // VIOLAÇÃO no-polling-in-frontend
+       }
+     }`, 'utf-8');
+    // 3. Violando use-standard-devkit-queries (HTML sem devkit-table ou devkit-filter)
+    fs.writeFileSync(path.join(sandboxDir, 'frontend/src/app/modules/cabin/list/cabin-list.component.html'), `<div>Apenas uma div comum sem a tabela padrão</div>`, 'utf-8');
+    fs.writeFileSync(path.join(sandboxDir, 'frontend/src/app/services/cabin.service.ts'), `import { Injectable } from '@angular/core';
+     @Injectable({ providedIn: 'root' })
+     export class CabinService {
+       list() {}
+       create() {}
+       update() {}
+       delete() {}
+     }`, 'utf-8');
+    const config = {
+        backendPath: './backend',
+        frontendPath: './frontend',
+        rules: {
+            'no-polling-in-frontend': 'error',
+            'force-pagination-in-backend': 'error',
+            'use-standard-devkit-queries': 'error',
+            'clean-architecture-imports': 'warn',
+            'force-separate-template-and-styles': 'error'
+        }
+    };
+    const result = (0, linter_rules_1.runLinter)(sandboxDir, config);
+    teardownSandbox();
+    // Verifica que os arquivos foram escaneados
+    assert.ok(result.filesScanned >= 4);
+    // Mapeia regras violadas por facilidade de asserção
+    const rulesViolated = result.violations.map(v => v.rule);
+    // Deve encontrar clean-architecture-imports
+    assert.ok(rulesViolated.includes('clean-architecture-imports'), 'Deveria detectar clean-architecture-imports');
+    // Deve encontrar use-standard-devkit-queries no Controller
+    assert.ok(rulesViolated.includes('use-standard-devkit-queries'), 'Deveria detectar use-standard-devkit-queries');
+    // Deve encontrar force-separate-template-and-styles (template e styles inline)
+    const separateViolations = result.violations.filter(v => v.rule === 'force-separate-template-and-styles');
+    assert.strictEqual(separateViolations.length, 2, 'Deveria detectar template e styles inline (2 violações)');
+    // Deve encontrar no-polling-in-frontend (setInterval e rxjs interval)
+    const pollingViolations = result.violations.filter(v => v.rule === 'no-polling-in-frontend');
+    assert.strictEqual(pollingViolations.length, 2, 'Deveria detectar setInterval e interval do rxjs (2 violações)');
+});
+(0, node_test_1.test)('runLinter should pass use-standard-devkit-queries when using devkit-card-list or devkit-simple-list', () => {
+    setupSandbox();
+    // Caso 1: Usando devkit-card-list no HTML e import correto no TS
+    fs.writeFileSync(path.join(sandboxDir, 'frontend/src/app/modules/cabin/list/cabin-list.component.html'), `<div class="p-6">
+       <devkit-filter [config]="[]"></devkit-filter>
+       <devkit-card-list [columns]="[]" [items]="[]"></devkit-card-list>
+     </div>`, 'utf-8');
+    fs.writeFileSync(path.join(sandboxDir, 'frontend/src/app/modules/cabin/list/cabin-list.component.ts'), `import { Component } from '@angular/core';
+     import { BaseListPage } from '@devstroupe/devkit-angular';
+     @Component({
+       selector: 'app-cabin-list',
+       templateUrl: './cabin-list.component.html',
+       styleUrls: ['./cabin-list.component.css']
+     })
+     export class CabinListComponent extends BaseListPage<any> {}`, 'utf-8');
+    const config = {
+        backendPath: './backend',
+        frontendPath: './frontend',
+        rules: {
+            'use-standard-devkit-queries': 'error'
+        }
+    };
+    const result1 = (0, linter_rules_1.runLinter)(sandboxDir, config);
+    // Caso 2: Usando devkit-simple-list no HTML
+    fs.writeFileSync(path.join(sandboxDir, 'frontend/src/app/modules/cabin/list/cabin-list.component.html'), `<div class="p-6">
+       <devkit-filter [config]="[]"></devkit-filter>
+       <devkit-simple-list [columns]="[]" [items]="[]"></devkit-simple-list>
+     </div>`, 'utf-8');
+    const result2 = (0, linter_rules_1.runLinter)(sandboxDir, config);
+    teardownSandbox();
+    // As duas execuções não devem gerar violações no frontend
+    const violations1 = result1.violations.filter(v => v.file.includes('cabin-list.component.html'));
+    const violations2 = result2.violations.filter(v => v.file.includes('cabin-list.component.html'));
+    assert.strictEqual(violations1.length, 0, 'Deveria passar com devkit-card-list');
+    assert.strictEqual(violations2.length, 0, 'Deveria passar com devkit-simple-list');
+});
+(0, node_test_1.test)('runLinter should pass use-standard-devkit-queries when CRUD service extends BaseService', () => {
+    setupSandbox();
+    fs.writeFileSync(path.join(sandboxDir, 'frontend/src/app/services/cabin.service.ts'), `import { Injectable } from '@angular/core';
+     import { BaseService } from '@devstroupe/devkit-angular';
+     @Injectable({ providedIn: 'root' })
+     export class CabinService extends BaseService<any> {}`, 'utf-8');
+    const result = (0, linter_rules_1.runLinter)(sandboxDir, {
+        backendPath: './backend',
+        frontendPath: './frontend',
+        rules: {
+            'use-standard-devkit-queries': 'error'
+        }
+    });
+    teardownSandbox();
+    const serviceViolations = result.violations.filter(v => v.file.includes('cabin.service.ts'));
+    assert.strictEqual(serviceViolations.length, 0, 'Deveria passar quando serviço CRUD herda de BaseService');
+});
+(0, node_test_1.test)('runLinter should ignore Spartan generated primitives in frontend libs/ui', () => {
+    setupSandbox();
+    const spartanDir = path.join(sandboxDir, 'frontend/libs/ui/button/src/lib');
+    fs.ensureDirSync(spartanDir);
+    fs.writeFileSync(path.join(spartanDir, 'hlm-button.ts'), `import { Component } from '@angular/core';
+     @Component({
+       selector: 'button[hlmBtn]',
+       template: '<ng-content />',
+       styles: [':host { display: inline-flex; }']
+     })
+     export class HlmButton {}`, 'utf-8');
+    const result = (0, linter_rules_1.runLinter)(sandboxDir, {
+        backendPath: './backend',
+        frontendPath: './frontend',
+        rules: {
+            'force-separate-template-and-styles': 'error'
+        }
+    });
+    teardownSandbox();
+    const spartanViolations = result.violations.filter(v => v.file.includes('frontend/libs/ui/'));
+    assert.strictEqual(spartanViolations.length, 0, 'Não deveria auditar primitives Helm gerados em frontend/libs/ui');
+});
+(0, node_test_1.test)('runLinter should reject custom radius in DevKit wrappers', () => {
+    setupSandbox();
+    const wrapperDir = path.join(sandboxDir, 'frontend/src/app/shared/components/devkit/card');
+    fs.ensureDirSync(wrapperDir);
+    fs.writeFileSync(path.join(wrapperDir, 'card.component.css'), `:host { --radius: 12px; border-radius: 12px; }`, 'utf-8');
+    const result = (0, linter_rules_1.runLinter)(sandboxDir, {
+        backendPath: './backend',
+        frontendPath: './frontend',
+        rules: { 'no-custom-spartan-radius': 'error' }
+    });
+    teardownSandbox();
+    const violations = result.violations.filter(v => v.rule === 'no-custom-spartan-radius');
+    assert.strictEqual(violations.length, 1, 'Deveria detectar redefinição e radius próprio na mesma linha');
+});
+(0, node_test_1.test)('runLinter should reject TypeORM synchronize enabled', () => {
+    setupSandbox();
+    fs.writeFileSync(path.join(sandboxDir, 'backend/src/app.module.ts'), `export const databaseOptions = { synchronize: true };`, 'utf-8');
+    const result = (0, linter_rules_1.runLinter)(sandboxDir, {
+        backendPath: './backend',
+        frontendPath: './frontend',
+        rules: { 'disable-typeorm-synchronize': 'error' }
+    });
+    teardownSandbox();
+    const violations = result.violations.filter(v => v.rule === 'disable-typeorm-synchronize');
+    assert.strictEqual(violations.length, 1);
+});

package/dist/templates/angular/dialog-handler.template.d.ts

@@ -0,0 +1,2 @@
+export declare function angularFormDialogHandlerHtmlTemplate(name: string): string;
+export declare function angularFormDialogHandlerTsTemplate(name: string): string;

package/dist/templates/angular/dialog-handler.template.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.angularFormDialogHandlerHtmlTemplate = angularFormDialogHandlerHtmlTemplate;
+exports.angularFormDialogHandlerTsTemplate = angularFormDialogHandlerTsTemplate;
+const names_1 = require("../shared/names");
+function angularFormDialogHandlerHtmlTemplate(name) {
+    return `<devkit-dialog [isOpen]="true" (close)="onClose()">
+  <app-${name}-form
+    [isDialog]="true"
+    [itemId]="itemId"
+    (saved)="onClose()"
+    (cancelled)="onClose()"
+  ></app-${name}-form>
+</devkit-dialog>
+`;
+}
+function angularFormDialogHandlerTsTemplate(name) {
+    const pascalName = (0, names_1.kebabToPascal)(name);
+    return `import { Component, OnInit, inject } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { ActivatedRoute, Router } from '@angular/router';
+import { DevkitDialogComponent } from '@devstroupe/ui/dialog/dialog.component';
+import { ${pascalName}FormComponent } from '../form/${name}-form.component';
+
+@Component({
+  selector: 'app-${name}-form-dialog-handler',
+  standalone: true,
+  imports: [CommonModule, DevkitDialogComponent, ${pascalName}FormComponent],
+  templateUrl: './${name}-form-dialog-handler.component.html'
+})
+export class ${pascalName}FormDialogHandlerComponent implements OnInit {
+  private router = inject(Router);
+  private route = inject(ActivatedRoute);
+
+  itemId?: string | number;
+
+  ngOnInit(): void {
+    const id = this.route.snapshot.paramMap.get('id');
+    if (id) {
+      this.itemId = id;
+    }
+  }
+
+  onClose(): void {
+    this.router.navigate(['../'], { relativeTo: this.route });
+  }
+}
+`;
+}