nestforge-generator 0.1.0

package/templates/typeorm/src/auth/auth.service.ts

@@ -0,0 +1,346 @@
+import {
+  ConflictException,
+  Injectable,
+  UnauthorizedException,
+} from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import {
+  DataSource,
+  IsNull,
+  Repository,
+} from 'typeorm';
+import * as bcrypt from 'bcryptjs';
+import { createHash, randomBytes } from 'crypto';
+import { UserEntity } from '../users/entities/user.entity';
+import { OAuthAccountEntity } from './entities/oauth-account.entity';
+
+// nestforge:feature:auth:token
+import { RefreshTokenEntity } from './entities/refresh-token.entity';
+// nestforge:feature:auth:token:end
+
+// nestforge:feature:redis,auth:password
+import { MailService } from '../mail/mail.service';
+import { PasswordResetTokenEntity } from './entities/password-reset-token.entity';
+import { EmailVerificationTokenEntity } from './entities/email-verification-token.entity';
+// nestforge:feature:redis,auth:password:end
+
+// nestforge:feature:auth:password
+import { RegisterDto } from './dto/register.dto';
+import { LoginDto } from './dto/login.dto';
+// nestforge:feature:auth:password:end
+
+import { OAuthProfile } from './strategies/google.strategy';
+
+@Injectable()
+export class AuthService {
+  constructor(
+    @InjectRepository(UserEntity)
+    private readonly usersRepository: Repository<UserEntity>,
+
+    @InjectRepository(OAuthAccountEntity)
+    private readonly oauthAccountsRepository: Repository<OAuthAccountEntity>,
+
+    private readonly dataSource: DataSource,
+
+    // nestforge:feature:redis,auth:password
+    @InjectRepository(PasswordResetTokenEntity)
+    private readonly passwordResetTokensRepository: Repository<PasswordResetTokenEntity>,
+
+    @InjectRepository(EmailVerificationTokenEntity)
+    private readonly emailVerificationTokensRepository: Repository<EmailVerificationTokenEntity>,
+
+    private readonly mailService: MailService,
+    // nestforge:feature:redis,auth:password:end
+  ) { }
+
+  // nestforge:feature:auth:password
+  async register(dto: RegisterDto) {
+    const existing = await this.usersRepository.findOne({
+      where: { email: dto.email },
+    });
+
+    if (existing) {
+      throw new ConflictException('E-mail já cadastrado');
+    }
+
+    const passwordHash = await bcrypt.hash(dto.password, 10);
+
+    const user = this.usersRepository.create({
+      name: dto.name,
+      email: dto.email,
+      passwordHash,
+    });
+
+    const savedUser = await this.usersRepository.save(user);
+
+    // nestforge:feature:redis
+    await this.sendEmailVerification(
+      savedUser.id,
+      savedUser.email,
+      savedUser.name,
+    );
+    // nestforge:feature:redis:end
+
+    return this.toAuthenticatedUser(savedUser);
+  }
+
+  async login(dto: LoginDto) {
+    const user = await this.usersRepository.findOne({
+      where: { email: dto.email },
+    });
+
+    if (!user || !user.passwordHash) {
+      throw new UnauthorizedException(
+        'Credenciais inválidas',
+      );
+    }
+
+    const passwordMatches = await bcrypt.compare(
+      dto.password,
+      user.passwordHash,
+    );
+
+    if (!passwordMatches) {
+      throw new UnauthorizedException(
+        'Credenciais inválidas',
+      );
+    }
+
+    return this.toAuthenticatedUser(user);
+  }
+  // nestforge:feature:auth:password:end
+
+  async validateOAuthLogin(profile: OAuthProfile) {
+    const linkedAccount =
+      await this.oauthAccountsRepository.findOne({
+        where: {
+          provider: profile.provider,
+          providerUserId: profile.providerUserId,
+        },
+        relations: {
+          user: true,
+        },
+      });
+
+    if (linkedAccount) {
+      return this.toAuthenticatedUser(
+        linkedAccount.user,
+      );
+    }
+
+    let user = await this.usersRepository.findOne({
+      where: { email: profile.email },
+    });
+
+    if (!user) {
+      const newUser = this.usersRepository.create({
+        name: profile.name,
+        email: profile.email,
+        emailVerifiedAt: new Date(),
+      });
+
+      user = await this.usersRepository.save(newUser);
+    }
+
+    const oauthAccount =
+      this.oauthAccountsRepository.create({
+        provider: profile.provider,
+        providerUserId: profile.providerUserId,
+        userId: user.id,
+      });
+
+    await this.oauthAccountsRepository.save(
+      oauthAccount,
+    );
+
+    return this.toAuthenticatedUser(user);
+  }
+
+  // nestforge:feature:redis,auth:password
+  async forgotPassword(email: string) {
+    const user = await this.usersRepository.findOne({
+      where: { email },
+    });
+
+    const genericResponse = {
+      message:
+        'Se o e-mail existir, enviaremos instruções de redefinição de senha',
+    };
+
+    if (!user) {
+      return genericResponse;
+    }
+
+    const rawToken = randomBytes(32).toString('hex');
+    const expiresAt = new Date();
+
+    expiresAt.setHours(expiresAt.getHours() + 1);
+
+    const resetToken =
+      this.passwordResetTokensRepository.create({
+        tokenHash: this.hashToken(rawToken),
+        userId: user.id,
+        expiresAt,
+        usedAt: null,
+      });
+
+    await this.passwordResetTokensRepository.save(
+      resetToken,
+    );
+
+    await this.mailService.queuePasswordResetEmail(
+      user.email,
+      user.name,
+      rawToken,
+    );
+
+    return genericResponse;
+  }
+
+  async resetPassword(
+    rawToken: string,
+    newPassword: string,
+  ) {
+    const tokenHash = this.hashToken(rawToken);
+
+    const stored =
+      await this.passwordResetTokensRepository.findOne({
+        where: { tokenHash },
+      });
+
+    if (
+      !stored ||
+      stored.usedAt ||
+      stored.expiresAt < new Date()
+    ) {
+      throw new UnauthorizedException(
+        'Token de redefinição inválido ou expirado',
+      );
+    }
+
+    const passwordHash = await bcrypt.hash(
+      newPassword,
+      10,
+    );
+
+    await this.dataSource.transaction(
+      async (manager) => {
+        await manager.update(
+          UserEntity,
+          { id: stored.userId },
+          { passwordHash },
+        );
+
+        await manager.update(
+          PasswordResetTokenEntity,
+          { id: stored.id },
+          { usedAt: new Date() },
+        );
+
+        // nestforge:feature:auth:token
+        await manager.update(
+          RefreshTokenEntity,
+          {
+            userId: stored.userId,
+            revokedAt: IsNull(),
+          },
+          {
+            revokedAt: new Date(),
+          },
+        );
+        // nestforge:feature:auth:token:end
+      },
+    );
+
+    return {
+      message: 'Senha redefinida com sucesso',
+    };
+  }
+
+  async verifyEmail(rawToken: string) {
+    const tokenHash = this.hashToken(rawToken);
+
+    const stored =
+      await this.emailVerificationTokensRepository.findOne({
+        where: { tokenHash },
+      });
+
+    if (
+      !stored ||
+      stored.usedAt ||
+      stored.expiresAt < new Date()
+    ) {
+      throw new UnauthorizedException(
+        'Token de verificação inválido ou expirado',
+      );
+    }
+
+    await this.dataSource.transaction(
+      async (manager) => {
+        await manager.update(
+          UserEntity,
+          { id: stored.userId },
+          { emailVerifiedAt: new Date() },
+        );
+
+        await manager.update(
+          EmailVerificationTokenEntity,
+          { id: stored.id },
+          { usedAt: new Date() },
+        );
+      },
+    );
+
+    return {
+      message: 'E-mail verificado com sucesso',
+    };
+  }
+
+  private async sendEmailVerification(
+    userId: string,
+    email: string,
+    name: string,
+  ) {
+    const rawToken = randomBytes(32).toString('hex');
+    const expiresAt = new Date();
+
+    expiresAt.setHours(expiresAt.getHours() + 24);
+
+    const verificationToken =
+      this.emailVerificationTokensRepository.create({
+        tokenHash: this.hashToken(rawToken),
+        userId,
+        expiresAt,
+        usedAt: null,
+      });
+
+    await this.emailVerificationTokensRepository.save(
+      verificationToken,
+    );
+
+    await this.mailService.queueVerificationEmail(
+      email,
+      name,
+      rawToken,
+    );
+  }
+  // nestforge:feature:redis,auth:password:end
+
+  private toAuthenticatedUser(user: {
+    id: string;
+    email: string;
+    role: string;
+  }) {
+    return {
+      id: user.id,
+      email: user.email,
+      role: user.role,
+    };
+  }
+
+  private hashToken(token: string): string {
+    return createHash('sha256')
+      .update(token)
+      .digest('hex');
+  }
+}

