innovationhub-cli 1.1.0 → 2.0.1

package/templates/nest/src/user/dto/create-user.dto.ts

@@ -0,0 +1,50 @@
+import { ApiProperty } from '@nestjs/swagger';
+import {
+  IsEmail,
+  IsNotEmpty,
+  IsOptional,
+  IsBoolean,
+  IsEnum,
+} from 'class-validator';
+import { Role } from '../../auth/enums/role.enum';
+import { Transform } from 'class-transformer';
+
+export class CreateUserDto {
+  @ApiProperty({
+    description: 'O endereço de e-mail do usuário',
+    example: 'joao.silva@exemplo.com',
+  })
+  @IsEmail()
+  email!: string;
+
+  @ApiProperty({
+    description: 'O nome completo do usuário',
+    example: 'João da Silva',
+  })
+  @IsNotEmpty()
+  name!: string;
+
+  @ApiProperty({
+    description: 'Status de ativação do usuário',
+    default: true,
+    required: false,
+  })
+  @Transform(({ value }: { value: string | boolean }) => {
+    if (value === 'true') return true;
+    if (value === 'false') return false;
+    return value;
+  })
+  @IsOptional()
+  @IsBoolean()
+  isActive?: boolean;
+
+  @ApiProperty({
+    description: 'A função do novo usuário (opcional, padrão será "user").',
+    enum: Role,
+    required: false,
+    default: Role.User,
+  })
+  @IsOptional()
+  @IsEnum(Role)
+  role?: Role;
+}

package/templates/nest/src/user/dto/query-users.dto.ts

@@ -0,0 +1,23 @@
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { IsIn, IsOptional, IsString } from 'class-validator';
+import { BaseQueryDto } from '../../common/dto/base-query.dto';
+
+export class QueryUsersDto extends BaseQueryDto {
+  @ApiPropertyOptional({
+    description: 'Coluna pela qual os resultados serão ordenados.',
+    default: 'id',
+    example: 'name',
+    enum: ['id', 'name', 'email', 'isActive', 'role', 'mustChangePassword'],
+  })
+  @IsOptional()
+  @IsString()
+  @IsIn(['id', 'name', 'email', 'isActive', 'role', 'mustChangePassword'])
+  override sortBy?: string = 'id';
+
+  @ApiPropertyOptional({
+    description: 'Ordem da classificação (ascendente ou descendente).',
+    default: 'ASC',
+    enum: ['ASC', 'DESC'],
+  })
+  override sortOrder?: 'ASC' | 'DESC' = 'ASC';
+}

package/templates/nest/src/user/dto/update-user.dto.ts

@@ -0,0 +1,15 @@
+import { PartialType } from '@nestjs/swagger';
+import { CreateUserDto } from './create-user.dto';
+import { ApiProperty } from '@nestjs/swagger';
+import { IsOptional, IsString } from 'class-validator';
+
+export class UpdateUserDto extends PartialType(CreateUserDto) {
+  @ApiProperty({
+    description: 'O número de telefone do usuário.',
+    example: '(11) 99999-9999',
+    required: false,
+  })
+  @IsOptional()
+  @IsString()
+  phone?: string;
+}

package/templates/nest/src/user/entities/user.entity.ts

@@ -0,0 +1,66 @@
+import { Column, DeleteDateColumn, Entity, OneToMany } from 'typeorm';
+import { ApiProperty } from '@nestjs/swagger';
+import { Role } from '../../auth/enums/role.enum';
+import { Exclude, Expose } from 'class-transformer';
+import { BaseEntity } from '../../common/base.entity';
+import { RefreshTokenEntity } from '../../auth/entities/refresh-token.entity';
+
+@Entity('users')
+@Exclude()
+export class UserEntity extends BaseEntity {
+  @Expose()
+  @ApiProperty({
+    description: 'E-mail do usuário',
+    example: 'user@example.com',
+  })
+  @Column({ unique: true })
+  email: string;
+
+  @Expose()
+  @ApiProperty({ description: 'Nome do usuário', example: 'João Silva' })
+  @Column()
+  name: string;
+
+  @Expose()
+  @ApiProperty({
+    description: 'Telefone do usuário',
+    example: '+55 11 99999-9999',
+    required: false,
+  })
+  @Column({ nullable: true })
+  phone?: string;
+
+  @Column({ select: false })
+  password: string;
+
+  @Expose()
+  @Column({
+    type: 'boolean',
+    default: true,
+  })
+  isActive: boolean;
+
+  @Expose()
+  @ApiProperty({ enum: Role, description: 'Papel do usuário no sistema' })
+  @Column({
+    type: 'enum',
+    enum: Role,
+    default: Role.User,
+  })
+  role: Role;
+
+  @Expose()
+  @Column({
+    name: 'must_change_password',
+    type: 'boolean',
+    default: false,
+  })
+  mustChangePassword: boolean;
+
+  @OneToMany(() => RefreshTokenEntity, (refreshToken) => refreshToken.user)
+  refreshTokens: RefreshTokenEntity[];
+
+  @Expose()
+  @DeleteDateColumn()
+  deletedAt: Date;
+}

