@devstroupe/devkit-cli 1.1.16 → 1.2.0-beta.1

package/dist/index.js

@@ -34,15 +34,21 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.program = void 0;
+exports.patchLocalDependencies = patchLocalDependencies;
 const commander_1 = require("commander");
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs-extra"));
 const cli_templates_1 = require("./templates/cli-templates");
+const functional_module_templates_1 = require("./templates/nest/functional-module.templates");
 const ui_templates_1 = require("./templates/ui-templates");
 const linter_rules_1 = require("./rules/linter-rules");
 const relationships_1 = require("./templates/shared/relationships");
 const sort_entities_1 = require("./migrations/sort-entities");
 const child_process_1 = require("child_process");
+const devkit_core_1 = require("@devstroupe/devkit-core");
+const backend_layout_1 = require("./generation/backend-layout");
+const entity_module_move_1 = require("./migrations/entity-module-move");
 // Registra ts-node para poder carregar arquivos .ts (como o config)
 try {
     require('ts-node').register({
@@ -53,6 +59,7 @@ catch (e) {
     // Silencioso se ts-node não estiver presente localmente
 }
 const program = new commander_1.Command();
+exports.program = program;
 const SPARTAN_STYLES = ['nova', 'vega', 'lyra', 'maia', 'mira', 'luma'];
 function isSpartanStyle(value) {
     return SPARTAN_STYLES.includes(value);
@@ -62,12 +69,7 @@ function getDesignSystemConfig(config) {
 }
 function assertValidRelationshipConfig(config) {
     (0, relationships_1.validateRelationships)(config.entities ?? []);
-    if (config.backendType !== 'microservices')
-        return;
-    const manyToMany = (config.entities ?? []).flatMap((item) => (0, relationships_1.getRelationships)(item.properties ?? []).filter((relation) => relation.kind === 'many-to-many'));
-    if (manyToMany.length > 0) {
-        throw new Error('Many-to-many relationships require a dedicated junction CRUD when backendType is "microservices".');
-    }
+    (0, backend_layout_1.validateModuleRelationships)(config.entities ?? []);
 }
 function ensureMigrationInfrastructure(backendRoot) {
     const databaseDir = path.join(backendRoot, 'src', 'database');
@@ -111,6 +113,112 @@ function ensureInitialMigrations(backendRoot, entities, propertyOverrides = new
         console.log(`[Migration] Criada ${fileName}`);
     });
 }
+const CRUD_USE_CASE_KINDS = ['create', 'update', 'find', 'list', 'soft-delete'];
+function generatedEntityReady(entityRoot, entityName) {
+    return fs.existsSync(path.join(entityRoot, entityName, 'application', 'use-cases', `${entityName}-crud.application.ts`));
+}
+function writeCrudEntityArtifacts(entityRoot, entity, properties, tenantScoped, moduleName) {
+    const root = path.join(entityRoot, entity.name);
+    const useCases = path.join(root, 'application', 'use-cases');
+    const ports = path.join(root, 'application', 'ports');
+    const persistence = path.join(root, 'infrastructure', 'persistence', 'typeorm');
+    const api = path.join(root, 'api');
+    [useCases, ports, persistence, api].forEach((directory) => fs.ensureDirSync(directory));
+    fs.writeFileSync(path.join(persistence, `${entity.name}.orm-entity.ts`), (0, cli_templates_1.nestOrmEntityTemplate)(entity.name, properties, entity.tableName || `${entity.name}s`, tenantScoped, entity.indexes, { ...(entity.persistence ?? {}), deletion: 'soft-delete' }, entity.automaticFields, '../../../../'), 'utf-8');
+    fs.writeFileSync(path.join(api, `${entity.name}.dto.ts`), (0, cli_templates_1.nestDtoTemplate)(entity.name, properties), 'utf-8');
+    fs.writeFileSync(path.join(ports, `${entity.name}.repository.port.ts`), (0, functional_module_templates_1.nestRepositoryPortV2Template)(entity.name), 'utf-8');
+    fs.writeFileSync(path.join(persistence, `${entity.name}.repository.ts`), (0, functional_module_templates_1.nestRepositoryAdapterV2Template)(entity.name, properties, tenantScoped), 'utf-8');
+    for (const kind of CRUD_USE_CASE_KINDS) {
+        fs.writeFileSync(path.join(useCases, `${kind}-${entity.name}.use-case.ts`), (0, functional_module_templates_1.nestCrudUseCaseTemplate)(entity.name, kind), 'utf-8');
+    }
+    fs.writeFileSync(path.join(useCases, `${entity.name}-crud.application.ts`), (0, functional_module_templates_1.nestCrudApplicationTemplate)(entity.name), 'utf-8');
+    fs.writeFileSync(path.join(api, `${entity.name}.controller.ts`), (0, functional_module_templates_1.nestControllerV2Template)(entity.name, moduleName), 'utf-8');
+}
+function generatedMembers(moduleRoot, entities, current) {
+    return entities.filter((candidate) => candidate.name === current.name || generatedEntityReady(moduleRoot, candidate.name));
+}
+function migrationPropertiesForEntity(entity, config) {
+    const properties = (0, backend_layout_1.persistencePropertiesForEntity)(entity, config.entities ?? []);
+    const tenantScoped = Boolean(config.multiTenant?.enabled && entity.tenantScoped !== false);
+    return tenantScoped && !properties.some((property) => property.name === 'tenantId')
+        ? [...properties, { name: 'tenantId', label: 'Tenant', type: 'string', required: true, index: true }]
+        : properties;
+}
+function platformPackageName(projectName) {
+    const scope = String(projectName || 'app')
+        .trim().toLowerCase().replace(/[^a-z0-9-]+/g, '-').replace(/^-+|-+$/g, '') || 'app';
+    return `@${scope}/platform`;
+}
+function linkPlatformPackage(applicationRoot, platformRoot, packageName) {
+    const packagePath = path.join(applicationRoot, 'package.json');
+    if (!fs.existsSync(packagePath))
+        return;
+    const localPackageRoot = path.join(applicationRoot, 'local_packages', 'project-platform');
+    fs.removeSync(localPackageRoot);
+    fs.copySync(platformRoot, localPackageRoot, {
+        filter: (source) => !source.split(path.sep).some((part) => ['node_modules', 'dist'].includes(part)),
+    });
+    const packageJson = fs.readJsonSync(packagePath);
+    packageJson.dependencies ??= {};
+    packageJson.dependencies[packageName] = 'file:local_packages/project-platform';
+    fs.writeJsonSync(packagePath, packageJson, { spaces: 2 });
+}
+function ensurePlatformLayout(backendRoot, microservices, projectName = 'app') {
+    const platformRoot = microservices
+        ? path.join(backendRoot, 'packages', 'platform')
+        : path.join(backendRoot, 'src', 'platform');
+    const capabilitiesRoot = microservices ? path.join(platformRoot, 'src') : platformRoot;
+    const capabilities = ['security', 'tenancy', 'http', 'messaging', 'observability', 'storage', 'integrations'];
+    capabilities.forEach((capability) => {
+        const capabilityRoot = path.join(capabilitiesRoot, capability);
+        fs.ensureDirSync(capabilityRoot);
+        const capabilityReadme = path.join(capabilityRoot, 'README.md');
+        if (!fs.existsSync(capabilityReadme)) {
+            fs.writeFileSync(capabilityReadme, `# ${capability}\n\nAdapters técnicos compartilhados de ${capability}. Não importe entities ou repositories de negócio aqui.\n`, 'utf-8');
+        }
+    });
+    const readmePath = path.join(platformRoot, 'README.md');
+    if (!fs.existsSync(readmePath)) {
+        fs.writeFileSync(readmePath, `# Platform\n\nInfraestrutura técnica compartilhada. Este diretório não representa um microsserviço.\n\n- Contratos de negócio permanecem nos módulos funcionais.\n- Integrações compartilhadas são nomeadas pela capacidade.\n- Platform nunca importa entities ou repositories de negócio.\n- Em microsserviços, edite este package central; as cópias em local_packages são sincronizadas pelo gerador.\n- Promova uma capacidade a serviço somente quando estado, quota, chave única, persistência, fila, auditoria ou governança central exigirem ownership próprio.\n`, 'utf-8');
+    }
+    if (microservices) {
+        const requestedPackageName = platformPackageName(projectName);
+        const platformPackagePath = path.join(platformRoot, 'package.json');
+        if (!fs.existsSync(platformPackagePath)) {
+            fs.writeJsonSync(platformPackagePath, {
+                name: requestedPackageName,
+                version: '0.0.0',
+                private: true,
+                main: './src/index.js',
+                types: './src/index.d.ts',
+                peerDependencies: { '@devstroupe/devkit-nest': `^${cliVersion}` },
+            }, { spaces: 2 });
+        }
+        const packageName = fs.readJsonSync(platformPackagePath).name;
+        const rootJs = path.join(capabilitiesRoot, 'index.js');
+        const rootTypes = path.join(capabilitiesRoot, 'index.d.ts');
+        if (!fs.existsSync(rootJs))
+            fs.writeFileSync(rootJs, `module.exports = require('@devstroupe/devkit-nest');\n`, 'utf-8');
+        if (!fs.existsSync(rootTypes))
+            fs.writeFileSync(rootTypes, `export * from '@devstroupe/devkit-nest';\n`, 'utf-8');
+        for (const capability of capabilities) {
+            const capabilityRoot = path.join(capabilitiesRoot, capability);
+            const capabilityJs = path.join(capabilityRoot, 'index.js');
+            const capabilityTypes = path.join(capabilityRoot, 'index.d.ts');
+            if (!fs.existsSync(capabilityJs))
+                fs.writeFileSync(capabilityJs, `module.exports = require('@devstroupe/devkit-nest');\n`, 'utf-8');
+            if (!fs.existsSync(capabilityTypes))
+                fs.writeFileSync(capabilityTypes, `export * from '@devstroupe/devkit-nest';\n`, 'utf-8');
+        }
+        const applicationRoots = [
+            path.join(backendRoot, 'api-gateway'),
+            ...(fs.existsSync(path.join(backendRoot, 'apps'))
+                ? fs.readdirSync(path.join(backendRoot, 'apps')).map((entry) => path.join(backendRoot, 'apps', entry))
+                : []),
+        ];
+        applicationRoots.forEach((applicationRoot) => linkPlatformPackage(applicationRoot, platformRoot, packageName));
+    }
+}
 function getSpartanStyle(config) {
     const designSystem = getDesignSystemConfig(config);
     const configuredStyle = designSystem.spartanStyle || designSystem.style || designSystem.preset || 'vega';
@@ -1105,13 +1213,6 @@ program
             const isMultiTenant = !!config.multiTenant?.enabled;
             const isTenantScoped = isMultiTenant && (entity.tenantScoped !== false);
             const isMicroservices = config.backendType === 'microservices';
-            const backendProperties = isMicroservices
-                ? entity.properties
-                    .filter((property) => property.type !== 'relationship' || (0, relationships_1.getRelationships)([property])[0].kind !== 'one-to-many')
-                    .map((property) => property.type === 'relationship'
-                    ? { ...property, type: 'number', name: (0, relationships_1.getRelationships)([property])[0].foreignKey }
-                    : property)
-                : entity.properties;
             let boilerplatesDir = path.resolve(__dirname, 'boilerplates');
             if (!fs.existsSync(boilerplatesDir)) {
                 boilerplatesDir = path.resolve(__dirname, '../boilerplates');
@@ -1120,131 +1221,64 @@ program
                 boilerplatesDir = path.resolve(__dirname, '../../boilerplates');
             }
             const nestTemplateDir = path.join(boilerplatesDir, 'nest-template');
+            const group = (0, backend_layout_1.moduleForEntity)(entity, config.entities ?? []);
+            const backendProperties = (0, backend_layout_1.persistencePropertiesForEntity)(entity, config.entities ?? []);
             if (isMicroservices) {
-                const entityIndex = config.entities.findIndex((e) => e.name.toLowerCase() === entity.name.toLowerCase());
-                const port = 3001 + (entityIndex >= 0 ? entityIndex : 0);
-                // Garantir estrutura do API Gateway
                 const gatewayRoot = path.join(backendRoot, 'api-gateway');
-                if (!fs.existsSync(gatewayRoot) || !fs.existsSync(path.join(gatewayRoot, 'src', 'app.module.ts'))) {
-                    console.log(`[Gateway] Inicializando estrutura do API Gateway...`);
+                if (!fs.existsSync(path.join(gatewayRoot, 'src', 'app.module.ts'))) {
+                    console.log('[Gateway] Inicializando estrutura do API Gateway...');
                     fs.ensureDirSync(gatewayRoot);
-                    fs.copySync(nestTemplateDir, gatewayRoot);
-                    const gatewayEnv = `PORT=13000
-DB_HOST=database
-DB_PORT=3306
-DB_USER=root
-DB_PASSWORD=root
-DB_NAME=devstroupe
-JWT_SECRET=devstroupe-secret-key-12345
-`;
+                    fs.copySync(nestTemplateDir, gatewayRoot, { filter: createBoilerplateCopyFilter(nestTemplateDir) });
+                    const gatewayEnv = `PORT=13000\nJWT_SECRET=devstroupe-secret-key-12345\n`;
                     fs.writeFileSync(path.join(gatewayRoot, '.env'), gatewayEnv, 'utf-8');
                     fs.writeFileSync(path.join(gatewayRoot, '.env.example'), gatewayEnv, 'utf-8');
                     patchLocalDependencies(gatewayRoot, null, boilerplatesDir);
-                    try {
-                        console.log(`[Gateway] Instalando dependências em: ${gatewayRoot}...`);
-                        (0, child_process_1.execSync)('npm install', { cwd: gatewayRoot, stdio: 'inherit' });
-                    }
-                    catch (err) {
-                        console.warn(`[Aviso] Falha ao rodar "npm install" no API Gateway. Instale manualmente.`);
-                    }
+                    prepareStatelessGateway(gatewayRoot);
                 }
-                const msRoot = path.join(backendRoot, 'services', entity.name);
-                console.log(`Gerando Microsserviço para a entidade "${currentEntityName}" em: ${msRoot}...`);
-                if (!fs.existsSync(msRoot) || !fs.existsSync(path.join(msRoot, 'src', 'app.module.ts'))) {
-                    console.log(`[Microsserviço] Inicializando estrutura do microsserviço...`);
+                const msRoot = path.join(backendRoot, 'apps', group.serviceName);
+                if (!fs.existsSync(path.join(msRoot, 'src', 'app.module.ts'))) {
+                    console.log(`[Microsserviço] Inicializando ${group.serviceName}...`);
                     fs.ensureDirSync(msRoot);
-                    fs.copySync(nestTemplateDir, msRoot);
-                    // Limpa módulos desnecessários
-                    fs.removeSync(path.join(msRoot, 'src', 'modules', 'user'));
-                    fs.removeSync(path.join(msRoot, 'src', 'modules', 'auth'));
-                    // Injeta arquivos específicos de microsserviço
-                    fs.writeFileSync(path.join(msRoot, 'src', 'main.ts'), generateMsMainTs(port), 'utf-8');
-                    fs.writeFileSync(path.join(msRoot, 'src', 'app.module.ts'), generateMsAppModule(entity.name), 'utf-8');
-                    // Injeta env básico no microsserviço
-                    const msEnv = `PORT=${port}
-DB_HOST=database
-DB_PORT=3306
-DB_USER=root
-DB_PASSWORD=root
-DB_NAME=devstroupe_${entity.name.toLowerCase()}
-SERVICE_PORT=${port}
-`;
+                    fs.copySync(nestTemplateDir, msRoot, { filter: createBoilerplateCopyFilter(nestTemplateDir) });
+                    const isCoreService = group.name === 'core';
+                    if (!isCoreService) {
+                        const jwtGuard = fs.readFileSync(path.join(msRoot, 'src', 'modules', 'auth', 'jwt-auth.guard.ts'), 'utf-8');
+                        for (const moduleName of ['user', 'auth', 'role', 'storage', 'core']) {
+                            fs.removeSync(path.join(msRoot, 'src', 'modules', moduleName));
+                        }
+                        const authRoot = path.join(msRoot, 'src', 'modules', 'auth');
+                        fs.ensureDirSync(authRoot);
+                        fs.writeFileSync(path.join(authRoot, 'jwt-auth.guard.ts'), jwtGuard, 'utf-8');
+                        fs.emptyDirSync(path.join(msRoot, 'src', 'database', 'migrations'));
+                    }
+                    fs.writeFileSync(path.join(msRoot, 'src', 'main.ts'), generateMsMainTs(group.port), 'utf-8');
+                    fs.writeFileSync(path.join(msRoot, 'src', 'app.module.ts'), generateMsAppModule(group.name, isCoreService), 'utf-8');
+                    const msEnv = `PORT=${group.port}\nDB_HOST=database\nDB_PORT=3306\nDB_USER=root\nDB_PASSWORD=root\nDB_NAME=${group.databaseName}\nSERVICE_PORT=${group.port}\n`;
                     fs.writeFileSync(path.join(msRoot, '.env'), msEnv, 'utf-8');
                     fs.writeFileSync(path.join(msRoot, '.env.example'), msEnv, 'utf-8');
                     patchLocalDependencies(msRoot, null, boilerplatesDir);
-                    try {
-                        console.log(`[Microsserviço] Instalando dependências em: ${msRoot}...`);
-                        (0, child_process_1.execSync)('npm install', { cwd: msRoot, stdio: 'inherit' });
-                    }
-                    catch (err) {
-                        console.warn(`[Aviso] Falha ao rodar "npm install" no microsserviço. Instale manualmente.`);
-                    }
                 }
-                const modulePath = path.join(msRoot, 'src', 'modules', entity.name);
-                fs.ensureDirSync(path.join(modulePath, 'domain'));
-                fs.ensureDirSync(path.join(modulePath, 'service'));
-                fs.ensureDirSync(path.join(modulePath, 'infra', 'database'));
-                fs.ensureDirSync(path.join(modulePath, 'infra', 'http'));
-                // Domain Entity
-                fs.writeFileSync(path.join(modulePath, 'domain', `${entity.name}.ts`), (0, cli_templates_1.nestDomainEntityTemplate)(entity.name, backendProperties, isTenantScoped, entity.automaticFields), 'utf-8');
-                // Repository Port
-                fs.writeFileSync(path.join(modulePath, 'domain', `${entity.name}.repository.port.ts`), (0, cli_templates_1.nestRepositoryPortTemplate)(entity.name), 'utf-8');
-                // DTO
-                fs.writeFileSync(path.join(modulePath, 'infra', 'http', `${entity.name}.dto.ts`), (0, cli_templates_1.nestDtoTemplate)(entity.name, backendProperties), 'utf-8');
-                // Controller (TCP)
-                fs.writeFileSync(path.join(modulePath, 'infra', 'http', `${entity.name}.ms.controller.ts`), (0, cli_templates_1.nestMsControllerTemplate)(entity.name), 'utf-8');
-                // ORM Entity
-                fs.writeFileSync(path.join(modulePath, 'infra', 'database', `${entity.name}.orm-entity.ts`), (0, cli_templates_1.nestOrmEntityTemplate)(entity.name, backendProperties, entity.tableName || `${entity.name}s`, isTenantScoped, entity.indexes, entity.persistence, entity.automaticFields), 'utf-8');
-                // Repository Adapter
-                fs.writeFileSync(path.join(modulePath, 'infra', 'database', `${entity.name}.repository.ts`), (0, cli_templates_1.nestRepositoryAdapterTemplate)(entity.name, backendProperties, isTenantScoped), 'utf-8');
-                // Service
-                fs.writeFileSync(path.join(modulePath, 'service', `${entity.name}.service.ts`), (0, cli_templates_1.nestServiceTemplate)(entity.name), 'utf-8');
-                // Module (TCP)
-                fs.writeFileSync(path.join(modulePath, `${entity.name}.module.ts`), (0, cli_templates_1.nestMsModuleTemplate)(entity.name), 'utf-8');
-                console.log(`[Microsserviço] Arquivos do microsserviço "${currentEntityName}" gerados com sucesso.`);
+                const moduleRoot = path.join(msRoot, 'src', 'modules', group.name);
+                writeCrudEntityArtifacts(moduleRoot, entity, backendProperties, isTenantScoped, group.name);
+                const members = generatedMembers(moduleRoot, group.entities, entity);
+                fs.writeFileSync(path.join(moduleRoot, `${group.name}.module.ts`), (0, functional_module_templates_1.nestFunctionalModuleTemplate)(group.name, members), 'utf-8');
                 if (entity.crud?.generateMigration !== false) {
-                    ensureInitialMigrations(msRoot, [entity], new Map([[entity.name, backendProperties]]));
+                    ensureInitialMigrations(msRoot, members, new Map(members.map((member) => [member.name, migrationPropertiesForEntity(member, config)])));
                 }
-                // --- Gerar API Gateway Module ---
-                const gatewayModulePath = path.join(backendRoot, 'api-gateway', 'src', 'modules', entity.name);
-                console.log(`Gerando Módulo Gateway para a entidade "${currentEntityName}" em: ${gatewayModulePath}...`);
-                fs.ensureDirSync(path.join(gatewayModulePath, 'infra', 'http'));
-                // DTO (Gateway)
-                fs.writeFileSync(path.join(gatewayModulePath, 'infra', 'http', `${entity.name}.dto.ts`), (0, cli_templates_1.nestDtoTemplate)(entity.name, backendProperties), 'utf-8');
-                // Controller (Gateway)
-                fs.writeFileSync(path.join(gatewayModulePath, 'infra', 'http', `${entity.name}.controller.ts`), (0, cli_templates_1.nestGatewayControllerTemplate)(entity.name), 'utf-8');
-                // Module (Gateway)
-                fs.writeFileSync(path.join(gatewayModulePath, `${entity.name}.module.ts`), (0, cli_templates_1.nestGatewayModuleTemplate)(entity.name, port), 'utf-8');
-                // Patch app.module.ts do Gateway
-                patchGatewayAppModule(path.join(backendRoot, 'api-gateway', 'src', 'app.module.ts'), entity.name);
-                console.log(`[Gateway] Módulo Gateway "${currentEntityName}" gerado com sucesso.`);
+                const gatewayModuleRoot = path.join(gatewayRoot, 'src', 'modules', group.name);
+                fs.ensureDirSync(gatewayModuleRoot);
+                fs.writeFileSync(path.join(gatewayModuleRoot, `${group.name}.gateway.controller.ts`), (0, functional_module_templates_1.nestGatewayModuleProxyControllerTemplate)(group.name, group.port), 'utf-8');
+                fs.writeFileSync(path.join(gatewayModuleRoot, `${group.name}.module.ts`), (0, functional_module_templates_1.nestGatewayFunctionalModuleTemplate)(group.name, group.port), 'utf-8');
+                patchGatewayAppModule(path.join(gatewayRoot, 'src', 'app.module.ts'), group.name);
+                console.log(`[Microsserviço] ${currentEntityName} adicionado a ${group.serviceName}.`);
             }
             else {
-                // Monolito
-                console.log(`Gerando arquivos NestJS Monolito para a entidade "${currentEntityName}"...`);
-                const modulePath = path.join(backendRoot, 'src', 'modules', entity.name);
-                fs.ensureDirSync(path.join(modulePath, 'domain'));
-                fs.ensureDirSync(path.join(modulePath, 'service'));
-                fs.ensureDirSync(path.join(modulePath, 'infra', 'database'));
-                fs.ensureDirSync(path.join(modulePath, 'infra', 'http'));
-                // Domain Entity
-                fs.writeFileSync(path.join(modulePath, 'domain', `${entity.name}.ts`), (0, cli_templates_1.nestDomainEntityTemplate)(entity.name, entity.properties, isTenantScoped, entity.automaticFields), 'utf-8');
-                // Repository Port
-                fs.writeFileSync(path.join(modulePath, 'domain', `${entity.name}.repository.port.ts`), (0, cli_templates_1.nestRepositoryPortTemplate)(entity.name), 'utf-8');
-                // DTO
-                fs.writeFileSync(path.join(modulePath, 'infra', 'http', `${entity.name}.dto.ts`), (0, cli_templates_1.nestDtoTemplate)(entity.name, entity.properties), 'utf-8');
-                // Controller
-                fs.writeFileSync(path.join(modulePath, 'infra', 'http', `${entity.name}.controller.ts`), (0, cli_templates_1.nestControllerTemplate)(entity.name, entity.persistence), 'utf-8');
-                // ORM Entity
-                fs.writeFileSync(path.join(modulePath, 'infra', 'database', `${entity.name}.orm-entity.ts`), (0, cli_templates_1.nestOrmEntityTemplate)(entity.name, entity.properties, entity.tableName || `${entity.name}s`, isTenantScoped, entity.indexes, entity.persistence, entity.automaticFields), 'utf-8');
-                // Repository Adapter
-                fs.writeFileSync(path.join(modulePath, 'infra', 'database', `${entity.name}.repository.ts`), (0, cli_templates_1.nestRepositoryAdapterTemplate)(entity.name, entity.properties, isTenantScoped), 'utf-8');
-                // Service
-                fs.writeFileSync(path.join(modulePath, 'service', `${entity.name}.service.ts`), (0, cli_templates_1.nestServiceTemplate)(entity.name), 'utf-8');
-                // Module
-                fs.writeFileSync(path.join(modulePath, `${entity.name}.module.ts`), (0, cli_templates_1.nestModuleTemplate)(entity.name), 'utf-8');
-                console.log(`[NestJS] Módulo Monolito "${currentEntityName}" gerado com sucesso em: ${modulePath}`);
-                patchMonolithAppModule(path.join(backendRoot, 'src', 'app.module.ts'), entity.name);
+                const moduleRoot = path.join(backendRoot, 'src', 'modules', group.name);
+                writeCrudEntityArtifacts(moduleRoot, entity, backendProperties, isTenantScoped, group.name);
+                const members = generatedMembers(moduleRoot, group.entities, entity);
+                fs.writeFileSync(path.join(moduleRoot, `${group.name}.module.ts`), (0, functional_module_templates_1.nestFunctionalModuleTemplate)(group.name, members), 'utf-8');
+                patchMonolithAppModule(path.join(backendRoot, 'src', 'app.module.ts'), group.name);
+                console.log(`[NestJS] ${currentEntityName} adicionado ao módulo funcional ${group.name}.`);
             }
         }
         // 2. Gerar Frontend (Angular)
@@ -1268,7 +1302,7 @@ SERVICE_PORT=${port}
                 fs.ensureDirSync(path.join(modulePath, 'form-dialog-handler'));
             }
             // Angular Service
-            fs.writeFileSync(path.join(servicePath, `${entity.name}.service.ts`), (0, cli_templates_1.angularServiceTemplate)(entity.name), 'utf-8');
+            fs.writeFileSync(path.join(servicePath, `${entity.name}.service.ts`), (0, cli_templates_1.angularServiceTemplate)(entity.name, (0, devkit_core_1.resolveEntityModule)(entity)), 'utf-8');
             // List HTML
             fs.writeFileSync(path.join(modulePath, 'list', `${entity.name}-list.component.html`), (0, cli_templates_1.angularListHtmlTemplate)(entity.name, entity.properties, listType, formType, filterType), 'utf-8');
             // List TS
@@ -1287,11 +1321,15 @@ SERVICE_PORT=${port}
     // 3. Pós-processamento geral (depois de gerar todas as entidades selecionadas)
     // Sincronizar migrações no Monolito, se houver
     const isMicroservices = config.backendType === 'microservices';
+    ensurePlatformLayout(backendRoot, isMicroservices, config.projectName);
     if (!isMicroservices) {
         const migrationEntities = (config.entities ?? []).filter((configuredEntity) => configuredEntity.crud?.generateBackend !== false
             && configuredEntity.crud?.generateMigration !== false);
         if (migrationEntities.length > 0) {
-            ensureInitialMigrations(backendRoot, migrationEntities);
+            ensureInitialMigrations(backendRoot, migrationEntities, new Map(migrationEntities.map((member) => [
+                member.name,
+                migrationPropertiesForEntity(member, config),
+            ])));
         }
     }
     // Regerar docker-compose.yml e init.sql
@@ -1371,8 +1409,6 @@ function patchLocalDependencies(backendDest, frontendDest, boilerplatesDir) {
             return;
         const packageJson = fs.readJsonSync(packagePath);
         delete packageJson.devDependencies;
-        delete packageJson.peerDependencies;
-        delete packageJson.dependencies;
         packageJson.scripts = {};
         fs.writeJsonSync(packagePath, packageJson, { spaces: 2 });
     };
@@ -1442,17 +1478,19 @@ function patchLocalDependencies(backendDest, frontendDest, boilerplatesDir) {
                 console.error('[Erro] Falha ao injetar links locais no backend:', err);
             }
         }
-        // Patch Backend Dockerfile para injetar "COPY local_packages/ ./local_packages/" antes do npm install e limpar node_modules local após instalação
+        // File dependencies keep their runtime dependencies under local_packages.
+        // Removing that node_modules directory makes packaged drivers unavailable.
+        // Peer dependencies remain resolved by the application root.
         const backendDockerfile = path.join(backendDest, 'Dockerfile');
         if (fs.existsSync(backendDockerfile)) {
             try {
                 let content = fs.readFileSync(backendDockerfile, 'utf-8');
                 const targetStr = 'COPY package*.json ./';
                 const replacementStr = 'COPY package*.json ./\nCOPY local_packages/ ./local_packages/';
-                content = content.split(targetStr).join(replacementStr);
-                // Injeta limpeza de node_modules locais após npm install
-                content = content.replace('RUN npm install --only=production', 'RUN npm install --only=production && rm -rf local_packages/*/node_modules');
-                content = content.replace('RUN npm install', 'RUN npm install && rm -rf local_packages/*/node_modules');
+                if (!content.includes('COPY local_packages/ ./local_packages/')) {
+                    content = content.split(targetStr).join(replacementStr);
+                }
+                content = content.replaceAll(' && rm -rf local_packages/*/node_modules', '');
                 fs.writeFileSync(backendDockerfile, content, 'utf-8');
                 console.log('[DevConfig] Dockerfile do backend ajustado para incluir dependências locais.');
             }
@@ -1530,16 +1568,17 @@ function patchLocalDependencies(backendDest, frontendDest, boilerplatesDir) {
                 console.error('[Erro] Falha ao injetar links locais no frontend:', err);
             }
         }
-        // Patch Frontend Dockerfile para injetar "COPY local_packages/ ./local_packages/" antes do npm install e limpar node_modules local após instalação
+        // Preserve runtime dependencies installed for local file packages.
         const frontendDockerfile = path.join(frontendDest, 'Dockerfile');
         if (fs.existsSync(frontendDockerfile)) {
             try {
                 let content = fs.readFileSync(frontendDockerfile, 'utf-8');
                 const targetStr = 'COPY package*.json ./';
                 const replacementStr = 'COPY package*.json ./\nCOPY local_packages/ ./local_packages/';
-                content = content.split(targetStr).join(replacementStr);
-                // Injeta limpeza de node_modules locais após npm install
-                content = content.replace('RUN npm install --legacy-peer-deps', 'RUN npm install --legacy-peer-deps && rm -rf local_packages/*/node_modules');
+                if (!content.includes('COPY local_packages/ ./local_packages/')) {
+                    content = content.split(targetStr).join(replacementStr);
+                }
+                content = content.replaceAll(' && rm -rf local_packages/*/node_modules', '');
                 fs.writeFileSync(frontendDockerfile, content, 'utf-8');
                 console.log('[DevConfig] Dockerfile do frontend ajustado para incluir dependências locais.');
             }
@@ -1607,32 +1646,51 @@ if (fs.existsSync(envPath)) {
 }
 
 import { NestFactory } from '@nestjs/core';
-import { Transport, MicroserviceOptions } from '@nestjs/microservices';
 import { AppModule } from './app.module';
+import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
 
 async function bootstrap() {
   const port = Number(process.env.SERVICE_PORT) || ${port};
-  const app = await NestFactory.createMicroservice<MicroserviceOptions>(AppModule, {
-    transport: Transport.TCP,
-    options: {
-      host: '0.0.0.0',
-      port: port,
-    },
-  });
-  await app.listen();
-  console.log(\`Microsserviço iniciado via TCP na porta \${port}\`);
+  const app = await NestFactory.create(AppModule);
+  app.setGlobalPrefix('api');
+  const swagger = new DocumentBuilder().setTitle('Module API').setVersion('1.0').addBearerAuth().build();
+  SwaggerModule.setup('docs', app, SwaggerModule.createDocument(app, swagger));
+  await app.listen(port, '0.0.0.0');
+  console.log(\`Serviço HTTP iniciado na porta \${port}\`);
 }
 bootstrap();
 `;
 }
-function generateMsAppModule(entityName) {
+function generateMsAppModule(entityName, coreService) {
     const pascalName = kebabToPascal(entityName);
+    const securityImport = coreService
+        ? `import { SecurityModule } from './platform/security/security.module';`
+        : `import { TokenVerificationModule } from './platform/security/token-verification.module';`;
+    const securityModule = coreService ? 'SecurityModule' : 'TokenVerificationModule';
+    const storageImports = coreService
+        ? `import { StorageModule } from '@devstroupe/devkit-nest';`
+        : '';
+    const storageRegistration = coreService
+        ? `
+    (StorageModule as any).registerAsync({
+      useFactory: () => ({
+        driver: (process.env.STORAGE_DRIVER || 'local') as 'local' | 's3' | 'r2',
+        local: { storagePath: process.env.STORAGE_LOCAL_PATH || './storage' },
+      }),
+    }),`
+        : '';
     return `import { Module } from '@nestjs/common';
+import { APP_INTERCEPTOR } from '@nestjs/core';
 import { TypeOrmModule } from '@nestjs/typeorm';
+import { ExecutionContextInterceptor } from '@devstroupe/devkit-nest';
+import * as path from 'path';
 import { ${pascalName}Module } from './modules/${entityName}/${entityName}.module';
+${securityImport}
+${storageImports}
 
 @Module({
   imports: [
+    ${securityModule},
     TypeOrmModule.forRoot({
       type: 'mysql',
       host: process.env.DB_HOST || 'localhost',
@@ -1642,15 +1700,49 @@ import { ${pascalName}Module } from './modules/${entityName}/${entityName}.modul
       database: process.env.DB_NAME || 'devstroupe_${entityName}',
       autoLoadEntities: true,
       synchronize: false,
+      migrations: [path.join(__dirname, './database/migrations/*{.ts,.js}')],
+      migrationsRun: true,
     }),
-    ${pascalName}Module,
+    ${pascalName}Module,${storageRegistration}
   ],
   controllers: [],
-  providers: [],
+  providers: [{ provide: APP_INTERCEPTOR, useClass: ExecutionContextInterceptor }],
+})
+export class AppModule {}
+`;
+}
+function generateGatewayMainTs() {
+    return `import { NestFactory } from '@nestjs/core';
+import { AppModule } from './app.module';
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule, { bodyParser: false });
+  app.setGlobalPrefix('api');
+  app.enableCors();
+  const port = Number(process.env.PORT) || 13000;
+  await app.listen(port, '0.0.0.0');
+  console.log(\`API Gateway stateless iniciado na porta \${port}\`);
+}
+bootstrap();
+`;
+}
+function generateGatewayAppModule() {
+    return `import { Module } from '@nestjs/common';
+import { TokenVerificationModule } from './platform/security/token-verification.module';
+
+@Module({
+  imports: [TokenVerificationModule],
 })
 export class AppModule {}
 `;
 }
+function prepareStatelessGateway(gatewayRoot) {
+    fs.removeSync(path.join(gatewayRoot, 'src', 'database'));
+    fs.emptyDirSync(path.join(gatewayRoot, 'src', 'modules'));
+    fs.removeSync(path.join(gatewayRoot, 'src', 'platform', 'security', 'security.module.ts'));
+    fs.writeFileSync(path.join(gatewayRoot, 'src', 'main.ts'), generateGatewayMainTs(), 'utf-8');
+    fs.writeFileSync(path.join(gatewayRoot, 'src', 'app.module.ts'), generateGatewayAppModule(), 'utf-8');
+}
 function patchGatewayAppModule(appModulePath, entityName) {
     const pascalName = kebabToPascal(entityName);
     const moduleName = `${pascalName}GatewayModule`;
@@ -1667,16 +1759,11 @@ function patchGatewayAppModule(appModulePath, entityName) {
     // Adiciona a declaração de import no topo
     const importStatement = `import { ${moduleName} } from '${importPath}';\n`;
     content = importStatement + content;
-    // Encontra a lista de imports do decorator @Module
-    // Encontra a lista de imports do decorator @Module
-    const moduleDecoratorRegex = /@Module\s*\(\s*\{\s*imports\s*:\s*\[([\s\S]*?)\]/;
-    const match = content.match(moduleDecoratorRegex);
-    if (match) {
-        const currentImports = match[1];
-        // Adiciona o novo módulo no início dos imports
-        const updatedImports = `\n    ${moduleName},${currentImports}`;
-        content = content.replace(currentImports, updatedImports);
-    }
+    const moduleImportsRegex = /(@Module\s*\(\s*\{\s*imports\s*:\s*\[)([\s\S]*?)(\]\s*,?)/;
+    content = content.replace(moduleImportsRegex, (_match, prefix, body, suffix) => {
+        const imports = body.split(',').map((entry) => entry.trim()).filter(Boolean);
+        return `${prefix}\n${[moduleName, ...imports].map((entry) => `    ${entry},`).join('\n')}\n  ${suffix}`;
+    });
     fs.writeFileSync(appModulePath, content, 'utf-8');
     console.log(`[Gateway] app.module.ts patcheado com sucesso para importar ${moduleName}.`);
 }
@@ -1705,9 +1792,20 @@ function patchMonolithAppModule(appModulePath, entityName) {
     fs.writeFileSync(appModulePath, content, 'utf-8');
     console.log(`[NestJS] app.module.ts atualizado para importar ${moduleName}.`);
 }
+function removeMonolithModuleImport(appModulePath, moduleName) {
+    if (!fs.existsSync(appModulePath))
+        return;
+    const pascalName = kebabToPascal(moduleName);
+    const className = `${pascalName}Module`;
+    let content = fs.readFileSync(appModulePath, 'utf-8');
+    content = content.replace(new RegExp(`^import \\{ ${className} \\} from ['"]\\./modules/${moduleName}/${moduleName}\\.module['"];?\\n`, 'm'), '');
+    content = content.replace(new RegExp(`\\n\\s*${className},?`, 'g'), '');
+    fs.writeFileSync(appModulePath, content, 'utf-8');
+}
 function generateDockerComposeAndDbInit(projectRoot, config) {
     const isMicroservices = config.backendType === 'microservices';
     const projectName = config.projectName || 'devstroupe-project';
+    const moduleGroups = (0, backend_layout_1.buildBackendModuleGroups)(config.entities ?? []);
     // 1. db-init/init.sql
     const dbInitDir = path.join(projectRoot, 'db-init');
     fs.ensureDirSync(dbInitDir);
@@ -1715,12 +1813,9 @@ function generateDockerComposeAndDbInit(projectRoot, config) {
         fs.chmodSync(dbInitDir, 0o755);
     }
     catch { }
-    const dbs = ['devstroupe']; // Banco principal (usado pelo gateway ou monolith)
-    if (isMicroservices && config.entities) {
-        config.entities.forEach((entity) => {
-            dbs.push(`devstroupe_${entity.name.toLowerCase()}`);
-        });
-    }
+    const dbs = isMicroservices
+        ? moduleGroups.map((group) => group.databaseName)
+        : ['devstroupe'];
     const initSqlContent = dbs.map(db => `CREATE DATABASE IF NOT EXISTS \`${db}\`;`).join('\n') + '\n';
     const sqlPath = path.join(dbInitDir, 'init.sql');
     fs.writeFileSync(sqlPath, initSqlContent, 'utf-8');
@@ -1749,24 +1844,18 @@ function generateDockerComposeAndDbInit(projectRoot, config) {
     devServicesYaml += dbServiceYaml;
     if (isMicroservices) {
         // Gateway service
-        let gatewayEnv = `      DB_HOST: database
-      DB_PORT: 3306
-      DB_USER: root
-      DB_PASSWORD: root
-      DB_NAME: devstroupe
+        let gatewayEnv = `      PORT: 13000
       JWT_SECRET: devstroupe-secret-key-12345
 `;
-        let gatewayDependsOn = `      - database
-`;
+        let gatewayDependsOn = '';
         // Adiciona variáveis de microsserviços no gateway
-        if (config.entities) {
-            config.entities.forEach((entity, index) => {
-                const port = 3001 + index;
-                const nameUpper = entity.name.toUpperCase();
-                gatewayEnv += `      ${nameUpper}_SERVICE_HOST: ${entity.name}-service
-      ${nameUpper}_SERVICE_PORT: ${port}
+        if (moduleGroups.length) {
+            moduleGroups.forEach((group) => {
+                const nameUpper = group.name.replace(/-/g, '_').toUpperCase();
+                gatewayEnv += `      ${nameUpper}_SERVICE_HOST: ${group.serviceName}
+      ${nameUpper}_SERVICE_PORT: ${group.port}
 `;
-                gatewayDependsOn += `      - ${entity.name}-service
+                gatewayDependsOn += `      - ${group.serviceName}
 `;
             });
         }
@@ -1796,44 +1885,45 @@ ${gatewayEnv}    command: sh -c "npm install && npm run start:dev"
     depends_on:
 ${gatewayDependsOn}`;
         // Containers de microsserviços
-        if (config.entities) {
-            config.entities.forEach((entity, index) => {
-                const port = 3001 + index;
-                servicesYaml += `\n\n  ${entity.name}-service:
+        if (moduleGroups.length) {
+            moduleGroups.forEach((group) => {
+                servicesYaml += `\n\n  ${group.serviceName}:
     build:
-      context: ./backend/services/${entity.name}
+      context: ./backend/apps/${group.serviceName}
       dockerfile: Dockerfile
-    container_name: ${projectName}-${entity.name}-service
+    container_name: ${projectName}-${group.serviceName}
     restart: always
-    ports:
-      - "${port}0:${port}"
+    expose:
+      - "${group.port}"
     environment:
       DB_HOST: database
       DB_PORT: 3306
       DB_USER: root
       DB_PASSWORD: root
-      DB_NAME: devstroupe_${entity.name.toLowerCase()}
-      SERVICE_PORT: ${port}
+      DB_NAME: ${group.databaseName}
+      SERVICE_PORT: ${group.port}
+      JWT_SECRET: devstroupe-secret-key-12345
     depends_on:
       - database
 `;
-                devServicesYaml += `\n\n  ${entity.name}-service:
+                devServicesYaml += `\n\n  ${group.serviceName}:
     image: node:20-alpine
-    container_name: ${projectName}-${entity.name}-service-dev
+    container_name: ${projectName}-${group.serviceName}-dev
     working_dir: /app
     restart: always
     volumes:
-      - ./backend/services/${entity.name}:/app
+      - ./backend/apps/${group.serviceName}:/app
       - /app/node_modules
-    ports:
-      - "${port}0:${port}"
+    expose:
+      - "${group.port}"
     environment:
       DB_HOST: database
       DB_PORT: 3306
       DB_USER: root
       DB_PASSWORD: root
-      DB_NAME: devstroupe_${entity.name.toLowerCase()}
-      SERVICE_PORT: ${port}
+      DB_NAME: ${group.databaseName}
+      SERVICE_PORT: ${group.port}
+      JWT_SECRET: devstroupe-secret-key-12345
     command: sh -c "npm install && npm run start:dev"
     depends_on:
       - database
@@ -1864,7 +1954,7 @@ ${gatewayDependsOn}`;
       - "14200:4200"
     command: sh -c "npm install && npm run start -- --host 0.0.0.0 --poll 2000"
     depends_on:
-      - api-gateway-dev
+      - api-gateway
 `;
     }
     else {
@@ -1934,16 +2024,12 @@ ${gatewayDependsOn}`;
       - backend
 `;
     }
-    const dockerComposeContent = `version: '3.8'
-
-services:
+    const dockerComposeContent = `services:
 ${servicesYaml}
 volumes:
   mysql_data:
 `;
-    const dockerComposeDevContent = `version: '3.8'
-
-services:
+    const dockerComposeDevContent = `services:
 ${devServicesYaml}
 volumes:
   mysql_data:
@@ -1963,7 +2049,8 @@ function generateProject(projectRoot, config) {
     let backendDest;
     if (isMicroservices) {
         backendDest = path.resolve(projectRoot, backendPathRel, 'api-gateway');
-        fs.ensureDirSync(path.resolve(projectRoot, backendPathRel, 'services'));
+        fs.ensureDirSync(path.resolve(projectRoot, backendPathRel, 'apps'));
+        fs.ensureDirSync(path.resolve(projectRoot, backendPathRel, 'packages', 'platform'));
     }
     else {
         backendDest = path.resolve(projectRoot, backendPathRel);
@@ -1991,7 +2078,9 @@ function generateProject(projectRoot, config) {
             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
+            const envContent = isMicroservices ? `PORT=13000
+JWT_SECRET=devstroupe-secret-key-12345
+` : `PORT=13000
 DB_HOST=localhost
 DB_PORT=3306
 DB_USER=root
@@ -2016,6 +2105,8 @@ R2_SECRET_KEY=
 `;
             fs.writeFileSync(path.join(backendDest, '.env'), envContent, 'utf-8');
             fs.writeFileSync(path.join(backendDest, '.env.example'), envContent, 'utf-8');
+            if (isMicroservices)
+                prepareStatelessGateway(backendDest);
         }
         if (!fs.existsSync(frontendDest) || fs.readdirSync(frontendDest).length === 0) {
             console.log(`Copiando boilerplate do frontend para: ${frontendDest}...`);
@@ -2345,4 +2436,72 @@ export class Devkit${pascalName}Component {}
         console.log(`[UI] Componente customizado do DevKit "devkit-${componentName}" criado com sucesso em: ${customDir}`);
     }
 });
-program.parse(process.argv);
+program
+    .command('entity:set-module <entityName> <moduleName>')
+    .description('Planeja ou aplica a movimentação segura de uma entidade entre módulos funcionais')
+    .option('--dry-run', 'Exibe o plano sem alterar arquivos (padrão)')
+    .option('--apply', 'Aplica o plano monolítico quando não há conflitos')
+    .action((entityName, moduleName, options) => {
+    const projectRoot = process.cwd();
+    const configPath = path.join(projectRoot, 'devstroupe.config.ts');
+    if (!fs.existsSync(configPath))
+        throw new Error('devstroupe.config.ts não encontrado.');
+    const imported = require(configPath);
+    const config = imported.default ?? imported;
+    const plan = (0, entity_module_move_1.planEntityModuleMove)(projectRoot, config, entityName, moduleName);
+    console.log(JSON.stringify(plan, null, 2));
+    if (!options.apply) {
+        console.log('[Dry-run] Nenhum arquivo foi alterado. Revise o plano e use --apply para aprovar.');
+        return;
+    }
+    if (plan.conflicts.length) {
+        throw new Error(`Movimentação não aplicada:\n- ${plan.conflicts.join('\n- ')}`);
+    }
+    if (plan.backendType !== 'monolith') {
+        throw new Error('Mudanças de ownership entre bancos exigem plano de dados explícito e não são aplicadas automaticamente.');
+    }
+    const configSource = fs.readFileSync(configPath, 'utf-8');
+    const backupPath = `${configPath}.devstroupe-backup`;
+    if (!fs.existsSync(backupPath))
+        fs.copyFileSync(configPath, backupPath);
+    fs.writeFileSync(configPath, (0, entity_module_move_1.updateEntityModuleInConfig)(configSource, entityName, plan.targetModule), 'utf-8');
+    const entity = config.entities.find((candidate) => candidate.name === entityName);
+    entity.module = plan.targetModule;
+    const move = plan.operations.find((operation) => operation.kind === 'move');
+    fs.ensureDirSync(path.dirname(move.to));
+    fs.moveSync(move.from, move.to, { overwrite: false });
+    const movedController = path.join(move.to, 'api', `${entityName}.controller.ts`);
+    if (fs.existsSync(movedController)) {
+        const source = fs.readFileSync(movedController, 'utf-8');
+        fs.writeFileSync(movedController, source.replace(/@Controller\(['"][^'"]+['"]\)/, `@Controller('${plan.targetModule}/${entityName}')`), 'utf-8');
+    }
+    const backendRoot = path.resolve(projectRoot, config.backendPath ?? './backend');
+    for (const functionalModule of [plan.sourceModule, plan.targetModule]) {
+        const moduleRoot = path.join(backendRoot, 'src', 'modules', functionalModule);
+        const members = config.entities.filter((candidate) => (0, devkit_core_1.resolveEntityModule)(candidate) === functionalModule && generatedEntityReady(moduleRoot, candidate.name));
+        const moduleFile = path.join(moduleRoot, `${functionalModule}.module.ts`);
+        if (members.length || functionalModule === 'core') {
+            fs.writeFileSync(moduleFile, (0, functional_module_templates_1.nestFunctionalModuleTemplate)(functionalModule, members), 'utf-8');
+            patchMonolithAppModule(path.join(backendRoot, 'src', 'app.module.ts'), functionalModule);
+        }
+        else {
+            if (fs.existsSync(moduleFile))
+                fs.removeSync(moduleFile);
+            removeMonolithModuleImport(path.join(backendRoot, 'src', 'app.module.ts'), functionalModule);
+        }
+    }
+    const migrationsRoot = path.join(backendRoot, 'src', 'database', 'migrations');
+    if (fs.existsSync(migrationsRoot)) {
+        for (const file of fs.readdirSync(migrationsRoot).filter((candidate) => candidate.endsWith(`-create-${entityName}.ts`))) {
+            const migrationPath = path.join(migrationsRoot, file);
+            const source = fs.readFileSync(migrationPath, 'utf-8');
+            fs.writeFileSync(migrationPath, source.match(/^\/\/ owner-module:/)
+                ? source.replace(/^\/\/ owner-module:.*$/m, `// owner-module: ${plan.targetModule}`)
+                : `// owner-module: ${plan.targetModule}\n${source}`, 'utf-8');
+        }
+    }
+    console.log(`[Aplicado] ${entityName}: ${plan.sourceModule} -> ${plan.targetModule}. Backup: ${backupPath}`);
+});
+if (require.main === module) {
+    program.parse(process.argv);
+}