package/templates/typeorm/src/auth/dto/forgot-password.dto.ts

@@ -0,0 +1,9 @@
+// nestforge:feature-file:redis,auth:password
+import { z } from 'zod';
+import { createZodDto } from 'nestjs-zod';
+
+export const forgotPasswordSchema = z.object({
+    email: z.string().email().describe('E-mail da conta a ser recuperada'),
+});
+
+export class ForgotPasswordDto extends createZodDto(forgotPasswordSchema) { }

package/templates/typeorm/src/auth/dto/login.dto.ts

@@ -0,0 +1,10 @@
+// nestforge:feature-file:auth:password
+import { z } from 'zod';
+import { createZodDto } from 'nestjs-zod';
+
+export const loginSchema = z.object({
+  email: z.string().email().describe('E-mail do usuário'),
+  password: z.string().min(8).describe('Senha'),
+});
+
+export class LoginDto extends createZodDto(loginSchema) { }

package/templates/typeorm/src/auth/dto/refresh-token.dto.ts

@@ -0,0 +1,9 @@
+// nestforge:feature-file:auth:token
+import { z } from 'zod';
+import { createZodDto } from 'nestjs-zod';
+
+export const refreshTokenSchema = z.object({
+  refreshToken: z.string().describe('Refresh token emitido no login'),
+});
+
+export class RefreshTokenDto extends createZodDto(refreshTokenSchema) { }

