@devstroupe/devkit-cli 1.1.0 → 1.1.2

package/dist/boilerplates/angular-template/src/app/core/services/auth.service.ts

@@ -6,7 +6,7 @@ export interface User {
   id: number;
   name: string;
   email: string;
-  role: 'ADMIN' | 'USER';
+  role: any;
   avatar?: string;
   tenantId?: string;
   isActive: boolean;
@@ -95,4 +95,22 @@ export class AuthService {
   get isAuthenticated(): boolean {
     return !!this.token;
   }
+
+  hasPermission(permission: string): boolean {
+    const user = this.currentUser;
+    if (!user) return false;
+
+    const roleName = typeof user.role === 'object' ? (user.role as any).name : user.role;
+    const permissions = typeof user.role === 'object' ? (user.role as any).permissions : [];
+    
+    if (
+      roleName === 'ADMIN' ||
+      roleName === 'Administrador' ||
+      (Array.isArray(permissions) && permissions.includes('*'))
+    ) {
+      return true;
+    }
+
+    return Array.isArray(permissions) && permissions.includes(permission);
+  }
 }

package/dist/boilerplates/nest-template/package.json

@@ -29,7 +29,12 @@
     "bcryptjs": "^2.4.3",
     "dotenv": "^16.4.5",
     "@devstroupe/devkit-core": "workspace:*",
-    "@devstroupe/devkit-nest": "workspace:*"
+    "@devstroupe/devkit-nest": "workspace:*",
+    "class-validator": "^0.14.1",
+    "class-transformer": "^0.5.1",
+    "@nestjs/websockets": "^11.0.0",
+    "@nestjs/platform-socket.io": "^11.0.0",
+    "socket.io": "^4.7.5"
   },
   "devDependencies": {
     "@nestjs/cli": "^11.0.0",

package/dist/boilerplates/nest-template/src/main.ts

@@ -20,6 +20,7 @@ if (fs.existsSync(envPath)) {
 import { NestFactory } from '@nestjs/core';
 import { AppModule } from './app.module';
 import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
+import { DataSource } from 'typeorm';
 
 async function bootstrap() {
   const app = await NestFactory.create(AppModule);
@@ -39,6 +40,12 @@ async function bootstrap() {
   const document = SwaggerModule.createDocument(app, config);
   SwaggerModule.setup('docs', app, document);
 
+  // Executar migrations programaticamente antes de iniciar a aplicação
+  const dataSource = app.get(DataSource);
+  console.log('Executando migrations do banco de dados...');
+  await dataSource.runMigrations();
+  console.log('Migrations executadas com sucesso!');
+
   await app.listen(13000);
   console.log('Backend NestJS iniciado com sucesso na porta 13000!');
   console.log('Documentação Swagger disponível em: http://localhost:13000/docs');

package/dist/boilerplates/nest-template/src/modules/role/domain/role.repository.ts

@@ -1,3 +1,4 @@
+import { IPaginator } from '@devstroupe/devkit-core';
 import { Role } from './role';
 
 export interface IRoleRepository {
@@ -6,5 +7,6 @@ export interface IRoleRepository {
   findById(id: number): Promise<Role | null>;
   findByName(name: string): Promise<Role | null>;
   findAll(): Promise<Role[]>;
+  findMany(query: any): Promise<IPaginator<Role>>;
   delete(id: number): Promise<void>;
 }

package/dist/boilerplates/nest-template/src/modules/role/infra/database/role.repository.adapter.ts

@@ -1,16 +1,20 @@
 import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { Repository } from 'typeorm';
+import { BaseRepository } from '@devstroupe/devkit-nest';
+import { IPaginator } from '@devstroupe/devkit-core';
 import { IRoleRepository } from '../../domain/role.repository';
 import { Role } from '../../domain/role';
 import { RoleOrmEntity } from './role.orm-entity';
 
 @Injectable()
-export class RoleRepositoryAdapter implements IRoleRepository {
+export class RoleRepositoryAdapter extends BaseRepository<RoleOrmEntity> implements IRoleRepository {
   constructor(
     @InjectRepository(RoleOrmEntity)
     private readonly repo: Repository<RoleOrmEntity>,
-  ) {}
+  ) {
+    super(repo);
+  }
 
   private toDomain(orm: RoleOrmEntity): Role {
     return {
@@ -48,6 +52,19 @@ export class RoleRepositoryAdapter implements IRoleRepository {
     return found.map(orm => this.toDomain(orm));
   }
 
+  async findMany(query: any): Promise<IPaginator<Role>> {
+    const qb = this.repo.createQueryBuilder('role');
+    const paginated = await this.paginate(qb, query, {
+      allowedFilters: ['name'],
+      allowedSorts: ['id', 'name'],
+      searchableFields: ['name'],
+    });
+    return {
+      items: paginated.items.map((orm) => this.toDomain(orm)),
+      meta: paginated.meta,
+    };
+  }
+
   async delete(id: number): Promise<void> {
     await this.repo.delete(id);
   }

package/dist/boilerplates/nest-template/src/modules/role/service/role.service.ts

@@ -1,4 +1,5 @@
 import { Injectable, Inject } from '@nestjs/common';
+import { IPaginator } from '@devstroupe/devkit-core';
 import { IRoleRepository } from '../domain/role.repository';
 import { Role } from '../domain/role';
 
@@ -33,6 +34,10 @@ export class RoleService {
     return this.roleRepo.findAll();
   }
 
+  async findMany(query: any): Promise<IPaginator<Role>> {
+    return this.roleRepo.findMany(query);
+  }
+
   async delete(id: number): Promise<void> {
     await this.roleRepo.delete(id);
   }

package/dist/boilerplates/nest-template/src/modules/storage/infra/http/storage-download.controller.ts

@@ -12,7 +12,7 @@ export class StorageDownloadController {
     private readonly storageService: StorageService,
   ) {}
 
-  @Get('download/:key(*)')
+  @Get('download/*key')
   async download(@Param('key') key: string, @Res() res: Response) {
     if (this.storageOptions.driver === 'local') {
       const storagePath = path.resolve(this.storageOptions.local?.storagePath || './storage');

package/dist/boilerplates/nest-template/src/modules/user/domain/user.repository.ts

@@ -1,3 +1,4 @@
+import { IPaginator } from '@devstroupe/devkit-core';
 import { User } from './user';
 
 export interface IUserRepository {
@@ -6,5 +7,6 @@ export interface IUserRepository {
   findById(id: number): Promise<User | null>;
   findByEmail(email: string): Promise<User | null>;
   findAll(): Promise<User[]>;
+  findMany(filter: any): Promise<IPaginator<User>>;
   delete(id: number): Promise<void>;
 }

package/dist/boilerplates/nest-template/src/modules/user/domain/user.ts

@@ -9,4 +9,6 @@ export class User {
   tenantId?: string;
   currentRefreshToken?: string;
   isActive!: boolean;
+  createdAt!: Date;
+  updatedAt!: Date;
 }

package/dist/boilerplates/nest-template/src/modules/user/infra/database/user.repository.adapter.ts

@@ -1,16 +1,20 @@
 import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { Repository } from 'typeorm';
+import { BaseRepository } from '@devstroupe/devkit-nest';
+import { IPaginator } from '@devstroupe/devkit-core';
 import { IUserRepository } from '../../domain/user.repository';
 import { User } from '../../domain/user';
 import { UserOrmEntity } from './user.orm-entity';
 
 @Injectable()
-export class UserRepositoryAdapter implements IUserRepository {
+export class UserRepositoryAdapter extends BaseRepository<UserOrmEntity> implements IUserRepository {
   constructor(
     @InjectRepository(UserOrmEntity)
     private readonly repo: Repository<UserOrmEntity>,
-  ) {}
+  ) {
+    super(repo);
+  }
 
   private toDomain(orm: UserOrmEntity): User {
     return {
@@ -22,6 +26,8 @@ export class UserRepositoryAdapter implements IUserRepository {
       tenantId: orm.tenantId,
       currentRefreshToken: orm.currentRefreshToken,
       isActive: orm.isActive,
+      createdAt: orm.createdAt,
+      updatedAt: orm.updatedAt,
     };
   }
 
@@ -53,6 +59,22 @@ export class UserRepositoryAdapter implements IUserRepository {
     return found.map((u) => this.toDomain(u));
   }
 
+  async findMany(filter: any): Promise<IPaginator<User>> {
+    const alias = 'user';
+    const qb = this.repo.createQueryBuilder(alias);
+    qb.leftJoinAndSelect(`${alias}.role`, 'role');
+    const paginated = await this.paginate(qb, filter, {
+      allowedFilters: ['name', 'email', 'isActive'],
+      allowedSorts: ['id', 'name', 'email'],
+      searchableFields: ['name', 'email'],
+    });
+
+    return {
+      items: paginated.items.map((u) => this.toDomain(u)),
+      meta: paginated.meta,
+    };
+  }
+
   async delete(id: number): Promise<void> {
     await this.repo.delete(id);
   }

package/dist/boilerplates/nest-template/src/modules/user/infra/http/user.controller.ts

@@ -1,56 +1,52 @@
-import { Controller, Get, Post, Put, Delete, Body, Param, UseGuards, ParseIntPipe } from '@nestjs/common';
+import { Controller, Get, Post, Put, Delete, Body, Param, UseGuards, Query } from '@nestjs/common';
 import { ApiTags, ApiOperation, ApiResponse, ApiBearerAuth } from '@nestjs/swagger';
 import { UserService } from '../../service/user.service';
 import { JwtAuthGuard } from '../../../auth/jwt-auth.guard';
-import { Permissions, PermissionsGuard } from '@devstroupe/devkit-nest';
+import { BaseCrudController, Permissions, PermissionsGuard } from '@devstroupe/devkit-nest';
 import { User } from '../../domain/user';
 
 @ApiTags('users')
 @Controller('user')
 @UseGuards(JwtAuthGuard, PermissionsGuard)
 @ApiBearerAuth()
-export class UserController {
-  constructor(private readonly userService: UserService) {}
+export class UserController extends BaseCrudController<User> {
+  constructor(private readonly userService: UserService) {
+    super(userService);
+  }
 
   @Get()
   @Permissions('read:user')
-  @ApiOperation({ summary: 'Listar todos os usuários (Admin)' })
+  @ApiOperation({ summary: 'Listar usuários com filtros e paginação' })
   @ApiResponse({ status: 200, description: 'Usuários listados com sucesso.' })
-  async findAll() {
-    // Retorna todos os usuários (como é para administração)
-    // Nota: O ideal em produção seria paginar, mas para o CRUD administrativo básico serve
-    // Vamos chamar o repositório ou expor um método de listagem.
-    // Como o UserService atual não possui findAll, vamos buscar direto
-    // do repositório ou implementar no UserService.
-    return this.userService.findAll();
+  override async findMany(@Query() query: any): Promise<any> {
+    return super.findMany(query);
   }
 
   @Get(':id')
   @Permissions('read:user')
   @ApiOperation({ summary: 'Obter um usuário pelo ID' })
-  async findOne(@Param('id', ParseIntPipe) id: number) {
-    return this.userService.findById(id);
+  override async findById(@Param('id') id: string): Promise<User> {
+    return super.findById(id);
   }
 
   @Post()
   @Permissions('create:user')
   @ApiOperation({ summary: 'Criar um novo usuário' })
-  async create(@Body() body: Omit<User, 'id'>) {
-    return this.userService.create(body);
+  override async create(@Body() body: any): Promise<User> {
+    return super.create(body);
   }
 
   @Put(':id')
   @Permissions('update:user')
   @ApiOperation({ summary: 'Atualizar dados de um usuário' })
-  async update(@Param('id', ParseIntPipe) id: number, @Body() body: Partial<User>) {
-    return this.userService.update(id, body);
+  override async update(@Param('id') id: string, @Body() body: any): Promise<User> {
+    return super.update(id, body);
   }
 
   @Delete(':id')
   @Permissions('delete:user')
   @ApiOperation({ summary: 'Excluir um usuário' })
-  async delete(@Param('id', ParseIntPipe) id: number) {
-    await this.userService.delete(id);
-    return { success: true };
+  override async delete(@Param('id') id: string): Promise<void> {
+    return super.delete(id);
   }
 }

package/dist/boilerplates/nest-template/src/modules/user/service/user.service.ts

@@ -1,5 +1,6 @@
 import { Injectable, Inject } from '@nestjs/common';
 import * as bcrypt from 'bcryptjs';
+import { IPaginator } from '@devstroupe/devkit-core';
 import { IUserRepository } from '../domain/user.repository';
 import { User } from '../domain/user';
 
@@ -27,6 +28,10 @@ export class UserService {
     return this.userRepo.findById(id);
   }
 
+  async findOne(id: number): Promise<User | null> {
+    return this.findById(id);
+  }
+
   async findByEmail(email: string): Promise<User | null> {
     return this.userRepo.findByEmail(email);
   }
@@ -42,6 +47,10 @@ export class UserService {
     return this.userRepo.findAll();
   }
 
+  async findMany(filter: any): Promise<IPaginator<User>> {
+    return this.userRepo.findMany(filter);
+  }
+
   async delete(id: number): Promise<void> {
     await this.userRepo.delete(id);
   }

package/dist/index.js

@@ -556,6 +556,32 @@ function initUi(frontendRoot, config) {
     // Atualizar roteamento para suportar MainLayoutComponent
     updateAppRoutes(frontendRoot, config);
 }
+function getEntityRoutePath(entityName, config) {
+    const navigation = config.layout?.navigation;
+    if (!Array.isArray(navigation)) {
+        return entityName;
+    }
+    const findInMenu = (items) => {
+        for (const item of items) {
+            if (item.route) {
+                const routeClean = item.route.replace(/^\//, '');
+                if (routeClean === entityName ||
+                    routeClean === `${entityName}s` ||
+                    routeClean === `${entityName}es` ||
+                    routeClean.replace(/s$/, '') === entityName) {
+                    return routeClean;
+                }
+            }
+            if (item.children) {
+                const found = findInMenu(item.children);
+                if (found)
+                    return found;
+            }
+        }
+        return null;
+    };
+    return findInMenu(navigation) || entityName;
+}
 function updateAppRoutes(frontendRoot, config = {}) {
     const routesPath = path.join(frontendRoot, 'src', 'app', 'app.routes.ts');
     if (!fs.existsSync(routesPath)) {
@@ -596,7 +622,8 @@ function updateAppRoutes(frontendRoot, config = {}) {
         featureRoutes += `];\n`;
         fs.writeFileSync(featureRoutesPath, featureRoutes, 'utf-8');
         routeImports += `import { ${routeConstant} } from './modules/${entity.name}/${entity.name}.routes';\n`;
-        entityRoutes += `  { path: '${entity.name}', children: ${routeConstant} },\n`;
+        const routePath = getEntityRoutePath(entity.name, config);
+        entityRoutes += `  { path: '${routePath}', children: ${routeConstant} },\n`;
     });
     const entityRoutesPath = path.join(frontendRoot, 'src', 'app', 'app.entity-routes.ts');
     fs.writeFileSync(entityRoutesPath, `import { Routes } from '@angular/router';
@@ -719,10 +746,16 @@ function ensureNavigationIcons(frontendRoot, icons) {
     content = content.replace(/(provideIcons\(\{[\s\S]*?)(\n\s*}\))/, (match, providers, suffix) => `${providers.replace(/\s*$/, '')},\n      ${missingIcons.join(',\n      ')}${suffix}`);
     fs.writeFileSync(configPath, content, 'utf-8');
 }
+let cliVersion = '1.1.0';
+try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8'));
+    cliVersion = pkg.version;
+}
+catch { }
 program
     .name('devstroupe')
     .description('DevsTroupe Development Kit (DT-DevKit) CLI')
-    .version('1.0.0');
+    .version(cliVersion);
 // Comando init
 program
     .command('init')
@@ -1036,7 +1069,7 @@ SERVICE_PORT=${port}
             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), 'utf-8');
+            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
@@ -1078,7 +1111,7 @@ SERVICE_PORT=${port}
             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), 'utf-8');
+            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
@@ -1497,6 +1530,10 @@ function generateDockerComposeAndDbInit(projectRoot, config) {
     // 1. db-init/init.sql
     const dbInitDir = path.join(projectRoot, 'db-init');
     fs.ensureDirSync(dbInitDir);
+    try {
+        fs.chmodSync(dbInitDir, 0o755);
+    }
+    catch { }
     const dbs = ['devstroupe']; // Banco principal (usado pelo gateway ou monolith)
     if (isMicroservices && config.entities) {
         config.entities.forEach((entity) => {
@@ -1504,12 +1541,18 @@ function generateDockerComposeAndDbInit(projectRoot, config) {
         });
     }
     const initSqlContent = dbs.map(db => `CREATE DATABASE IF NOT EXISTS \`${db}\`;`).join('\n') + '\n';
-    fs.writeFileSync(path.join(dbInitDir, 'init.sql'), initSqlContent, 'utf-8');
+    const sqlPath = path.join(dbInitDir, 'init.sql');
+    fs.writeFileSync(sqlPath, initSqlContent, 'utf-8');
+    try {
+        fs.chmodSync(sqlPath, 0o644);
+    }
+    catch { }
     console.log(`[Docker] db-init/init.sql gerado com sucesso.`);
-    // 2. docker-compose.yml
+    // 2. docker-compose.yml e docker-compose.dev.yml
     let servicesYaml = '';
+    let devServicesYaml = '';
     // Database service
-    servicesYaml += `  database:
+    const dbServiceYaml = `  database:
     image: mysql:8.0
     container_name: ${projectName}-database
     restart: always
@@ -1521,6 +1564,8 @@ function generateDockerComposeAndDbInit(projectRoot, config) {
       - mysql_data:/var/lib/mysql
       - ./db-init:/docker-entrypoint-initdb.d
 `;
+    servicesYaml += dbServiceYaml;
+    devServicesYaml += dbServiceYaml;
     if (isMicroservices) {
         // Gateway service
         let gatewayEnv = `      DB_HOST: database
@@ -1554,6 +1599,20 @@ function generateDockerComposeAndDbInit(projectRoot, config) {
       - "13000:13000"
     environment:
 ${gatewayEnv}    depends_on:
+${gatewayDependsOn}`;
+        devServicesYaml += `\n  api-gateway:
+    image: node:20-alpine
+    container_name: ${projectName}-api-gateway-dev
+    working_dir: /app
+    restart: always
+    volumes:
+      - ./backend/api-gateway:/app
+      - /app/node_modules
+    ports:
+      - "13000:13000"
+    environment:
+${gatewayEnv}    command: sh -c "npm install && npm run start:dev"
+    depends_on:
 ${gatewayDependsOn}`;
         // Containers de microsserviços
         if (config.entities) {
@@ -1576,6 +1635,27 @@ ${gatewayDependsOn}`;
       SERVICE_PORT: ${port}
     depends_on:
       - database
+`;
+                devServicesYaml += `\n\n  ${entity.name}-service:
+    image: node:20-alpine
+    container_name: ${projectName}-${entity.name}-service-dev
+    working_dir: /app
+    restart: always
+    volumes:
+      - ./backend/services/${entity.name}:/app
+      - /app/node_modules
+    ports:
+      - "${port}0:${port}"
+    environment:
+      DB_HOST: database
+      DB_PORT: 3306
+      DB_USER: root
+      DB_PASSWORD: root
+      DB_NAME: devstroupe_${entity.name.toLowerCase()}
+      SERVICE_PORT: ${port}
+    command: sh -c "npm install && npm run start:dev"
+    depends_on:
+      - database
 `;
             });
         }
@@ -1590,6 +1670,20 @@ ${gatewayDependsOn}`;
       - "14200:80"
     depends_on:
       - api-gateway
+`;
+        devServicesYaml += `\n\n  frontend:
+    image: node:20-alpine
+    container_name: ${projectName}-frontend-dev
+    working_dir: /app
+    restart: always
+    volumes:
+      - ./frontend:/app
+      - /app/node_modules
+    ports:
+      - "14200:4200"
+    command: sh -c "npm install && npm run start -- --host 0.0.0.0 --poll 2000"
+    depends_on:
+      - api-gateway-dev
 `;
     }
     else {
@@ -1622,17 +1716,61 @@ ${gatewayDependsOn}`;
       - "14200:80"
     depends_on:
       - backend
+`;
+        devServicesYaml += `\n  backend:
+    image: node:20-alpine
+    container_name: ${projectName}-backend-dev
+    working_dir: /app
+    restart: always
+    volumes:
+      - ./backend:/app
+      - /app/node_modules
+    ports:
+      - "13000:13000"
+    environment:
+      DB_HOST: database
+      DB_PORT: 3306
+      DB_USER: root
+      DB_PASSWORD: root
+      DB_NAME: devstroupe
+      JWT_SECRET: devstroupe-secret-key-12345
+    command: sh -c "npm install && npm run start:dev"
+    depends_on:
+      - database
+
+  frontend:
+    image: node:20-alpine
+    container_name: ${projectName}-frontend-dev
+    working_dir: /app
+    restart: always
+    volumes:
+      - ./frontend:/app
+      - /app/node_modules
+    ports:
+      - "14200:4200"
+    command: sh -c "npm install && npm run start -- --host 0.0.0.0 --poll 2000"
+    depends_on:
+      - backend-dev
 `;
     }
     const dockerComposeContent = `version: '3.8'
 
 services:
 ${servicesYaml}
+volumes:
+  mysql_data:
+`;
+    const dockerComposeDevContent = `version: '3.8'
+
+services:
+${devServicesYaml}
 volumes:
   mysql_data:
 `;
     fs.writeFileSync(path.join(projectRoot, 'docker-compose.yml'), dockerComposeContent, 'utf-8');
     console.log(`[Docker] docker-compose.yml regerado com sucesso.`);
+    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

package/dist/rules/linter-rules.js

@@ -155,7 +155,7 @@ function runLinter(projectRoot, config) {
             // 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')) {
+                if (file.endsWith('.controller.ts') && !file.endsWith('auth.controller.ts') && !file.endsWith('storage.controller.ts') && !file.endsWith('storage-download.controller.ts') && content.includes('@Controller') && !content.includes('extends BaseCrudController')) {
                     violations.push({
                         file: relativePath,
                         line: 1,

package/dist/templates/nest/crud.templates.d.ts

@@ -1,5 +1,9 @@
 import { IDevkitEntityProperty } from '@devstroupe/devkit-core';
-export declare function nestDomainEntityTemplate(name: string, properties: IDevkitEntityProperty[], isTenantScoped: boolean): string;
+export declare function nestDomainEntityTemplate(name: string, properties: IDevkitEntityProperty[], isTenantScoped: boolean, automaticFields?: {
+    timestamps?: boolean;
+    blamers?: boolean;
+    optimisticLocking?: boolean;
+}): string;
 export declare function nestRepositoryPortTemplate(name: string): string;
 export declare function nestOrmEntityTemplate(name: string, properties: IDevkitEntityProperty[], tableName: string, isTenantScoped: boolean, indexes?: Array<{
     columns: string[];

package/dist/templates/nest/crud.templates.js

@@ -10,7 +10,7 @@ exports.nestControllerTemplate = nestControllerTemplate;
 exports.nestModuleTemplate = nestModuleTemplate;
 const names_1 = require("../shared/names");
 const relationships_1 = require("../shared/relationships");
-function nestDomainEntityTemplate(name, properties, isTenantScoped) {
+function nestDomainEntityTemplate(name, properties, isTenantScoped, automaticFields) {
     const pascalName = (0, names_1.kebabToPascal)(name);
     const propsCode = properties
         .map((p) => {
@@ -38,9 +38,19 @@ function nestDomainEntityTemplate(name, properties, isTenantScoped) {
     })
         .join('\n');
     const tenantField = isTenantScoped ? '\n  tenantId!: string;' : '';
+    let autoFieldsStr = '';
+    if (automaticFields?.timestamps) {
+        autoFieldsStr += '\n  createdAt!: Date;\n  updatedAt!: Date;';
+    }
+    if (automaticFields?.blamers) {
+        autoFieldsStr += '\n  createdByUserId?: number;\n  updatedByUserId?: number;';
+    }
+    if (automaticFields?.optimisticLocking) {
+        autoFieldsStr += '\n  version!: number;';
+    }
     return `export class ${pascalName} {
   id!: number;
-${propsCode}${tenantField}
+${propsCode}${tenantField}${autoFieldsStr}
 }
 `;
 }
@@ -74,7 +84,7 @@ function nestOrmEntityTemplate(name, properties, tableName, isTenantScoped, inde
         typeormImports.push('JoinColumn');
     if (relationships.some((relation) => relation.kind === 'many-to-many' && relation.owner))
         typeormImports.push('JoinTable');
-    if (indexes && indexes.length > 0)
+    if ((indexes && indexes.length > 0) || properties.some((p) => p.index))
         typeormImports.push('Index');
     if (persistence?.deletion === 'soft-delete')
         typeormImports.push('DeleteDateColumn');
@@ -90,6 +100,7 @@ function nestOrmEntityTemplate(name, properties, tableName, isTenantScoped, inde
         .join('\n');
     const propsCode = properties
         .map((p) => {
+        const indexDecorator = p.index ? '@Index()\n  ' : '';
         if (p.type === 'relationship') {
             const relation = (0, relationships_1.getRelationships)([p])[0];
             const targetPascal = (0, names_1.kebabToPascal)(relation.target);
@@ -111,11 +122,20 @@ function nestOrmEntityTemplate(name, properties, tableName, isTenantScoped, inde
                 return `  @ManyToMany(() => ${targetPascal}OrmEntity${relation.inverseSide ? inverse : ''})${joinTable}\n  ${relation.relationName}?: ${targetPascal}OrmEntity[];`;
             }
             const decorator = relation.kind === 'one-to-one' ? 'OneToOne' : 'ManyToOne';
-            const fkDecorator = p.required ? '@Column()' : '@Column({ nullable: true })';
+            let fkOptions = [];
+            if (!p.required)
+                fkOptions.push('nullable: true');
+            if (p.unique)
+                fkOptions.push('unique: true');
+            const fkDecorator = fkOptions.length > 0 ? `@Column({ ${fkOptions.join(', ')} })` : '@Column()';
             const joinColumn = relation.owner ? `\n  @JoinColumn({ name: '${relation.foreignKey}', referencedColumnName: '${relation.valueField}' })` : '';
-            return `  ${fkDecorator}\n  ${relation.foreignKey}!: number;\n\n  @${decorator}(() => ${targetPascal}OrmEntity${relation.inverseSide ? inverse : ''}, ${options})${joinColumn}\n  ${relation.relationName}?: ${targetPascal}OrmEntity;`;
+            return `  ${indexDecorator}${fkDecorator}\n  ${relation.foreignKey}!: number;\n\n  @${decorator}(() => ${targetPascal}OrmEntity${relation.inverseSide ? inverse : ''}, ${options})${joinColumn}\n  ${relation.relationName}?: ${targetPascal}OrmEntity;`;
         }
-        let decorator = p.required ? '@Column()' : '@Column({ nullable: true })';
+        let colOptions = [];
+        if (!p.required)
+            colOptions.push('nullable: true');
+        if (p.unique)
+            colOptions.push('unique: true');
         let typeStr = 'string';
         const type = p.type;
         if (type === 'number' || type === 'decimal' || type === 'currency' || type === 'integer') {
@@ -123,39 +143,40 @@ function nestOrmEntityTemplate(name, properties, tableName, isTenantScoped, inde
             if (type === 'decimal' || type === 'currency') {
                 const precision = p.precision !== undefined ? p.precision : 12;
                 const scale = p.scale !== undefined ? p.scale : 2;
-                decorator = `@Column({ type: 'decimal', precision: ${precision}, scale: ${scale}${p.required ? '' : ', nullable: true'} })`;
+                colOptions.push(`type: 'decimal'`, `precision: ${precision}`, `scale: ${scale}`);
             }
             else if (type === 'integer') {
-                decorator = p.required ? `@Column({ type: 'int' })` : `@Column({ type: 'int', nullable: true })`;
+                colOptions.push(`type: 'int'`);
             }
         }
         else if (type === 'bigint') {
             typeStr = 'string';
-            decorator = p.required ? `@Column({ type: 'bigint' })` : `@Column({ type: 'bigint', nullable: true })`;
+            colOptions.push(`type: 'bigint'`);
         }
         else if (type === 'boolean') {
             typeStr = 'boolean';
         }
         else if (type === 'datepicker' || type === 'datetime') {
             typeStr = 'Date';
-            decorator = p.required ? `@Column({ type: 'datetime' })` : `@Column({ type: 'datetime', nullable: true })`;
+            colOptions.push(`type: 'datetime'`);
         }
         else if (type === 'date') {
             typeStr = 'Date';
-            decorator = p.required ? `@Column({ type: 'date' })` : `@Column({ type: 'date', nullable: true })`;
+            colOptions.push(`type: 'date'`);
         }
         else if (type === 'text') {
-            decorator = `@Column({ type: 'text'${p.required ? '' : ', nullable: true'} })`;
+            colOptions.push(`type: 'text'`);
         }
         else if (type === 'json') {
             typeStr = 'any';
-            decorator = p.required ? `@Column({ type: 'json' })` : `@Column({ type: 'json', nullable: true })`;
+            colOptions.push(`type: 'json'`);
         }
         else if (type === 'enum' && p.enumOptions) {
             typeStr = p.enumOptions.map(o => `'${o}'`).join(' | ');
-            decorator = `@Column({ type: 'enum', enum: ${JSON.stringify(p.enumOptions)}${p.required ? '' : ', nullable: true'} })`;
+            colOptions.push(`type: 'enum'`, `enum: ${JSON.stringify(p.enumOptions)}`);
         }
-        return `  ${decorator}\n  ${p.name}!: ${typeStr};`;
+        const decorator = colOptions.length > 0 ? `@Column({ ${colOptions.join(', ')} })` : '@Column()';
+        return `  ${indexDecorator}${decorator}\n  ${p.name}!: ${typeStr};`;
     })
         .join('\n\n');
     const tenantField = isTenantScoped ? '\n\n  @Column()\n  tenantId!: string;' : '';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devstroupe/devkit-cli",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "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.0"
+    "@devstroupe/devkit-core": "1.1.2"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",