package/templates/nest/src/user/user.controller.ts

@@ -0,0 +1,172 @@
+import {
+  Controller,
+  Get,
+  Post,
+  Body,
+  UseGuards,
+  Param,
+  Patch,
+  HttpCode,
+  NotFoundException,
+  HttpStatus,
+  Query,
+  Req,
+  Delete,
+} from '@nestjs/common';
+import { ERRORS } from '../common/constants/errors.constants';
+import { ApiTags, ApiOperation, ApiResponse, ApiBody } from '@nestjs/swagger';
+import { UserService } from './user.service';
+import { UserEntity } from './entities/user.entity';
+import { UpdateUserDto } from './dto/update-user.dto';
+import { JwtAuthGuard } from '../auth/guards/jwt-auth.guard';
+import { CreateUserDto } from './dto/create-user.dto';
+import { RolesGuard } from '../auth/guards/roles.guard';
+import { Roles } from '../auth/decorators/roles.decorator';
+import { Role } from '../auth/enums/role.enum';
+import { QueryUsersDto } from './dto/query-users.dto';
+
+@ApiTags('users')
+@Controller('users')
+export class UserController {
+  constructor(private readonly userService: UserService) {}
+
+  @Post()
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.Admin)
+  @ApiOperation({ summary: 'Cria um novo usuário (admin)' })
+  @ApiBody({
+    type: CreateUserDto,
+  })
+  @ApiResponse({
+    status: 201,
+    description: 'Usuário criado com sucesso.',
+    type: UserEntity,
+  })
+  async create(@Body() createUserDto: CreateUserDto) {
+    return this.userService.create(createUserDto);
+  }
+
+  @Get('me')
+  @UseGuards(JwtAuthGuard)
+  @ApiOperation({ summary: 'Retorna o perfil do usuário logado' })
+  @ApiResponse({
+    status: 200,
+    description: 'Perfil do usuário.',
+    type: UserEntity,
+  })
+  async getMe(@Req() req: { user: { id: string } }): Promise<UserEntity> {
+    const id = req.user.id;
+    const user = await this.userService.findById(id);
+    if (!user) {
+      throw new NotFoundException(ERRORS.USER.NOT_FOUND);
+    }
+    return user;
+  }
+
+  @Patch('me')
+  @UseGuards(JwtAuthGuard)
+  @ApiOperation({ summary: 'Atualiza o perfil do usuário logado' })
+  @ApiBody({
+    type: UpdateUserDto,
+  })
+  @HttpCode(200)
+  @ApiResponse({
+    status: 200,
+    description: 'Perfil atualizado com sucesso.',
+    type: UserEntity,
+  })
+  async updateMe(
+    @Req() req: { user: { id: string } },
+    @Body() updateUserDto: UpdateUserDto,
+  ): Promise<UserEntity> {
+    const id = req.user.id;
+    await this.userService.updateProfile(id, updateUserDto);
+    return this.getMe(req);
+  }
+
+  @Get()
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.Admin)
+  @ApiOperation({ summary: 'Busca todos os usuários' })
+  @ApiResponse({
+    status: 200,
+    description: 'Lista de usuários retornada com sucesso.',
+  })
+  findAll() {
+    return this.userService.findAll();
+  }
+
+  @Get('paginated')
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.Admin)
+  @ApiOperation({ summary: 'Busca todos os usuários com paginação' })
+  @ApiResponse({
+    status: 200,
+    description: 'Lista de usuários retornada com sucesso.',
+  })
+  findAndCountUsers(@Query() query: QueryUsersDto) {
+    return this.userService.findAndCountUsers(query);
+  }
+
+  @Get('/:id')
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.Admin)
+  @ApiOperation({ summary: 'Busca usuários pelo Id' })
+  @ApiResponse({
+    status: 200,
+    description: 'Usuário encontrado.',
+    type: UserEntity,
+  })
+  @ApiResponse({ status: 404, description: 'Usuário não encontrado.' })
+  async findById(@Param('id') id: string): Promise<UserEntity> {
+    const user = await this.userService.findById(id);
+    if (!user) {
+      throw new NotFoundException(ERRORS.USER.NOT_FOUND);
+    }
+    return user;
+  }
+
+  @Patch(':id')
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.Admin)
+  @ApiOperation({ summary: 'Atualiza um usuário pelo ID (admin)' })
+  @ApiBody({
+    type: UpdateUserDto,
+  })
+  @HttpCode(204)
+  @ApiResponse({ status: 204, description: 'Usuário atualizado com sucesso.' })
+  async update(
+    @Param('id') id: string,
+    @Body() updateUserDto: UpdateUserDto,
+  ): Promise<void> {
+    await this.userService.updateProfile(id, updateUserDto);
+  }
+
+  @Patch(':id/reset-password')
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.Admin)
+  @HttpCode(HttpStatus.OK)
+  @ApiOperation({ summary: 'Reseta a senha de um usuário (admin)' })
+  @ApiResponse({
+    status: 200,
+    description:
+      'Senha resetada com sucesso. A nova senha foi enviada para o e-mail do usuário.',
+  })
+  @ApiResponse({ status: 404, description: 'Usuário não encontrado.' })
+  async resetPasswordByAdmin(
+    @Param('id') id: string,
+  ): Promise<{ message: string }> {
+    return this.userService.resetPasswordByAdmin(id);
+  }
+
+  @Delete(':id')
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(Role.Admin)
+  @HttpCode(HttpStatus.NO_CONTENT)
+  @ApiOperation({ summary: 'Deleta um usuário (admin)' })
+  @ApiResponse({ status: 204, description: 'Usuário deletado com sucesso.' })
+  @ApiResponse({ status: 404, description: 'Usuário não encontrado.' })
+  async delete(@Param('id') id: string): Promise<void> {
+    await this.userService.delete(id);
+  }
+}