package/templates/typeorm/src/auth/dto/register.dto.ts

@@ -0,0 +1,11 @@
+// nestforge:feature-file:auth:password
+import { z } from 'zod';
+import { createZodDto } from 'nestjs-zod';
+
+export const registerSchema = z.object({
+  name: z.string().min(2).describe('Nome completo do usuário'),
+  email: z.string().email().describe('E-mail do usuário'),
+  password: z.string().min(8).describe('Senha (mínimo 8 caracteres)'),
+});
+
+export class RegisterDto extends createZodDto(registerSchema) { }

package/templates/typeorm/src/auth/dto/reset-password.dto.ts

@@ -0,0 +1,10 @@
+// nestforge:feature-file:redis,auth:password
+import { z } from 'zod';
+import { createZodDto } from 'nestjs-zod';
+
+export const resetPasswordSchema = z.object({
+    token: z.string().describe('Token recebido por e-mail'),
+    password: z.string().min(8).describe('Nova senha (mínimo 8 caracteres)'),
+});
+
+export class ResetPasswordDto extends createZodDto(resetPasswordSchema) { }

package/templates/typeorm/src/auth/entities/email-verification-token.entity.ts

@@ -0,0 +1,69 @@
+// nestforge:feature-file:redis,auth:password
+import {
+    Column,
+    CreateDateColumn,
+    Entity,
+    JoinColumn,
+    ManyToOne,
+    PrimaryGeneratedColumn,
+} from 'typeorm';
+import { UserEntity } from '../../users/entities/user.entity';
+
+@Entity({ name: 'email_verification_tokens' })
+export class EmailVerificationTokenEntity {
+    @PrimaryGeneratedColumn('uuid')
+    id!: string;
+
+    @Column({
+        name: 'token_hash',
+        type: 'varchar',
+        length: 64,
+        unique: true,
+    })
+    tokenHash!: string;
+
+    @Column({
+        name: 'user_id',
+        type: 'varchar',
+        length: 36,
+    })
+    userId!: string;
+
+    @ManyToOne(() => UserEntity, {
+        onDelete: 'CASCADE',
+    })
+    @JoinColumn({ name: 'user_id' })
+    user!: UserEntity;
+
+    @Column({
+        name: 'expires_at',
+        // nestforge:feature:database:postgres
+        type: 'timestamp with time zone',
+        // nestforge:feature:database:postgres:end
+        // nestforge:feature:database:mysql
+        type: 'datetime',
+        // nestforge:feature:database:mysql:end
+        // nestforge:feature:database:sqlite
+        type: 'datetime',
+        // nestforge:feature:database:sqlite:end
+    })
+    expiresAt!: Date;
+
+    @Column({
+        name: 'used_at',
+        nullable: true,
+        // nestforge:feature:database:postgres
+        type: 'timestamp with time zone',
+        // nestforge:feature:database:postgres:end
+        // nestforge:feature:database:mysql
+        type: 'datetime',
+        // nestforge:feature:database:mysql:end
+        // nestforge:feature:database:sqlite
+        type: 'datetime',
+        // nestforge:feature:database:sqlite:end
+    })
+    usedAt!: Date | null;
+
+    @CreateDateColumn({ name: 'created_at' })
+    createdAt!: Date;
+}

