innovationhub-cli 1.1.0 → 2.0.1

package/templates/nest/src/auth/entities/refresh-token.entity.ts

@@ -0,0 +1,18 @@
+import { BaseEntity } from '../../common/base.entity';
+import { UserEntity } from '../../user/entities/user.entity';
+import { Entity, Column, ManyToOne } from 'typeorm';
+
+@Entity('refresh_tokens')
+export class RefreshTokenEntity extends BaseEntity {
+  @Column({ unique: true })
+  public jti: string;
+
+  @Column()
+  public hashedToken: string;
+
+  @ManyToOne(() => UserEntity, (user) => user.refreshTokens)
+  public user: UserEntity;
+
+  @Column({ default: false })
+  public isRevoked: boolean;
+}

package/templates/nest/src/auth/enums/role.enum.ts

@@ -0,0 +1,4 @@
+export enum Role {
+  User = 'user',
+  Admin = 'admin',
+}

package/templates/nest/src/auth/guards/jwt-auth.guard.ts

@@ -0,0 +1,5 @@
+import { Injectable } from '@nestjs/common';
+import { AuthGuard } from '@nestjs/passport';
+
+@Injectable()
+export class JwtAuthGuard extends AuthGuard('jwt') {}

package/templates/nest/src/auth/guards/refresh-token.guard.ts

@@ -0,0 +1,5 @@
+import { Injectable } from '@nestjs/common';
+import { AuthGuard } from '@nestjs/passport';
+
+@Injectable()
+export class RefreshTokenGuard extends AuthGuard('jwt-refresh') {}

package/templates/nest/src/auth/guards/roles.guard.ts

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

package/templates/nest/src/auth/interfaces/jwt-payload.interface.ts

@@ -0,0 +1,10 @@
+export interface JwtPayload {
+  sub: string;
+  email: string;
+  role: string;
+  jti?: string;
+}
+
+export interface RefreshTokenPayload extends JwtPayload {
+  jti: string;
+}

package/templates/nest/src/auth/strategies/jwt.strategy.ts

@@ -0,0 +1,28 @@
+import { Injectable, UnauthorizedException } from '@nestjs/common';
+import { ERRORS } from '../../common/constants/errors.constants';
+import { PassportStrategy } from '@nestjs/passport';
+import { Strategy, ExtractJwt } from 'passport-jwt';
+import { ConfigService } from '@nestjs/config';
+import { UserService } from '../../user/user.service';
+
+@Injectable()
+export class JwtStrategy extends PassportStrategy(Strategy) {
+  constructor(
+    private configService: ConfigService,
+    private userService: UserService,
+  ) {
+    super({
+      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
+      ignoreExpiration: false,
+      secretOrKey: configService.getOrThrow<string>('JWT_SECRET'),
+    });
+  }
+  async validate(payload: { sub: string; email: string }) {
+    const user = await this.userService.findById(payload.sub);
+
+    if (!user) {
+      throw new UnauthorizedException(ERRORS.AUTH.INVALID_TOKEN);
+    }
+    return user;
+  }
+}

package/templates/nest/src/auth/strategies/local.strategy.ts

@@ -0,0 +1,23 @@
+import { Injectable, UnauthorizedException } from '@nestjs/common';
+import { ERRORS } from '../../common/constants/errors.constants';
+import { PassportStrategy } from '@nestjs/passport';
+import { Strategy } from 'passport-local';
+import { AuthService } from '../auth.service';
+import { UserEntity } from '../../user/entities/user.entity';
+
+@Injectable()
+export class LocalStrategy extends PassportStrategy(Strategy) {
+  constructor(private authService: AuthService) {
+    super({
+      usernameField: 'email',
+    });
+  }
+  async validate(email: string, password: string): Promise<UserEntity> {
+    const user = await this.authService.validateUser(email, password);
+
+    if (!user) {
+      throw new UnauthorizedException(ERRORS.AUTH.INVALID_CREDENTIALS);
+    }
+    return user;
+  }
+}

package/templates/nest/src/auth/strategies/refresh-token.strategy.ts

