chore: add auth module and jwt service

.env.dist

@@ -4,4 +4,9 @@ DATABASE_PORT=15432
 DATABASE_USER=postgres
 DATABASE_PASSWORD=postgres
 
+JWT_SECRET=nestjs-ddd-devops
+JWT_REFRESH_SECRET=nestjs-ddd-devops-refresh
+JWT_EXPIRES_IN=3600
+JET_REFRESH_EXPIRES_IN=360000
+
 PORT=3000

src/app.module.ts

@@ -4,12 +4,12 @@ import { CacheModule } from '@nestjs/cache-manager';
 import { ConfigModule, ConfigService } from '@nestjs/config';
 import { MikroOrmModule } from '@mikro-orm/nestjs';
 import mikroOrmConfig from './config/database/mikro-orm.config';
-import { ThrottlerGuard, ThrottlerModule } from '@nestjs/throttler';
+import { ThrottlerModule } from '@nestjs/throttler';
 import { EventEmitterModule } from '@nestjs/event-emitter';
 import { ScheduleModule } from '@nestjs/schedule';
-import { APP_GUARD } from '@nestjs/core';
 import { UserModule } from './modules/user/user.module';
 import { HealthModule } from './modules/health/health.module';
+import { AuthModule } from './modules/auth/auth.module';
 
 @Module({
   imports: [
@@ -42,13 +42,9 @@ import { HealthModule } from './modules/health/health.module';
     ScheduleModule.forRoot(),
     HealthModule,
     UserModule,
+    AuthModule,
   ],
   controllers: [],
-  providers: [
-    {
-      provide: APP_GUARD,
-      useClass: ThrottlerGuard,
-    },
-  ],
+  providers: [],
 })
 export class AppModule {}

src/config/env/configuration.constant.ts

@@ -0,0 +1,5 @@
+export const JWT_SECRET = 'JWT_SECRET';
+export const JWT_REFRESH_SECRET = 'JWT_REFRESH_SECRET';
+
+export const JWT_EXPIRES_IN = 'JWT_EXPIRES_IN';
+export const JWT_REFRESH_EXPIRES_IN = 'JWT_REFRESH_EXPIRES_IN';

src/libs/util/config.util.ts

@@ -0,0 +1,13 @@
+import { fromNullable, getOrThrowWith } from 'effect/Option';
+import { ConfigService } from '@nestjs/config';
+
+export const getConfigValue = <T>(
+  configService: ConfigService,
+  key: string,
+): T => {
+  console.log('AAA');
+  return getOrThrowWith<T>(
+    fromNullable(configService.get<T>(key)),
+    () => new Error(`Missing ${key}`),
+  );
+};

src/modules/auth/application/interface/jwt-authentication.interface.ts

@@ -0,0 +1,17 @@
+import { AuthUser } from '../presentation/dto/auth-user.dto';
+import { Option } from 'effect/Option';
+import { JwtUser } from '../presentation/dto/jwt-user.dto';
+
+export interface JwtAuthentication {
+  verifyToken(token: string): Promise<Option<AuthUser>>;
+
+  verifyRefreshToken(refreshToken: string): Promise<Option<AuthUser>>;
+
+  generateToken(user: AuthUser): Promise<string>;
+
+  generateRefreshToken(user: AuthUser): Promise<string>;
+
+  generateJwtUser(user: AuthUser): Promise<JwtUser>;
+
+  generateJwtUserFromRefresh(token: string): Promise<JwtUser>;
+}

src/modules/auth/application/presentation/body/login.body.ts

@@ -0,0 +1,29 @@
+import {
+  IsEmail,
+  IsNotEmpty,
+  IsString,
+  IsStrongPassword,
+  MaxLength,
+} from 'class-validator';
+
+export class LoginBody {
+  @IsNotEmpty()
+  @IsEmail()
+  @IsString()
+  email!: string;
+
+  @IsNotEmpty()
+  @IsString()
+  @MaxLength(20)
+  @IsStrongPassword(
+    {
+      minLength: 8,
+      minSymbols: 1,
+    },
+    {
+      message:
+        'Password must be at least 8 characters long and contain at least one symbol',
+    },
+  )
+  password!: string;
+}

src/modules/auth/application/presentation/body/signup.body.ts

@@ -0,0 +1,12 @@
+import { LoginBody } from './login.body';
+import { IsNotEmpty, IsString } from 'class-validator';
+
+export class SignupBody extends LoginBody {
+  @IsNotEmpty()
+  @IsString()
+  firstName!: string;
+
+  @IsNotEmpty()
+  @IsString()
+  lastName!: string;
+}

src/modules/auth/application/presentation/dto/auth-user.dto.ts

@@ -0,0 +1,5 @@
+export interface AuthUser {
+  id: string;
+  email: string;
+  role: number;
+}

src/modules/auth/application/presentation/dto/jwt-user.dto.ts

@@ -0,0 +1,9 @@
+import { AuthUser } from './auth-user.dto';
+
+export interface JwtUser {
+  token: string;
+  expiresIn: number;
+  refreshToken: string;
+  refreshExpiresIn: number;
+  user: AuthUser;
+}

src/modules/auth/application/service/jwt.service.ts

