Crealcs Development DokuWiki

Modifiez cette page et cliquez sur « Enregistrer ». Voyez le guide de mise en page pour une aide à propos du formatage. Veuillez ne modifier cette page que si vous pouvez l'améliorer. Si vous souhaitez faire des tests, faites vos premiers pas dans le bac à sable.

====== Sprint 1 — Authentification ======

===== Objectif =====

Implémenter le premier domaine métier réellement exécutable de la plateforme.

À l'issue du Sprint 1 :

<code>
✓ Register

✓ Login

✓ JWT

✓ Refresh Token

✓ RBAC

✓ Current User

✓ Swagger

✓ Unit Tests

✓ E2E Tests
</code>

Le système devient capable :

<code>
Créer un utilisateur

S'authentifier

Gérer les rôles

Sécuriser les endpoints
</code>

----

====== Périmètre ======

===== Modules concernés =====

<code>
AuthModule

UsersModule

SecurityModule
</code>

----

===== Entités Prisma =====

<code>
User

Role

Permission

UserRole

RolePermission

RefreshToken

Session
</code>

----

====== Sprint 1-A — Modèle Prisma ======

===== Vérification User =====

<code prisma>
model User {

id              String @id @default(uuid())

tenantId        String

email           String @unique

passwordHash    String

firstName       String

lastName        String

phone           String?

status          UserStatus

createdAt       DateTime @default(now())

updatedAt       DateTime @updatedAt

deletedAt       DateTime?

tenant          Tenant @relation(
                    fields:[tenantId],
                    references:[id]
                  )

roles           UserRole[]

refreshTokens   RefreshToken[]

sessions        Session[]
}
</code>

----

===== RefreshToken =====

<code prisma>
model RefreshToken {

id            String @id @default(uuid())

userId        String

tokenHash     String

expiresAt     DateTime

revokedAt     DateTime?

createdAt     DateTime @default(now())

user          User
    @relation(
      fields:[userId],
      references:[id]
    )
}
</code>

----

===== Session =====

<code prisma>
model Session {

id            String @id @default(uuid())

userId        String

ipAddress     String?

userAgent     String?

createdAt     DateTime @default(now())

lastSeenAt    DateTime

user          User
    @relation(
      fields:[userId],
      references:[id]
    )
}
</code>

----

====== Sprint 1-B — Installation ======

===== Packages NestJS =====

<code bash>
npm install @nestjs/jwt

npm install @nestjs/passport

npm install passport

npm install passport-jwt

npm install passport-local

npm install bcrypt

npm install class-validator

npm install class-transformer
</code>

----

===== Types =====

<code bash>
npm install -D

@types/bcrypt

@types/passport-jwt

@types/passport-local
</code>

----

====== Sprint 1-C — Structure Module ======

===== Arborescence =====

<code>
src/modules/auth

├── application

├── domain

├── infrastructure

├── presentation

└── auth.module.ts
</code>

----

===== Application =====

<code>
commands

queries

handlers

dto
</code>

----

====== Sprint 1-D — DTO ======

===== RegisterDto =====

<code ts>
export class RegisterDto {

@IsEmail()
  email: string;

@MinLength(8)
  password: string;

@IsString()
  firstName: string;

@IsString()
  lastName: string;
}
</code>

----

===== LoginDto =====

<code ts>
export class LoginDto {

@IsEmail()
  email: string;

@IsString()
  password: string;
}
</code>

----

===== RefreshTokenDto =====

<code ts>
export class RefreshTokenDto {

@IsString()
  refreshToken: string;
}
</code>

----

====== Sprint 1-E — Service Password ======

===== PasswordService =====

<code>
src/modules/auth/domain/services
</code>

----

===== Méthodes =====

<code ts>
hash()

compare()
</code>

----

===== Implémentation =====

<code ts>
const hash =
  await bcrypt.hash(password, 12);
</code>

----

====== Sprint 1-F — JWT ======

===== Variables =====

<code>
JWT_SECRET

JWT_EXPIRES_IN

REFRESH_SECRET

REFRESH_EXPIRES_IN
</code>

----

===== .env =====

<code>
JWT_SECRET=super-secret

JWT_EXPIRES_IN=15m

REFRESH_SECRET=refresh-secret

REFRESH_EXPIRES_IN=30d
</code>

----

===== Payload =====

<code ts>
export interface JwtPayload {

sub: string;

tenantId: string;

email: string;
}
</code>

----

====== Sprint 1-G — Register ======

===== Endpoint =====

<code http>
POST /auth/register
</code>

----

===== Workflow =====

<code>
Validation

↓

Email unique

↓

Hash password

↓

Create User

↓

Assign Role USER

↓

Return JWT
</code>

----

===== Response =====

<code json>
{
  "accessToken": "...",
  "refreshToken": "...",
  "user": {}
}
</code>

----

====== Sprint 1-H — Login ======

===== Endpoint =====

<code http>
POST /auth/login
</code>

----

===== Workflow =====

<code>
Find User

↓

Compare Password

↓

Generate JWT

↓

Generate Refresh Token

↓

Create Session
</code>

----

====== Sprint 1-I — Refresh Token ======

===== Endpoint =====

<code http>
POST /auth/refresh
</code>

----

===== Workflow =====

<code>
Validate Refresh Token

↓

Generate New JWT

↓

Rotate Refresh Token
</code>

----

====== Sprint 1-J — Logout ======

===== Endpoint =====

<code http>
POST /auth/logout
</code>

----

===== Action =====

<code>
Révocation Refresh Token

Suppression Session
</code>

----

====== Sprint 1-K — Current User ======

===== Endpoint =====

----

===== Response =====

<code json>
{
  "id": "...",
  "email": "...",
  "roles": ["USER"]
}
</code>

----

====== Sprint 1-L — JWT Strategy ======

===== Fichier =====

<code>
jwt.strategy.ts
</code>

----

===== Validation =====

<code>
Bearer Token

↓

Verify JWT

↓

Load User

↓

Inject Request.user
</code>

----

====== Sprint 1-M — RBAC ======

===== Decorator =====

<code ts>
@Roles('ADMIN')
</code>

----

===== Guard =====

<code>
RolesGuard
</code>

----

===== Exemple =====

<code ts>
@Roles('ADMIN')

@Get()
findAll()
</code>

----

====== Sprint 1-N — Permissions ======

===== Decorator =====

<code ts>
@Permissions(
  'users.read'
)
</code>

----

===== Guard =====

<code>
PermissionsGuard
</code>

----

===== Source =====

<code>
RolePermission

Permission
</code>

----

====== Sprint 1-O — Swagger ======

===== Tag =====

<code ts>
@ApiTags('Auth')
</code>

----

===== Security =====

<code ts>
@ApiBearerAuth()
</code>

----

===== Endpoints =====

<code>
POST /auth/register

POST /auth/login

POST /auth/refresh

POST /auth/logout

GET  /auth/me
</code>

----

====== Sprint 1-P — Seed Initial ======

===== Permissions =====

<code>
users.read

users.create

users.update

users.delete
</code>

----

===== Roles =====

<code>
SUPER_ADMIN

ADMIN

MANAGER

OWNER

CUSTOMER
</code>

----

===== Super Admin =====

<code>
admin@platform.local
</code>

----

====== Sprint 1-Q — Tests Unitaires ======

===== Services =====

<code>
AuthService

PasswordService

JwtService

RolesGuard

PermissionsGuard
</code>

----

===== Commande =====

----

====== Sprint 1-R — Tests E2E ======

===== Scénario =====

<code>
Register

↓

Login

↓

Access Protected Route

↓

Refresh Token

↓

Logout
</code>

----

===== Commande =====

----

====== Sprint 1-S — Critères d'acceptation ======

===== Register =====

<code>
Utilisateur créé

Mot de passe hashé

JWT retourné
</code>

----

===== Login =====

<code>
JWT valide

Refresh Token valide
</code>

----

===== RBAC =====

<code>
ADMIN autorisé

USER refusé
</code>

----

===== Swagger =====

<code>
100 % documenté
</code>

----

====== Livrables ======

<code>
AuthModule

JwtStrategy

AuthController

AuthService

RolesGuard

PermissionsGuard

RegisterDto

LoginDto

RefreshTokenDto

Swagger

Tests
</code>

----

====== Sprint 1 — Authentification ======

===== Objectif =====

Implémenter le premier domaine métier réellement exécutable de la plateforme.

À l'issue du Sprint 1 :

<code>
✓ Register

✓ Login

✓ JWT

✓ Refresh Token

✓ RBAC

✓ Current User

✓ Swagger

✓ Unit Tests

✓ E2E Tests
</code>

Le système devient capable :

<code>
Créer un utilisateur

S'authentifier

Gérer les rôles

Sécuriser les endpoints
</code>

----

====== Périmètre ======

===== Modules concernés =====

<code>
AuthModule

UsersModule

SecurityModule
</code>

----

===== Entités Prisma =====

<code>
User

Role

Permission

UserRole

RolePermission

RefreshToken

Session
</code>

----

====== Sprint 1-A — Modèle Prisma ======

===== Vérification User =====

<code prisma>
model User {

id              String @id @default(uuid())

tenantId        String

email           String @unique

passwordHash    String

firstName       String

lastName        String

phone           String?

status          UserStatus

createdAt       DateTime @default(now())

updatedAt       DateTime @updatedAt

deletedAt       DateTime?

tenant          Tenant @relation(
                    fields:[tenantId],
                    references:[id]
                  )

roles           UserRole[]

refreshTokens   RefreshToken[]

sessions        Session[]
}
</code>

----

===== RefreshToken =====

<code prisma>
model RefreshToken {

id            String @id @default(uuid())

userId        String

tokenHash     String

expiresAt     DateTime

revokedAt     DateTime?

createdAt     DateTime @default(now())

user          User
    @relation(
      fields:[userId],
      references:[id]
    )
}
</code>

----

===== Session =====

<code prisma>
model Session {

id            String @id @default(uuid())

userId        String

ipAddress     String?

userAgent     String?

createdAt     DateTime @default(now())

lastSeenAt    DateTime

user          User
    @relation(
      fields:[userId],
      references:[id]
    )
}
</code>

----

====== Sprint 1-B — Installation ======

===== Packages NestJS =====

<code bash>
npm install @nestjs/jwt

npm install @nestjs/passport

npm install passport

npm install passport-jwt

npm install passport-local

npm install bcrypt

npm install class-validator

npm install class-transformer
</code>

----

===== Types =====

<code bash>
npm install -D

@types/bcrypt

@types/passport-jwt

@types/passport-local
</code>

----

====== Sprint 1-C — Structure Module ======

===== Arborescence =====

<code>
src/modules/auth

├── application

├── domain

├── infrastructure

├── presentation

└── auth.module.ts
</code>

----

===== Application =====

<code>
commands

queries

handlers

dto
</code>

----

====== Sprint 1-D — DTO ======

===== RegisterDto =====

<code ts>
export class RegisterDto {

@IsEmail()
  email: string;

@MinLength(8)
  password: string;

@IsString()
  firstName: string;

@IsString()
  lastName: string;
}
</code>

----

===== LoginDto =====

<code ts>
export class LoginDto {

@IsEmail()
  email: string;

@IsString()
  password: string;
}
</code>

----

===== RefreshTokenDto =====

<code ts>
export class RefreshTokenDto {

@IsString()
  refreshToken: string;
}
</code>

----

====== Sprint 1-E — Service Password ======

===== PasswordService =====

<code>
src/modules/auth/domain/services
</code>

----

===== Méthodes =====

<code ts>
hash()

compare()
</code>

----

===== Implémentation =====

<code ts>
const hash =
  await bcrypt.hash(password, 12);
</code>

----

====== Sprint 1-F — JWT ======

===== Variables =====

<code>
JWT_SECRET

JWT_EXPIRES_IN

REFRESH_SECRET

REFRESH_EXPIRES_IN
</code>

----

===== .env =====

<code>
JWT_SECRET=super-secret

JWT_EXPIRES_IN=15m

REFRESH_SECRET=refresh-secret

REFRESH_EXPIRES_IN=30d
</code>

----

===== Payload =====

<code ts>
export interface JwtPayload {

sub: string;

tenantId: string;

email: string;
}
</code>

----

====== Sprint 1-G — Register ======

===== Endpoint =====

<code http>
POST /auth/register
</code>

----

===== Workflow =====

<code>
Validation

↓

Email unique

↓

Hash password

↓

Create User

↓

Assign Role USER

↓

Return JWT
</code>

----

===== Response =====

<code json>
{
  "accessToken": "...",
  "refreshToken": "...",
  "user": {}
}
</code>

----

====== Sprint 1-H — Login ======

===== Endpoint =====

<code http>
POST /auth/login
</code>

----

===== Workflow =====

<code>
Find User

↓

Compare Password

↓

Generate JWT

↓

Generate Refresh Token

↓

Create Session
</code>

----

====== Sprint 1-I — Refresh Token ======

===== Endpoint =====

<code http>
POST /auth/refresh
</code>

----

===== Workflow =====

<code>
Validate Refresh Token

↓

Generate New JWT

↓

Rotate Refresh Token
</code>

----

====== Sprint 1-J — Logout ======

===== Endpoint =====

<code http>
POST /auth/logout
</code>

----

===== Action =====

<code>
Révocation Refresh Token

Suppression Session
</code>

----

====== Sprint 1-K — Current User ======