@@ -0,0 +1,32 @@
+import { Injectable } from '@nestjs/common';
+import { PassportStrategy } from '@nestjs/passport';
+import { ExtractJwt, Strategy } from 'passport-jwt';
+import { Request } from 'express';
+import { ConfigService } from '@nestjs/config';
+import {
+  JwtPayload,
+  RefreshTokenPayload,
+} from '../interfaces/jwt-payload.interface';
+
+@Injectable()
+export class RefreshTokenStrategy extends PassportStrategy(
+  Strategy,
+  'jwt-refresh',
+) {
+  constructor(private readonly configService: ConfigService) {
+    super({
+      jwtFromRequest: ExtractJwt.fromBodyField('refreshToken'),
+      secretOrKey: configService.getOrThrow<string>('JWT_REFRESH_SECRET'),
+      passReqToCallback: true,
+    });
+  }
+
+  validate(
+    req: Request,
+    payload: JwtPayload,
+  ): RefreshTokenPayload & { refreshToken: string } {
+    const body = req.body as { refreshToken: string };
+    const refreshToken = body.refreshToken;
+    return { ...payload, refreshToken, jti: payload.jti! };
+  }
+}

package/templates/nest/src/common/base.entity.ts

@@ -0,0 +1,19 @@
+import {
+  BaseEntity as TypeOrmBaseEntity,
+  PrimaryGeneratedColumn,
+  CreateDateColumn,
+  UpdateDateColumn,
+} from 'typeorm';
+import { Expose } from 'class-transformer';
+
+export abstract class BaseEntity extends TypeOrmBaseEntity {
+  @Expose()
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @CreateDateColumn()
+  createdAt: Date;
+
+  @UpdateDateColumn()
+  updatedAt: Date;
+}

package/templates/nest/src/common/base.repository.ts

@@ -0,0 +1,79 @@
+import {
+  DeepPartial,
+  FindOptionsOrder,
+  Repository,
+  FindManyOptions,
+  FindOptionsWhere,
+} from 'typeorm';
+import { QueryDeepPartialEntity } from 'typeorm/query-builder/QueryPartialEntity';
+import { BaseEntity } from './base.entity';
+import { IRepository } from './irepository';
+import { buildPaginationMeta, PaginatedResult } from './utils/pagination.utils';
+
+export abstract class BaseRepository<
+  T extends BaseEntity,
+> implements IRepository<T> {
+  constructor(protected readonly repository: Repository<T>) {}
+
+  public get repo(): Repository<T> {
+    return this.repository;
+  }
+
+  async findAll(): Promise<T[]> {
+    return this.repository.find({
+      order: { createdAt: 'DESC' } as FindOptionsOrder<T>,
+    });
+  }
+
+  async findById(id: string): Promise<T | null> {
+    if (!id) {
+      return null;
+    }
+    return this.repository.findOneBy({ id } as FindOptionsWhere<T>);
+  }
+
+  async save(entity: T): Promise<T> {
+    return this.repository.save(entity);
+  }
+
+  async create(data: DeepPartial<T>): Promise<T> {
+    const entity = this.repository.create(data);
+    return this.repository.save(entity);
+  }
+
+  createInstance(data: DeepPartial<T>): T {
+    return this.repository.create(data);
+  }
+
+  async update(id: string, data: QueryDeepPartialEntity<T>): Promise<T | null> {
+    if (!id) {
+      return null;
+    }
+    await this.repository.update(id, data);
+    return this.findById(id);
+  }
+
+  async delete(id: string): Promise<void> {
+    if (!id) {
+      return;
+    }
+    await this.repository.delete(id);
+  }
+
+  async findAllPaginated(
+    options: FindManyOptions<T>,
+    meta: { page: number; limit: number },
+  ): Promise<PaginatedResult<T>> {
+    const { page, limit } = meta;
+    const [data, totalItems] = await this.repository.findAndCount({
+      ...options,
+      skip: (page - 1) * limit,
+      take: limit,
+    });
+
+    return {
+      data,
+      meta: buildPaginationMeta(totalItems, page, limit, data.length),
+    };
+  }
+}

package/templates/nest/src/common/base.service.ts