package/templates/nest/src/user/user.module.ts

@@ -0,0 +1,15 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { UserController } from './user.controller';
+import { UserService } from './user.service';
+
+import { UserEntity } from './entities/user.entity';
+import { UsersRepository } from './user.repository';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([UserEntity])],
+  controllers: [UserController],
+  providers: [UserService, UsersRepository],
+  exports: [UserService, UsersRepository],
+})
+export class UserModule {}

package/templates/nest/src/user/user.repository.ts

@@ -0,0 +1,61 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Brackets, Repository, IsNull } from 'typeorm';
+import { BaseRepository } from '../common/base.repository';
+import { UserEntity } from './entities/user.entity';
+import { QueryUsersDto } from './dto/query-users.dto';
+import { buildPaginationMeta } from '../common/utils/pagination.utils';
+
+@Injectable()
+export class UsersRepository extends BaseRepository<UserEntity> {
+  constructor(
+    @InjectRepository(UserEntity)
+    repository: Repository<UserEntity>,
+  ) {
+    super(repository);
+  }
+
+  async findById(id: string): Promise<UserEntity | null> {
+    if (!id) {
+      return null;
+    }
+    return this.repo.findOne({
+      where: { id, deletedAt: IsNull() },
+    });
+  }
+
+  async findAll(): Promise<UserEntity[]> {
+    return this.repo.find({
+      where: { deletedAt: IsNull() },
+      order: { createdAt: 'DESC' },
+    });
+  }
+
+  async findAndCountUsers(queryUsersDto: QueryUsersDto) {
+    const { page, limit, sortBy, sortOrder, search } = queryUsersDto;
+
+    const queryBuilder = this.repo.createQueryBuilder('user');
+
+    if (search) {
+      queryBuilder.andWhere(
+        new Brackets((qb) => {
+          qb.where('user.name ILIKE :search', {
+            search: `%${search}%`,
+          }).orWhere('user.email ILIKE :search', { search: `%${search}%` });
+        }),
+      );
+    }
+
+    queryBuilder.orderBy(`user.${sortBy}`, sortOrder);
+
+    const offset = (page - 1) * limit;
+    queryBuilder.skip(offset).take(limit);
+
+    const [users, totalItems] = await queryBuilder.getManyAndCount();
+
+    return {
+      data: users,
+      meta: buildPaginationMeta(totalItems, page, limit, users.length),
+    };
+  }
+}

