feat(auth): implement user registration with session creation, Redis caching, and refresh token

.env.example

@@ -24,6 +24,8 @@ JWT_EXPIRY_TIMEFRAME=3600
 
 ADMIN_SECRET_KEY=sometext
 
+REFRESH_TOKEN_EXPIRY=7
+
 GOOGLE_CLIENT_SECRET=
 GOOGLE_CLIENT_ID=
 

.gitignore

@@ -430,6 +430,3 @@ package-lock.json
 docker-compose.yml
 data/
 .dev.env
-
-temp_auto_push.bat
-temp_interactive_push.bat

src/database/migrations/1778335054510-migration.ts

@@ -0,0 +1,15 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class Migration1778335054510 implements MigrationInterface {
+  name = 'Migration1778335054510';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "users" ADD COLUMN IF NOT EXISTS "terms_accepted" boolean NOT NULL DEFAULT false`
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`ALTER TABLE "users" DROP COLUMN "terms_accepted"`);
+  }
+}

src/modules/auth/auth.controller.ts

@@ -1,5 +1,5 @@
 import { Body, Controller, HttpCode, HttpStatus, Post, Req } from '@nestjs/common';
-import { ApiBody, ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
+import { ApiBearerAuth, ApiBody, ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
 import { Request } from 'express';
 import * as SYS_MSG from '@shared/constants/SystemMessages';
 import { skipAuth } from '@shared/helpers/skipAuth';
@@ -9,20 +9,16 @@ import { LoginDto } from './dto/login.dto';
 import { ChangePasswordDto } from './dto/change-password.dto';
 import { SendOtpDto } from './dto/send-otp.dto';
 import { VerifyOtpDto } from './dto/verify-otp.dto';
-import { SendOtpDocs, VerifyOtpDocs, ResendOtpDocs, LoginDocs, ChangePasswordDocs } from './docs/auth-swagger.doc';
+import { SendOtpDocs, VerifyOtpDocs, ResendOtpDocs, LoginDocs, ChangePasswordDocs, RegisterDocs } from './docs/auth-swagger.doc';
 
 @ApiTags('Authentication')
 @Controller('auth')
 export default class RegistrationController {
   constructor(private readonly authService: AuthenticationService) { }
 
   @skipAuth()
+  @RegisterDocs()
   @Post('register')
-  @HttpCode(HttpStatus.CREATED)
-  @ApiOperation({ summary: 'Register a new user' })
-  @ApiBody({ type: CreateUserDTO })
-  @ApiResponse({ status: HttpStatus.CREATED, description: SYS_MSG.USER_CREATED_SUCCESSFULLY })
-  @ApiResponse({ status: HttpStatus.BAD_REQUEST, description: SYS_MSG.USER_ACCOUNT_EXIST })
   async register(@Body() body: CreateUserDTO) {
     return this.authService.createNewUser(body);
   }

src/modules/auth/auth.service.ts

@@ -1,7 +1,7 @@
-import { HttpStatus, Injectable } from '@nestjs/common';
+import { HttpStatus, Injectable, Logger } from '@nestjs/common';
 import { JwtService } from '@nestjs/jwt';
 import { InjectRepository } from '@nestjs/typeorm';
-import { Repository } from 'typeorm';
+import { DataSource, Repository } from 'typeorm';
 import * as bcrypt from 'bcrypt';
 import { randomInt } from 'crypto';
 import authConfig from '@config/auth.config';
@@ -10,7 +10,9 @@ import { CustomHttpException } from '@shared/helpers/custom-http-filter';
 import { User } from '@modules/user/entities/user.entity';
 import { CreateUserDTO } from './dto/create-user.dto';
 import { LoginDto } from './dto/login.dto';
+import { UserSession } from './entities/user-session.entity';
 import { RedisService } from '@modules/redis/services/redis.service';
+import { AuthMetadata } from './entities/auth-metadata.entity';
 import QueueService from '@modules/email/queue.service';
 import { LockoutService } from './lockout.service';
 import { SessionService } from './session.service';
@@ -22,14 +24,24 @@ const MAX_OTP_ATTEMPTS = 5;
 
 @Injectable()
 export default class AuthenticationService {
+  private readonly logger = new Logger(AuthenticationService.name);
+
   constructor(
     @InjectRepository(User)
     private readonly userRepository: Repository<User>,
     private readonly jwtService: JwtService,
     private readonly redisService: RedisService,
     private readonly queueService: QueueService,
     private readonly lockoutService: LockoutService,
-    private readonly sessionService: SessionService
+    private readonly sessionService: SessionService,
+
+    @InjectRepository(UserSession)
+    private readonly userSessionRepository: Repository<UserSession>,
+
+    @InjectRepository(AuthMetadata)
+    private readonly authMetaData: Repository<AuthMetadata>,
+
+    private readonly dataSource: DataSource,
   ) { }
 
   async createNewUser(createUserDto: CreateUserDTO) {
@@ -39,25 +51,65 @@ export default class AuthenticationService {
     }
 
     const hashedPassword = await bcrypt.hash(createUserDto.password, 10);
-    const saved = await this.userRepository.save(
-      this.userRepository.create({
+
+    const queryRunner = this.dataSource.createQueryRunner();
+    await queryRunner.connect();
+    await queryRunner.startTransaction();
+
+    let saved: User;
+
+    try {
+      const user = queryRunner.manager.create(User, {
         email: createUserDto.email,
         full_name: createUserDto.full_name,
         country: createUserDto.country ?? null,
         password: hashedPassword,
         auth_provider: 'email',
-      })
-    );
+        terms_accepted: createUserDto.terms_accepted,
+      });
+
+      saved = await queryRunner.manager.save(user);
+
+      const authMetaData = queryRunner.manager.create(AuthMetadata, {
+        user_id: saved.id,
+        last_login_at: null,
+      });
+      await queryRunner.manager.save(authMetaData);
+
+      await queryRunner.commitTransaction();
+    } catch (error) {
+      await queryRunner.rollbackTransaction();
+
+      const err = error as Error;
+      this.logger.error(`Registration failed: ${err.message}`, err.stack);
 
-    await this.issueOtp(saved.email);
+      let errorMessage = SYS_MSG.SESSION_CREATION_FAILED;
+      const statusCode = HttpStatus.INTERNAL_SERVER_ERROR;
 
-    const access_token = this.jwtService.sign({ id: saved.id, sub: saved.id, email: saved.email });
+      if (err.name === 'QueryFailedError') {
+        errorMessage = 'Database error occurred during registration';
+        this.logger.error('DB_ERROR during registration', err);
+      }
+
+      throw new CustomHttpException(errorMessage, statusCode);
+    } finally {
+      await queryRunner.release();
+    }
+
+    // Issued after commit so a DB rollback does not leave a dangling OTP in Redis or send a spurious email.
+    // Failure here is non-fatal — the user was created and can request a resend via /resend-otp.
+    try {
+      await this.issueOtp(createUserDto.email);
+    } catch (otpError) {
+      const err = otpError as Error;
+      this.logger.error(`OTP dispatch failed after registration: ${err.message}`, err.stack);
+    }
 
     return {
       status_code: HttpStatus.CREATED,
       message: SYS_MSG.USER_CREATED_SUCCESSFULLY,
-      access_token,
       data: {
+        redirect_url: '/dashboard',
         user: {
           id: saved.id,
           full_name: saved.full_name,
@@ -170,24 +222,38 @@ export default class AuthenticationService {
       throw new CustomHttpException(SYS_MSG.INVALID_OTP, HttpStatus.BAD_REQUEST);
     }
 
-    user.is_verified = true;
-    user.otp_code = null;
-    user.expires_at = null;
-    await this.userRepository.save(user);
+    try {
+      user.is_verified = true;
+      user.otp_code = null;
+      user.expires_at = null;
+      await this.userRepository.save(user);
+    } catch (error) {
+      const err = error as Error;
+      this.logger.error(`OTP verification failed: ${err.message}`, err.stack);
+      throw new CustomHttpException(SYS_MSG.SESSION_CREATION_FAILED, HttpStatus.INTERNAL_SERVER_ERROR);
+    }
 
     await Promise.all([
       this.redisService.del(`otp:${email}`),
       this.redisService.del(`attempts:${email}`),
       this.redisService.del(`limit:${email}`),
     ]);
 
-    const access_token = this.jwtService.sign({ id: user.id, sub: user.id, email: user.email });
+    const { rawToken, sessionId } = await this.sessionService.create(user);
+
+    const access_token = this.jwtService.sign({
+      id: user.id,
+      sub: user.id,
+      sid: sessionId,
+      email: user.email,
+    });
 
     return {
       status_code: HttpStatus.OK,
       message: SYS_MSG.EMAIL_VERIFIED,
-      access_token,
       data: {
+        access_token,
+        refresh_token: rawToken,
         user: {
           id: user.id,
           full_name: user.full_name,

src/modules/auth/docs/auth-swagger.doc.ts

@@ -4,6 +4,7 @@ import { SendOtpDto } from '../dto/send-otp.dto';
 import { VerifyOtpDto } from '../dto/verify-otp.dto';
 import { LoginDto } from '../dto/login.dto';
 import { ChangePasswordDto } from '../dto/change-password.dto';
+import { CreateUserDTO } from '../dto/create-user.dto';
 
 export function SendOtpDocs() {
   return applyDecorators(
@@ -53,6 +54,16 @@ export function LoginDocs() {
   );
 }
 
+export function RegisterDocs() {
+  return applyDecorators(
+    HttpCode(HttpStatus.CREATED),
+    ApiOperation({ summary: 'Register a new user' }),
+    ApiBody({ type: CreateUserDTO }),
+    ApiResponse({ status: HttpStatus.CREATED, description: 'User Created Successfully' }),
+    ApiResponse({ status: HttpStatus.BAD_REQUEST, description: 'Account with the specified email exists' })
+  );
+}
+
 export function ChangePasswordDocs() {
   return applyDecorators(
     ApiBearerAuth(),

src/modules/auth/dto/create-user.dto.ts

@@ -1,5 +1,14 @@
 import { ApiProperty } from '@nestjs/swagger';
-import { IsEmail, IsNotEmpty, IsOptional, IsString, IsStrongPassword, MaxLength, MinLength } from 'class-validator';
+import {
+  IsBoolean,
+  IsEmail,
+  IsNotEmpty,
+  IsOptional,
+  IsString,
+  IsStrongPassword,
+  MaxLength,
+  MinLength,
+} from 'class-validator';
 
 export class CreateUserDTO {
   @ApiProperty({
@@ -43,4 +52,13 @@ export class CreateUserDTO {
     }
   )
   password: string;
+
+  @ApiProperty({
+    description: 'The user must accept the Terms and Conditions of the application to continue with signup',
+    example: true,
+    required: true,
+  })
+  @IsBoolean()
+  @IsNotEmpty()
+  terms_accepted: boolean;
 }

src/modules/auth/session.service.ts

@@ -5,14 +5,13 @@ import { randomBytes, createHash } from 'crypto';
 import { User } from '@modules/user/entities/user.entity';
 import { UserSession } from './entities/user-session.entity';
 
-const REFRESH_TOKEN_EXPIRY_DAYS = 7;
-
+const REFRESH_TOKEN_EXPIRY_DAYS = +process.env.REFRESH_TOKEN_EXPIRY
 @Injectable()
 export class SessionService {
   constructor(
     @InjectRepository(UserSession)
     private readonly repo: Repository<UserSession>
-  ) {}
+  ) { }
 
   async create(user: User): Promise<{ rawToken: string; sessionId: string }> {
     const rawToken = randomBytes(32).toString('hex');