@@ -0,0 +1,28 @@
+import { DeepPartial } from 'typeorm';
+import { QueryDeepPartialEntity } from 'typeorm/query-builder/QueryPartialEntity';
+import { BaseEntity } from './base.entity';
+import { IRepository } from './irepository';
+
+export abstract class BaseService<T extends BaseEntity> {
+  constructor(private readonly repository: IRepository<T>) {}
+
+  async findAll(): Promise<T[]> {
+    return this.repository.findAll();
+  }
+
+  async findById(id: string): Promise<T | null> {
+    return this.repository.findById(id);
+  }
+
+  async create(data: DeepPartial<T>): Promise<T> {
+    return this.repository.create(data);
+  }
+
+  async update(id: string, data: QueryDeepPartialEntity<T>): Promise<T | null> {
+    return this.repository.update(id, data);
+  }
+
+  async delete(id: string): Promise<void> {
+    return this.repository.delete(id);
+  }
+}

package/templates/nest/src/common/constants/errors.constants.ts

@@ -0,0 +1,33 @@
+export const ERRORS = {
+  AUTH: {
+    NOT_FOUND: 'Usuário não encontrado.',
+    INVALID_TOKEN: 'Token inválido.',
+    ACCESS_DENIED: 'Acesso negado',
+    EMAIL_IN_USE: 'O e-mail já está em uso.',
+    INVALID_CREDENTIALS:
+      'E-mail ou senha inválidos. Por favor, verifique seus dados e tente novamente.',
+    ACCOUNT_DELETED:
+      'Sua conta foi excluída. Por favor, entre em contato com o suporte.',
+    ACCOUNT_DISABLED:
+      'Sua conta está desativada. Por favor, entre em contato com o suporte.',
+    OLD_PASSWORD_INCORRECT: 'A senha antiga está incorreta. Tente novamente.',
+    PASSWORD_SAME_AS_OLD:
+      'A nova senha deve ser diferente da senha antiga. Por favor, escolha uma nova senha.',
+    PASSWORD_MIN_LENGTH: 'A nova senha deve ter no mínimo 8 caracteres.',
+    PASSWORD_CHANGED: 'Senha alterada com sucesso.',
+  },
+  USER: {
+    NOT_FOUND: 'Usuário não encontrado.',
+    EMAIL_IN_USE: 'O e-mail já está em uso.',
+    DEFAULT_PASSWORD_NOT_SET:
+      'Variável de ambiente DEFAULT_PASSWORD não configurada.',
+  },
+  IMAGE: {
+    REQUIRED: 'O arquivo de imagem é obrigatório.',
+  },
+  COMMON: {
+    NOT_FOUND: 'Recurso não encontrado.',
+    BAD_REQUEST: 'Requisição inválida.',
+    INVALID_ARRAY_FORMAT: 'Formato de array inválido.',
+  },
+};

package/templates/nest/src/common/decorators/user.decorator.ts

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

package/templates/nest/src/common/dto/base-query.dto.ts

@@ -0,0 +1,56 @@
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { Transform, Type } from 'class-transformer';
+import { IsInt, IsOptional, IsString, Max, Min, IsIn } from 'class-validator';
+
+export class BaseQueryDto {
+  @ApiPropertyOptional({
+    description: 'Número da página que deseja buscar.',
+    default: 1,
+    minimum: 1,
+  })
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt()
+  @Min(1)
+  page: number = 1;
+
+  @ApiPropertyOptional({
+    description: 'Quantidade de itens por página.',
+    default: 10,
+    minimum: 1,
+    maximum: 100,
+  })
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt()
+  @Min(1)
+  @Max(100)
+  limit: number = 10;
+
+  @ApiPropertyOptional({
+    description: 'Termo de busca.',
+    example: 'termo',
+  })
+  @IsOptional()
+  @IsString()
+  search?: string;
+
+  @ApiPropertyOptional({
+    description: 'Coluna pela qual os resultados serão ordenados.',
+    default: 'createdAt',
+  })
+  @IsOptional()
+  @IsString()
+  sortBy?: string = 'createdAt';
+
+  @ApiPropertyOptional({
+    description: 'Ordem da classificação (ascendente ou descendente).',
+    default: 'DESC',
+    enum: ['ASC', 'DESC'],
+  })
+  @IsOptional()
+  @IsString()
+  @Transform(({ value }: { value: string }) => value.toUpperCase())
+  @IsIn(['ASC', 'DESC'])
+  sortOrder?: 'ASC' | 'DESC' = 'DESC';
+}

package/templates/nest/src/common/irepository.ts