package/templates/nest/src/user/user.service.ts

@@ -0,0 +1,138 @@
+import {
+  BadRequestException,
+  Injectable,
+  InternalServerErrorException,
+  NotFoundException,
+} from '@nestjs/common';
+import { ERRORS } from '../common/constants/errors.constants';
+import { UserEntity } from './entities/user.entity';
+import * as bcrypt from 'bcryptjs';
+import { CreateUserDto } from './dto/create-user.dto';
+import { ConfigService } from '@nestjs/config';
+import { QueryUsersDto } from './dto/query-users.dto';
+import { UsersRepository } from './user.repository';
+import { BaseService } from '../common/base.service';
+import { UpdateUserDto } from './dto/update-user.dto';
+
+@Injectable()
+export class UserService extends BaseService<UserEntity> {
+  constructor(
+    private usersRepository: UsersRepository,
+    private configService: ConfigService,
+  ) {
+    super(usersRepository);
+  }
+
+  async create(newUser: CreateUserDto): Promise<UserEntity> {
+    const existingUser = await this.findOneByEmail(newUser.email);
+
+    if (existingUser) {
+      throw new BadRequestException(
+        `${ERRORS.USER.EMAIL_IN_USE} (Email: ${newUser.email})`,
+      );
+    }
+
+    const defaultPassword = this.configService.get<string>('DEFAULT_PASSWORD');
+    if (!defaultPassword) {
+      throw new InternalServerErrorException(
+        ERRORS.USER.DEFAULT_PASSWORD_NOT_SET,
+      );
+    }
+
+    const hashedPassword = await bcrypt.hash(defaultPassword, 12);
+
+    return super.create({
+      ...newUser,
+      password: hashedPassword,
+      mustChangePassword: true,
+    });
+  }
+
+  async updateProfile(
+    id: string,
+    updateUserDto: UpdateUserDto,
+  ): Promise<UserEntity | null> {
+    const user = await this.usersRepository.findById(id);
+    if (!user) {
+      throw new NotFoundException(ERRORS.USER.NOT_FOUND);
+    }
+
+    const dataToUpdate: UpdateUserDto = { ...updateUserDto };
+    Object.assign(user, dataToUpdate);
+
+    return this.usersRepository.repo.save(user);
+  }
+
+  async findAndCountUsers(queryUsersDto: QueryUsersDto) {
+    return this.usersRepository.findAndCountUsers(queryUsersDto);
+  }
+
+  async findOneByEmail(email: string): Promise<UserEntity | null> {
+    return this.usersRepository.repo.findOne({
+      where: { email: email },
+      select: ['id', 'email', 'name', 'isActive', 'role', 'mustChangePassword'],
+    });
+  }
+
+  async findOneByEmailWithPassword(email: string): Promise<UserEntity | null> {
+    return this.usersRepository.repo.findOne({
+      where: { email },
+      select: [
+        'id',
+        'email',
+        'name',
+        'isActive',
+        'role',
+        'mustChangePassword',
+        'password',
+        'deletedAt',
+      ],
+    });
+  }
+
+  async findOneByIdWithPassword(id: string): Promise<UserEntity | null> {
+    return this.usersRepository.repo.findOne({
+      where: { id },
+      select: ['id', 'email', 'name', 'password', 'mustChangePassword'],
+    });
+  }
+
+  async comparePassword(plainPassword: string, hash: string): Promise<boolean> {
+    return bcrypt.compare(plainPassword, hash);
+  }
+
+  async updatePassword(id: string, newPasswordHash: string): Promise<void> {
+    await this.update(id, { password: newPasswordHash });
+  }
+
+  async resetPasswordByAdmin(id: string): Promise<{ message: string }> {
+    const user = await this.findById(id);
+
+    if (!user) throw new NotFoundException(ERRORS.USER.NOT_FOUND);
+
+    const defaultPassword = this.configService.get<string>('DEFAULT_PASSWORD');
+    if (!defaultPassword)
+      throw new InternalServerErrorException(
+        ERRORS.USER.DEFAULT_PASSWORD_NOT_SET,
+      );
+
+    const hashedPassword = await bcrypt.hash(defaultPassword, 12);
+
+    await this.update(id, {
+      password: hashedPassword,
+      mustChangePassword: true,
+    });
+
+    return {
+      message: `A senha do usuário ${user.name} foi resetada com sucesso`,
+    };
+  }
+
+  async disableMustChangePasswordFlag(id: string): Promise<void> {
+    await this.update(id, { mustChangePassword: false });
+  }
+
+  async delete(id: string): Promise<void> {
+    await this.usersRepository.repo.softDelete(id);
+  }
+}