package/templates/typeorm/src/auth/entities/oauth-account.entity.ts

@@ -0,0 +1,50 @@
+import {
+    Column,
+    CreateDateColumn,
+    Entity,
+    Index,
+    JoinColumn,
+    ManyToOne,
+    PrimaryGeneratedColumn,
+} from 'typeorm';
+import { UserEntity } from '../../users/entities/user.entity';
+
+@Entity({ name: 'oauth_accounts' })
+@Index(
+    'oauth_accounts_provider_provider_user_id_key',
+    ['provider', 'providerUserId'],
+    { unique: true },
+)
+export class OAuthAccountEntity {
+    @PrimaryGeneratedColumn('uuid')
+    id!: string;
+
+    @Column({
+        type: 'varchar',
+        length: 32,
+    })
+    provider!: string;
+
+    @Column({
+        name: 'provider_user_id',
+        type: 'varchar',
+        length: 255,
+    })
+    providerUserId!: string;
+
+    @Column({
+        name: 'user_id',
+        type: 'varchar',
+        length: 36,
+    })
+    userId!: string;
+
+    @ManyToOne(() => UserEntity, {
+        onDelete: 'CASCADE',
+    })
+    @JoinColumn({ name: 'user_id' })
+    user!: UserEntity;
+
+    @CreateDateColumn({ name: 'created_at' })
+    createdAt!: Date;
+}

package/templates/typeorm/src/auth/entities/password-reset-token.entity.ts

@@ -0,0 +1,69 @@
+// nestforge:feature-file:redis,auth:password
+import {
+    Column,
+    CreateDateColumn,
+    Entity,
+    JoinColumn,
+    ManyToOne,
+    PrimaryGeneratedColumn,
+} from 'typeorm';
+import { UserEntity } from '../../users/entities/user.entity';
+
+@Entity({ name: 'password_reset_tokens' })
+export class PasswordResetTokenEntity {
+    @PrimaryGeneratedColumn('uuid')
+    id!: string;
+
+    @Column({
+        name: 'token_hash',
+        type: 'varchar',
+        length: 64,
+        unique: true,
+    })
+    tokenHash!: string;
+
+    @Column({
+        name: 'user_id',
+        type: 'varchar',
+        length: 36,
+    })
+    userId!: string;
+
+    @ManyToOne(() => UserEntity, {
+        onDelete: 'CASCADE',
+    })
+    @JoinColumn({ name: 'user_id' })
+    user!: UserEntity;
+
+    @Column({
+        name: 'expires_at',
+        // nestforge:feature:database:postgres
+        type: 'timestamp with time zone',
+        // nestforge:feature:database:postgres:end
+        // nestforge:feature:database:mysql
+        type: 'datetime',
+        // nestforge:feature:database:mysql:end
+        // nestforge:feature:database:sqlite
+        type: 'datetime',
+        // nestforge:feature:database:sqlite:end
+    })
+    expiresAt!: Date;
+
+    @Column({
+        name: 'used_at',
+        nullable: true,
+        // nestforge:feature:database:postgres
+        type: 'timestamp with time zone',
+        // nestforge:feature:database:postgres:end
+        // nestforge:feature:database:mysql
+        type: 'datetime',
+        // nestforge:feature:database:mysql:end
+        // nestforge:feature:database:sqlite
+        type: 'datetime',
+        // nestforge:feature:database:sqlite:end
+    })
+    usedAt!: Date | null;
+
+    @CreateDateColumn({ name: 'created_at' })
+    createdAt!: Date;
+}

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