@@ -0,0 +1,18 @@
+import { DeepPartial, FindManyOptions } from 'typeorm';
+import { QueryDeepPartialEntity } from 'typeorm/query-builder/QueryPartialEntity';
+import { BaseEntity } from './base.entity';
+import { PaginatedResult } from './utils/pagination.utils';
+
+export interface IRepository<T extends BaseEntity> {
+  findAll(): Promise<T[]>;
+  findById(id: string): Promise<T | null>;
+  save(entity: T): Promise<T>;
+  create(data: DeepPartial<T>): Promise<T>;
+  createInstance(data: DeepPartial<T>): T;
+  update(id: string, data: QueryDeepPartialEntity<T>): Promise<T | null>;
+  delete(id: string): Promise<void>;
+  findAllPaginated(
+    options: FindManyOptions<T>,
+    meta: { page: number; limit: number },
+  ): Promise<PaginatedResult<T>>;
+}

package/templates/nest/src/common/utils/duration.utils.ts

@@ -0,0 +1,33 @@
+export function parseDurationToSeconds(
+  value: string | number | undefined,
+  defaultSeconds: number,
+): number {
+  if (value === undefined || value === null) {
+    return defaultSeconds;
+  }
+  if (typeof value === 'number') {
+    return value;
+  }
+
+  const trimmed = (value || '').toString().trim();
+  const match = /^(\d+)\s*(s|m|h|d)?$/i.exec(trimmed);
+  if (!match) {
+    return defaultSeconds;
+  }
+
+  const amount = parseInt(match[1], 10);
+  const unit = (match[2] || 's').toLowerCase();
+
+  switch (unit) {
+    case 's':
+      return amount;
+    case 'm':
+      return amount * 60;
+    case 'h':
+      return amount * 60 * 60;
+    case 'd':
+      return amount * 60 * 60 * 24;
+    default:
+      return defaultSeconds;
+  }
+}

package/templates/nest/src/common/utils/pagination.utils.ts

@@ -0,0 +1,35 @@
+export interface PaginationMeta {
+  totalItems: number;
+  itemCount: number;
+  itemsPerPage: number;
+  totalPages: number;
+  currentPage: number;
+}
+
+export interface PaginatedResult<T> {
+  data: T[];
+  meta: PaginationMeta;
+}
+
+/**
+ * Constrói o objeto de metadados de paginação.
+ *
+ * @param totalItems - Total de registros no banco
+ * @param page - Página atual
+ * @param limit - Itens por página
+ * @param itemCount - Quantidade de itens retornados nesta página
+ */
+export function buildPaginationMeta(
+  totalItems: number,
+  page: number,
+  limit: number,
+  itemCount: number,
+): PaginationMeta {
+  return {
+    totalItems,
+    itemCount,
+    itemsPerPage: limit,
+    totalPages: Math.ceil(totalItems / limit),
+    currentPage: page,
+  };
+}

package/templates/nest/src/common/utils/slug.utils.ts

@@ -0,0 +1,14 @@
+export function createSlug(title: string): string {
+  let slug = title
+    .toLowerCase()
+    .normalize('NFD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/(^-|-$)+/g, '');
+
+  if (slug.length > 50) {
+    slug = slug.substring(0, 50).replace(/-$/, '');
+  }
+
+  return slug;
+}

package/templates/nest/src/common/utils/transform.utils.ts

@@ -0,0 +1,62 @@
+import { BadRequestException } from '@nestjs/common';
+import { ERRORS } from '../constants/errors.constants';
+
+export function parseJSON<T = unknown>(value: unknown): T {
+  if (typeof value === 'string') {
+    if (value.trim() === '') {
+      return undefined as T;
+    }
+
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+      return JSON.parse(value);
+    } catch {
+      throw new BadRequestException(ERRORS.COMMON.BAD_REQUEST);
+    }
+  }
+  return value as T;
+}
+
+export function parseBoolean(value: unknown): boolean {
+  if (value === 'false' || value === false) return false;
+  return true;
+}
+
+export function parseStringArray(value: unknown): string[] {
+  if (value === undefined || value === null || value === '') return [];
+
+  if (Array.isArray(value)) {
+    return value.map(String).filter((s) => s.trim().length > 0);
+  }
+
+  if (typeof value === 'number') {
+    return [String(value)];
+  }
+
+  if (typeof value === 'string') {
+    const trimmed = value.trim();
+    if (!trimmed) return [];
+
+    if (trimmed.startsWith('[')) {
+      try {
+        const parsed = JSON.parse(trimmed) as unknown;
+        if (Array.isArray(parsed)) {
+          return parsed.map(String).filter((s) => s.trim().length > 0);
+        }
+      } catch {
+        throw new BadRequestException(ERRORS.COMMON.INVALID_ARRAY_FORMAT);
+      }
+    }
+
+    if (trimmed.includes(',')) {
+      return trimmed
+        .split(',')
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+    }
+
+    return [trimmed];
+  }
+
+  return [];
+}