===== Endpoint =====

----

===== Response =====

<code json>
{
  "id": "...",
  "email": "...",
  "roles": ["USER"]
}
</code>

----

====== Sprint 1-L — JWT Strategy ======

===== Fichier =====

<code>
jwt.strategy.ts
</code>

----

===== Validation =====

<code>
Bearer Token

↓

Verify JWT

↓

Load User

↓

Inject Request.user
</code>

----

====== Sprint 1-M — RBAC ======

===== Decorator =====

<code ts>
@Roles('ADMIN')
</code>

----

===== Guard =====

<code>
RolesGuard
</code>

----

===== Exemple =====

<code ts>
@Roles('ADMIN')

@Get()
findAll()
</code>

----

====== Sprint 1-N — Permissions ======

===== Decorator =====

<code ts>
@Permissions(
  'users.read'
)
</code>

----

===== Guard =====

<code>
PermissionsGuard
</code>

----

===== Source =====

<code>
RolePermission

Permission
</code>

----

====== Sprint 1-O — Swagger ======

===== Tag =====

<code ts>
@ApiTags('Auth')
</code>

----

===== Security =====

<code ts>
@ApiBearerAuth()
</code>

----

===== Endpoints =====

<code>
POST /auth/register

POST /auth/login

POST /auth/refresh

POST /auth/logout

GET  /auth/me
</code>

----

====== Sprint 1-P — Seed Initial ======

===== Permissions =====

<code>
users.read

users.create

users.update

users.delete
</code>

----

===== Roles =====

<code>
SUPER_ADMIN

ADMIN

MANAGER

OWNER

CUSTOMER
</code>

----

===== Super Admin =====

<code>
admin@platform.local
</code>

----

====== Sprint 1-Q — Tests Unitaires ======

===== Services =====

<code>
AuthService

PasswordService

JwtService

RolesGuard

PermissionsGuard
</code>

----

===== Commande =====

----

====== Sprint 1-R — Tests E2E ======

===== Scénario =====

<code>
Register

↓

Login

↓

Access Protected Route

↓

Refresh Token

↓

Logout
</code>

----

===== Commande =====

----

====== Sprint 1-S — Critères d'acceptation ======

===== Register =====

<code>
Utilisateur créé

Mot de passe hashé

JWT retourné
</code>

----

===== Login =====

<code>
JWT valide

Refresh Token valide
</code>

----

===== RBAC =====

<code>
ADMIN autorisé

USER refusé
</code>

----

===== Swagger =====

<code>
100 % documenté
</code>

----

====== Livrables ======

<code>
AuthModule

JwtStrategy

AuthController

AuthService

RolesGuard

PermissionsGuard

RegisterDto

LoginDto

RefreshTokenDto

Swagger

Tests
</code>

----

====== Sprint 1-A.1 — Implémentation Prisma Auth ======

===== Objectif =====

Implémenter réellement les entités Prisma nécessaires à :

<code>
Register

Login

JWT

Refresh Token

RBAC

Sessions
</code>

avant toute écriture de code NestJS.

Cette étape produit :

<code>
User

Role

Permission

UserRole

RolePermission

RefreshToken

Session
</code>

dans le fichier :

<code>
apps/api/prisma/schema.prisma
</code>

----

====== Étape 1 — Vérification des Enums ======

===== Ajouter =====

<code prisma>
enum UserStatus {

ACTIVE

INACTIVE

BLOCKED

PENDING
}
</code>

----

====== Étape 2 — Modèle User ======

===== Ajouter =====

<code prisma>
model User {

id                String @id @default(uuid())

tenantId          String

email             String @unique

passwordHash      String

firstName         String

lastName          String

phone             String?

status            UserStatus @default(ACTIVE)

emailVerified     Boolean @default(false)

lastLoginAt       DateTime?

createdAt         DateTime @default(now())

updatedAt         DateTime @updatedAt

deletedAt         DateTime?

createdBy         String?

updatedBy         String?

tenant            Tenant
                     @relation(
                       fields:[tenantId],
                       references:[id]
                     )

userRoles         UserRole[]

refreshTokens     RefreshToken[]

sessions          Session[]

@@index([tenantId])

@@index([email])

@@index([status])

@@index([deletedAt])
}
</code>

----

====== Étape 3 — Modèle Role ======

===== Ajouter =====

<code prisma>
model Role {

id                String @id @default(uuid())

tenantId          String

code              String

name              String

description       String?

createdAt         DateTime @default(now())

updatedAt         DateTime @updatedAt

deletedAt         DateTime?

tenant            Tenant
                     @relation(
                       fields:[tenantId],
                       references:[id]
                     )

userRoles         UserRole[]

rolePermissions   RolePermission[]

@@unique([tenantId, code])

@@index([tenantId])

@@index([code])
}
</code>

----

====== Étape 4 — Modèle Permission ======

===== Ajouter =====

<code prisma>
model Permission {

id                String @id @default(uuid())

code              String @unique

name              String

description       String?

createdAt         DateTime @default(now())

updatedAt         DateTime @updatedAt

rolePermissions   RolePermission[]

@@index([code])
}
</code>

----

====== Étape 5 — Modèle UserRole ======

===== Ajouter =====

<code prisma>
model UserRole {

id                String @id @default(uuid())

userId            String

roleId            String

assignedAt        DateTime @default(now())

assignedBy        String?

user              User
                     @relation(
                       fields:[userId],
                       references:[id]
                     )

role              Role
                     @relation(
                       fields:[roleId],
                       references:[id]
                     )

@@unique([userId, roleId])

@@index([userId])

@@index([roleId])
}
</code>

----

====== Étape 6 — Modèle RolePermission ======

===== Ajouter =====

<code prisma>
model RolePermission {

id                String @id @default(uuid())

roleId            String

permissionId      String

role              Role
                     @relation(
                       fields:[roleId],
                       references:[id]
                     )

permission        Permission
                     @relation(
                       fields:[permissionId],
                       references:[id]
                     )

@@unique([
    roleId,
    permissionId
  ])

@@index([roleId])

@@index([permissionId])
}
</code>

----

====== Étape 7 — Modèle RefreshToken ======

===== Ajouter =====

<code prisma>
model RefreshToken {

id                String @id @default(uuid())

userId            String

tokenHash         String

expiresAt         DateTime

revokedAt         DateTime?

createdAt         DateTime @default(now())

user              User
                     @relation(
                       fields:[userId],
                       references:[id]
                     )

@@index([userId])

@@index([expiresAt])

@@index([revokedAt])
}
</code>

----

====== Étape 8 — Modèle Session ======

===== Ajouter =====

<code prisma>
model Session {

id                String @id @default(uuid())

userId            String

ipAddress         String?

country           String?

userAgent         String?

device            String?

lastSeenAt        DateTime

createdAt         DateTime @default(now())

revokedAt         DateTime?

user              User
                     @relation(
                       fields:[userId],
                       references:[id]
                     )

@@index([userId])

@@index([lastSeenAt])

@@index([revokedAt])
}
</code>

----

====== Étape 9 — Vérification des relations Tenant ======

===== Vérifier =====

Le modèle :

<code prisma>
Tenant
</code>

doit contenir :

<code prisma>
users User[]

roles Role[]
</code>

----

===== Exemple =====

<code prisma>
model Tenant {

id                String @id @default(uuid())

code              String @unique

name              String

active            Boolean @default(true)

users             User[]

roles             Role[]

createdAt         DateTime @default(now())

updatedAt         DateTime @updatedAt
}
</code>

----

====== Étape 10 — Validation Prisma ======

===== Vérifier =====

<code bash>
cd apps/api

npx prisma validate
</code>

----

===== Résultat attendu =====

<code>
The schema at prisma/schema.prisma is valid
</code>

----

====== Étape 11 — Formatage ======

<code bash>
npx prisma format
</code>

----

====== Étape 12 — Création de la migration ======

===== Générer =====

<code bash>
npx prisma migrate dev \
--name auth_module
</code>

----

===== Prisma génère =====

<code>
prisma/migrations

└── xxxx_auth_module

└── migration.sql
</code>

----

====== Étape 13 — Génération du Client Prisma ======

===== Exécuter =====

<code bash>
npx prisma generate
</code>

----

====== Étape 14 — Vérification SQL ======

===== Ouvrir PostgreSQL =====

<code bash>
docker exec -it postgres psql -U postgres
</code>

----

===== Base =====

<code sql>
\c rental_platform
</code>

----

===== Vérifier =====

<code sql>
\d "User"

\d "Role"

\d "Permission"

\d "UserRole"

\d "RolePermission"

\d "RefreshToken"

\d "Session"
</code>

----

====== Définition de terminé ======

Le Sprint 1-A.1 est terminé lorsque :

<code>
✓ User créé

✓ Role créé

✓ Permission créée

✓ UserRole créé

✓ RolePermission créé

✓ RefreshToken créé

✓ Session créée

✓ Migration exécutée

✓ Prisma Client généré

✓ Validation Prisma verte
</code>

----

====== Livrables ======

<code>
schema.prisma

migration auth_module

Prisma Client
</code>

----

====== Sprint 1-A.2 — Prisma Seed Auth ======

===== Objectif =====

Créer automatiquement les données minimales nécessaires au démarrage de la plateforme.

À l'issue de cette étape :

<code>
✓ Tenant principal créé

✓ Permissions créées

✓ Rôles créés

✓ Super Administrateur créé

✓ Affectation des permissions

✓ Affectation du rôle Super Admin

✓ Première connexion possible
</code>

----

====== Architecture du Seed ======

===== Fichier =====

<code>
apps/api/prisma/seed.ts
</code>

----

===== Responsabilités =====

<code>
Créer Tenant

Créer Permissions

Créer Rôles

Créer Super Admin

Associer les permissions

Associer les rôles
</code>

----

====== Étape 1 — Installation bcrypt ======

===== Vérifier =====

<code bash>
npm install bcrypt

npm install -D @types/bcrypt
</code>

----

====== Étape 2 — Configuration package.json ======

===== Ajouter =====

<code json>
{
  "prisma": {
    "seed": "tsx prisma/seed.ts"
  }
}
</code>

----

===== Installer TSX =====

<code bash>
npm install -D tsx
</code>

----

====== Étape 3 — Initialisation du Seed ======

===== Créer =====

<code>
apps/api/prisma/seed.ts
</code>

----

===== Base =====

<code ts>
import { PrismaClient } from '@prisma/client';
import * as bcrypt from 'bcrypt';

const prisma = new PrismaClient();

async function main() {

console.log('Starting seed...');
}

main()
  .then(() => prisma.$disconnect())
  .catch(async (error) => {

console.error(error);

await prisma.$disconnect();

process.exit(1);
  });
</code>

----

====== Étape 4 — Création du Tenant principal ======

===== Ajouter =====

<code ts>
const tenant =
  await prisma.tenant.upsert({

where: {
      code: 'MAIN'
    },

update: {},

create: {

code: 'MAIN',

active: true
    }
  });
</code>

----

===== Résultat =====

devient le tenant par défaut.

----

====== Étape 5 — Création des Permissions ======

===== Liste minimale =====

<code>
users.read
users.create
users.update
users.delete

roles.read
roles.manage

properties.read
properties.create
properties.update
properties.delete

reservations.read
reservations.create
reservations.update
reservations.delete

payments.read
payments.create

crm.read
crm.manage

security.read
security.manage
</code>

----

===== Implémentation =====

<code ts>
const permissions = [

'users.read',
  'users.create',
  'users.update',
  'users.delete',

'roles.read',
  'roles.manage',

'properties.read',
  'properties.create',
  'properties.update',
  'properties.delete',

'reservations.read',
  'reservations.create',
  'reservations.update',
  'reservations.delete',

'payments.read',
  'payments.create',

'crm.read',
  'crm.manage',

'security.read',
  'security.manage'
];
</code>

----

===== Création =====

