@devstroupe/devkit-cli 1.0.0

package/dist/boilerplates/nest-template/node_modules/.bin/typeorm

@@ -0,0 +1,21 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -z "$NODE_PATH" ]; then
+  export NODE_PATH="/home/vitor/trabalho/devstroupe/framework/node_modules/.pnpm/typeorm@0.3.30_babel-plugin-macros@3.1.0_mysql2@3.22.5_@types+node@20.19.43_/node_modules/typeorm/node_modules:/home/vitor/trabalho/devstroupe/framework/node_modules/.pnpm/typeorm@0.3.30_babel-plugin-macros@3.1.0_mysql2@3.22.5_@types+node@20.19.43_/node_modules:/home/vitor/trabalho/devstroupe/framework/node_modules/.pnpm/node_modules"
+else
+  export NODE_PATH="/home/vitor/trabalho/devstroupe/framework/node_modules/.pnpm/typeorm@0.3.30_babel-plugin-macros@3.1.0_mysql2@3.22.5_@types+node@20.19.43_/node_modules/typeorm/node_modules:/home/vitor/trabalho/devstroupe/framework/node_modules/.pnpm/typeorm@0.3.30_babel-plugin-macros@3.1.0_mysql2@3.22.5_@types+node@20.19.43_/node_modules:/home/vitor/trabalho/devstroupe/framework/node_modules/.pnpm/node_modules:$NODE_PATH"
+fi
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../typeorm/cli.js" "$@"
+else
+  exec node  "$basedir/../typeorm/cli.js" "$@"
+fi

package/dist/boilerplates/nest-template/node_modules/.bin/typeorm-ts-node-commonjs

@@ -0,0 +1,21 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -z "$NODE_PATH" ]; then
+  export NODE_PATH="/home/vitor/trabalho/devstroupe/framework/node_modules/.pnpm/typeorm@0.3.30_babel-plugin-macros@3.1.0_mysql2@3.22.5_@types+node@20.19.43_/node_modules/typeorm/node_modules:/home/vitor/trabalho/devstroupe/framework/node_modules/.pnpm/typeorm@0.3.30_babel-plugin-macros@3.1.0_mysql2@3.22.5_@types+node@20.19.43_/node_modules:/home/vitor/trabalho/devstroupe/framework/node_modules/.pnpm/node_modules"
+else
+  export NODE_PATH="/home/vitor/trabalho/devstroupe/framework/node_modules/.pnpm/typeorm@0.3.30_babel-plugin-macros@3.1.0_mysql2@3.22.5_@types+node@20.19.43_/node_modules/typeorm/node_modules:/home/vitor/trabalho/devstroupe/framework/node_modules/.pnpm/typeorm@0.3.30_babel-plugin-macros@3.1.0_mysql2@3.22.5_@types+node@20.19.43_/node_modules:/home/vitor/trabalho/devstroupe/framework/node_modules/.pnpm/node_modules:$NODE_PATH"
+fi
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../typeorm/cli-ts-node-commonjs.js" "$@"
+else
+  exec node  "$basedir/../typeorm/cli-ts-node-commonjs.js" "$@"
+fi

package/dist/boilerplates/nest-template/node_modules/.bin/typeorm-ts-node-esm

@@ -0,0 +1,21 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -z "$NODE_PATH" ]; then
+  export NODE_PATH="/home/vitor/trabalho/devstroupe/framework/node_modules/.pnpm/typeorm@0.3.30_babel-plugin-macros@3.1.0_mysql2@3.22.5_@types+node@20.19.43_/node_modules/typeorm/node_modules:/home/vitor/trabalho/devstroupe/framework/node_modules/.pnpm/typeorm@0.3.30_babel-plugin-macros@3.1.0_mysql2@3.22.5_@types+node@20.19.43_/node_modules:/home/vitor/trabalho/devstroupe/framework/node_modules/.pnpm/node_modules"
+else
+  export NODE_PATH="/home/vitor/trabalho/devstroupe/framework/node_modules/.pnpm/typeorm@0.3.30_babel-plugin-macros@3.1.0_mysql2@3.22.5_@types+node@20.19.43_/node_modules/typeorm/node_modules:/home/vitor/trabalho/devstroupe/framework/node_modules/.pnpm/typeorm@0.3.30_babel-plugin-macros@3.1.0_mysql2@3.22.5_@types+node@20.19.43_/node_modules:/home/vitor/trabalho/devstroupe/framework/node_modules/.pnpm/node_modules:$NODE_PATH"
+fi
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../typeorm/cli-ts-node-esm.js" "$@"
+else
+  exec node  "$basedir/../typeorm/cli-ts-node-esm.js" "$@"
+fi