@@ -0,0 +1,69 @@
+// nestforge:feature-file:auth:token
+import {
+    Column,
+    CreateDateColumn,
+    Entity,
+    JoinColumn,
+    ManyToOne,
+    PrimaryGeneratedColumn,
+} from 'typeorm';
+import { UserEntity } from '../../users/entities/user.entity';
+
+@Entity({ name: 'refresh_tokens' })
+export class RefreshTokenEntity {
+    @PrimaryGeneratedColumn('uuid')
+    id!: string;
+
+    @Column({
+        name: 'token_hash',
+        type: 'varchar',
+        length: 64,
+        unique: true,
+    })
+    tokenHash!: string;
+
+    @Column({
+        name: 'user_id',
+        type: 'varchar',
+        length: 36,
+    })
+    userId!: string;
+
+    @ManyToOne(() => UserEntity, {
+        onDelete: 'CASCADE',
+    })
+    @JoinColumn({ name: 'user_id' })
+    user!: UserEntity;
+
+    @Column({
+        name: 'expires_at',
+        // nestforge:feature:database:postgres
+        type: 'timestamp with time zone',
+        // nestforge:feature:database:postgres:end
+        // nestforge:feature:database:mysql
+        type: 'datetime',
+        // nestforge:feature:database:mysql:end
+        // nestforge:feature:database:sqlite
+        type: 'datetime',
+        // nestforge:feature:database:sqlite:end
+    })
+    expiresAt!: Date;
+
+    @Column({
+        name: 'revoked_at',
+        nullable: true,
+        // nestforge:feature:database:postgres
+        type: 'timestamp with time zone',
+        // nestforge:feature:database:postgres:end
+        // nestforge:feature:database:mysql
+        type: 'datetime',
+        // nestforge:feature:database:mysql:end
+        // nestforge:feature:database:sqlite
+        type: 'datetime',
+        // nestforge:feature:database:sqlite:end
+    })
+    revokedAt!: Date | null;
+
+    @CreateDateColumn({ name: 'created_at' })
+    createdAt!: Date;
+}

package/templates/typeorm/src/auth/entities/session.entity.ts

@@ -0,0 +1,50 @@
+// nestforge:feature-file:auth:session
+import { ISession } from 'connect-typeorm';
+import {
+    Column,
+    DeleteDateColumn,
+    Entity,
+    Index,
+    PrimaryColumn,
+    ValueTransformer,
+} from 'typeorm';
+
+const bigintTransformer: ValueTransformer = {
+    to: (value: number) => value,
+    from: (value: string | number) => Number(value),
+};
+
+@Entity({ name: 'sessions' })
+export class SessionEntity implements ISession {
+    @Index()
+    @Column({
+        name: 'expired_at',
+        type: 'bigint',
+        transformer: bigintTransformer,
+    })
+    expiredAt = Date.now();
+
+    @PrimaryColumn({
+        type: 'varchar',
+        length: 255,
+    })
+    id = '';
+
+    @Column({ type: 'text' })
+    json = '';
+
+    @DeleteDateColumn({
+        name: 'destroyed_at',
+        nullable: true,
+        // nestforge:feature:database:postgres
+        type: 'timestamp with time zone',
+        // nestforge:feature:database:postgres:end
+        // nestforge:feature:database:mysql
+        type: 'datetime',
+        // nestforge:feature:database:mysql:end
+        // nestforge:feature:database:sqlite
+        type: 'datetime',
+        // nestforge:feature:database:sqlite:end
+    })
+    destroyedAt?: Date;
+}