@devstroupe/devkit-cli 1.0.1 → 1.1.0

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

@@ -0,0 +1,12 @@
+import { Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { BaseService } from '@devstroupe/devkit-angular';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class UserService extends BaseService<any> {
+  constructor(http: HttpClient) {
+    super(http as any, '/api/user');
+  }
+}

package/dist/boilerplates/nest-template/src/app.module.ts

@@ -1,8 +1,10 @@
 import { Module } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';
+import { StorageModule } from '@devstroupe/devkit-nest';
 import { UserModule } from './modules/user/user.module';
 import { AuthModule } from './modules/auth/auth.module';
 import { RoleModule } from './modules/role/role.module';
+import { StorageDownloadModule } from './modules/storage/storage.module';
 
 @Module({
   imports: [
@@ -16,9 +18,30 @@ import { RoleModule } from './modules/role/role.module';
       autoLoadEntities: true,
       synchronize: false,
     }),
+    (StorageModule as any).registerAsync({
+      useFactory: () => ({
+        driver: (process.env.STORAGE_DRIVER || 'local') as 'local' | 's3' | 'r2',
+        local: {
+          storagePath: process.env.STORAGE_LOCAL_PATH || './storage',
+        },
+        s3: {
+          bucket: process.env.S3_BUCKET || 'my-bucket',
+          region: process.env.SRegion || 'us-east-1',
+          accessKeyId: process.env.S3_ACCESS_KEY || '',
+          secretAccessKey: process.env.S3_SECRET_KEY || '',
+        },
+        r2: {
+          bucket: process.env.R2_BUCKET || 'my-bucket',
+          accountId: process.env.R2_ACCOUNT_ID || '',
+          accessKeyId: process.env.R2_ACCESS_KEY || '',
+          secretAccessKey: process.env.R2_SECRET_KEY || '',
+        }
+      })
+    }),
     UserModule,
     AuthModule,
     RoleModule,
+    StorageDownloadModule,
   ],
   controllers: [],
   providers: [],

package/dist/boilerplates/nest-template/src/database/migrations/1600000000000-create-roles.ts

@@ -0,0 +1,20 @@
+import { MigrationInterface, QueryRunner, Table } from 'typeorm';
+
+export class CreateRoles1600000000000 implements MigrationInterface {
+  name = 'CreateRoles1600000000000';
+
+  async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.createTable(new Table({
+      name: 'roles',
+      columns: [
+        { name: 'id', type: 'int', isPrimary: true, isGenerated: true, generationStrategy: 'increment' },
+        { name: 'name', type: 'varchar', length: '255', isUnique: true },
+        { name: 'permissions', type: 'text', isNullable: true }
+      ]
+    }), true);
+  }
+
+  async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.dropTable('roles', true);
+  }
+}

package/dist/boilerplates/nest-template/src/database/migrations/1700000000000-create-users.ts

@@ -1,4 +1,4 @@
-import { MigrationInterface, QueryRunner, Table } from 'typeorm';
+import { MigrationInterface, QueryRunner, Table, TableForeignKey } from 'typeorm';
 
 export class CreateUsers1700000000000 implements MigrationInterface {
   name = 'CreateUsers1700000000000';
@@ -11,16 +11,27 @@ export class CreateUsers1700000000000 implements MigrationInterface {
         { name: 'name', type: 'varchar', length: '255' },
         { name: 'email', type: 'varchar', length: '255', isUnique: true },
         { name: 'password', type: 'varchar', length: '255' },
-        { name: 'role', type: 'varchar', length: '50', default: "'USER'" },
+        { name: 'role_id', type: 'int' },
+        { name: 'current_refresh_token', type: 'varchar', length: '500', isNullable: true },
         { name: 'tenant_id', type: 'varchar', length: '255', isNullable: true },
         { name: 'is_active', type: 'boolean', default: "'1'" },
         { name: 'created_at', type: 'datetime', default: 'CURRENT_TIMESTAMP' },
         { name: 'updated_at', type: 'datetime', default: 'CURRENT_TIMESTAMP', onUpdate: 'CURRENT_TIMESTAMP' }
       ]
     }), true);
+
+    await queryRunner.createForeignKey('users', new TableForeignKey({
+      name: 'FK_users_role_id',
+      columnNames: ['role_id'],
+      referencedColumnNames: ['id'],
+      referencedTableName: 'roles',
+      onDelete: 'RESTRICT'
+    }));
   }
 
   async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.dropForeignKey('users', 'FK_users_role_id');
     await queryRunner.dropTable('users', true);
   }
 }
+

package/dist/boilerplates/nest-template/src/modules/auth/auth.controller.ts

@@ -16,6 +16,22 @@ export class AuthController {
     return this.authService.login(body.email, body.password);
   }
 