package/dist/boilerplates/nest-template/node_modules/.bin/webpack

@@ -0,0 +1,21 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -z "$NODE_PATH" ]; then
+  export NODE_PATH="/home/vitor/trabalho/devstroupe/framework/node_modules/.pnpm/webpack@5.106.2/node_modules/webpack/node_modules:/home/vitor/trabalho/devstroupe/framework/node_modules/.pnpm/webpack@5.106.2/node_modules:/home/vitor/trabalho/devstroupe/framework/node_modules/.pnpm/node_modules"
+else
+  export NODE_PATH="/home/vitor/trabalho/devstroupe/framework/node_modules/.pnpm/webpack@5.106.2/node_modules/webpack/node_modules:/home/vitor/trabalho/devstroupe/framework/node_modules/.pnpm/webpack@5.106.2/node_modules:/home/vitor/trabalho/devstroupe/framework/node_modules/.pnpm/node_modules:$NODE_PATH"
+fi
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../../../../node_modules/.pnpm/webpack@5.106.2/node_modules/webpack/bin/webpack.js" "$@"
+else
+  exec node  "$basedir/../../../../node_modules/.pnpm/webpack@5.106.2/node_modules/webpack/bin/webpack.js" "$@"
+fi

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

@@ -0,0 +1,43 @@
+{
+  "name": "devkit-nest-boilerplate",
+  "version": "1.0.0",
+  "description": "Boilerplate NestJS integrado ao DT-DevKit",
+  "private": true,
+  "scripts": {
+    "build": "nest build",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "start": "nest start",
+    "start:dev": "nest start --watch",
+    "start:debug": "nest start --debug --watch",
+    "start:prod": "node dist/main",
+    "migration:run": "typeorm-ts-node-commonjs -d src/database/data-source.ts migration:run",
+    "migration:revert": "typeorm-ts-node-commonjs -d src/database/data-source.ts migration:revert",
+    "migration:generate": "typeorm-ts-node-commonjs -d src/database/data-source.ts migration:generate src/database/migrations/schema"
+  },
+  "dependencies": {
+    "@nestjs/common": "^11.0.0",
+    "@nestjs/core": "^11.0.0",
+    "@nestjs/platform-express": "^11.0.0",
+    "@nestjs/swagger": "^11.0.0",
+    "@nestjs/typeorm": "^11.0.0",
+    "@nestjs/jwt": "^11.0.0",
+    "@nestjs/microservices": "^11.0.0",
+    "typeorm": "^0.3.20",
+    "mysql2": "^3.9.0",
+    "reflect-metadata": "^0.2.0",
+    "rxjs": "^7.8.1",
+    "bcryptjs": "^2.4.3",
+    "dotenv": "^16.4.5",
+    "@devstroupe/devkit-core": "workspace:*",
+    "@devstroupe/devkit-nest": "workspace:*"
+  },
+  "devDependencies": {
+    "@nestjs/cli": "^11.0.0",
+    "@nestjs/schematics": "^11.0.0",
+    "@types/express": "^5.0.0",
+    "@types/node": "^20.11.0",
+    "@types/bcryptjs": "^2.4.6",
+    "typescript": "^5.4.5",
+    "ts-node": "^10.9.2"
+  }
+}

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

