@devstroupe/devkit-cli 1.0.0 → 1.1.0

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

@@ -0,0 +1,20 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { RoleOrmEntity } from './infra/database/role.orm-entity';
+import { RoleController } from './infra/http/role.controller';
+import { RoleService } from './service/role.service';
+import { RoleRepositoryAdapter } from './infra/database/role.repository.adapter';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([RoleOrmEntity])],
+  controllers: [RoleController],
+  providers: [
+    RoleService,
+    {
+      provide: 'IRoleRepository',
+      useClass: RoleRepositoryAdapter,
+    },
+  ],
+  exports: [RoleService],
+})
+export class RoleModule {}

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

@@ -0,0 +1,39 @@
+import { Injectable, Inject } from '@nestjs/common';
+import { IRoleRepository } from '../domain/role.repository';
+import { Role } from '../domain/role';
+
+@Injectable()
+export class RoleService {
+  constructor(
+    @Inject('IRoleRepository')
+    private readonly roleRepo: IRoleRepository,
+  ) {}
+
+  async create(role: Omit<Role, 'id'>): Promise<Role> {
+    const existing = await this.roleRepo.findByName(role.name);
+    if (existing) {
+      throw new Error('Role name already exists');
+    }
+    return this.roleRepo.create(role);
+  }
+
+  async update(id: number, role: Partial<Role>): Promise<Role> {
+    return this.roleRepo.update(id, role);
+  }
+
+  async findById(id: number): Promise<Role | null> {
+    return this.roleRepo.findById(id);
+  }
+
+  async findByName(name: string): Promise<Role | null> {
+    return this.roleRepo.findByName(name);
+  }
+
+  async findAll(): Promise<Role[]> {
+    return this.roleRepo.findAll();
+  }
+
+  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

@@ -0,0 +1,38 @@
+import { Controller, Get, Param, Res, NotFoundException, Inject } from '@nestjs/common';
+import { Response } from 'express';
+import * as path from 'path';
+import * as fs from 'fs';
+import { STORAGE_OPTIONS_TOKEN, StorageService } from '@devstroupe/devkit-nest';
+
+@Controller('storage')
+export class StorageDownloadController {
+  constructor(
+    @Inject(STORAGE_OPTIONS_TOKEN)
+    private readonly storageOptions: any,
+    private readonly storageService: StorageService,
+  ) {}
+
+  @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');
+      const targetFile = path.resolve(storagePath, key);
+      const rootPrefix = storagePath.endsWith(path.sep) ? storagePath : storagePath + path.sep;
+
+      // Mitigação Directory Traversal
+      if (!targetFile.startsWith(rootPrefix)) {
+        throw new NotFoundException('Arquivo não encontrado ou acesso inválido.');
+      }
+
+      if (!fs.existsSync(targetFile)) {
+        throw new NotFoundException('Arquivo não encontrado.');
+      }
+
+      return res.sendFile(targetFile);
+    } else {
+      // S3 / R2
+      const url = await this.storageService.getSignedUrl(key, 300);
+      return res.redirect(url);
+    }
+  }
+}

package/dist/boilerplates/nest-template/src/modules/storage/storage.module.ts

@@ -0,0 +1,7 @@
+import { Module } from '@nestjs/common';
+import { StorageDownloadController } from './infra/http/storage-download.controller';
+
+@Module({
+  controllers: [StorageDownloadController],
+})
+export class StorageDownloadModule {}

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

@@ -1,11 +1,15 @@
 import { Injectable, OnApplicationBootstrap, Logger } from '@nestjs/common';
 import { UserService } from './service/user.service';