package/templates/nest/src/common/validators/is-date-after.validator.ts

@@ -0,0 +1,40 @@
+import {
+  registerDecorator,
+  ValidationOptions,
+  ValidationArguments,
+} from 'class-validator';
+
+export function IsDateAfter(
+  property: string,
+  validationOptions?: ValidationOptions,
+) {
+  return function (object: object, propertyName: string) {
+    registerDecorator({
+      name: 'isDateAfter',
+      target: object.constructor,
+      propertyName: propertyName,
+      constraints: [property],
+      options: validationOptions,
+      validator: {
+        validate(value: any, args: ValidationArguments) {
+          const [relatedPropertyName] = args.constraints as string[];
+          const relatedValue = (args.object as Record<string, unknown>)[
+            relatedPropertyName
+          ];
+
+          if (!value || !relatedValue) {
+            return true;
+          }
+
+          const startDate = new Date(relatedValue as string | number | Date);
+          const endDate = new Date(value as string | number | Date);
+
+          return endDate >= startDate;
+        },
+        defaultMessage() {
+          return `A data de término deve ser maior ou igual à data de início`;
+        },
+      },
+    });
+  };
+}

package/templates/nest/src/data-source.ts

@@ -0,0 +1,23 @@
+import { DataSource } from 'typeorm';
+import * as dotenv from 'dotenv';
+
+dotenv.config();
+
+export default new DataSource({
+  type: 'postgres',
+  host: process.env.DATABASE_HOST,
+  port: Number(process.env.DATABASE_PORT),
+  username: process.env.DATABASE_USERNAME,
+  password: process.env.DATABASE_PASSWORD,
+  database: process.env.DATABASE_NAME,
+  entities: [__dirname + '/**/*.entity{.ts,.js}'],
+  migrations: ['src/migrations/*.ts'],
+  migrationsTableName: 'migrations',
+  synchronize: false,
+  ssl:
+    process.env.DATABASE_SSL === 'true'
+      ? {
+          rejectUnauthorized: false,
+        }
+      : false,
+});

package/templates/nest/src/main.ts

@@ -0,0 +1,44 @@
+import { NestFactory, Reflector } from '@nestjs/core';
+import { AppModule } from './app.module';
+import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
+import { ConfigService } from '@nestjs/config';
+import { ClassSerializerInterceptor, ValidationPipe } from '@nestjs/common';
+import { useContainer } from 'class-validator';
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+  const configService = app.get(ConfigService);
+
+  app.useGlobalPipes(new ValidationPipe({ transform: true, whitelist: true }));
+  app.useGlobalInterceptors(new ClassSerializerInterceptor(app.get(Reflector)));
+
+  useContainer(app.select(AppModule), { fallbackOnErrors: true });
+
+  const corsOrigin = configService.get<string>('CORS_ORIGIN');
+  const origins = corsOrigin ? corsOrigin.split(',') : [];
+
+  app.enableCors({
+    origin: origins,
+    methods: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS'],
+    allowedHeaders: ['Content-Type', 'Authorization'],
+    credentials: true,
+  });
+
+  const config = new DocumentBuilder()
+    .setTitle('API da Landing Page/Blog')
+    .setDescription(
+      'Documentação da API do backend (NestJS) para Autenticação e Blog.',
+    )
+    .setVersion('1.0')
+    .addSecurity('bearer', {
+      type: 'http',
+      scheme: 'bearer',
+    })
+    .addSecurityRequirements('bearer')
+    .build();
+
+  const document = SwaggerModule.createDocument(app, config);
+  SwaggerModule.setup('api/docs', app, document);
+  await app.listen(process.env.PORT ?? 3000, '0.0.0.0');
+}
+void bootstrap();