@@ -0,0 +1,24 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { UserModule } from './modules/user/user.module';
+import { AuthModule } from './modules/auth/auth.module';
+
+@Module({
+  imports: [
+    TypeOrmModule.forRoot({
+      type: 'mysql',
+      host: process.env.DB_HOST || 'localhost',
+      port: Number(process.env.DB_PORT) || 3306,
+      username: process.env.DB_USER || 'root',
+      password: process.env.DB_PASSWORD || 'root',
+      database: process.env.DB_NAME || 'devstroupe',
+      autoLoadEntities: true,
+      synchronize: false,
+    }),
+    UserModule,
+    AuthModule,
+  ],
+  controllers: [],
+  providers: [],
+})
+export class AppModule {}

package/dist/boilerplates/nest-template/src/database/data-source.ts

@@ -0,0 +1,16 @@
+import 'reflect-metadata';
+import 'dotenv/config';
+import { DataSource } from 'typeorm';
+import * as path from 'path';
+
+export default new DataSource({
+  type: 'mysql',
+  host: process.env.DB_HOST || 'localhost',
+  port: Number(process.env.DB_PORT) || 3306,
+  username: process.env.DB_USER || 'root',
+  password: process.env.DB_PASSWORD || 'root',
+  database: process.env.DB_NAME || 'devstroupe',
+  entities: [path.join(__dirname, '../modules/**/infra/database/*.orm-entity{.ts,.js}')],
+  migrations: [path.join(__dirname, './migrations/*{.ts,.js}')],
+  synchronize: false,
+});

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