@@ -0,0 +1,95 @@
+import { Injectable, UnauthorizedException } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import {
+  JWT_EXPIRES_IN,
+  JWT_REFRESH_EXPIRES_IN,
+  JWT_REFRESH_SECRET,
+  JWT_SECRET,
+} from '../../../../config/env/configuration.constant';
+import { isNone, liftThrowable, Option } from 'effect/Option';
+import { JwtAuthentication } from '../interface/jwt-authentication.interface';
+import { AuthUser } from '../presentation/dto/auth-user.dto';
+import * as jwt from 'jsonwebtoken';
+import { getConfigValue } from '../../../../libs/util/config.util';
+import { JwtUser } from '../presentation/dto/jwt-user.dto';
+
+@Injectable()
+export class JwtService implements JwtAuthentication {
+  private readonly tokenSecret: string;
+  private readonly refreshTokenSecret: string;
+  private readonly tokenExpiration: number;
+  private readonly refreshTokenExpiration: number;
+
+  constructor(private readonly configService: ConfigService) {
+    this.tokenSecret = getConfigValue(this.configService, JWT_SECRET);
+    this.refreshTokenSecret = getConfigValue<string>(
+      this.configService,
+      JWT_REFRESH_SECRET,
+    );
+    this.tokenExpiration = getConfigValue<number>(
+      this.configService,
+      JWT_EXPIRES_IN,
+    );
+    this.refreshTokenExpiration = getConfigValue<number>(
+      this.configService,
+      JWT_REFRESH_EXPIRES_IN,
+    );
+  }
+
+  async generateToken(user: AuthUser): Promise<string> {
+    return jwt.sign(user, this.tokenSecret, {
+      expiresIn: this.tokenExpiration,
+    });
+  }
+
+  async generateRefreshToken(user: AuthUser): Promise<string> {
+    return jwt.sign(user, this.refreshTokenSecret, {
+      expiresIn: this.refreshTokenExpiration,
+    });
+  }
+
+  async generateJwtUser(authUser: AuthUser): Promise<JwtUser> {
+    const token = await this.generateToken(authUser);
+    const refreshToken = await this.generateRefreshToken(authUser);
+    return {
+      token,
+      expiresIn: this.tokenExpiration,
+      refreshToken,
+      refreshExpiresIn: this.refreshTokenExpiration,
+      user: authUser,
+    };
+  }
+
+  async generateJwtUserFromRefresh(refreshToken: string): Promise<JwtUser> {
+    const authUser = this.verifyJwt<AuthUser>(
+      refreshToken,
+      this.refreshTokenSecret,
+    );
+    if (isNone(authUser)) throw new UnauthorizedException('Invalid Token!');
+    return this.generateJwtUser(this.convertToAuthUser(authUser.value));
+  }
+
+  async verifyToken(token: string): Promise<Option<AuthUser>> {
+    return this.verifyJwt<AuthUser>(token, this.tokenSecret);
+  }
+
+  async verifyRefreshToken(refreshToken: string): Promise<Option<AuthUser>> {
+    return this.verifyJwt<AuthUser>(refreshToken, this.refreshTokenSecret);
+  }
+
+  /**
+   * Generic JWT verification method.
+   */
+  private verifyJwt<T>(token: string, secret: string): Option<T> {
+    return liftThrowable(() => jwt.verify(token, secret) as T)();
+  }
+
+  /**
+   * Helper method to clean the AuthUser object.
+   */
+  convertToAuthUser = (authUser: AuthUser): AuthUser => ({
+    id: authUser.id,
+    email: authUser.email,
+    role: authUser.role,
+  });
+}

src/modules/auth/auth.module.ts

@@ -0,0 +1,18 @@
+import { Module } from '@nestjs/common';
+import { APP_GUARD } from '@nestjs/core';
+import { ThrottlerGuard } from '@nestjs/throttler';
+import { JwtService } from './application/service/jwt.service';
+
+@Module({
+  imports: [],
+  controllers: [],
+  providers: [
+    JwtService,
+    {
+      provide: APP_GUARD,
+      useClass: ThrottlerGuard,
+    },
+  ],
+  exports: [],
+})
+export class AuthModule {}

src/modules/user/domain/entity/user.entity.ts

@@ -1,5 +1,7 @@
-import { Entity, PrimaryKey, Property } from '@mikro-orm/core';
+import { Entity, Enum, PrimaryKey, Property } from '@mikro-orm/core';
 import { v4 } from 'uuid';
+import { UserRole } from '../value-object/user-role.enum';
+import { UserState } from '../value-object/user-state.enum';
 
 @Entity({
   tableName: 'Users',
@@ -15,10 +17,16 @@ export class User {
   password!: string;
 
   @Property({ nullable: true })
-  firstname?: string;
+  firstName?: string;
 
   @Property({ nullable: true })
-  lastname?: string;
+  lastName?: string;
+
+  @Enum({ items: () => UserRole })
+  role!: UserRole;
+
+  @Enum({ items: () => UserState })
+  state!: UserState;
 
   @Property({ onCreate: () => new Date() })
   createdAt: Date = new Date();

src/modules/user/domain/value-object/user-role.enum.ts

@@ -0,0 +1,4 @@
+export enum UserRole {
+  ADMIN = 0,
+  USER = 1,
+}

src/modules/user/domain/value-object/user-state.enum.ts

@@ -0,0 +1,4 @@
+export enum UserState {
+  ACTIVE = 'ACTIVE',
+  DISABLED = 'DISABLED',
+}