package/templates/nest/template.json

@@ -0,0 +1,5 @@
+{
+  "label": "NestJS",
+  "description": "Backend Node.js com TypeScript, TypeORM, JWT Auth",
+  "installCmd": "npm install"
+}

package/templates/nest/test/jest-e2e.json

@@ -0,0 +1,12 @@
+{
+  "moduleFileExtensions": ["js", "json", "ts"],
+  "rootDir": ".",
+  "testEnvironment": "node",
+  "testRegex": ".e2e-spec.ts$",
+  "transform": {
+    "^.+\\.(t|j)s$": "ts-jest"
+  },
+  "moduleNameMapper": {
+    "^src/(.*)$": "<rootDir>/../src/$1"
+  }
+}

package/templates/nest/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["node_modules", "test", "dist", "addons", "**/*spec.ts"]
+}

package/templates/nest/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "resolvePackageJsonExports": true,
+    "esModuleInterop": true,
+    "isolatedModules": true,
+    "declaration": true,
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "allowSyntheticDefaultImports": true,
+    "target": "ES2023",
+    "sourceMap": true,
+    "outDir": "./dist",
+    "baseUrl": "./",
+    "incremental": true,
+    "skipLibCheck": true,
+    "strictNullChecks": true,
+    "forceConsistentCasingInFileNames": true,
+    "noImplicitAny": false,
+    "strictBindCallApply": false,
+    "noFallthroughCasesInSwitch": false
+  }
+}

package/templates/python/.env.example

@@ -0,0 +1,37 @@
+# Configurações do Postgres - Docker (OBRIGATÓRIAS)
+POSTGRES_USER=postgres
+POSTGRES_PASSWORD=docker
+POSTGRES_DB=innovationhub
+
+# Configurações do Banco de Dados
+DATABASE_HOST=postgres
+DATABASE_PORT=5432
+DATABASE_USERNAME=postgres
+DATABASE_PASSWORD=docker
+DATABASE_NAME=innovationhub
+DATABASE_SSL=false
+
+# Configurações JWT
+JWT_SECRET=codigo-longo-aqui
+JWT_EXPIRATION_MINUTES=15
+JWT_REFRESH_SECRET=outro-codigo-longo-aqui
+JWT_REFRESH_EXPIRATION_DAYS=7
+
+# Senha padrão para novos usuários criados pelo admin ou para reset de senha
+DEFAULT_PASSWORD=ih123
+
+# variavel de ambiente para configuração do CORS
+CORS_ORIGIN=http://localhost:3001
+
+# Configurações do Cloudinary
+CLOUDINARY_CLOUD_NAME=####SEU_NOME_DE_NUVEM_DO_CLOUDINARY####
+CLOUDINARY_API_KEY=####SUA_CHAVE_DE_API_DO_CLOUDINARY####
+CLOUDINARY_API_SECRET=####SUA_CHAVE_SECRETA_DO_CLOUDINARY####
+
+# Serviço de email
+MAIL_HOST=smtp.gmail.com
+MAIL_PORT=587
+MAIL_USER=noreply@innovationhub.com
+MAIL_PASSWORD=#xxxx_xxxx_xxxx_xxxx
+MAIL_FROM="Innovation Hub <noreply@innovationhub.com>"
+MAIL_DESTINATION=innovationhub@gmail.com

package/templates/python/Dockerfile

@@ -0,0 +1,18 @@
+FROM python:3.11-slim AS base
+WORKDIR /app
+
+COPY pyproject.toml ./
+RUN pip install --no-cache-dir .
+
+FROM base AS production
+WORKDIR /app
+COPY --from=base /usr/local /usr/local
+COPY . .
+RUN alembic upgrade head || true
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "3000"]
+
+FROM base AS development
+WORKDIR /app
+COPY --from=base /usr/local /usr/local
+COPY . .
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "3000", "--reload"]