@devstroupe/devkit-cli 1.1.9 → 1.1.11

package/dist/index.js

@@ -955,13 +955,13 @@ program
         process.exit(0);
     }
 });
-// Comando generate crud
+// Comando generate crud ou project
 program
-    .command('generate <type> <entityName>')
-    .description('Gera artefatos do DevKit. Tipos suportados: crud')
+    .command('generate <type> [entityName]')
+    .description('Gera artefatos do DevKit. Tipos suportados: crud, project')
     .action((type, entityName) => {
-    if (type !== 'crud') {
-        console.error(`Tipo de geração "${type}" não é suportado. Use "crud".`);
+    if (type !== 'crud' && type !== 'project') {
+        console.error(`Tipo de geração "${type}" não é suportado. Use "crud" ou "project".`);
         process.exit(1);
     }
     const configPath = path.join(process.cwd(), 'devstroupe.config.ts');
@@ -978,6 +978,14 @@ program
         console.error('Erro ao carregar devstroupe.config.ts:', error);
         process.exit(1);
     }
+    if (type === 'project') {
+        generateProject(process.cwd(), config);
+        return;
+    }
+    if (!entityName) {
+        console.error('Nome da entidade não fornecido. Use "devstroupe generate crud all" ou "devstroupe generate crud <nome_da_entidade>".');
+        process.exit(1);
+    }
     try {
         assertValidRelationshipConfig(config);
     }
@@ -1862,19 +1870,22 @@ volumes:
     fs.writeFileSync(path.join(projectRoot, 'docker-compose.dev.yml'), dockerComposeDevContent, 'utf-8');
     console.log(`[Docker] docker-compose.dev.yml gerado com sucesso.`);
 }
-// Comando new-project
-program
-    .command('new-project <projectName>')
-    .description('Cria um novo projeto com frontend Angular e backend NestJS pré-configurados')
-    .option('--microservices', 'Cria o projeto utilizando arquitetura de microsserviços')
-    .action((projectName, options) => {
-    const projectRoot = path.resolve(process.cwd(), projectName);
-    if (fs.existsSync(projectRoot) && fs.readdirSync(projectRoot).length > 0) {
-        console.error(`[Erro] O diretório "${projectName}" já existe e não está vazio.`);
-        process.exit(1);
+// Função que gera a estrutura de pastas e arquivos base a partir de um devstroupe.config.ts existente
+function generateProject(projectRoot, config) {
+    const projectName = config.projectName || 'DevsTroupe Project';
+    const isMicroservices = config.backendType === 'microservices';
+    const frontendPathRel = config.frontendPath || './frontend';
+    const backendPathRel = config.backendPath || './backend';
+    const frontendDest = path.resolve(projectRoot, frontendPathRel);
+    let backendDest;
+    if (isMicroservices) {
+        backendDest = path.resolve(projectRoot, backendPathRel, 'api-gateway');
+        fs.ensureDirSync(path.resolve(projectRoot, backendPathRel, 'services'));
     }
-    const isMicroservices = !!options.microservices;
-    console.log(`Criando novo projeto "${projectName}" (Modo: ${isMicroservices ? 'Microsserviços' : 'Monólito'}) em: ${projectRoot}...`);
+    else {
+        backendDest = path.resolve(projectRoot, backendPathRel);
+    }
+    console.log(`Configurando estrutura física do projeto "${projectName}" (Modo: ${isMicroservices ? 'Microsserviços' : 'Monólito'})...`);
     // Resolver caminhos de boilerplates
     let boilerplatesDir = path.resolve(__dirname, 'boilerplates');
     if (!fs.existsSync(boilerplatesDir)) {
@@ -1890,25 +1901,14 @@ program
         process.exit(1);
     }
     try {
-        // 1. Criar diretórios de destino
-        fs.ensureDirSync(projectRoot);
-        const frontendDest = path.join(projectRoot, 'frontend');
-        let backendDest;
-        if (isMicroservices) {
-            backendDest = path.join(projectRoot, 'backend', 'api-gateway');
-            fs.ensureDirSync(path.join(projectRoot, 'backend', 'services'));
-        }
-        else {
-            backendDest = path.join(projectRoot, 'backend');
-        }
-        // 2. Copiar boilerplates
-        console.log(`Copiando boilerplate do backend (${isMicroservices ? 'API Gateway' : 'NestJS Monólito'})...`);
-        fs.copySync(nestTemplateDir, backendDest, { filter: createBoilerplateCopyFilter(nestTemplateDir) });
-        console.log('Copiando boilerplate do frontend (Angular)...');
-        fs.copySync(angularTemplateDir, frontendDest, { filter: createBoilerplateCopyFilter(angularTemplateDir) });
-        // 2.1 Criar arquivos .env e .env.example no backend
-        console.log('Gerando arquivos .env e .env.example no backend...');
-        const envContent = `PORT=13000
+        // 1. Criar diretórios de destino e copiar boilerplates
+        if (!fs.existsSync(backendDest) || fs.readdirSync(backendDest).length === 0) {
+            console.log(`Copiando boilerplate do backend para: ${backendDest}...`);
+            fs.ensureDirSync(backendDest);
+            fs.copySync(nestTemplateDir, backendDest, { filter: createBoilerplateCopyFilter(nestTemplateDir) });
+            // Gerar arquivos .env e .env.example
+            console.log('Gerando arquivos .env e .env.example no backend...');
+            const envContent = `PORT=13000
 DB_HOST=localhost
 DB_PORT=3306
 DB_USER=root
@@ -1931,90 +1931,20 @@ R2_ACCOUNT_ID=
 R2_ACCESS_KEY=
 R2_SECRET_KEY=
 `;
-        fs.writeFileSync(path.join(backendDest, '.env'), envContent, 'utf-8');
-        fs.writeFileSync(path.join(backendDest, '.env.example'), envContent, 'utf-8');
+            fs.writeFileSync(path.join(backendDest, '.env'), envContent, 'utf-8');
+            fs.writeFileSync(path.join(backendDest, '.env.example'), envContent, 'utf-8');
+        }
+        if (!fs.existsSync(frontendDest) || fs.readdirSync(frontendDest).length === 0) {
+            console.log(`Copiando boilerplate do frontend para: ${frontendDest}...`);
+            fs.ensureDirSync(frontendDest);
+            fs.copySync(angularTemplateDir, frontendDest, { filter: createBoilerplateCopyFilter(angularTemplateDir) });
+        }
         // Patch local dependencies if in monorepo development
         patchLocalDependencies(backendDest, frontendDest, boilerplatesDir);
-        // 3. Criar devstroupe.config.ts
-        console.log('Gerando arquivo devstroupe.config.ts...');
-        const configPath = path.join(projectRoot, 'devstroupe.config.ts');
-        const designSystemConfig = {
-            provider: 'spartan',
-            spartanStyle: 'vega',
-            spartanTheme: 'neutral',
-            installAllPrimitives: true,
-            includePlayground: true,
-        };
-        const configContent = `export default {
-  projectName: '${projectName}',
-  backendType: '${isMicroservices ? 'microservices' : 'monolith'}',
-  backendPath: './backend',
-  frontendPath: './frontend',
-  designSystem: {
-    provider: '${designSystemConfig.provider}',
-    spartanStyle: '${designSystemConfig.spartanStyle}',
-    spartanTheme: '${designSystemConfig.spartanTheme}',
-    installAllPrimitives: ${designSystemConfig.installAllPrimitives},
-    includePlayground: ${designSystemConfig.includePlayground}
-  },
-  entities: [
-    {
-      name: 'company',
-      label: 'Empresa',
-      tableName: 'companies',
-      properties: [
-        { name: 'name', type: 'string', required: true, label: 'Nome' },
-        {
-          name: 'cabins', type: 'relationship', required: false, label: 'Cabines',
-          relation: {
-            target: 'cabin', kind: 'one-to-many', foreignKey: 'company_id',
-            inverseSide: 'company', control: 'table', embedded: true,
-            columns: ['name', 'code', 'is_active'], lookup: { pageSize: 10 }
-          }
-        }
-      ],
-      crud: { generateFrontend: true, generateBackend: true }
-    },
-    {
-      name: 'cabin',
-      label: 'Cabine',
-      tableName: 'cabins',
-      properties: [
-        { name: 'name', type: 'string', required: true, label: 'Nome' },
-        { name: 'code', type: 'string', required: false, label: 'Código' },
-        {
-          name: 'company_id', type: 'relationship', required: true, label: 'Empresa',
-          relation: {
-            target: 'company', kind: 'many-to-one', relationName: 'company',
-            inverseSide: 'cabins', control: 'select', displayField: 'name', onDelete: 'CASCADE',
-            lookup: { mode: 'remote', pageSize: 20, minSearchLength: 0 }
-          }
-        },
-        { name: 'is_active', type: 'boolean', required: true, label: 'Ativo', default: true }
-      ],
-      crud: {
-        generateFrontend: true,
-        generateBackend: true
-      }
-    }
-  ]
-};
-`;
-        fs.writeFileSync(configPath, configContent, 'utf-8');
-        // 3.1 Criar docker-compose.yml e init.sql
+        // 2. Gerar docker-compose.yml e init.sql
         console.log('Gerando docker-compose.yml e base de dados...');
-        const tempConfig = {
-            projectName,
-            backendType: isMicroservices ? 'microservices' : 'monolith',
-            entities: [
-                {
-                    name: 'cabin',
-                    tableName: 'cabins',
-                }
-            ]
-        };
-        generateDockerComposeAndDbInit(projectRoot, tempConfig);
-        // 3.2 Criar Makefile na raiz
+        generateDockerComposeAndDbInit(projectRoot, config);
+        // 3. Gerar Makefile na raiz
         console.log('Gerando arquivo Makefile na raiz...');
         const backendServiceName = isMicroservices ? 'api-gateway' : 'backend';
         const makefileContent = `.PHONY: up down restart build logs ps clean backend-shell frontend-shell db-shell dev-up dev-down dev-restart dev-build dev-logs dev-ps dev-clean help
@@ -2120,17 +2050,100 @@ db-shell:
         catch (err) {
             console.warn('[Aviso] Falha ao rodar "npm install" no frontend. Instale as dependências manualmente.');
         }
-        // 5. Inicializar UI no frontend depois do install para disponibilizar @spartan-ng/cli
+        // 5. Inicializar componentes de UI Spartan
         console.log('Inicializando componentes de UI locais...');
-        const generatedConfig = require(configPath).default ?? require(configPath);
-        initUi(frontendDest, generatedConfig);
-        console.log(`\n\x1b[32m[SUCESSO] Projeto "${projectName}" criado com sucesso!\x1b[0m`);
+        initUi(frontendDest, config);
+        console.log(`\n\x1b[32m[SUCESSO] Projeto "${projectName}" gerado com sucesso!\x1b[0m`);
+    }
+    catch (err) {
+        console.error('[Erro] Falha ao gerar o projeto:', err);
+        process.exit(1);
+    }
+}
+// Comando new-project
+program
+    .command('new-project <projectName>')
+    .description('Cria um novo diretório de projeto e inicializa o devstroupe.config.ts')
+    .option('--microservices', 'Cria o projeto utilizando arquitetura de microsserviços')
+    .action((projectName, options) => {
+    const projectRoot = path.resolve(process.cwd(), projectName);
+    if (fs.existsSync(projectRoot) && fs.readdirSync(projectRoot).length > 0) {
+        console.error(`[Erro] O diretório "${projectName}" já existe e não está vazio.`);
+        process.exit(1);
+    }
+    const isMicroservices = !!options.microservices;
+    console.log(`Inicializando novo projeto "${projectName}" em: ${projectRoot}...`);
+    try {
+        // 1. Criar diretório de destino
+        fs.ensureDirSync(projectRoot);
+        // 2. Criar devstroupe.config.ts padrão
+        console.log('Gerando arquivo devstroupe.config.ts...');
+        const configPath = path.join(projectRoot, 'devstroupe.config.ts');
+        const configContent = `export default {
+  projectName: '${projectName}',
+  backendType: '${isMicroservices ? 'microservices' : 'monolith'}',
+  backendPath: './backend',
+  frontendPath: './frontend',
+  designSystem: {
+    provider: 'spartan',
+    spartanStyle: 'vega',
+    spartanTheme: 'neutral',
+    installAllPrimitives: true,
+    includePlayground: true
+  },
+  entities: [
+    {
+      name: 'company',
+      label: 'Empresa',
+      tableName: 'companies',
+      properties: [
+        { name: 'name', type: 'string', required: true, label: 'Nome' },
+        {
+          name: 'cabins', type: 'relationship', required: false, label: 'Cabines',
+          relation: {
+            target: 'cabin', kind: 'one-to-many', foreignKey: 'company_id',
+            inverseSide: 'company', control: 'table', embedded: true,
+            columns: ['name', 'code', 'is_active'], lookup: { pageSize: 10 }
+          }
+        }
+      ],
+      crud: { generateFrontend: true, generateBackend: true }
+    },
+    {
+      name: 'cabin',
+      label: 'Cabine',
+      tableName: 'cabins',
+      properties: [
+        { name: 'name', type: 'string', required: true, label: 'Nome' },
+        { name: 'code', type: 'string', required: false, label: 'Código' },
+        {
+          name: 'company_id', type: 'relationship', required: true, label: 'Empresa',
+          relation: {
+            target: 'company', kind: 'many-to-one', relationName: 'company',
+            inverseSide: 'cabins', control: 'select', displayField: 'name', onDelete: 'CASCADE',
+            lookup: { mode: 'remote', pageSize: 20, minSearchLength: 0 }
+          }
+        },
+        { name: 'is_active', type: 'boolean', required: true, label: 'Ativo', default: true }
+      ],
+      crud: {
+        generateFrontend: true,
+        generateBackend: true
+      }
+    }
+  ]
+};
+`;
+        fs.writeFileSync(configPath, configContent, 'utf-8');
+        console.log(`\n\x1b[32m[SUCESSO] Projeto "${projectName}" inicializado com sucesso!\x1b[0m`);
         console.log(`Para começar:`);
-        console.log(`  1. Entre na pasta do projeto: cd ${projectName}`);
-        console.log(`  2. Desenvolva sua aplicação com o DT-DevKit!`);
+        console.log(`  1. Acesse a pasta do projeto: cd ${projectName}`);
+        console.log(`  2. Ajuste suas entidades e configurações no arquivo: devstroupe.config.ts`);
+        console.log(`  3. Execute o comando a seguir para gerar toda a estrutura física (frontend, backend, Docker):`);
+        console.log(`     devstroupe generate project`);
     }
     catch (err) {
-        console.error('[Erro] Falha ao criar o novo projeto:', err);
+        console.error('[Erro] Falha ao inicializar o novo projeto:', err);
         process.exit(1);
     }
 });

package/dist/templates/nest/migration.template.js

@@ -80,23 +80,39 @@ function nestMigrationTemplate(entity, entities, timestamp, properties = entity.
     const relationColumns = relationships
         .filter((relationship) => (0, relationships_1.isSingularRelationship)(relationship.kind))
         .map((relationship) => `        { name: '${relationship.foreignKey}', type: 'int', isNullable: ${!relationship.property.required}, isUnique: ${relationship.kind === 'one-to-one'} }`);
-    // Gera SQL idempotente para cada FK: DROP IF EXISTS + ADD CONSTRAINT
+    // Gera código TypeORM seguro para cada FK no método UP
     const foreignKeysSql = relationships
         .filter((relationship) => (0, relationships_1.isSingularRelationship)(relationship.kind))
         .map((relationship) => {
         const fkName = `FK_${tableName}_${relationship.foreignKey}`;
         const refTable = targetTable(relationship.target, entities);
-        return [
-            `    await queryRunner.query(\`ALTER TABLE \\\`${tableName}\\\` DROP FOREIGN KEY IF EXISTS \\\`${fkName}\\\`\`);`,
-            `    await queryRunner.query(\`ALTER TABLE \\\`${tableName}\\\` ADD CONSTRAINT \\\`${fkName}\\\` FOREIGN KEY (\\\`${relationship.foreignKey}\\\`) REFERENCES \\\`${refTable}\\\`(\\\`${relationship.valueField}\\\`) ON DELETE ${relationship.onDelete}\`);`,
-        ].join('\n');
+        return `    const table_${relationship.foreignKey} = await queryRunner.getTable('${tableName}');
+    if (table_${relationship.foreignKey}) {
+      const foreignKey = table_${relationship.foreignKey}.foreignKeys.find(fk => fk.name === '${fkName}');
+      if (foreignKey) {
+        await queryRunner.dropForeignKey('${tableName}', foreignKey);
+      }
+    }
+    await queryRunner.createForeignKey('${tableName}', new TableForeignKey({
+      name: '${fkName}',
+      columnNames: ['${relationship.foreignKey}'],
+      referencedTableName: '${refTable}',
+      referencedColumnNames: ['${relationship.valueField}'],
+      onDelete: '${relationship.onDelete}'
+    }));`;
     })
         .join('\n');
     const dropForeignKeysSql = relationships
         .filter((relationship) => (0, relationships_1.isSingularRelationship)(relationship.kind))
         .map((relationship) => {
         const fkName = `FK_${tableName}_${relationship.foreignKey}`;
-        return `    await queryRunner.query(\`ALTER TABLE \\\`${tableName}\\\` DROP FOREIGN KEY IF EXISTS \\\`${fkName}\\\`\`);`;
+        return `    const table_${relationship.foreignKey} = await queryRunner.getTable('${tableName}');
+    if (table_${relationship.foreignKey}) {
+      const foreignKey = table_${relationship.foreignKey}.foreignKeys.find(fk => fk.name === '${fkName}');
+      if (foreignKey) {
+        await queryRunner.dropForeignKey('${tableName}', foreignKey);
+      }
+    }`;
     })
         .join('\n');
     const junctions = relationships
@@ -163,7 +179,7 @@ function nestMigrationTemplate(entity, entities, timestamp, properties = entity.
             return `    await queryRunner.query('ALTER TABLE \`${tableName}\` DROP CONSTRAINT \`${checkName}\`');`;
         }).join('\n')
         : '';
-    return `import { MigrationInterface, QueryRunner, Table, TableIndex } from 'typeorm';
+    return `import { MigrationInterface, QueryRunner, Table, TableForeignKey, TableIndex } from 'typeorm';
 
 export class ${className} implements MigrationInterface {
   name = '${className}';

package/dist/templates/relationship-templates.test.js

@@ -149,9 +149,9 @@ function assertValidTypeScript(source) {
     strict_1.default.match(companyMigration, /name: 'companies'/);
     strict_1.default.doesNotMatch(companyMigration, /FK_companies_cabins/);
     strict_1.default.match(cabinMigration, /name: 'company_id', type: 'int'/);
-    strict_1.default.match(cabinMigration, /ADD CONSTRAINT/);
+    strict_1.default.match(cabinMigration, /createForeignKey/);
     strict_1.default.match(cabinMigration, /FK_cabins_company_id/);
-    strict_1.default.match(cabinMigration, /ON DELETE CASCADE/);
+    strict_1.default.match(cabinMigration, /onDelete: 'CASCADE'/);
     strict_1.default.match(dataSource, /migrations: \[path\.join/);
     strict_1.default.match(dataSource, /synchronize: false/);
     assertValidTypeScript(companyMigration);

package/dist/templates/ui/layout/header.template.js

@@ -8,7 +8,7 @@ import { CommonModule } from '@angular/common';
 import { HlmButton } from '@spartan-ng/helm/button';
 import { HlmInput } from '@spartan-ng/helm/input';
 import { NgIconComponent } from '@ng-icons/core';
-import type { ThemeMode } from '../../../core/services/theme.service';
+import type { ThemeMode } from '../../../../core/services/theme.service';
 
 export interface IUserProfile {
   name: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devstroupe/devkit-cli",
-  "version": "1.1.9",
+  "version": "1.1.11",
   "description": "DevsTroupe Development Kit CLI — scaffold NestJS+Angular projects, inject Spartan UI, generate CRUDs and audit architectural governance",
   "license": "MIT",
   "keywords": [
@@ -36,7 +36,7 @@
   "dependencies": {
     "commander": "^12.0.0",
     "fs-extra": "^11.2.0",
-    "@devstroupe/devkit-core": "1.1.9"
+    "@devstroupe/devkit-core": "1.1.11"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",