+import { RoleService } from '../role/service/role.service';
 
 @Injectable()
 export class DatabaseSeedService implements OnApplicationBootstrap {
   private readonly logger = new Logger(DatabaseSeedService.name);
 
-  constructor(private readonly userService: UserService) {}
+  constructor(
+    private readonly userService: UserService,
+    private readonly roleService: RoleService,
+  ) {}
 
   async onApplicationBootstrap() {
     await this.seedUsers();
@@ -13,32 +17,69 @@ export class DatabaseSeedService implements OnApplicationBootstrap {
 
   private async seedUsers() {
     try {
-      const adminEmail = 'admin@devstroupe.com';
+      const isProduction = process.env.NODE_ENV === 'production';
+
+      // 1. Criar Perfil Administrador se não existir
+      let adminRole = await this.roleService.findByName('Administrador');
+      if (!adminRole) {
+        this.logger.log('Semente: Criando Perfil Administrador...');
+        adminRole = await this.roleService.create({
+          name: 'Administrador',
+          permissions: [
+            'read:cabin', 'create:cabin', 'update:cabin', 'delete:cabin',
+            'read:company', 'create:company', 'update:company', 'delete:company',
+            'read:role', 'create:role', 'update:role', 'delete:role', 'manage:permissions'
+          ],
+        });
+      }
+
+      // 2. Criar Perfil Usuário Comum se não existir (apenas se não for produção)
+      let userRole = await this.roleService.findByName('Usuário Comum');
+      if (!userRole && !isProduction) {
+        this.logger.log('Semente: Criando Perfil Usuário Comum...');
+        userRole = await this.roleService.create({
+          name: 'Usuário Comum',
+          permissions: ['read:cabin', 'read:company'],
+        });
+      }
+
+      // 3. Admin Inicial das Envs
+      const adminEmail = process.env.ADMIN_EMAIL || 'admin@devstroupe.com';
+      const adminPassword = process.env.ADMIN_PASSWORD;
+
+      if (isProduction && !process.env.ADMIN_PASSWORD) {
+        this.logger.error('Semente: ERRO! A variável de ambiente ADMIN_PASSWORD precisa ser definida em produção.');
+        throw new Error('ADMIN_PASSWORD não configurada em produção.');
+      }
+
       const existingAdmin = await this.userService.findByEmail(adminEmail);
       if (!existingAdmin) {
-        this.logger.log('Semente: Criando usuário administrador padrão...');
+        this.logger.log('Semente: Criando usuário administrador...');
         await this.userService.create({
-          name: 'Administrador DevsTroupe',
+          name: 'Administrador',
           email: adminEmail,
-          password: 'adminpassword123',
-          role: 'ADMIN',
+          password: adminPassword || 'adminpassword123',
+          role: adminRole,
           isActive: true,
         });
         this.logger.log('Semente: Usuário administrador cadastrado com sucesso!');
       }
 
-      const userEmail = 'user@devstroupe.com';
-      const existingUser = await this.userService.findByEmail(userEmail);
-      if (!existingUser) {
-        this.logger.log('Semente: Criando usuário comum padrão...');
-        await this.userService.create({
-          name: 'Usuário Comum',
-          email: userEmail,
-          password: 'userpassword123',
-          role: 'USER',
-          isActive: true,
-        });
-        this.logger.log('Semente: Usuário comum cadastrado com sucesso!');
+      // 4. Criar Usuário Comum apenas se não for ambiente de produção
+      if (!isProduction) {
+        const userEmail = 'user@devstroupe.com';
+        const existingUser = await this.userService.findByEmail(userEmail);
+        if (!existingUser && userRole) {
+          this.logger.log('Semente: Criando usuário comum padrão...');
+          await this.userService.create({
+            name: 'Usuário Comum',
+            email: userEmail,
+            password: 'userpassword123',
+            role: userRole,
+            isActive: true,
+          });
+          this.logger.log('Semente: Usuário comum cadastrado com sucesso!');
+        }
       }
     } catch (error) {
       this.logger.error('Erro durante a execução do seeding de usuários:', error);

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

@@ -5,5 +5,6 @@ export interface IUserRepository {
   update(id: number, user: Partial<User>): Promise<User>;
   findById(id: number): Promise<User | null>;
   findByEmail(email: string): Promise<User | null>;
+  findAll(): Promise<User[]>;
   delete(id: number): Promise<void>;
 }

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

@@ -1,9 +1,12 @@
+import { Role } from '../../role/domain/role';
+
 export class User {
   id!: number;
   name!: string;
   email!: string;
   password!: string;
-  role!: 'ADMIN' | 'USER';
+  role!: Role;
   tenantId?: string;
+  currentRefreshToken?: string;
   isActive!: boolean;
 }

package/dist/boilerplates/nest-template/src/modules/user/infra/database/user.orm-entity.ts

@@ -1,4 +1,5 @@
-import { Entity, PrimaryGeneratedColumn, Column, CreateDateColumn, UpdateDateColumn } from 'typeorm';
+import { Entity, PrimaryGeneratedColumn, Column, CreateDateColumn, UpdateDateColumn, ManyToOne, JoinColumn } from 'typeorm';
+import { RoleOrmEntity } from '../../../role/infra/database/role.orm-entity';
 
 @Entity('users')
 export class UserOrmEntity {
@@ -14,12 +15,16 @@ export class UserOrmEntity {
   @Column({ type: 'varchar', length: 255 })
   password!: string;
 
-  @Column({ type: 'varchar', length: 50, default: 'USER' })
-  role!: 'ADMIN' | 'USER';
+  @ManyToOne(() => RoleOrmEntity, { nullable: false, eager: true })
+  @JoinColumn({ name: 'role_id' })
+  role!: RoleOrmEntity;
 
   @Column({ type: 'varchar', length: 255, nullable: true, name: 'tenant_id' })
   tenantId?: string;
 
+  @Column({ type: 'varchar', length: 500, nullable: true, name: 'current_refresh_token' })
+  currentRefreshToken?: string;
+
   @Column({ type: 'boolean', default: true, name: 'is_active' })
   isActive!: boolean;
 

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

@@ -20,6 +20,7 @@ export class UserRepositoryAdapter implements IUserRepository {
       password: orm.password,
       role: orm.role,
       tenantId: orm.tenantId,
+      currentRefreshToken: orm.currentRefreshToken,
       isActive: orm.isActive,
     };
   }
@@ -47,6 +48,11 @@ export class UserRepositoryAdapter implements IUserRepository {
     return found ? this.toDomain(found) : null;
   }
 
+  async findAll(): Promise<User[]> {
+    const found = await this.repo.find({ relations: ['role'] });
+    return found.map((u) => this.toDomain(u));
+  }
+
   async delete(id: number): Promise<void> {
     await this.repo.delete(id);
   }

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

@@ -0,0 +1,56 @@
+import { Controller, Get, Post, Put, Delete, Body, Param, UseGuards, ParseIntPipe } 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 { User } from '../../domain/user';
+
+@ApiTags('users')
+@Controller('user')
+@UseGuards(JwtAuthGuard, PermissionsGuard)
+@ApiBearerAuth()
+export class UserController {
+  constructor(private readonly userService: UserService) {}
+
+  @Get()
+  @Permissions('read:user')
+  @ApiOperation({ summary: 'Listar todos os usuários (Admin)' })
+  @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();
+  }
+
+  @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);
+  }
+
+  @Post()
+  @Permissions('create:user')
+  @ApiOperation({ summary: 'Criar um novo usuário' })
+  async create(@Body() body: Omit<User, 'id'>) {
+    return this.userService.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);
+  }
+
+  @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 };
+  }
+}

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

@@ -38,6 +38,10 @@ export class UserService {
     return this.userRepo.update(id, user);
   }
 
+  async findAll(): Promise<User[]> {
+    return this.userRepo.findAll();
+  }
+
   async delete(id: number): Promise<void> {
     await this.userRepo.delete(id);
   }

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

@@ -4,9 +4,15 @@ import { UserOrmEntity } from './infra/database/user.orm-entity';
 import { UserRepositoryAdapter } from './infra/database/user.repository.adapter';
 import { UserService } from './service/user.service';
 import { DatabaseSeedService } from './database-seed.service';
+import { RoleModule } from '../role/role.module';
+import { UserController } from './infra/http/user.controller';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([UserOrmEntity])],
+  imports: [
+    TypeOrmModule.forFeature([UserOrmEntity]),
+    RoleModule,
+  ],
+  controllers: [UserController],
   providers: [
     UserService,
     DatabaseSeedService,

package/dist/index.js

@@ -450,6 +450,7 @@ function initUi(frontendRoot, config) {
     fs.ensureDirSync(path.join(targetDir, 'card-list'));
     fs.ensureDirSync(path.join(targetDir, 'simple-list'));
     fs.ensureDirSync(path.join(targetDir, 'dialog'));
+    fs.ensureDirSync(path.join(targetDir, 'textarea'));
     fs.ensureDirSync(path.join(targetDir, 'shell'));
     fs.ensureDirSync(path.join(targetDir, 'sidebar'));
     fs.ensureDirSync(path.join(targetDir, 'header'));
@@ -468,6 +469,10 @@ function initUi(frontendRoot, config) {
     const inp = (0, ui_templates_1.devkitInputTemplate)();
     fs.writeFileSync(path.join(targetDir, 'input', 'input.component.ts'), inp.ts, 'utf-8');
     fs.writeFileSync(path.join(targetDir, 'input', 'input.component.html'), inp.html, 'utf-8');
+    // 3.5. Escrever Textarea Component
+    const txt = (0, ui_templates_1.devkitTextareaTemplate)();
+    fs.writeFileSync(path.join(targetDir, 'textarea', 'textarea.component.ts'), txt.ts, 'utf-8');
+    fs.writeFileSync(path.join(targetDir, 'textarea', 'textarea.component.html'), txt.html, 'utf-8');
     // 4. Escrever Select Component
     const sel = (0, ui_templates_1.devkitSelectTemplate)();
     fs.writeFileSync(path.join(targetDir, 'select', 'select.component.ts'), sel.ts, 'utf-8');
@@ -1039,7 +1044,7 @@ SERVICE_PORT=${port}
             // 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), 'utf-8');
+            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
@@ -1079,9 +1084,9 @@ SERVICE_PORT=${port}
             // 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), 'utf-8');
+            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), 'utf-8');
+            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
@@ -1681,6 +1686,22 @@ DB_PORT=3306
 DB_USER=root
 DB_PASSWORD=root
 DB_NAME=devstroupe
+
+# Configuração de Storage Nátivo
+STORAGE_DRIVER=local
+STORAGE_LOCAL_PATH=./storage
+
+# Configuração AWS S3 (Opcional se STORAGE_DRIVER=s3)
+S3_BUCKET=my-bucket
+SRegion=us-east-1
+S3_ACCESS_KEY=
+S3_SECRET_KEY=
+
+# Configuração Cloudflare R2 (Opcional se STORAGE_DRIVER=r2)
+R2_BUCKET=my-bucket
+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');

package/dist/templates/angular/form.template.js

@@ -38,13 +38,14 @@ function angularFormHtmlTemplate(name, properties, entities = []) {
         .filter((property) => property.type !== 'relationship' || (0, relationships_1.getRelationships)([property])[0].kind !== 'one-to-many')
         .map((property) => {
         const controlName = formControlName(property);
-        if (property.type === 'boolean') {
+        const type = property.type;
+        if (type === 'boolean') {
             return `    <div *ngIf="!isFieldHidden('${controlName}')" class="flex items-center space-x-2 pt-2">
       <input type="checkbox" formControlName="${controlName}" id="${controlName}" class="h-4 w-4 rounded border-input bg-background text-primary focus:ring-ring">
       <label for="${controlName}" class="text-sm font-medium text-foreground">${property.label}</label>
     </div>`;
         }
-        if (property.type === 'relationship') {
+        if (type === 'relationship') {
             const relationship = (0, relationships_1.getRelationships)([property])[0];
             const stateName = relationStateName(relationship);
             return `    <devkit-select
@@ -62,15 +63,81 @@ function angularFormHtmlTemplate(name, properties, entities = []) {
       [required]="${Boolean(property.required)}">
     </devkit-select>`;
         }
-        const isNumber = property.type === 'number';
-        return `    <devkit-input
+        if (type === 'text' || type === 'json') {
+            return `    <devkit-textarea
       *ngIf="!isFieldHidden('${controlName}')"
-      ${isNumber ? 'type="number"' : ''}
+      formControlName="${controlName}"
+      label="${property.label}"
+      placeholder="Digite ${property.label.toLowerCase()}"
+      [required]="${Boolean(property.required)}">
+    </devkit-textarea>`;
+        }
+        if (type === 'enum') {
+            return `    <devkit-select
+      *ngIf="!isFieldHidden('${controlName}')"
+      formControlName="${controlName}"
+      label="${property.label}"
+      placeholder="Selecione ${property.label.toLowerCase()}"
+      [options]="${controlName}Options"
+      [required]="${Boolean(property.required)}">
+    </devkit-select>`;
+        }
+        if (type === 'string' ||
+            type === 'number' ||
+            type === 'decimal' ||
+            type === 'currency' ||
+            type === 'integer' ||
+            type === 'bigint' ||
+            type === 'email' ||
+            type === 'phone' ||
+            type === 'document' ||
+            type === 'color' ||
+            type === 'datepicker' ||
+            type === 'date' ||
+            type === 'datetime' ||
+            type === 'file') {
+            let typeAttr = 'type="text"';
+            let stepAttr = '';
+            let prefixAttr = '';
+            if (type === 'number' || type === 'integer') {
+                typeAttr = 'type="number"';
+            }
+            else if (type === 'decimal') {
+                typeAttr = 'type="number"';
+                stepAttr = 'step="any"';
+            }
+            else if (type === 'currency') {
+                typeAttr = 'type="number"';
+                stepAttr = 'step="0.01"';
+                prefixAttr = 'prefix="R$"';
+            }
+            else if (type === 'email') {
+                typeAttr = 'type="email"';
+            }
+            else if (type === 'color') {
+                typeAttr = 'type="color"';
+            }
+            else if (type === 'date' || type === 'datepicker') {
+                typeAttr = 'type="date"';
+            }
+            else if (type === 'datetime') {
+                typeAttr = 'type="datetime-local"';
+            }
+            else if (type === 'file') {
+                typeAttr = 'type="file"';
+            }
+            return `    <devkit-input
+      *ngIf="!isFieldHidden('${controlName}')"
+      ${typeAttr}
+      ${stepAttr}
+      ${prefixAttr}
       formControlName="${controlName}"
       label="${property.label}"
       placeholder="Digite ${property.label.toLowerCase()}"
       [required]="${Boolean(property.required)}">
     </devkit-input>`;
+        }
+        return '';
     })
         .join('\n\n');
     const dependentSections = dependentRelationships.map((relationship) => {
@@ -155,8 +222,9 @@ function angularFormTsTemplate(name, properties, entities = []) {
     const relationships = (0, relationships_1.getRelationships)(properties);
     const optionRelationships = relationships.filter((relationship) => relationship.kind !== 'one-to-many');
     const dependents = relationships.filter((relationship) => relationship.kind === 'one-to-many' && relationship.embedded);
-    const usesInput = properties.some((property) => property.type === 'string' || property.type === 'number' || property.type === 'datepicker');
-    const usesSelect = optionRelationships.length > 0;
+    const usesInput = properties.some((p) => p.type === 'string' || p.type === 'number' || p.type === 'decimal' || p.type === 'currency' || p.type === 'datepicker');
+    const usesTextarea = properties.some((property) => property.type === 'text');
+    const usesSelect = optionRelationships.length > 0 || properties.some((property) => property.type === 'enum');
     const formGroupProps = properties
         .filter((property) => property.type !== 'relationship' || (0, relationships_1.getRelationships)([property])[0].kind !== 'one-to-many')
         .map((property) => {
@@ -198,6 +266,13 @@ function angularFormTsTemplate(name, properties, entities = []) {
     minSearchLength: ${relationship.minSearchLength}
   });`;
     }).join('\n');
+    const enumOptionsState = properties
+        .filter((p) => p.type === 'enum' && p.enumOptions)
+        .map((p) => {
+        const options = p.enumOptions.map(o => ({ label: o, value: o }));
+        return `  readonly ${p.name}Options = ${JSON.stringify(options)};`;
+    })
+        .join('\n');
     const dependentState = dependents.map((relationship) => {
         const stateName = relationStateName(relationship);
         const columns = relationshipColumns(relationship, entities);
@@ -315,6 +390,7 @@ import { CommonModule } from '@angular/common';
 import { FormBuilder, FormGroup, Validators, ReactiveFormsModule } from '@angular/forms';
 import { ActivatedRoute, Router } from '@angular/router';
 ${usesInput ? "import { DevkitInputComponent } from '@devstroupe/ui/input/input.component';" : ''}
+${usesTextarea ? "import { DevkitTextareaComponent } from '@devstroupe/ui/textarea/textarea.component';" : ''}
 ${usesSelect ? "import { DevkitSelectComponent } from '@devstroupe/ui/select/select.component';" : ''}
 import { DevkitButtonComponent } from '@devstroupe/ui/button/button.component';
 import { HlmCardImports } from '@spartan-ng/helm/card';
@@ -328,7 +404,7 @@ import { ${pascalName}Service } from '../../../services/${name}.service';
 @Component({
   selector: 'app-${name}-form',
   standalone: true,
-  imports: [CommonModule, ReactiveFormsModule${usesInput ? ', DevkitInputComponent' : ''}${usesSelect ? ', DevkitSelectComponent' : ''}, DevkitButtonComponent, HlmCardImports, HlmSkeletonImports${componentImports.map((item) => `, ${item}`).join('')}],
+  imports: [CommonModule, ReactiveFormsModule${usesInput ? ', DevkitInputComponent' : ''}${usesTextarea ? ', DevkitTextareaComponent' : ''}${usesSelect ? ', DevkitSelectComponent' : ''}, DevkitButtonComponent, HlmCardImports, HlmSkeletonImports${componentImports.map((item) => `, ${item}`).join('')}],
   templateUrl: './${name}-form.component.html'
 })
 export class ${pascalName}FormComponent implements OnInit${optionRelationships.length > 0 ? ', OnDestroy' : ''} {
@@ -351,7 +427,7 @@ ${relationServiceInjections}
   isEdit = false;
   isFetching = false;
   loading = false;
-${optionState}
+${optionState}${enumOptionsState ? '\n' + enumOptionsState : ''}
 ${dependentState}
 
   ngOnInit(): void {