<code ts>
for (const code of permissions) {

await prisma.permission.upsert({

where: { code },

update: {},

create: {

code,

----

====== Étape 6 — Création des rôles ======

===== Rôles système =====

<code>
SUPER_ADMIN

ADMIN

MANAGER

OWNER

CUSTOMER
</code>

----

===== Création =====

<code ts>
const superAdminRole =
  await prisma.role.upsert({

where: {

tenantId_code: {

tenantId: tenant.id,

code: 'SUPER_ADMIN'
      }
    },

update: {},

create: {

tenantId: tenant.id,

code: 'SUPER_ADMIN',

----

===== Répéter pour =====

<code>
ADMIN

MANAGER

OWNER

CUSTOMER
</code>

----

====== Étape 7 — Attribution des permissions ======

===== Charger =====

<code ts>
const allPermissions =
  await prisma.permission.findMany();
</code>

----

===== Affectation =====

<code ts>
for (const permission of allPermissions) {

await prisma.rolePermission.upsert({

where: {

roleId_permissionId: {

roleId: superAdminRole.id,

permissionId: permission.id
      }
    },

update: {},

create: {

roleId: superAdminRole.id,

permissionId: permission.id
    }
  });
}
</code>

----

===== Résultat =====

<code>
SUPER_ADMIN

↓

Toutes les permissions
</code>

----

====== Étape 8 — Création du compte Super Admin ======

===== Variables =====

<code>
admin@platform.local

Admin123!
</code>

----

===== Hash =====

<code ts>
const passwordHash =
  await bcrypt.hash(
    'Admin123!',
    12
  );
</code>

----

===== Création =====

<code ts>
const admin =
  await prisma.user.upsert({

where: {

email: 'admin@platform.local'
    },

update: {},

create: {

tenantId: tenant.id,

email: 'admin@platform.local',

passwordHash,

firstName: 'Super',

lastName: 'Admin',

emailVerified: true,

status: 'ACTIVE'
    }
  });
</code>

----

====== Étape 9 — Affectation du rôle ======

===== Ajouter =====

<code ts>
await prisma.userRole.upsert({

where: {

userId_roleId: {

userId: admin.id,

roleId: superAdminRole.id
    }
  },

update: {},

create: {

userId: admin.id,

roleId: superAdminRole.id
  }
});
</code>

----

====== Étape 10 — Logs ======

===== Ajouter =====

<code ts>
console.log(
  'Tenant created:',
  tenant.code
);

console.log(
  'Admin:',
  admin.email
);

console.log(
  'Seed completed'
);
</code>

----

====== Étape 11 — Exécution ======

===== Lancer =====

<code bash>
cd apps/api

npx prisma db seed
</code>

----

===== Résultat attendu =====

<code>
Starting seed...

Tenant created: MAIN

Admin: admin@platform.local

Seed completed
</code>

----

====== Étape 12 — Vérification Prisma Studio ======

===== Ouvrir =====

<code bash>
npx prisma studio
</code>

----

===== Vérifier =====

<code>
Tenant

User

Role

Permission

UserRole

RolePermission
</code>

----

====== Étape 13 — Vérification SQL ======

===== Utilisateur =====

<code sql>
SELECT email

FROM "User";
</code>

----

===== Résultat =====

<code>
admin@platform.local
</code>

----

===== Permissions =====

<code sql>
SELECT count(*)

FROM "Permission";
</code>

----

===== Résultat =====

----

====== Sécurisation future ======

===== Ne jamais conserver =====

<code>
Admin123!
</code>

en production.

----

===== Prévoir =====

<code>
ADMIN_EMAIL

ADMIN_PASSWORD
</code>

dans :

pour les environnements réels.

----

====== Définition de terminé ======

Le Sprint 1-A.2 est terminé lorsque :

<code>
✓ Tenant créé

✓ Permissions créées

✓ Rôles créés

✓ Super Admin créé

✓ Affectation des permissions

✓ Affectation du rôle

✓ Seed exécutable

✓ Première connexion possible
</code>

----

====== Livrables ======

<code>
prisma/seed.ts

package.json

Permissions système

Rôles système

Compte Super Admin
</code>

----

====== Sprint 1-B.1 — Création du AuthModule NestJS ======

===== Objectif =====

Implémenter le premier module métier réellement exécutable de la plateforme.

À l'issue de cette étape :

<code>
✓ AuthModule

✓ AuthController

✓ AuthService

✓ PasswordService

✓ JwtStrategy

✓ JwtAuthGuard

✓ Register

✓ Login

✓ Refresh

✓ Logout

✓ Current User
</code>

----

====== Étape 1 — Création de la structure ======

===== Répertoire =====

Créer :

<code>
apps/api/src/modules/auth
</code>

----

===== Arborescence =====

<code>
auth

├── application
│
│   ├── dto
│   ├── commands
│   ├── queries
│   └── handlers
│
├── domain
│
│   └── services
│
├── infrastructure
│
│   └── strategies
│
├── presentation
│
│   ├── controllers
│   └── guards
│
└── auth.module.ts
</code>

----

====== Étape 2 — Création du AuthModule ======

===== Fichier =====

<code>
auth.module.ts
</code>

----

===== Implémentation =====

<code ts>
import { Module } from '@nestjs/common';
import { JwtModule } from '@nestjs/jwt';

import { AuthController } from './presentation/controllers/auth.controller';
import { AuthService } from './domain/services/auth.service';
import { PasswordService } from './domain/services/password.service';
import { JwtStrategy } from './infrastructure/strategies/jwt.strategy';

@Module({

imports: [

JwtModule.register({})
  ],

controllers: [

AuthController
  ],

providers: [

AuthService,

PasswordService,

JwtStrategy
  ],

exports: [

AuthService
  ]
})
export class AuthModule {}
</code>

----

====== Étape 3 — RegisterDto ======

===== Fichier =====

<code>
application/dto/register.dto.ts
</code>

----

===== Code =====

<code ts>
import {
  IsEmail,
  IsString,
  MinLength
} from 'class-validator';

export class RegisterDto {

@IsEmail()
  email: string;

@MinLength(8)
  password: string;

@IsString()
  firstName: string;

@IsString()
  lastName: string;
}
</code>

----

====== Étape 4 — LoginDto ======

===== Fichier =====

<code>
application/dto/login.dto.ts
</code>

----

===== Code =====

<code ts>
import {
  IsEmail,
  IsString
} from 'class-validator';

export class LoginDto {

@IsEmail()
  email: string;

@IsString()
  password: string;
}
</code>

----

====== Étape 5 — RefreshTokenDto ======

===== Fichier =====

<code>
application/dto/refresh-token.dto.ts
</code>

----

===== Code =====

<code ts>
import {
  IsString
} from 'class-validator';

export class RefreshTokenDto {

@IsString()
  refreshToken: string;
}
</code>

----

====== Étape 6 — PasswordService ======

===== Fichier =====

<code>
domain/services/password.service.ts
</code>

----

===== Implémentation =====

<code ts>
import * as bcrypt from 'bcrypt';

export class PasswordService {

async hash(
    password: string
  ): Promise<string> {

return bcrypt.hash(
      password,
      12
    );
  }

async compare(
    password: string,
    hash: string
  ): Promise<boolean> {

return bcrypt.compare(
      password,
      hash
    );
  }
}
</code>

----

====== Étape 7 — AuthService ======

===== Fichier =====

<code>
domain/services/auth.service.ts
</code>

----

===== Responsabilités =====

<code>
Register

Login

Refresh

Logout

Current User
</code>

----

===== Squelette =====

<code ts>
@Injectable()
export class AuthService {

async register() {}

async login() {}

async refresh() {}

async logout() {}

async me() {}
}
</code>

----

====== Étape 8 — JWT Payload ======

===== Fichier =====

<code>
infrastructure/strategies/jwt-payload.interface.ts
</code>

----

===== Code =====

<code ts>
export interface JwtPayload {

sub: string;

tenantId: string;

email: string;
}
</code>

----

====== Étape 9 — JwtStrategy ======

===== Fichier =====

<code>
infrastructure/strategies/jwt.strategy.ts
</code>

----

===== Implémentation =====

<code ts>
@Injectable()
export class JwtStrategy
extends PassportStrategy(
  Strategy
) {

constructor() {

super({

jwtFromRequest:
        ExtractJwt.fromAuthHeaderAsBearerToken(),

ignoreExpiration: false,

secretOrKey:
        process.env.JWT_SECRET
    });
  }

async validate(
    payload: JwtPayload
  ) {

return payload;
  }
}
</code>

----

====== Étape 10 — JwtAuthGuard ======

===== Fichier =====

<code>
presentation/guards/jwt-auth.guard.ts
</code>

----

===== Code =====

<code ts>
@Injectable()
export class JwtAuthGuard
extends AuthGuard('jwt') {}
</code>

----

====== Étape 11 — AuthController ======

===== Fichier =====

<code>
presentation/controllers/auth.controller.ts
</code>

----

===== Déclaration =====

<code ts>
@ApiTags('Auth')

@Controller('auth')

export class AuthController {

}
</code>

----

====== Étape 12 — Endpoint Register ======

===== Route =====

<code http>
POST /auth/register
</code>

----

===== Code =====

<code ts>
@Post('register')

register(
  @Body()
  dto: RegisterDto
) {

return this.authService
    .register(dto);
}
</code>

----

====== Étape 13 — Endpoint Login ======

===== Route =====

<code http>
POST /auth/login
</code>

----

===== Code =====

<code ts>
@Post('login')

login(
  @Body()
  dto: LoginDto
) {

return this.authService
    .login(dto);
}
</code>

----

====== Étape 14 — Endpoint Refresh ======

===== Route =====

<code http>
POST /auth/refresh
</code>

----

===== Code =====

<code ts>
@Post('refresh')

refresh(
  @Body()
  dto: RefreshTokenDto
) {

return this.authService
    .refresh(dto);
}
</code>

----

====== Étape 15 — Endpoint Logout ======

===== Route =====

<code http>
POST /auth/logout
</code>

----

===== Sécurisé =====

<code ts>
@UseGuards(
  JwtAuthGuard
)
</code>

----

===== Code =====

<code ts>
@Post('logout')

logout(
  @Req() req
) {

return this.authService
    .logout(
      req.user.sub
    );
}
</code>

----

====== Étape 16 — Endpoint Me ======

===== Route =====

----

===== Sécurisé =====

<code ts>
@UseGuards(
  JwtAuthGuard
)
</code>

----

===== Code =====

<code ts>
@Get('me')

me(
  @Req() req
) {

return this.authService
    .me(
      req.user.sub
    );
}
</code>

----

====== Étape 17 — Configuration JWT ======

===== .env =====

<code>
JWT_SECRET=change-me

JWT_EXPIRES_IN=15m

REFRESH_SECRET=change-me-too

REFRESH_EXPIRES_IN=30d
</code>

----

====== Étape 18 — Import Module ======

===== AppModule =====

Ajouter :

<code ts>
imports: [

AuthModule
]
</code>

----

====== Étape 19 — Vérification compilation ======

===== Build =====

<code bash>
nx build api
</code>

----

===== Résultat attendu =====

<code>
SUCCESS
</code>

----

====== Étape 20 — Swagger ======

===== Vérification =====

<code>
/auth/register

/auth/login

/auth/refresh

/auth/logout

/auth/me
</code>

doivent apparaître dans :

<code>
http://localhost:3000/api
</code>

----

====== Définition de terminé ======

Le Sprint 1-B.1 est terminé lorsque :

<code>
✓ AuthModule créé

✓ DTO créés

✓ PasswordService créé

✓ JwtStrategy créée

✓ JwtAuthGuard créé

✓ AuthController créé

✓ Endpoints exposés

✓ Swagger visible

✓ Build vert
</code>

----

====== Livrables ======

<code>
AuthModule

AuthController

AuthService

PasswordService

JwtStrategy

JwtAuthGuard

RegisterDto

LoginDto

RefreshTokenDto
</code>

----

====== Sprint 1-B.2 — Implémentation réelle du Register ======

===== Objectif =====

Rendre le endpoint :

<code http>
POST /auth/register
</code>

entièrement fonctionnel.

À l'issue de cette étape :

<code>
✓ Vérification email unique

✓ Hash du mot de passe

✓ Création User

✓ Attribution rôle CUSTOMER

✓ Création RefreshToken

✓ Génération JWT

✓ Retour utilisateur connecté
</code>

----

====== Workflow complet ======

<code>
Register Request

↓

Validation DTO

↓

Vérification email

↓

Hash Password

↓

Create User

↓

Assign CUSTOMER Role

↓

Generate JWT

↓

Generate Refresh Token

↓

Persist Refresh Token

↓

Response
</code>

----

====== Étape 1 — Création des types de réponse ======

===== AuthResponse =====

Créer :

<code>
application/dto/auth-response.dto.ts
</code>

----

===== Code =====

<code ts>
export class AuthResponseDto {

accessToken: string;

refreshToken: string;

user: {

id: string;

email: string;

firstName: string;

lastName: string;
  };
}
</code>

----

====== Étape 2 — Injection Prisma ======

===== Prérequis =====

Le :

<code>
PrismaModule
</code>

doit exporter :

<code>
PrismaService
</code>

----

===== AuthModule =====

Ajouter :

<code ts>
imports: [

PrismaModule,

JwtModule.register({})
]
</code>

----

====== Étape 3 — Injection des dépendances ======

===== AuthService =====

Modifier :

<code ts>
@Injectable()
export class AuthService {

constructor(

private readonly prisma: PrismaService,

private readonly jwtService: JwtService,

private readonly passwordService: PasswordService
  ) {}
}
</code>

----

====== Étape 4 — Recherche du rôle CUSTOMER ======

===== Constante =====

Créer :

<code>
shared/constants/roles.constants.ts
</code>

----

===== Code =====

<code ts>
export const SYSTEM_ROLES = {

SUPER_ADMIN: 'SUPER_ADMIN',

ADMIN: 'ADMIN',

MANAGER: 'MANAGER',

OWNER: 'OWNER',

CUSTOMER: 'CUSTOMER'
};
</code>

----

====== Étape 5 — Création du Register ======

===== Signature =====

<code ts>
async register(
  dto: RegisterDto
): Promise<AuthResponseDto>
</code>

----

====== Étape 6 — Vérification email ======

===== Ajouter =====

<code ts>
const existingUser =
  await this.prisma.user.findUnique({

where: {

email: dto.email
    }
  });

if (existingUser) {

throw new ConflictException(
    'Email already exists'
  );
}
</code>

----

====== Étape 7 — Charger le Tenant principal ======

===== Ajouter =====

<code ts>
const tenant =
  await this.prisma.tenant.findUnique({

where: {

code: 'MAIN'
    }
  });

if (!tenant) {

throw new Error(
    'Main tenant not found'
  );
}
</code>

----

====== Étape 8 — Hash mot de passe ======

===== Ajouter =====

<code ts>
const passwordHash =
  await this.passwordService.hash(
    dto.password
  );
</code>

----

====== Étape 9 — Création User ======

===== Ajouter =====

<code ts>
const user =
  await this.prisma.user.create({

data: {

tenantId: tenant.id,

email: dto.email,

passwordHash,

firstName: dto.firstName,

lastName: dto.lastName,

status: 'ACTIVE'
    }
  });
</code>

----

====== Étape 10 — Charger rôle CUSTOMER ======

===== Ajouter =====

<code ts>
const customerRole =
  await this.prisma.role.findFirst({

where: {

tenantId: tenant.id,

code: SYSTEM_ROLES.CUSTOMER
    }
  });

if (!customerRole) {

throw new Error(
    'Customer role missing'
  );
}
</code>

----

====== Étape 11 — Affecter le rôle ======

===== Ajouter =====

<code ts>
await this.prisma.userRole.create({

data: {

userId: user.id,

roleId: customerRole.id
  }
});
</code>

----

====== Étape 12 — Génération JWT ======

===== Payload =====

<code ts>
const payload = {

sub: user.id,

tenantId: tenant.id,

email: user.email
};
</code>

----

===== Token =====

<code ts>
const accessToken =
  await this.jwtService.signAsync(
    payload,
    {
      secret:
        process.env.JWT_SECRET,

expiresIn:
        process.env.JWT_EXPIRES_IN
    }
  );
</code>

----

====== Étape 13 — Génération Refresh Token ======

===== Token brut =====

<code ts>
const refreshToken =
  randomUUID();
</code>

----

===== Hash =====

<code ts>
const refreshTokenHash =
  await this.passwordService.hash(
    refreshToken
  );
</code>

----

===== Sauvegarde =====

<code ts>
await this.prisma.refreshToken.create({

data: {

userId: user.id,

tokenHash: refreshTokenHash,

expiresAt: addDays(
      new Date(),
      30
    )
  }
});
</code>

----

====== Étape 14 — Réponse ======

===== Retour =====

<code ts>
return {

accessToken,

refreshToken,

user: {

id: user.id,

email: user.email,

firstName: user.firstName,

lastName: user.lastName
  }
};
</code>

----

====== Étape 15 — Controller ======

===== Route =====

<code ts>
@Post('register')

@ApiOperation({

summary:
    'Register a new user'
})
</code>

----

===== Response =====

<code ts>
@ApiCreatedResponse({

type: AuthResponseDto
})
</code>

----

====== Étape 16 — Validation globale ======

===== main.ts =====

Vérifier :

<code ts>
app.useGlobalPipes(

new ValidationPipe({

whitelist: true,

forbidNonWhitelisted: true,

transform: true
  })
);
</code>

----

====== Étape 17 — Test manuel ======

===== Requête =====

<code http>
POST /auth/register
</code>

----

===== Body =====

<code json>
{
  "email": "john@example.com",
  "password": "Password123!",
  "firstName": "John",
  "lastName": "Doe"
}
</code>

----

===== Réponse attendue =====

<code json>
{
  "accessToken": "...",

"refreshToken": "...",

"user": {

"id": "...",

"email": "john@example.com",

"firstName": "John",

"lastName": "Doe"
  }
}
</code>

----

====== Étape 18 — Vérification SQL ======

===== User =====

<code sql>
SELECT email

FROM "User";
</code>

----

===== UserRole =====

<code sql>
SELECT *

FROM "UserRole";
</code>

----

===== RefreshToken =====

<code sql>
SELECT *

FROM "RefreshToken";
</code>

----

====== Cas d'erreur ======

===== Email déjà utilisé =====

<code json>
{
  "statusCode": 409,

"message":
    "Email already exists"
}
</code>

----

===== Tenant absent =====

<code json>
{
  "statusCode": 500,

"message":
    "Main tenant not found"
}
</code>

----

====== Définition de terminé ======

Le Sprint 1-B.2 est terminé lorsque :

<code>
✓ Register fonctionnel

✓ User créé

✓ Password hashé

✓ CUSTOMER assigné

✓ JWT généré

✓ Refresh Token généré

✓ Swagger documenté

✓ Test manuel réussi
</code>

----

====== Livrables ======

<code>
AuthService.register()

AuthResponseDto

roles.constants.ts

Swagger Register

Validation complète
</code>

----

====== Sprint 1-B.3 — Implémentation réelle du Login ======

===== Objectif =====

Rendre le endpoint :

<code http>
POST /auth/login
</code>

entièrement fonctionnel.

À l'issue de cette étape :

<code>
✓ Recherche utilisateur

✓ Vérification mot de passe

✓ Vérification statut utilisateur

✓ Création Session

✓ Génération JWT

✓ Génération Refresh Token

✓ Historisation connexion

✓ Retour utilisateur authentifié
</code>

----

====== Workflow complet ======

<code>
Login Request

↓

Find User

↓

Verify Password

↓

Verify Status

↓

Create Session

↓

Generate JWT

↓

Generate Refresh Token

↓

Store Refresh Token

↓

Return Auth Response
</code>

----

====== Étape 1 — Création de SessionDto ======

===== Créer =====

<code>
application/dto/session-info.dto.ts
</code>

----

===== Contenu =====

<code ts>
export class SessionInfoDto {

ipAddress?: string;

userAgent?: string;
}
</code>

----

====== Étape 2 — Mise à jour AuthController ======

===== Login =====

Modifier :

<code ts>
@Post('login')

login(

@Body()
  dto: LoginDto,

@Req()
  request: Request
) {

return this.authService.login(

dto,

{
      ipAddress: request.ip,

userAgent:
        request.headers['user-agent']
    }
  );
}
</code>

----

====== Étape 3 — Signature Login ======

===== AuthService =====

Modifier :

<code ts>
async login(

dto: LoginDto,

session: SessionInfoDto
): Promise<AuthResponseDto>
</code>

----

====== Étape 4 — Recherche utilisateur ======

===== Ajouter =====

<code ts>
const user =
  await this.prisma.user.findUnique({

where: {

email: dto.email
    },

include: {

userRoles: {

include: {

role: true
        }
      }
    }
  });
</code>

----

===== Vérification =====

<code ts>
if (!user) {

throw new UnauthorizedException(
    'Invalid credentials'
  );
}
</code>

----

====== Étape 5 — Vérification statut ======

===== Ajouter =====

<code ts>
if (

user.status !== 'ACTIVE'

) {

throw new ForbiddenException(
    'Account disabled'
  );
}
</code>

----

====== Étape 6 — Vérification mot de passe ======

===== Ajouter =====

<code ts>
const validPassword =
  await this.passwordService.compare(

dto.password,

user.passwordHash
  );
</code>

----

===== Contrôle =====

<code ts>
if (!validPassword) {

throw new UnauthorizedException(
    'Invalid credentials'
  );
}
</code>

----

====== Étape 7 — Génération du JWT ======

===== Payload =====

<code ts>
const payload = {

sub: user.id,

tenantId: user.tenantId,

email: user.email
};
</code>

----

===== Génération =====

<code ts>
const accessToken =
  await this.jwtService.signAsync(

payload,

{

secret:
        process.env.JWT_SECRET,

expiresIn:
        process.env.JWT_EXPIRES_IN
    }
  );
</code>

----

====== Étape 8 — Génération Refresh Token ======

===== Token =====

<code ts>
const refreshToken =
  randomUUID();
</code>

----

===== Hash =====

<code ts>
const refreshTokenHash =
  await this.passwordService.hash(

refreshToken
  );
</code>

----

===== Sauvegarde =====

<code ts>
await this.prisma.refreshToken.create({

data: {

userId: user.id,

tokenHash: refreshTokenHash,

expiresAt: addDays(
      new Date(),
      30
    )
  }
});
</code>

----

====== Étape 9 — Création Session ======

===== Ajouter =====

<code ts>
await this.prisma.session.create({

data: {

userId: user.id,

ipAddress:
      session.ipAddress,

userAgent:
      session.userAgent,

lastSeenAt:
      new Date()
  }
});
</code>

----

====== Étape 10 — Historisation connexion ======

===== Mise à jour User =====

<code ts>
await this.prisma.user.update({

where: {

id: user.id
  },

data: {

lastLoginAt:
      new Date()
  }
});
</code>

----

====== Étape 11 — Chargement des rôles ======

===== Extraire =====

<code ts>
const roles =
  user.userRoles.map(

item => item.role.code
  );
</code>

----

====== Étape 12 — Retour réponse ======

===== Réponse =====

<code ts>
return {

accessToken,

refreshToken,

user: {

id: user.id,

email: user.email,

firstName: user.firstName,

lastName: user.lastName,

roles
  }
};
</code>

----

====== Étape 13 — Swagger ======

===== Login =====

Ajouter :

<code ts>
@ApiOperation({

summary:
    'Authenticate user'
})
</code>

----

===== Response =====

<code ts>
@ApiOkResponse({

type: AuthResponseDto
})
</code>

----

====== Étape 14 — Cas d'erreurs ======

===== Mauvais mot de passe =====

<code json>
{
  "statusCode": 401,

"message":
    "Invalid credentials"
}
</code>

----

===== Utilisateur absent =====

<code json>
{
  "statusCode": 401,

"message":
    "Invalid credentials"
}
</code>

----

===== Compte bloqué =====

<code json>
{
  "statusCode": 403,

"message":
    "Account disabled"
}
</code>

----

====== Étape 15 — Test Swagger ======

===== Requête =====

<code http>
POST /auth/login
</code>

----

===== Body =====

<code json>
{
  "email": "admin@platform.local",

"password": "Admin123!"
}
</code>

----

===== Réponse =====

<code json>
{
  "accessToken": "...",

"refreshToken": "...",

"user": {

"id": "...",

"email": "admin@platform.local",

"firstName": "Super",

"lastName": "Admin",

"roles": [

"SUPER_ADMIN"
    ]
  }
}
</code>

----

====== Étape 16 — Vérification SQL ======

===== Session =====

<code sql>
SELECT *

FROM "Session";
</code>

----

===== RefreshToken =====

<code sql>
SELECT *

FROM "RefreshToken";
</code>

----

===== User =====

<code sql>
SELECT
  email,
  "lastLoginAt"

FROM "User";
</code>

----

====== Refactoring recommandé ======

À partir de maintenant, factoriser la génération des tokens.

Créer :

<code>
domain/services/token.service.ts
</code>

----

===== Responsabilités =====

<code>
generateAccessToken()

generateRefreshToken()

verifyRefreshToken()
</code>

----

====== Définition de terminé ======

Le Sprint 1-B.3 est terminé lorsque :

<code>
✓ Login fonctionnel

✓ Password vérifié

✓ Statut vérifié

✓ JWT généré

✓ Refresh Token généré

✓ Session créée

✓ Historique connexion mis à jour

✓ Swagger documenté

✓ Test manuel réussi
</code>

----

====== Livrables ======

<code>
AuthService.login()

SessionInfoDto

Swagger Login

Création Session

Historisation connexion
</code>

----
====== Sprint 1-B.4 — Implémentation réelle du Refresh Token ======

===== Objectif =====

Rendre le endpoint :

<code http>
POST /auth/refresh
</code>

entièrement fonctionnel.

À l'issue de cette étape :

<code>
✓ Validation Refresh Token

✓ Recherche utilisateur

✓ Vérification expiration

✓ Rotation Refresh Token

✓ Révocation ancien token

✓ Nouveau JWT

✓ Nouveau Refresh Token

✓ Réponse authentifiée
</code>

----

====== Workflow complet ======

<code>
Refresh Request

↓

Find Valid Refresh Token

↓

Verify Token

↓

Load User

↓

Revoke Old Token

↓

Generate New JWT

↓

Generate New Refresh Token

↓

Persist New Refresh Token

↓

Return Tokens
</code>

----

====== Étape 1 — Création du TokenService ======

===== Créer =====

<code>
src/modules/auth/domain/services/token.service.ts
</code>

----

===== Responsabilités =====

<code>
generateAccessToken()

generateRefreshToken()

hashRefreshToken()

verifyRefreshToken()
</code>

----

===== Squelette =====

<code ts>
@Injectable()
export class TokenService {

constructor(
    private readonly jwtService: JwtService,
    private readonly passwordService: PasswordService
  ) {}
}
</code>

----

====== Étape 2 — Génération Access Token ======

===== Ajouter =====

<code ts>
async generateAccessToken(
  payload: JwtPayload
): Promise<string> {

return this.jwtService.signAsync(
    payload,
    {
      secret:
        process.env.JWT_SECRET,

expiresIn:
        process.env.JWT_EXPIRES_IN
    }
  );
}
</code>

----

====== Étape 3 — Génération Refresh Token ======

===== Ajouter =====

<code ts>
async generateRefreshToken() {

const rawToken =
    randomUUID();

return rawToken;
}
</code>

----

====== Étape 4 — Hash Refresh Token ======

===== Ajouter =====

<code ts>
async hashRefreshToken(
  token: string
) {

return this.passwordService.hash(
    token
  );
}
</code>

----

====== Étape 5 — Enregistrement Refresh Token ======

===== Ajouter =====

<code ts>
async storeRefreshToken(

userId: string,

token: string
) {

const tokenHash =
    await this.hashRefreshToken(
      token
    );

return prisma.refreshToken.create({

data: {

userId,

tokenHash,

expiresAt: addDays(
        new Date(),
        30
      )
    }
  });
}
</code>

----

====== Étape 6 — Injection dans AuthModule ======

===== Ajouter =====

<code ts>
providers: [

AuthService,

PasswordService,

TokenService,

JwtStrategy
]
</code>

----

====== Étape 7 — Injection dans AuthService ======

===== Constructeur =====

<code ts>
constructor(

private readonly prisma:
    PrismaService,

private readonly tokenService:
    TokenService,

private readonly passwordService:
    PasswordService
) {}
</code>

----

====== Étape 8 — Signature Refresh ======

===== AuthService =====

<code ts>
async refresh(

dto: RefreshTokenDto
): Promise<AuthResponseDto>
</code>

----

====== Étape 9 — Charger les Refresh Tokens ======

===== Ajouter =====

<code ts>
const refreshTokens =
  await this.prisma.refreshToken.findMany({

where: {

revokedAt: null,

expiresAt: {

gt: new Date()
      }
    },

include: {

user: {

include: {

userRoles: {

include: {

role: true
            }
          }
        }
      }
    }
  });
</code>

----

====== Étape 10 — Vérification du token ======

===== Recherche =====

<code ts>
let matchedToken = null;

for (
  const refreshToken
  of refreshTokens
) {

const valid =
    await this.passwordService.compare(

dto.refreshToken,

refreshToken.tokenHash
    );

if (valid) {

matchedToken =
      refreshToken;

break;
  }
}
</code>

----

===== Contrôle =====

<code ts>
if (!matchedToken) {

throw new UnauthorizedException(
    'Invalid refresh token'
  );
}
</code>

----

====== Étape 11 — Vérifier utilisateur ======

===== Ajouter =====

<code ts>
const user =
  matchedToken.user;
</code>

----

===== Contrôle =====

<code ts>
if (

user.status !== 'ACTIVE'

) {

throw new UnauthorizedException(
    'User inactive'
  );
}
</code>

----

====== Étape 12 — Révocation ancien Refresh Token ======

===== Ajouter =====

<code ts>
await this.prisma.refreshToken.update({

where: {

id: matchedToken.id
  },

data: {

revokedAt:
      new Date()
  }
});
</code>

----

====== Étape 13 — Génération nouveau JWT ======

===== Payload =====

<code ts>
const payload = {

sub: user.id,

tenantId: user.tenantId,

email: user.email
};
</code>

----

===== Génération =====

<code ts>
const accessToken =
  await this.tokenService
    .generateAccessToken(
      payload
    );
</code>

----

====== Étape 14 — Génération nouveau Refresh Token ======

===== Ajouter =====

<code ts>
const refreshToken =
  await this.tokenService
    .generateRefreshToken();
</code>

----

===== Persistance =====

<code ts>
await this.tokenService
  .storeRefreshToken(

user.id,

refreshToken
  );
</code>

----

====== Étape 15 — Chargement des rôles ======

===== Ajouter =====

<code ts>
const roles =
  user.userRoles.map(

role => role.role.code
  );
</code>

----

====== Étape 16 — Retour ======

===== Réponse =====

<code ts>
return {

accessToken,

refreshToken,

user: {

id: user.id,

email: user.email,

firstName:
      user.firstName,

lastName:
      user.lastName,

roles
  }
};
</code>

----

====== Étape 17 — Swagger ======

===== Route =====

<code ts>
@Post('refresh')
</code>

----

===== Documentation =====

<code ts>
@ApiOperation({

summary:
    'Refresh access token'
})

@ApiOkResponse({

type: AuthResponseDto
})
</code>

----

====== Étape 18 — Cas d'erreurs ======

===== Token invalide =====

<code json>
{
  "statusCode": 401,

"message":
    "Invalid refresh token"
}
</code>

----

===== Utilisateur inactif =====

<code json>
{
  "statusCode": 401,

"message":
    "User inactive"
}
</code>

----

====== Étape 19 — Test Swagger ======

===== Requête =====

<code http>
POST /auth/refresh
</code>

----

===== Body =====

<code json>
{
  "refreshToken":
    "xxxxxxxx"
}
</code>

----

===== Réponse =====

<code json>
{
  "accessToken": "...",

"refreshToken": "...",

"user": {

"id": "...",

"email": "...",

"roles": [
      "CUSTOMER"
    ]
  }
}
</code>

----

====== Étape 20 — Vérification SQL ======

===== Ancien token =====

<code sql>
SELECT *

FROM "RefreshToken"

WHERE "revokedAt"
IS NOT NULL;
</code>

----

===== Nouveau token =====

<code sql>
SELECT *

FROM "RefreshToken"

WHERE "revokedAt"
IS NULL;
</code>

----

====== Optimisation recommandée ======

===== Problème =====

La recherche par :

<code ts>
findMany()
</code>

puis comparaison BCrypt n'est pas scalable.

----

===== Amélioration Sprint 1.5 =====

Ajouter :

<code prisma>
tokenId String @unique
</code>

dans :

<code>
RefreshToken
</code>

et stocker :

<code>
tokenId.rawToken
</code>

afin de retrouver directement le token.

----

====== Définition de terminé ======

Le Sprint 1-B.4 est terminé lorsque :

<code>
✓ Refresh fonctionnel

✓ Ancien token révoqué

✓ Nouveau JWT généré

✓ Nouveau Refresh Token généré

✓ Rotation opérationnelle

✓ Swagger documenté

✓ Tests manuels réussis
</code>

----

====== Livrables ======

<code>
TokenService

AuthService.refresh()

Swagger Refresh

Rotation Refresh Token
</code>

----

====== Sprint 1-B.5 — Implémentation réelle du Logout ======

===== Objectif =====

Rendre le endpoint :

<code http>
POST /auth/logout
</code>

entièrement fonctionnel.

À l'issue de cette étape :

<code>
✓ JWT requis

✓ Session révoquée

✓ Refresh Tokens révoqués

✓ Déconnexion complète

✓ Audit de déconnexion

✓ Swagger documenté
</code>

----

====== Workflow complet ======

<code>
Logout Request

↓

JWT Validation

↓

Load User

↓

Load Active Session

↓

Revoke Session

↓

Revoke Refresh Tokens

↓

Audit Log

↓

Success Response
</code>

----

====== Étape 1 — Création du DTO de réponse ======

===== Créer =====

<code>
application/dto/logout-response.dto.ts
</code>

----

===== Code =====

<code ts>
export class LogoutResponseDto {

success: boolean;

message: string;
}
</code>

----

====== Étape 2 — Amélioration du JWT Payload ======

===== Fichier =====

<code>
jwt-payload.interface.ts
</code>

----

===== Ajouter =====

<code ts>
export interface JwtPayload {

sub: string;

tenantId: string;

email: string;

sessionId?: string;
}
</code>

----

===== Objectif =====

Pouvoir relier :

<code>
JWT

↓

Session
</code>

afin de révoquer précisément la session active.

----

====== Étape 3 — Adapter le Login ======

===== Lors de la création Session =====

Modifier :

<code ts>
const createdSession =
  await this.prisma.session.create({
    data: {
      userId: user.id,
      ipAddress: session.ipAddress,
      userAgent: session.userAgent,
      lastSeenAt: new Date()
    }
  });
</code>

----

===== JWT Payload =====

Ajouter :

<code ts>
const payload = {

sub: user.id,

tenantId: user.tenantId,

email: user.email,

sessionId: createdSession.id
};
</code>

----

===== Résultat =====

Chaque JWT référence désormais :

<code>
Session.id
</code>

----

====== Étape 4 — Signature Logout ======

===== AuthService =====

Ajouter :

<code ts>
async logout(

userId: string,

sessionId?: string
): Promise<LogoutResponseDto>
</code>

----

====== Étape 5 — Révocation Session ======

===== Ajouter =====

<code ts>
if (sessionId) {

await this.prisma.session.updateMany({

where: {

id: sessionId,

userId
    },

data: {

revokedAt:
        new Date()
    }
  });
}
</code>

----

===== Résultat =====

La session courante devient :

<code>
Révoquée
</code>

----

====== Étape 6 — Révocation Refresh Tokens ======

===== Ajouter =====

<code ts>
await this.prisma.refreshToken.updateMany({

where: {

userId,

revokedAt: null
  },

data: {

revokedAt:
      new Date()
  }
});
</code>

----

===== Résultat =====

Tous les refresh tokens actifs :

<code>
INVALIDES
</code>

----

====== Étape 7 — Mise à jour dernière activité ======

===== Optionnel =====

Ajouter :

<code ts>
await this.prisma.user.update({

where: {

id: userId
  },

data: {

updatedAt:
      new Date()
  }
});
</code>

----

====== Étape 8 — Réponse ======

===== Retour =====

<code ts>
return {

success: true,

message:
    'Successfully logged out'
};
</code>

----

====== Étape 9 — Controller ======

===== Modifier =====

<code ts>
@Post('logout')

@UseGuards(
  JwtAuthGuard
)

@ApiBearerAuth()
</code>

----

===== Implémentation =====

<code ts>
logout(
  @Req() req
) {

return this.authService.logout(

req.user.sub,

req.user.sessionId
  );
}
</code>

----

====== Étape 10 — Swagger ======

===== Documentation =====

<code ts>
@ApiOperation({

summary:
    'Logout current user'
})
</code>

----

===== Réponse =====

<code ts>
@ApiOkResponse({

type:
    LogoutResponseDto
})
</code>

----

====== Étape 11 — Cas particulier ======

===== Déconnexion globale =====

Créer un futur endpoint :

<code http>
POST /auth/logout-all
</code>

----

===== Fonction =====

Révoquer :

<code>
Toutes les sessions

Tous les refresh tokens
</code>

sur tous les appareils.

----

====== Étape 12 — Vérification Session ======

===== SQL =====

<code sql>
SELECT

id,

"revokedAt"

FROM "Session";
</code>

----

===== Résultat attendu =====

<code>
revokedAt != null
</code>

----

====== Étape 13 — Vérification Refresh Tokens ======

===== SQL =====

<code sql>
SELECT

id,

"revokedAt"

FROM "RefreshToken";
</code>

----

===== Résultat attendu =====

Tous les tokens actifs deviennent :

<code>
revokedAt != null
</code>

----

====== Étape 14 — Test Swagger ======

===== Login =====

<code http>
POST /auth/login
</code>

Récupérer :

<code>
accessToken
</code>

----

===== Logout =====

<code http>
POST /auth/logout
Authorization: Bearer xxx
</code>

----

===== Réponse =====

<code json>
{
  "success": true,
  "message": "Successfully logged out"
}
</code>

----

====== Étape 15 — Vérification sécurité ======

===== Tester =====

Réutiliser :

<code>
Refresh Token précédent
</code>

----

===== Résultat attendu =====

<code json>
{
  "statusCode": 401,
  "message": "Invalid refresh token"
}
</code>

----

====== Amélioration Sprint 1-C ======

Pour renforcer la sécurité Enterprise :

Ajouter dans :

<code prisma>
model Session
</code>

le champ :

<code prisma>
sessionToken String? @unique
</code>

afin de permettre :

<code>
Gestion multi-appareils

Révocation ciblée

Historique complet
</code>

----

====== Définition de terminé ======

Le Sprint 1-B.5 est terminé lorsque :

<code>
✓ Logout fonctionnel

✓ Session révoquée

✓ Refresh Tokens révoqués

✓ Swagger documenté

✓ Test manuel réussi

✓ Sécurité validée
</code>

----

====== Livrables ======

<code>
AuthService.logout()

LogoutResponseDto

Swagger Logout

Révocation Session

Révocation RefreshToken
</code>

----

====== Sprint 1-B.6 — Implémentation réelle du Current User ======

===== Objectif =====

Rendre le endpoint :

entièrement fonctionnel.

À l'issue de cette étape :

<code>
✓ JWT validé

✓ Utilisateur chargé

✓ Rôles chargés

✓ Permissions chargées

✓ Tenant chargé

✓ Profil utilisateur complet

✓ Swagger documenté
</code>

----

====== Workflow complet ======

<code>
GET /auth/me

↓

JWT Validation

↓

Extract UserId

↓

Load User

↓

Load Roles

↓

Load Permissions

↓

Build Profile

↓

Return Response
</code>

----

====== Étape 1 — DTO de réponse ======

===== Créer =====

<code>
application/dto/current-user.dto.ts
</code>

----

===== Contenu =====

<code ts>
export class CurrentUserDto {

id: string;

tenantId: string;

email: string;

firstName: string;

lastName: string;

phone?: string;

status: string;

emailVerified: boolean;

roles: string[];

permissions: string[];

tenant: {

id: string;

code: string;

----

====== Étape 2 — Signature du service ======

===== AuthService =====

Ajouter :

<code ts>
async me(
  userId: string
): Promise<CurrentUserDto>
</code>

----

====== Étape 3 — Chargement utilisateur ======

===== Ajouter =====

<code ts>
const user =
  await this.prisma.user.findUnique({

where: {

id: userId
    },

include: {

tenant: true,

userRoles: {

include: {

role: {

include: {

rolePermissions: {

include: {

permission: true
                }
              }
            }
          }
        }
      }
    }
  });
</code>

----

====== Étape 4 — Vérification utilisateur ======

===== Ajouter =====

<code ts>
if (!user) {

throw new NotFoundException(
    'User not found'
  );
}
</code>

----

====== Étape 5 — Extraction des rôles ======

===== Ajouter =====

<code ts>
const roles =
  user.userRoles.map(

item => item.role.code
  );
</code>

----

===== Résultat =====

Exemple :

<code json>
[
  "SUPER_ADMIN",
  "OWNER"
]
</code>

----

====== Étape 6 — Extraction permissions ======

===== Ajouter =====

<code ts>
const permissions =
  user.userRoles.flatMap(

userRole =>

userRole.role
        .rolePermissions
        .map(

rp =>
            rp.permission.code
        )
  );
</code>

----

====== Étape 7 — Déduplication ======

===== Ajouter =====

<code ts>
const uniquePermissions =

[...new Set(
    permissions
  )];
</code>

----

===== Résultat =====

<code>
users.read

users.create

properties.read

reservations.read
</code>

----

====== Étape 8 — Construction réponse ======

===== Retour =====

<code ts>
return {

id: user.id,

tenantId: user.tenantId,

email: user.email,

firstName: user.firstName,

lastName: user.lastName,

phone: user.phone,

status: user.status,

emailVerified:
    user.emailVerified,

roles,

permissions:
    uniquePermissions,

tenant: {

id: user.tenant.id,

code: user.tenant.code,

----

====== Étape 9 — Contrôleur ======

===== Endpoint =====

<code ts>
@Get('me')

@UseGuards(
  JwtAuthGuard
)

@ApiBearerAuth()
</code>

----

===== Implémentation =====

<code ts>
me(
  @Req() req
) {

return this.authService.me(
    req.user.sub
  );
}
</code>

----

====== Étape 10 — Swagger ======

===== Documentation =====

<code ts>
@ApiOperation({

summary:
    'Get current authenticated user'
})
</code>

----

===== Réponse =====

<code ts>
@ApiOkResponse({

type:
    CurrentUserDto
})
</code>

----

====== Étape 11 — Exemple de réponse ======

===== Retour attendu =====

<code json>
{
  "id": "e1d1c8",

"tenantId": "tenant1",

"email":
    "admin@platform.local",

"firstName":
    "Super",

"lastName":
    "Admin",

"status":
    "ACTIVE",

"emailVerified": true,

"roles": [

"SUPER_ADMIN"
  ],

"permissions": [

"users.read",

"users.create",

"users.update",

"users.delete",

"roles.manage"
  ],

"tenant": {

"id": "tenant-id",

"code": "MAIN",

"name":
      "Main Tenant"
  }
}
</code>

----

====== Étape 12 — Sécurisation ======

===== Refuser =====

<code>
Utilisateur supprimé

Utilisateur bloqué

Utilisateur inactif
</code>

----

===== Ajouter =====

<code ts>
if (

user.status !== 'ACTIVE'

) {

throw new ForbiddenException(
    'Account disabled'
  );
}
</code>

----

====== Étape 13 — Test Swagger ======

===== Login =====

<code http>
POST /auth/login
</code>

----

===== Copier =====

<code>
accessToken
</code>

----

===== Tester =====

<code http>
GET /auth/me

Authorization:
Bearer xxx
</code>

----

===== Résultat =====

Profil utilisateur complet.

----

====== Étape 14 — Vérification SQL ======

===== Utilisateur =====

<code sql>
SELECT *

FROM "User"

WHERE email =
'admin@platform.local';
</code>

----

===== Rôles =====

<code sql>
SELECT *

FROM "UserRole";
</code>

----

===== Permissions =====

<code sql>
SELECT *

FROM "RolePermission";
</code>

----

====== Optimisation future ======

===== Sprint 1-C =====

Ajouter :

<code>
Redis Cache
</code>

sur :

afin d'éviter :

<code>
Chargement complet
des permissions
à chaque requête.
</code>

----

====== Définition de terminé ======

Le Sprint 1-B.6 est terminé lorsque :

<code>
✓ GET /auth/me fonctionnel

✓ JWT validé

✓ Utilisateur chargé

✓ Rôles chargés

✓ Permissions chargées

✓ Swagger documenté

✓ Test manuel réussi
</code>

----

====== Livrables ======

<code>
CurrentUserDto

AuthService.me()

Swagger Current User

Chargement rôles

Chargement permissions
</code>

----

====== Bilan Sprint 1-B ======

Les endpoints suivants sont maintenant opérationnels :

<code>
POST /auth/register

POST /auth/login

POST /auth/refresh

POST /auth/logout

GET /auth/me
</code>

----

====== Sprint 1-C.1 — Implémentation du RBAC Enterprise ======

===== Objectif =====

Mettre en place le moteur de contrôle d'accès central de la plateforme.

À l'issue de cette étape :

<code>
✓ @Roles()

✓ RolesGuard

✓ @Permissions()

✓ PermissionsGuard

✓ Metadata Reflector

✓ Contrôle d'accès complet

✓ Swagger compatible

✓ Réutilisable dans tous les modules
</code>

----

====== Architecture cible ======

<code>
Controller

↓

@Roles()

@Permissions()

↓

JwtAuthGuard

↓

RolesGuard

↓

PermissionsGuard

↓

Access Granted
</code>

----

====== Structure ======

===== Créer =====

<code>
src/modules/auth/presentation

├── decorators
│
│   ├── roles.decorator.ts
│   └── permissions.decorator.ts
│
├── guards
│
│   ├── jwt-auth.guard.ts
│   ├── roles.guard.ts
│   └── permissions.guard.ts
│
└── constants
    └── auth.constants.ts
</code>

----

====== Étape 1 — Constantes RBAC ======

===== Créer =====

<code>
auth.constants.ts
</code>

----

===== Contenu =====

<code ts>
export const ROLES_KEY =
  'roles';

export const PERMISSIONS_KEY =
  'permissions';
</code>

----

====== Étape 2 — Décorateur Roles ======

===== Créer =====

<code>
roles.decorator.ts
</code>

----

===== Implémentation =====

<code ts>
import { SetMetadata }
from '@nestjs/common';

import {
  ROLES_KEY
}
from '../constants/auth.constants';

export const Roles = (

...roles: string[]

) => SetMetadata(
  ROLES_KEY,
  roles
);
</code>

----

====== Étape 3 — Décorateur Permissions ======

===== Créer =====

<code>
permissions.decorator.ts
</code>

----

===== Implémentation =====

<code ts>
import { SetMetadata }
from '@nestjs/common';

import {
  PERMISSIONS_KEY
}
from '../constants/auth.constants';

export const Permissions = (

...permissions: string[]

) => SetMetadata(
  PERMISSIONS_KEY,
  permissions
);
</code>

----

====== Étape 4 — Extension JWT Payload ======

===== Fichier =====

<code>
jwt-payload.interface.ts
</code>

----

===== Ajouter =====

<code ts>
roles?: string[];

permissions?: string[];
</code>

----

===== Objectif =====

Éviter des requêtes SQL inutiles.

Le JWT transporte :

<code>
Roles

Permissions
</code>

du compte connecté.

----

====== Étape 5 — Enrichir le Login ======

===== Charger permissions =====

Dans :

<code>
AuthService.login()
</code>

----

===== Ajouter =====

<code ts>
const permissions =

user.userRoles.flatMap(

userRole =>

userRole.role
        .rolePermissions
        .map(

rp =>
            rp.permission.code
        )
  );
</code>

----

===== Dédupliquer =====

<code ts>
const uniquePermissions =

[...new Set(
    permissions
  )];
</code>

----

===== Payload JWT =====

Modifier :

<code ts>
const payload = {

sub: user.id,

tenantId: user.tenantId,

email: user.email,

sessionId: createdSession.id,

roles,

permissions:
    uniquePermissions
};
</code>

----

====== Étape 6 — Enrichir Register ======

===== Ajouter =====

Lors du :

<code>
register()
</code>

----

===== Payload =====

<code ts>
roles: [

SYSTEM_ROLES.CUSTOMER
]

permissions: []
</code>

----

====== Étape 7 — Création RolesGuard ======

===== Créer =====

<code>
roles.guard.ts
</code>

----

===== Injection =====

<code ts>
constructor(

private reflector:
    Reflector
) {}
</code>

----

===== Implémentation =====

<code ts>
@Injectable()
export class RolesGuard
implements CanActivate {

constructor(
    private reflector:
      Reflector
  ) {}

canActivate(
    context:
      ExecutionContext
  ): boolean {

const requiredRoles =

this.reflector.getAllAndOverride<
        string[]
      >(
        ROLES_KEY,
        [
          context.getHandler(),
          context.getClass()
        ]
      );

if (
      !requiredRoles ||
      requiredRoles.length === 0
    ) {

return true;
    }

const request =
      context
        .switchToHttp()
        .getRequest();

const user =
      request.user;

return requiredRoles.some(

role =>

user.roles?.includes(
          role
        )
    );
  }
}
</code>

----

====== Étape 8 — Création PermissionsGuard ======

===== Créer =====

<code>
permissions.guard.ts
</code>

----

===== Implémentation =====

<code ts>
@Injectable()
export class PermissionsGuard
implements CanActivate {

constructor(
    private reflector:
      Reflector
  ) {}

canActivate(
    context:
      ExecutionContext
  ): boolean {

const requiredPermissions =

this.reflector.getAllAndOverride<
        string[]
      >(
        PERMISSIONS_KEY,
        [
          context.getHandler(),
          context.getClass()
        ]
      );

if (
      !requiredPermissions ||
      requiredPermissions.length === 0
    ) {

return true;
    }

const request =
      context
        .switchToHttp()
        .getRequest();

const user =
      request.user;

return requiredPermissions.every(

permission =>

user.permissions?.includes(
          permission
        )
    );
  }
}
</code>

----

====== Étape 9 — Mise à jour JwtStrategy ======

===== Validation =====

Remplacer :

<code ts>
return payload;
</code>

----

===== Par =====

<code ts>
return {

id: payload.sub,

tenantId:
    payload.tenantId,

email:
    payload.email,

sessionId:
    payload.sessionId,

roles:
    payload.roles ?? [],

permissions:
    payload.permissions ?? []
};
</code>

----

====== Étape 10 — Export Guards ======

===== AuthModule =====

Ajouter :

<code ts>
providers: [

AuthService,

PasswordService,

TokenService,

JwtStrategy,

RolesGuard,

PermissionsGuard
]
</code>

----

===== Exports =====

<code ts>
exports: [

RolesGuard,

PermissionsGuard
]
</code>

----

====== Étape 11 — Utilisation Roles ======

===== Exemple =====

<code ts>
@Get()

@UseGuards(

JwtAuthGuard,

RolesGuard
)

@Roles(
  'SUPER_ADMIN'
)

findAllUsers() {}
</code>

----

====== Étape 12 — Utilisation Permissions ======

===== Exemple =====

<code ts>
@Get()

@UseGuards(

JwtAuthGuard,

PermissionsGuard
)

@Permissions(
  'users.read'
)

findAllUsers() {}
</code>

----

====== Étape 13 — Combinaison RBAC ======

===== Exemple =====

<code ts>
@Get()

@UseGuards(

JwtAuthGuard,

RolesGuard,

PermissionsGuard
)

@Roles(
  'ADMIN',
  'SUPER_ADMIN'
)

@Permissions(
  'users.read'
)

findAllUsers() {}
</code>

----

====== Étape 14 — Création d'un endpoint de test ======

===== AuthController =====

Ajouter :

<code ts>
@Get('admin')

@UseGuards(

JwtAuthGuard,

RolesGuard
)

@Roles(
  'SUPER_ADMIN'
)

adminOnly() {

return {

success: true
  };
}
</code>

----

====== Étape 15 — Endpoint permissions ======

===== Ajouter =====

<code ts>
@Get('permissions')

@UseGuards(

JwtAuthGuard,

PermissionsGuard
)

@Permissions(
  'users.read'
)

permissionsOnly() {

return {

success: true
  };
}
</code>

----

====== Étape 16 — Tests manuels ======

===== SUPER_ADMIN =====

Doit accéder :

<code>
GET /auth/admin
</code>

----

===== CUSTOMER =====

Doit recevoir :

<code json>
{
  "statusCode": 403,
  "message": "Forbidden resource"
}
</code>

----

====== Étape 17 — Gestion du Super Admin ======

===== Bypass recommandé =====

Dans :

<code>
PermissionsGuard
</code>

ajouter :

<code ts>
if (

user.roles?.includes(
    'SUPER_ADMIN'
  )
) {

return true;
}
</code>

----

===== Résultat =====

Le :

<code>
SUPER_ADMIN
</code>

contourne toutes les permissions.

----

====== Étape 18 — Préparation Sprint 2 ======

Le RBAC est maintenant réutilisable sur :

<code>
Users

Properties

Reservations

CRM

Finance

Marketing

Security

Administration
</code>

----

====== Définition de terminé ======

Le Sprint 1-C.1 est terminé lorsque :

<code>
✓ @Roles créé

✓ @Permissions créé

✓ RolesGuard créé

✓ PermissionsGuard créé

✓ JWT enrichi

✓ Contrôle d'accès fonctionnel

✓ Tests manuels réussis

✓ Swagger toujours opérationnel
</code>

----

====== Livrables ======

<code>
RolesDecorator

PermissionsDecorator

RolesGuard

PermissionsGuard

JWT enrichi

RBAC Enterprise
</code>

----

====== Sprint 1-C.1 — Implémentation du RBAC Enterprise ======

===== Objectif =====

Mettre en place le moteur de contrôle d'accès central de la plateforme.

À l'issue de cette étape :

<code>
✓ @Roles()

✓ RolesGuard

✓ @Permissions()

✓ PermissionsGuard

✓ Metadata Reflector

✓ Contrôle d'accès complet

✓ Swagger compatible

✓ Réutilisable dans tous les modules
</code>

----

====== Architecture cible ======

<code>
Controller

↓

@Roles()

@Permissions()

↓

JwtAuthGuard

↓

RolesGuard

↓

PermissionsGuard

↓

Access Granted
</code>

----

====== Structure ======

===== Créer =====

<code>
src/modules/auth/presentation

├── decorators
│
│   ├── roles.decorator.ts
│   └── permissions.decorator.ts
│
├── guards
│
│   ├── jwt-auth.guard.ts
│   ├── roles.guard.ts
│   └── permissions.guard.ts
│
└── constants
    └── auth.constants.ts
</code>

----

====== Étape 1 — Constantes RBAC ======

===== Créer =====

<code>
auth.constants.ts
</code>

----

===== Contenu =====

<code ts>
export const ROLES_KEY =
  'roles';

export const PERMISSIONS_KEY =
  'permissions';
</code>

----

====== Étape 2 — Décorateur Roles ======

===== Créer =====

<code>
roles.decorator.ts
</code>

----

===== Implémentation =====

<code ts>
import { SetMetadata }
from '@nestjs/common';

import {
  ROLES_KEY
}
from '../constants/auth.constants';

export const Roles = (

...roles: string[]

) => SetMetadata(
  ROLES_KEY,
  roles
);
</code>

----

====== Étape 3 — Décorateur Permissions ======

===== Créer =====

<code>
permissions.decorator.ts
</code>

----

===== Implémentation =====

<code ts>
import { SetMetadata }
from '@nestjs/common';

import {
  PERMISSIONS_KEY
}
from '../constants/auth.constants';

export const Permissions = (

...permissions: string[]

) => SetMetadata(
  PERMISSIONS_KEY,
  permissions
);
</code>

----

====== Étape 4 — Extension JWT Payload ======

===== Fichier =====

<code>
jwt-payload.interface.ts
</code>

----

===== Ajouter =====

<code ts>
roles?: string[];

permissions?: string[];
</code>

----

===== Objectif =====

Éviter des requêtes SQL inutiles.

Le JWT transporte :

<code>
Roles

Permissions
</code>

du compte connecté.

----

====== Étape 5 — Enrichir le Login ======

===== Charger permissions =====

Dans :

<code>
AuthService.login()
</code>

----

===== Ajouter =====

<code ts>
const permissions =

user.userRoles.flatMap(

userRole =>

userRole.role
        .rolePermissions
        .map(

rp =>
            rp.permission.code
        )
  );
</code>

----

===== Dédupliquer =====

<code ts>
const uniquePermissions =

[...new Set(
    permissions
  )];
</code>

----

===== Payload JWT =====

Modifier :

<code ts>
const payload = {

sub: user.id,

tenantId: user.tenantId,

email: user.email,

sessionId: createdSession.id,

roles,

permissions:
    uniquePermissions
};
</code>

----

====== Étape 6 — Enrichir Register ======

===== Ajouter =====

Lors du :

<code>
register()
</code>

----

===== Payload =====

<code ts>
roles: [

SYSTEM_ROLES.CUSTOMER
]

permissions: []
</code>

----

====== Étape 7 — Création RolesGuard ======

===== Créer =====

<code>
roles.guard.ts
</code>

----

===== Injection =====

<code ts>
constructor(

private reflector:
    Reflector
) {}
</code>

----

===== Implémentation =====

<code ts>
@Injectable()
export class RolesGuard
implements CanActivate {

constructor(
    private reflector:
      Reflector
  ) {}

canActivate(
    context:
      ExecutionContext
  ): boolean {

const requiredRoles =

this.reflector.getAllAndOverride<
        string[]
      >(
        ROLES_KEY,
        [
          context.getHandler(),
          context.getClass()
        ]
      );

if (
      !requiredRoles ||
      requiredRoles.length === 0
    ) {

return true;
    }

const request =
      context
        .switchToHttp()
        .getRequest();

const user =
      request.user;

return requiredRoles.some(

role =>

user.roles?.includes(
          role
        )
    );
  }
}
</code>

----

====== Étape 8 — Création PermissionsGuard ======

===== Créer =====

<code>
permissions.guard.ts
</code>

----

===== Implémentation =====

<code ts>
@Injectable()
export class PermissionsGuard
implements CanActivate {

constructor(
    private reflector:
      Reflector
  ) {}

canActivate(
    context:
      ExecutionContext
  ): boolean {

const requiredPermissions =

this.reflector.getAllAndOverride<
        string[]
      >(
        PERMISSIONS_KEY,
        [
          context.getHandler(),
          context.getClass()
        ]
      );

if (
      !requiredPermissions ||
      requiredPermissions.length === 0
    ) {

return true;
    }

const request =
      context
        .switchToHttp()
        .getRequest();

const user =
      request.user;

return requiredPermissions.every(

permission =>

user.permissions?.includes(
          permission
        )
    );
  }
}
</code>

----

====== Étape 9 — Mise à jour JwtStrategy ======

===== Validation =====

Remplacer :

<code ts>
return payload;
</code>

----

===== Par =====

<code ts>
return {

id: payload.sub,

tenantId:
    payload.tenantId,

email:
    payload.email,

sessionId:
    payload.sessionId,

roles:
    payload.roles ?? [],

permissions:
    payload.permissions ?? []
};
</code>

----

====== Étape 10 — Export Guards ======

===== AuthModule =====

Ajouter :

<code ts>
providers: [

AuthService,

PasswordService,

TokenService,

JwtStrategy,

RolesGuard,

PermissionsGuard
]
</code>

----

===== Exports =====

<code ts>
exports: [

RolesGuard,

PermissionsGuard
]
</code>

----

====== Étape 11 — Utilisation Roles ======

===== Exemple =====

<code ts>
@Get()

@UseGuards(

JwtAuthGuard,

RolesGuard
)

@Roles(
  'SUPER_ADMIN'
)

findAllUsers() {}
</code>

----

====== Étape 12 — Utilisation Permissions ======

===== Exemple =====

<code ts>
@Get()

@UseGuards(

JwtAuthGuard,

PermissionsGuard
)

@Permissions(
  'users.read'
)

findAllUsers() {}
</code>

----

====== Étape 13 — Combinaison RBAC ======

===== Exemple =====

<code ts>
@Get()

@UseGuards(

JwtAuthGuard,

RolesGuard,

PermissionsGuard
)

@Roles(
  'ADMIN',
  'SUPER_ADMIN'
)

@Permissions(
  'users.read'
)

findAllUsers() {}
</code>

----

====== Étape 14 — Création d'un endpoint de test ======

===== AuthController =====

Ajouter :

<code ts>
@Get('admin')

@UseGuards(

JwtAuthGuard,

RolesGuard
)

@Roles(
  'SUPER_ADMIN'
)

adminOnly() {

return {

success: true
  };
}
</code>

----

====== Étape 15 — Endpoint permissions ======

===== Ajouter =====

<code ts>
@Get('permissions')

@UseGuards(

JwtAuthGuard,

PermissionsGuard
)

@Permissions(
  'users.read'
)

permissionsOnly() {

return {

success: true
  };
}
</code>

----

====== Étape 16 — Tests manuels ======

===== SUPER_ADMIN =====

Doit accéder :

<code>
GET /auth/admin
</code>

----

===== CUSTOMER =====

Doit recevoir :

<code json>
{
  "statusCode": 403,
  "message": "Forbidden resource"
}
</code>

----

====== Étape 17 — Gestion du Super Admin ======

===== Bypass recommandé =====

Dans :

<code>
PermissionsGuard
</code>

ajouter :

<code ts>
if (

user.roles?.includes(
    'SUPER_ADMIN'
  )
) {

return true;
}
</code>

----

===== Résultat =====

Le :

<code>
SUPER_ADMIN
</code>

contourne toutes les permissions.

----

====== Étape 18 — Préparation Sprint 2 ======

Le RBAC est maintenant réutilisable sur :

<code>
Users

Properties

Reservations

CRM

Finance

Marketing

Security

Administration
</code>

----

====== Définition de terminé ======

Le Sprint 1-C.1 est terminé lorsque :

<code>
✓ @Roles créé

✓ @Permissions créé

✓ RolesGuard créé

✓ PermissionsGuard créé

✓ JWT enrichi

✓ Contrôle d'accès fonctionnel

✓ Tests manuels réussis

✓ Swagger toujours opérationnel
</code>

----

====== Livrables ======

<code>
RolesDecorator

PermissionsDecorator

RolesGuard

PermissionsGuard

JWT enrichi

RBAC Enterprise
</code>

----

====== Sprint 1-C.2 — Tests Unitaires Auth & RBAC ======

===== Objectif =====

Sécuriser l'ensemble du module Auth avant de poursuivre les développements métier.

À l'issue de cette étape :

<code>
✓ PasswordService testé

✓ TokenService testé

✓ AuthService testé

✓ JwtStrategy testée

✓ RolesGuard testé

✓ PermissionsGuard testé

✓ Couverture > 80%

✓ CI compatible
</code>

----

====== Architecture des tests ======

===== Répertoire =====

Créer :

<code>
apps/api/src/modules/auth

├── domain
│
│   └── services
│
│       ├── auth.service.spec.ts
│       ├── password.service.spec.ts
│       └── token.service.spec.ts
│
├── infrastructure
│
│   └── strategies
│
│       └── jwt.strategy.spec.ts
│
└── presentation
    │
    └── guards

├── roles.guard.spec.ts
        └── permissions.guard.spec.ts
</code>

----

====== Étape 1 — Configuration Jest ======

===== Vérifier =====

<code bash>
npm install -D

jest

ts-jest

@types/jest
</code>

----

===== Vérifier =====

<code>
apps/api/jest.config.ts
</code>

----

===== Coverage =====

<code ts>
coverageThreshold: {

global: {

branches: 80,

functions: 80,

lines: 80,

statements: 80
  }
}
</code>

----

====== Étape 2 — PasswordService ======

===== Fichier =====

<code>
password.service.spec.ts
</code>

----

===== Test hash =====

<code ts>
describe(
  'PasswordService',
  () => {

it(
      'should hash password',
      async () => {

const hash =

await service.hash(
            'Password123!'
          );

expect(hash)
          .toBeDefined();

expect(hash)
          .not
          .toEqual(
            'Password123!'
          );
      }
    );
  }
);
</code>

----

===== Test compare =====

<code ts>
it(
  'should compare password',
  async () => {

const hash =

await service.hash(
        'Password123!'
      );

const result =

await service.compare(

'Password123!',

hash
      );

expect(result)
      .toBe(true);
  }
);
</code>

----

====== Étape 3 — TokenService ======

===== Fichier =====

<code>
token.service.spec.ts
</code>

----

===== Test Access Token =====

<code ts>
it(
  'should generate access token',
  async () => {

const token =

await service
        .generateAccessToken({

sub: '1',

tenantId: '1',

email:
            'test@test.com'
        });

expect(token)
      .toBeDefined();
  }
);
</code>

----

===== Test Refresh Token =====

<code ts>
it(
  'should generate refresh token',
  async () => {

const token =

await service
        .generateRefreshToken();

expect(token)
      .toBeDefined();
  }
);
</code>

----

====== Étape 4 — Mock Prisma ======

===== Créer =====

<code>
test/mocks/prisma.mock.ts
</code>

----

===== Contenu =====

<code ts>
export const prismaMock = {

user: {

findUnique: jest.fn(),

create: jest.fn(),

update: jest.fn()
  },

role: {

findFirst: jest.fn()
  },

userRole: {

create: jest.fn()
  },

refreshToken: {

create: jest.fn(),

findMany: jest.fn(),

update: jest.fn(),

updateMany: jest.fn()
  },

session: {

create: jest.fn(),

updateMany: jest.fn()
  },

tenant: {

findUnique: jest.fn()
  }
};
</code>

----

====== Étape 5 — AuthService ======

===== Fichier =====

<code>
auth.service.spec.ts
</code>

----

===== Setup =====

<code ts>
beforeEach(
  async () => {

const module =

await Test
        .createTestingModule({

providers: [

AuthService,

{
              provide:
                PrismaService,

useValue:
                prismaMock
            }
          ]
        })
        .compile();
  }
);
</code>

----

====== Étape 6 — Test Register ======

===== Cas nominal =====

<code ts>
it(
  'should register user',
  async () => {

prismaMock.user
      .findUnique
      .mockResolvedValue(
        null
      );

const result =

await service.register({

email:
          'john@test.com',

password:
          'Password123!',

firstName:
          'John',

lastName:
          'Doe'
      });

expect(result)
      .toBeDefined();
  }
);
</code>

----

====== Étape 7 — Email déjà utilisé ======

===== Test =====

<code ts>
it(
  'should throw conflict',
  async () => {

prismaMock.user
      .findUnique
      .mockResolvedValue({});

await expect(

service.register(
        dto
      )

).rejects.toThrow(
      ConflictException
    );
  }
);
</code>

----

====== Étape 8 — Test Login ======

===== Succès =====

<code ts>
it(
  'should login user',
  async () => {

const result =

await service.login(
        dto,
        session
      );

expect(result)
      .toBeDefined();
  }
);
</code>

----

===== Mot de passe invalide =====

<code ts>
it(
  'should reject login',
  async () => {

await expect(

service.login(
        dto,
        session
      )

).rejects.toThrow(
      UnauthorizedException
    );
  }
);
</code>

----

====== Étape 9 — Test Refresh ======

===== Succès =====

<code ts>
it(
  'should refresh token',
  async () => {

const result =

await service.refresh({

refreshToken:
          'token'
      });

expect(result)
      .toBeDefined();
  }
);
</code>

----

===== Échec =====

<code ts>
it(
  'should reject invalid token',
  async () => {

await expect(

service.refresh({

refreshToken:
          'bad-token'
      })

).rejects.toThrow(
      UnauthorizedException
    );
  }
);
</code>

----

====== Étape 10 — Test Logout ======

===== Succès =====

<code ts>
it(
  'should logout user',
  async () => {

const result =

await service.logout(
        'user-id'
      );

expect(
      result.success
    ).toBe(true);
  }
);
</code>

----

====== Étape 11 — Test Current User ======

===== Succès =====

<code ts>
it(
  'should return current user',
  async () => {

const result =

await service.me(
        'user-id'
      );

expect(result)
      .toBeDefined();

expect(
      result.email
    ).toEqual(
      'admin@platform.local'
    );
  }
);
</code>

----

====== Étape 12 — JwtStrategy ======

===== Fichier =====

<code>
jwt.strategy.spec.ts
</code>

----

===== Test =====

<code ts>
it(
  'should validate payload',
  async () => {

const result =

await strategy.validate({

sub: '1',

email:
          'test@test.com',

tenantId:
          'tenant'
      });

expect(
      result.id
    ).toEqual('1');
  }
);
</code>

----

====== Étape 13 — RolesGuard ======

===== Fichier =====

<code>
roles.guard.spec.ts
</code>

----

===== Autorisé =====

<code ts>
it(
  'should allow role',
  () => {

expect(
      guard.canActivate(
        context
      )
    ).toBe(true);
  }
);
</code>

----

===== Refusé =====

<code ts>
it(
  'should reject role',
  () => {

expect(
      guard.canActivate(
        context
      )
    ).toBe(false);
  }
);
</code>

----

====== Étape 14 — PermissionsGuard ======

===== Fichier =====

<code>
permissions.guard.spec.ts
</code>

----

===== Autorisé =====

<code ts>
it(
  'should allow permission',
  () => {

expect(
      guard.canActivate(
        context
      )
    ).toBe(true);
  }
);
</code>

----

===== Refusé =====

<code ts>
it(
  'should reject permission',
  () => {

expect(
      guard.canActivate(
        context
      )
    ).toBe(false);
  }
);
</code>

----

====== Étape 15 — Exécution ======

===== Lancer =====

----

===== Avec coverage =====

<code bash>
nx test api \
--coverage
</code>

----

====== Étape 16 — Rapport ======

===== Généré dans =====

<code>
coverage/apps/api
</code>

----

===== Ouvrir =====

<code>
coverage/apps/api/lcov-report/index.html
</code>

----

====== Étape 17 — Objectifs ======

===== PasswordService =====

----

===== TokenService =====

----

===== RolesGuard =====

----

===== PermissionsGuard =====

----

===== AuthService =====

----

====== Étape 18 — Ajout CI ======

===== Workflow =====

<code>
.github/workflows/ci.yml
</code>

----

===== Ajouter =====

<code yaml>
- name: Run Tests

run: nx test api
</code>

----

===== Coverage =====

<code yaml>
- name: Coverage

run: nx test api --coverage
</code>

----

====== Étape 19 — Badge Coverage ======

===== README =====

<code markdown>
![Coverage]
</code>

----

====== Définition de terminé ======

Le Sprint 1-C.2 est terminé lorsque :

<code>
✓ PasswordService testé

✓ TokenService testé

✓ AuthService testé

✓ JwtStrategy testée

✓ RolesGuard testé

✓ PermissionsGuard testé

✓ Coverage > 80 %

✓ CI verte
</code>

----

====== Livrables ======

<code>
auth.service.spec.ts

password.service.spec.ts

token.service.spec.ts

jwt.strategy.spec.ts

roles.guard.spec.ts

permissions.guard.spec.ts

coverage report
</code>

----

====== Sprint 1-C.3 — Tests E2E Authentification ======

===== Objectif =====

Valider le fonctionnement réel de toute la chaîne d'authentification.

À l'issue de cette étape :

<code>
✓ Register testé

✓ Login testé

✓ Current User testé

✓ Refresh testé

✓ Logout testé

✓ RBAC testé

✓ PostgreSQL réel

✓ JWT réel

✓ Prisma réel
</code>

Ces tests constituent la première validation métier complète de la plateforme.

----

====== Architecture E2E ======

===== Environnement =====

<code>
NestJS

↓

Prisma

↓

PostgreSQL

↓

JWT

↓

API réelle
</code>

----

===== Pas de Mock =====

Contrairement aux tests unitaires :

<code>
Aucun Mock

Aucun Fake Service

Base PostgreSQL réelle
</code>

----

====== Étape 1 — Création du projet E2E ======

===== Vérifier =====

----

===== Structure =====

<code>
apps

├── api

└── api-e2e

├── src

│   └── auth

│       └── auth.e2e-spec.ts

│
    ├── jest.config.ts

└── project.json
</code>

----

====== Étape 2 — Installation ======

===== Vérifier =====

<code bash>
npm install -D supertest

npm install -D @types/supertest
</code>

----

====== Étape 3 — Base de test ======

===== Créer =====

----

===== Contenu =====

<code>
DATABASE_URL=

postgresql://postgres:
postgres@localhost:5432/
rental_platform_test

JWT_SECRET=test-secret

JWT_EXPIRES_IN=15m

REFRESH_SECRET=test-refresh

REFRESH_EXPIRES_IN=30d
</code>

----

====== Étape 4 — Création DB Test ======

===== PostgreSQL =====

<code sql>
CREATE DATABASE
rental_platform_test;
</code>

----

====== Étape 5 — Migration ======

===== Exécuter =====

<code bash>
DATABASE_URL=...

npx prisma migrate deploy
</code>

----

===== Seed =====

<code bash>
DATABASE_URL=...

npx prisma db seed
</code>

----

====== Étape 6 — Bootstrap E2E ======

===== Créer =====

----

===== Base =====

<code ts>
describe(
  'Auth E2E',
  () => {

let app:
      INestApplication;

beforeAll(
      async () => {

const moduleRef =

await Test
            .createTestingModule({

imports: [

AppModule
              ]
            })
            .compile();

app =
          moduleRef
            .createNestApplication();

await app.init();
      }
    );

afterAll(
      async () => {

await app.close();
      }
    );
  }
);
</code>

----

====== Étape 7 — Variables de scénario ======

===== Ajouter =====

<code ts>
let accessToken:
  string;

let refreshToken:
  string;

let userId:
  string;
</code>

----

====== Étape 8 — Test Register ======

===== Cas nominal =====

<code ts>
it(
  'should register user',
  async () => {

const response =

await request(

app.getHttpServer()
      )

.post(
        '/auth/register'
      )

.send({

email:
          'john@test.com',

password:
          'Password123!',

firstName:
          'John',

lastName:
          'Doe'
      })

.expect(201);

expect(

response.body
        .accessToken

).toBeDefined();

userId =

response.body
        .user.id;
  }
);
</code>

----

====== Étape 9 — Test Login ======

===== Cas nominal =====

<code ts>
it(
  'should login',
  async () => {

const response =

await request(

app.getHttpServer()
      )

.post(
        '/auth/login'
      )

.send({

email:
          'john@test.com',

password:
          'Password123!'
      })

.expect(201);

accessToken =

response.body
        .accessToken;

refreshToken =

response.body
        .refreshToken;

expect(
      accessToken
    ).toBeDefined();

expect(
      refreshToken
    ).toBeDefined();
  }
);
</code>

----

====== Étape 10 — Test Current User ======

===== Endpoint =====

----

===== Test =====

<code ts>
it(
  'should return current user',
  async () => {

const response =

await request(

app.getHttpServer()
      )

.get(
        '/auth/me'
      )

.set(

'Authorization',

`Bearer ${accessToken}`
      )

.expect(200);

expect(

response.body.email

).toEqual(
      'john@test.com'
    );
  }
);
</code>

----

====== Étape 11 — Test RBAC ======

===== Endpoint =====

<code>
GET /auth/admin
</code>

----

===== CUSTOMER =====

<code ts>
it(
  'should reject customer',
  async () => {

await request(

app.getHttpServer()
    )

.get(
      '/auth/admin'
    )

.set(

'Authorization',

`Bearer ${accessToken}`
    )

.expect(403);
  }
);
</code>

----

====== Étape 12 — Test Refresh ======

===== Endpoint =====

<code>
POST /auth/refresh
</code>

----

===== Test =====

<code ts>
it(
  'should refresh token',
  async () => {

const response =

await request(

app.getHttpServer()
      )

.post(
        '/auth/refresh'
      )

.send({

refreshToken
      })

.expect(201);

accessToken =

response.body
        .accessToken;

refreshToken =

response.body
        .refreshToken;

expect(
      accessToken
    ).toBeDefined();
  }
);
</code>

----

====== Étape 13 — Test Logout ======

===== Endpoint =====

<code>
POST /auth/logout
</code>

----

===== Test =====

<code ts>
it(
  'should logout',
  async () => {

await request(

app.getHttpServer()
    )

.post(
      '/auth/logout'
    )

.set(

'Authorization',

`Bearer ${accessToken}`
    )

.expect(201);
  }
);
</code>

----

====== Étape 14 — Vérification sécurité ======

===== Ancien Refresh Token =====

Ne doit plus fonctionner.

----

===== Test =====

<code ts>
it(
  'should reject old refresh token',
  async () => {

await request(

app.getHttpServer()
    )

.post(
      '/auth/refresh'
    )

.send({

refreshToken
    })

.expect(401);
  }
);
</code>

----

====== Étape 15 — Cas erreur Login ======

===== Mauvais mot de passe =====

<code ts>
it(
  'should reject invalid password',
  async () => {

await request(

app.getHttpServer()
    )

.post(
      '/auth/login'
    )

.send({

email:
        'john@test.com',

password:
        'BAD_PASSWORD'
    })

.expect(401);
  }
);
</code>

----

====== Étape 16 — Cas erreur Register ======

===== Email existant =====

<code ts>
it(
  'should reject duplicate email',
  async () => {

await request(

app.getHttpServer()
    )

.post(
      '/auth/register'
    )

.send({

email:
        'john@test.com',

password:
        'Password123!',

firstName:
        'John',

lastName:
        'Doe'
    })

.expect(409);
  }
);
</code>

----

====== Étape 17 — Nettoyage ======

===== Supprimer utilisateur =====

Dans :

<code>
afterAll()
</code>

----

===== Exemple =====

<code ts>
await prisma.user.deleteMany({

where: {

email:
      'john@test.com'
  }
});
</code>

----

====== Étape 18 — Configuration NX ======

===== project.json =====

Ajouter :

<code json>
{
  "targets": {

"e2e": {

"executor":

"@nx/jest:jest"
    }
  }
}
</code>

----

====== Étape 19 — Exécution ======

===== Lancer =====

----

===== Résultat attendu =====

<code>
PASS

Register

PASS

Login

PASS

Current User

PASS

Refresh

PASS

Logout

PASS

RBAC
</code>

----

====== Étape 20 — Intégration CI ======

===== Workflow =====

<code>
.github/workflows/ci.yml
</code>

----

===== Ajouter =====

<code yaml>
- name: E2E Tests

run:

nx e2e api-e2e
</code>

----

====== Étape 21 — Pipeline qualité ======

===== Ordre =====

<code>
Lint

↓

Build

↓

Unit Tests

↓

E2E Tests

↓

Docker Build
</code>

----

====== Définition de terminé ======

Le Sprint 1-C.3 est terminé lorsque :

<code>
✓ Register testé

✓ Login testé

✓ Current User testé

✓ Refresh testé

✓ Logout testé

✓ RBAC testé

✓ PostgreSQL réel

✓ JWT réel

✓ CI verte
</code>

----

====== Livrables ======

<code>
auth.e2e-spec.ts

.env.test

Configuration E2E

Pipeline CI
</code>

----

====== Bilan Sprint 1 ======

Le Sprint 1 est considéré terminé lorsque :

<code>
✓ AuthModule opérationnel

✓ Register opérationnel

✓ Login opérationnel

✓ Refresh opérationnel

✓ Logout opérationnel

✓ Current User opérationnel

✓ RBAC opérationnel

✓ Tests unitaires verts

✓ Tests E2E verts

✓ Swagger documenté

✓ CI verte
</code>

----

====== Étape suivante ======

===== Sprint 2 — Gestion des Utilisateurs =====

Objectif :

Construire le premier domaine métier protégé par le RBAC :

<code>
User

Profile

Address

Preferences

NotificationSettings

UserSession

ConnectionHistory
</code>

avec :

<code>
CRUD Utilisateurs

Gestion Profil

Gestion Préférences

Historique Connexions

Administration Utilisateurs
</code>

Résumé

Note : En modifiant cette page, vous acceptez que le contenu soit placé sous les termes de la licence suivante : CC Attribution-Share Alike 4.0 International