+  @Post('refresh')
+  @ApiOperation({ summary: 'Atualiza o access token a partir do refresh token' })
+  @ApiResponse({ status: 200, description: 'Tokens atualizados com sucesso.' })
+  async refresh(@Body() body: any) {
+    return this.authService.refresh(body.email, body.refreshToken);
+  }
+
+  @Post('logout')
+  @UseGuards(JwtAuthGuard)
+  @ApiBearerAuth()
+  @ApiOperation({ summary: 'Efetua logout e revoga a sessão do usuário' })
+  @ApiResponse({ status: 200, description: 'Logout efetuado com sucesso.' })
+  async logout(@CurrentUser() user: any) {
+    return this.authService.logout(user.sub);
+  }
+
   @Post('register')
   @ApiOperation({ summary: 'Auto-cadastro de novos usuários' })
   @ApiResponse({ status: 201, description: 'Usuário cadastrado com sucesso.' })

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

@@ -25,7 +25,7 @@ export class AuthService {
     });
   }
 
-  async login(email: string, pass: string): Promise<{ accessToken: string; user: Omit<User, 'password'> }> {
+  async login(email: string, pass: string): Promise<{ accessToken: string; refreshToken: string; user: Omit<User, 'password' | 'currentRefreshToken'> }> {
     const user = await this.userService.findByEmail(email);
     if (!user) {
       throw new UnauthorizedException('Invalid credentials');
@@ -40,6 +40,37 @@ export class AuthService {
       throw new UnauthorizedException('User is inactive');
     }
 
+    return this.generateTokensForUser(user);
+  }
+
+  async refresh(email: string, refreshToken: string): Promise<{ accessToken: string; refreshToken: string; user: Omit<User, 'password' | 'currentRefreshToken'> }> {
+    try {
+      const payload = await this.jwtService.verifyAsync(refreshToken);
+      if (payload.email !== email) {
+        throw new UnauthorizedException('Invalid refresh token');
+      }
+
+      const user = await this.userService.findByEmail(email);
+      if (!user || !user.currentRefreshToken || !user.isActive) {
+        throw new UnauthorizedException('Session expired or user inactive');
+      }
+
+      const isMatch = await bcrypt.compare(refreshToken, user.currentRefreshToken);
+      if (!isMatch) {
+        throw new UnauthorizedException('Invalid session');
+      }
+
+      return this.generateTokensForUser(user);
+    } catch (e) {
+      throw new UnauthorizedException('Invalid or expired refresh token');
+    }
+  }
+
+  async logout(userId: number): Promise<void> {
+    await this.userService.update(userId, { currentRefreshToken: undefined } as any);
+  }
+
+  private async generateTokensForUser(user: User) {
     const payload = { 
       sub: user.id, 
       email: user.email, 
@@ -48,17 +79,25 @@ export class AuthService {
       permissions: user.role?.permissions || []
     };
 
-    const { password, ...result } = user;
+    const accessToken = await this.jwtService.signAsync(payload, { expiresIn: '15m' });
+    const refreshToken = await this.jwtService.signAsync({ email: user.email }, { expiresIn: '7d' });
+
+    const salt = await bcrypt.genSalt(10);
+    const hashedRefreshToken = await bcrypt.hash(refreshToken, salt);
+    await this.userService.update(user.id, { currentRefreshToken: hashedRefreshToken } as any);
+
+    const { password, currentRefreshToken, ...result } = user;
     return {
-      accessToken: await this.jwtService.signAsync(payload),
+      accessToken,
+      refreshToken,
       user: result,
     };
   }
 
-  async validateUserById(id: number): Promise<Omit<User, 'password'> | null> {
+  async validateUserById(id: number): Promise<Omit<User, 'password' | 'currentRefreshToken'> | null> {
     const user = await this.userService.findById(id);
     if (!user) return null;
-    const { password, ...result } = user;
+    const { password, currentRefreshToken, ...result } = user;
     return result;
   }
 }

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

@@ -17,6 +17,8 @@ export class DatabaseSeedService implements OnApplicationBootstrap {
 
   private async seedUsers() {
     try {
+      const isProduction = process.env.NODE_ENV === 'production';
+
       // 1. Criar Perfil Administrador se não existir
       let adminRole = await this.roleService.findByName('Administrador');
       if (!adminRole) {
@@ -31,9 +33,9 @@ export class DatabaseSeedService implements OnApplicationBootstrap {
         });
       }
 
-      // 2. Criar Perfil Usuário Comum se não existir
+      // 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) {
+      if (!userRole && !isProduction) {
         this.logger.log('Semente: Criando Perfil Usuário Comum...');
         userRole = await this.roleService.create({
           name: 'Usuário Comum',
@@ -41,32 +43,43 @@ export class DatabaseSeedService implements OnApplicationBootstrap {
         });
       }
 
-      const adminEmail = 'admin@devstroupe.com';
+      // 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',
+          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: userRole,
-          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

@@ -7,5 +7,6 @@ export class User {
   password!: string;
   role!: Role;
   tenantId?: string;
+  currentRefreshToken?: string;
   isActive!: boolean;
 }

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

@@ -22,6 +22,9 @@ export class UserOrmEntity {
   @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

@@ -5,12 +5,14 @@ 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]),
     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');