@@ -0,0 +1,26 @@
+import { MigrationInterface, QueryRunner, Table } from 'typeorm';
+
+export class CreateUsers1700000000000 implements MigrationInterface {
+  name = 'CreateUsers1700000000000';
+
+  async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.createTable(new Table({
+      name: 'users',
+      columns: [
+        { name: 'id', type: 'int', isPrimary: true, isGenerated: true, generationStrategy: 'increment' },
+        { 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: '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);
+  }
+
+  async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.dropTable('users', true);
+  }
+}

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

@@ -0,0 +1,46 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+// Carrega variáveis do arquivo .env manualmente se ele existir
+const envPath = path.resolve(process.cwd(), '.env');
+if (fs.existsSync(envPath)) {
+  const envConfig = fs.readFileSync(envPath, 'utf-8');
+  envConfig.split('\n').forEach((line) => {
+    const trimmed = line.trim();
+    if (trimmed && !trimmed.startsWith('#')) {
+      const [key, ...values] = trimmed.split('=');
+      const val = values.join('=').trim();
+      if (key && val && process.env[key.trim()] === undefined) {
+        process.env[key.trim()] = val.replace(/^['"]|['"]$/g, '');
+      }
+    }
+  });
+}
+
+import { NestFactory } from '@nestjs/core';
+import { AppModule } from './app.module';
+import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+
+  // Prefixo de rota global
+  app.setGlobalPrefix('api');
+
+  // Habilitar CORS
+  app.enableCors();
+
+  // Documentação do Swagger
+  const config = new DocumentBuilder()
+    .setTitle('DevsTroupe API')
+    .setDescription('Documentação das APIs geradas pelo DT-DevKit')
+    .setVersion('1.0')
+    .build();
+  const document = SwaggerModule.createDocument(app, config);
+  SwaggerModule.setup('docs', app, document);
+
+  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');
+}
+bootstrap();

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

@@ -0,0 +1,34 @@
+import { Controller, Post, Body, Get, UseGuards } from '@nestjs/common';
+import { ApiTags, ApiOperation, ApiResponse, ApiBearerAuth } from '@nestjs/swagger';
+import { AuthService } from './auth.service';
+import { JwtAuthGuard } from './jwt-auth.guard';
+import { CurrentUser } from './current-user.decorator';
+
+@ApiTags('auth')
+@Controller('auth')
+export class AuthController {
+  constructor(private readonly authService: AuthService) {}
+
+  @Post('login')
+  @ApiOperation({ summary: 'Login de usuário e emissão de JWT' })
+  @ApiResponse({ status: 200, description: 'Login efetuado com sucesso.' })
+  async login(@Body() body: any) {
+    return this.authService.login(body.email, body.password);
+  }
+
+  @Post('register')
+  @ApiOperation({ summary: 'Auto-cadastro de novos usuários' })
+  @ApiResponse({ status: 201, description: 'Usuário cadastrado com sucesso.' })
+  async register(@Body() body: any) {
+    return this.authService.register(body);
+  }
+
+  @Get('me')
+  @UseGuards(JwtAuthGuard)
+  @ApiBearerAuth()
+  @ApiOperation({ summary: 'Retorna os dados do usuário autenticado' })
+  @ApiResponse({ status: 200, description: 'Dados retornados com sucesso.' })
+  async getMe(@CurrentUser() user: any) {
+    return this.authService.validateUserById(user.sub);
+  }
+}

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

@@ -0,0 +1,22 @@
+import { Module } from '@nestjs/common';
+import { JwtModule } from '@nestjs/jwt';
+import { UserModule } from '../user/user.module';
+import { AuthService } from './auth.service';
+import { AuthController } from './auth.controller';
+import { JwtAuthGuard } from './jwt-auth.guard';
+import { RolesGuard } from './roles.guard';
+
+@Module({
+  imports: [
+    UserModule,
+    JwtModule.register({
+      global: true,
+      secret: process.env.JWT_SECRET || 'devstroupe-secret-key-12345',
+      signOptions: { expiresIn: '1d' },
+    }),
+  ],
+  providers: [AuthService, JwtAuthGuard, RolesGuard],
+  controllers: [AuthController],
+  exports: [AuthService, JwtAuthGuard, RolesGuard],
+})
+export class AuthModule {}

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

@@ -0,0 +1,57 @@
+import { Injectable, UnauthorizedException } from '@nestjs/common';
+import { JwtService } from '@nestjs/jwt';
+import * as bcrypt from 'bcryptjs';
+import { UserService } from '../user/service/user.service';
+import { User } from '../user/domain/user';
+
+@Injectable()
+export class AuthService {
+  constructor(
+    private readonly userService: UserService,
+    private readonly jwtService: JwtService,
+  ) {}
+
+  async register(data: Omit<User, 'id' | 'role' | 'isActive'>): Promise<User> {
+    return this.userService.create({
+      ...data,
+      role: 'USER',
+      isActive: true,
+    });
+  }
+
+  async login(email: string, pass: string): Promise<{ accessToken: string; user: Omit<User, 'password'> }> {
+    const user = await this.userService.findByEmail(email);
+    if (!user) {
+      throw new UnauthorizedException('Invalid credentials');
+    }
+
+    const isMatch = await bcrypt.compare(pass, user.password);
+    if (!isMatch) {
+      throw new UnauthorizedException('Invalid credentials');
+    }
+
+    if (!user.isActive) {
+      throw new UnauthorizedException('User is inactive');
+    }
+
+    const payload = { 
+      sub: user.id, 
+      email: user.email, 
+      role: user.role, 
+      tenantId: user.tenantId 
+    };
+
+    const { password, ...result } = user;
+    return {
+      accessToken: await this.jwtService.signAsync(payload),
+      user: result,
+    };
+  }
+
+  async validateUserById(id: number): Promise<Omit<User, 'password'> | null> {
+    const user = await this.userService.findById(id);
+    if (!user) return null;
+    const { password, ...result } = user;
+    return result;
+  }
+}

package/dist/boilerplates/nest-template/src/modules/auth/current-user.decorator.ts

@@ -0,0 +1,8 @@
+import { createParamDecorator, ExecutionContext } from '@nestjs/common';
+
+export const CurrentUser = createParamDecorator(
+  (data: unknown, ctx: ExecutionContext) => {
+    const request = ctx.switchToHttp().getRequest();
+    return request.user;
+  },
+);

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

@@ -0,0 +1,31 @@
+import { CanActivate, ExecutionContext, Injectable, UnauthorizedException } from '@nestjs/common';
+import { JwtService } from '@nestjs/jwt';
+import { Request } from 'express';
+
+@Injectable()
+export class JwtAuthGuard implements CanActivate {
+  constructor(private readonly jwtService: JwtService) {}
+
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    const request = context.switchToHttp().getRequest<Request>();
+    const token = this.extractTokenFromHeader(request);
+    if (!token) {
+      throw new UnauthorizedException('Token not found');
+    }
+    try {
+      const payload = await this.jwtService.verifyAsync(token, {
+        secret: process.env.JWT_SECRET || 'devstroupe-secret-key-12345',
+      });
+      // Injeta o payload decodificado (contendo sub, email, role, tenantId) na request
+      request['user'] = payload;
+    } catch {
+      throw new UnauthorizedException('Invalid or expired token');
+    }
+    return true;
+  }
+
+  private extractTokenFromHeader(request: Request): string | undefined {
+    const [type, token] = request.headers.authorization?.split(' ') ?? [];
+    return type === 'Bearer' ? token : undefined;
+  }
+}

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

@@ -0,0 +1,4 @@
+import { SetMetadata } from '@nestjs/common';
+
+export const ROLES_KEY = 'roles';
+export const Roles = (...roles: string[]) => SetMetadata(ROLES_KEY, roles);

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

@@ -0,0 +1,24 @@
+import { CanActivate, ExecutionContext, Injectable } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { ROLES_KEY } from './roles.decorator';
+
+@Injectable()
+export class RolesGuard implements CanActivate {
+  constructor(private readonly reflector: Reflector) {}
+
+  canActivate(context: ExecutionContext): boolean {
+    const requiredRoles = this.reflector.getAllAndOverride<string[]>(ROLES_KEY, [
+      context.getHandler(),
+      context.getClass(),
+    ]);
+    if (!requiredRoles) {
+      return true;
+    }
+    const request = context.switchToHttp().getRequest();
+    const user = request.user;
+    if (!user || !user.role) {
+      return false;
+    }
+    return requiredRoles.includes(user.role);
+  }
+}

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

@@ -0,0 +1,47 @@
+import { Injectable, OnApplicationBootstrap, Logger } from '@nestjs/common';
+import { UserService } from './service/user.service';
+
+@Injectable()
+export class DatabaseSeedService implements OnApplicationBootstrap {
+  private readonly logger = new Logger(DatabaseSeedService.name);
+
+  constructor(private readonly userService: UserService) {}
+
+  async onApplicationBootstrap() {
+    await this.seedUsers();
+  }
+
+  private async seedUsers() {
+    try {
+      const adminEmail = 'admin@devstroupe.com';
+      const existingAdmin = await this.userService.findByEmail(adminEmail);
+      if (!existingAdmin) {
+        this.logger.log('Semente: Criando usuário administrador padrão...');
+        await this.userService.create({
+          name: 'Administrador DevsTroupe',
+          email: adminEmail,
+          password: 'adminpassword123',
+          role: 'ADMIN',
+          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!');
+      }
+    } 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

@@ -0,0 +1,9 @@
+import { User } from './user';
+
+export interface IUserRepository {
+  create(user: Omit<User, 'id'>): Promise<User>;
+  update(id: number, user: Partial<User>): Promise<User>;
+  findById(id: number): Promise<User | null>;
+  findByEmail(email: string): Promise<User | null>;
+  delete(id: number): Promise<void>;
+}

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

@@ -0,0 +1,9 @@
+export class User {
+  id!: number;
+  name!: string;
+  email!: string;
+  password!: string;
+  role!: 'ADMIN' | 'USER';
+  tenantId?: string;
+  isActive!: boolean;
+}

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

@@ -0,0 +1,31 @@
+import { Entity, PrimaryGeneratedColumn, Column, CreateDateColumn, UpdateDateColumn } from 'typeorm';
+
+@Entity('users')
+export class UserOrmEntity {
+  @PrimaryGeneratedColumn()
+  id!: number;
+
+  @Column({ type: 'varchar', length: 255 })
+  name!: string;
+
+  @Column({ type: 'varchar', length: 255, unique: true })
+  email!: string;
+
+  @Column({ type: 'varchar', length: 255 })
+  password!: string;
+
+  @Column({ type: 'varchar', length: 50, default: 'USER' })
+  role!: 'ADMIN' | 'USER';
+
+  @Column({ type: 'varchar', length: 255, nullable: true, name: 'tenant_id' })
+  tenantId?: string;
+
+  @Column({ type: 'boolean', default: true, name: 'is_active' })
+  isActive!: boolean;
+
+  @CreateDateColumn({ name: 'created_at' })
+  createdAt!: Date;
+
+  @UpdateDateColumn({ name: 'updated_at' })
+  updatedAt!: Date;
+}

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

@@ -0,0 +1,53 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { IUserRepository } from '../../domain/user.repository';
+import { User } from '../../domain/user';
+import { UserOrmEntity } from './user.orm-entity';
+
+@Injectable()
+export class UserRepositoryAdapter implements IUserRepository {
+  constructor(
+    @InjectRepository(UserOrmEntity)
+    private readonly repo: Repository<UserOrmEntity>,
+  ) {}
+
+  private toDomain(orm: UserOrmEntity): User {
+    return {
+      id: orm.id,
+      name: orm.name,
+      email: orm.email,
+      password: orm.password,
+      role: orm.role,
+      tenantId: orm.tenantId,
+      isActive: orm.isActive,
+    };
+  }
+
+  async create(user: Omit<User, 'id'>): Promise<User> {
+    const created = this.repo.create(user);
+    const saved = await this.repo.save(created);
+    return this.toDomain(saved);
+  }
+
+  async update(id: number, user: Partial<User>): Promise<User> {
+    await this.repo.update(id, user);
+    const updated = await this.findById(id);
+    if (!updated) throw new Error('User not found after update');
+    return updated;
+  }
+
+  async findById(id: number): Promise<User | null> {
+    const found = await this.repo.findOne({ where: { id } });
+    return found ? this.toDomain(found) : null;
+  }
+
+  async findByEmail(email: string): Promise<User | null> {
+    const found = await this.repo.findOne({ where: { email } });
+    return found ? this.toDomain(found) : null;
+  }
+
+  async delete(id: number): Promise<void> {
+    await this.repo.delete(id);
+  }
+}

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

@@ -0,0 +1,44 @@
+import { Injectable, Inject } from '@nestjs/common';
+import * as bcrypt from 'bcryptjs';
+import { IUserRepository } from '../domain/user.repository';
+import { User } from '../domain/user';
+
+@Injectable()
+export class UserService {
+  constructor(
+    @Inject('IUserRepository')
+    private readonly userRepo: IUserRepository,
+  ) {}
+
+  async create(user: Omit<User, 'id'>): Promise<User> {
+    const existing = await this.userRepo.findByEmail(user.email);
+    if (existing) {
+      throw new Error('Email already registered');
+    }
+
+    const hashedPassword = await bcrypt.hash(user.password, 10);
+    return this.userRepo.create({
+      ...user,
+      password: hashedPassword,
+    });
+  }
+
+  async findById(id: number): Promise<User | null> {
+    return this.userRepo.findById(id);
+  }
+
+  async findByEmail(email: string): Promise<User | null> {
+    return this.userRepo.findByEmail(email);
+  }
+
+  async update(id: number, user: Partial<User>): Promise<User> {
+    if (user.password) {
+      user.password = await bcrypt.hash(user.password, 10);
+    }
+    return this.userRepo.update(id, user);
+  }
+
+  async delete(id: number): Promise<void> {
+    await this.userRepo.delete(id);
+  }
+}

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

@@ -0,0 +1,20 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+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';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([UserOrmEntity])],
+  providers: [
+    UserService,
+    DatabaseSeedService,
+    {
+      provide: 'IUserRepository',
+      useClass: UserRepositoryAdapter,
+    },
+  ],
+  exports: [UserService],
+})
+export class UserModule {}