Construire le premier domaine métier complet protégé par le système RBAC mis en place lors du Sprint 1.

À l'issue du Sprint 2 :

✓ Gestion des utilisateurs

✓ Gestion du profil

✓ Gestion des adresses

✓ Préférences utilisateur

✓ Paramètres notifications

✓ Sessions utilisateur

✓ Historique connexions

✓ Administration utilisateurs

UsersModule

ProfilesModule

PreferencesModule

NotificationModule

SessionsModule

User

UserProfile

Address

UserPreference

NotificationSetting

UserSession

ConnectionHistory

Compléter le modèle User existant avec les informations de profil et de personnalisation.

Ajouter :

model UserProfile {
 
  id                    String @id @default(uuid())
 
  userId                String @unique
 
  avatarUrl             String?
 
  birthDate             DateTime?
 
  gender                String?
 
  language              String?
 
  timezone              String?
 
  biography             String?
 
  createdAt             DateTime @default(now())
 
  updatedAt             DateTime @updatedAt
 
  user                  User
                         @relation(
                           fields:[userId],
                           references:[id]
                         )
}

Ajouter dans :

model User

profile UserProfile?

model Address {
 
  id                    String @id @default(uuid())
 
  userId                String
 
  label                 String
 
  addressLine1          String
 
  addressLine2          String?
 
  postalCode            String
 
  city                  String
 
  state                 String?
 
  country               String
 
  isDefault             Boolean @default(false)
 
  createdAt             DateTime @default(now())
 
  updatedAt             DateTime @updatedAt
 
  user                  User
                         @relation(
                           fields:[userId],
                           references:[id]
                         )
 
  @@index([userId])
}

Ajouter :

addresses Address[]

model UserPreference {
 
  id                    String @id @default(uuid())
 
  userId                String @unique
 
  theme                 String @default("light")
 
  language              String @default("fr")
 
  timezone              String @default("Europe/Paris")
 
  dateFormat            String @default("DD/MM/YYYY")
 
  currency              String @default("EUR")
 
  createdAt             DateTime @default(now())
 
  updatedAt             DateTime @updatedAt
 
  user                  User
                         @relation(
                           fields:[userId],
                           references:[id]
                         )
}

Ajouter :

preferences UserPreference?

model NotificationSetting {
 
  id                    String @id @default(uuid())
 
  userId                String @unique
 
  emailEnabled          Boolean @default(true)
 
  smsEnabled            Boolean @default(false)
 
  pushEnabled           Boolean @default(true)
 
  marketingEnabled      Boolean @default(false)
 
  createdAt             DateTime @default(now())
 
  updatedAt             DateTime @updatedAt
 
  user                  User
                         @relation(
                           fields:[userId],
                           references:[id]
                         )
}

Ajouter :

notificationSettings NotificationSetting?

model ConnectionHistory {
 
  id                    String @id @default(uuid())
 
  userId                String
 
  ipAddress             String?
 
  country               String?
 
  city                  String?
 
  userAgent             String?
 
  connectedAt           DateTime
 
  disconnectedAt        DateTime?
 
  success               Boolean
 
  user                  User
                         @relation(
                           fields:[userId],
                           references:[id]
                         )
 
  @@index([userId])
 
  @@index([connectedAt])
}

Ajouter :

connectionHistory ConnectionHistory[]

Compléter :

model Session

sessionToken      String? @unique
 
deviceName        String?
 
platform          String?
 
isCurrent         Boolean @default(false)

npx prisma migrate dev \
--name user_management

npx prisma generate

Créer :

src/modules/users

├── application
│
├── domain
│
├── infrastructure
│
├── presentation
│
└── users.module.ts

UsersService

ProfileService

PreferencesService

SessionsService

UsersController

ProfileController

PreferencesController

SessionsController

GET    /users
 
GET    /users/{id}
 
POST   /users
 
PUT    /users/{id}
 
DELETE /users/{id}

users.read

users.create

users.update

users.delete

GET /profile
 
PUT /profile

Avatar

Nom

Prénom

Téléphone

Date naissance

Langue

Fuseau horaire

GET    /profile/addresses
 
POST   /profile/addresses
 
PUT    /profile/addresses/{id}
 
DELETE /profile/addresses/{id}

GET /preferences
 
PUT /preferences

Langue

Devise

Format date

Fuseau horaire

Thème

GET /notifications/settings
 
PUT /notifications/settings

Email

SMS

Push

Marketing

GET /sessions
 
DELETE /sessions/{id}
 
DELETE /sessions

Lister sessions

Déconnexion appareil

Déconnexion globale

GET /connection-history

Date

IP

Pays

Navigateur

Résultat

Tous les endpoints doivent utiliser :

@UseGuards(
 
  JwtAuthGuard,
 
  PermissionsGuard
)

@Permissions(
  'users.read'
)

Le Sprint 2 est terminé lorsque :

✓ CRUD utilisateurs

✓ Profil utilisateur

✓ Adresses

✓ Préférences

✓ Notifications

✓ Sessions

✓ Historique connexions

✓ Swagger documenté

✓ Tests unitaires

✓ Tests E2E

Étendre le modèle d'authentification du Sprint 1 afin d'ajouter :

UserProfile

Address

UserPreference

NotificationSetting

ConnectionHistory

et enrichir :

User

Session

pour préparer la gestion complète des utilisateurs.

model User

profile                 UserProfile?
 
addresses               Address[]
 
preferences             UserPreference?
 
notificationSettings    NotificationSetting?
 
connectionHistory       ConnectionHistory[]

Les relations User deviennent :

userRoles               UserRole[]
 
refreshTokens           RefreshToken[]
 
sessions                Session[]
 
profile                 UserProfile?
 
addresses               Address[]
 
preferences             UserPreference?
 
notificationSettings    NotificationSetting?
 
connectionHistory       ConnectionHistory[]

model UserProfile {
 
  id                    String @id @default(uuid())
 
  userId                String @unique
 
  avatarUrl             String?
 
  birthDate             DateTime?
 
  gender                String?
 
  language              String?
 
  timezone              String?
 
  biography             String?
 
  createdAt             DateTime @default(now())
 
  updatedAt             DateTime @updatedAt
 
  user                  User
                         @relation(
                           fields: [userId],
                           references: [id],
                           onDelete: Cascade
                         )
}

model Address {
 
  id                    String @id @default(uuid())
 
  userId                String
 
  label                 String
 
  addressLine1          String
 
  addressLine2          String?
 
  postalCode            String
 
  city                  String
 
  state                 String?
 
  country               String
 
  isDefault             Boolean @default(false)
 
  createdAt             DateTime @default(now())
 
  updatedAt             DateTime @updatedAt
 
  user                  User
                         @relation(
                           fields: [userId],
                           references: [id],
                           onDelete: Cascade
                         )
 
  @@index([userId])
 
  @@index([country])
 
  @@index([city])
}

model UserPreference {
 
  id                    String @id @default(uuid())
 
  userId                String @unique
 
  theme                 String @default("light")
 
  language              String @default("fr")
 
  timezone              String @default("Europe/Paris")
 
  dateFormat            String @default("DD/MM/YYYY")
 
  currency              String @default("EUR")
 
  createdAt             DateTime @default(now())
 
  updatedAt             DateTime @updatedAt
 
  user                  User
                         @relation(
                           fields: [userId],
                           references: [id],
                           onDelete: Cascade
                         )
}

model NotificationSetting {
 
  id                    String @id @default(uuid())
 
  userId                String @unique
 
  emailEnabled          Boolean @default(true)
 
  smsEnabled            Boolean @default(false)
 
  pushEnabled           Boolean @default(true)
 
  marketingEnabled      Boolean @default(false)
 
  createdAt             DateTime @default(now())
 
  updatedAt             DateTime @updatedAt
 
  user                  User
                         @relation(
                           fields: [userId],
                           references: [id],
                           onDelete: Cascade
                         )
}

model ConnectionHistory {
 
  id                    String @id @default(uuid())
 
  userId                String
 
  ipAddress             String?
 
  country               String?
 
  city                  String?
 
  userAgent             String?
 
  connectedAt           DateTime
 
  disconnectedAt        DateTime?
 
  success               Boolean
 
  user                  User
                         @relation(
                           fields: [userId],
                           references: [id],
                           onDelete: Cascade
                         )
 
  @@index([userId])
 
  @@index([connectedAt])
 
  @@index([success])
}

model Session

sessionToken       String? @unique
 
deviceName         String?
 
platform           String?
 
isCurrent          Boolean @default(false)

Le modèle Session devient capable de gérer :

Multi-appareils

Historique appareils

Déconnexion ciblée

Déconnexion globale

cd apps/api
 
npx prisma validate

The schema at prisma/schema.prisma is valid

npx prisma format

npx prisma migrate dev \
--name user_management

prisma/migrations

└── xxxx_user_management

    └── migration.sql

npx prisma generate

docker exec -it postgres psql -U postgres

\c rental_platform

\d "UserProfile"
 
\d "Address"
 
\d "UserPreference"
 
\d "NotificationSetting"
 
\d "ConnectionHistory"
 
\d "Session"

Lors de la création d'un utilisateur, prévoir automatiquement :

UserProfile

UserPreference

NotificationSetting

afin d'éviter les valeurs nulles dans l'application.

Créer automatiquement :

Profil vide

Préférences par défaut

Notifications par défaut

pour chaque utilisateur.

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

✓ UserProfile créé

✓ Address créée

✓ UserPreference créée

✓ NotificationSetting créée

✓ ConnectionHistory créée

✓ Session enrichie

✓ Migration exécutée

✓ Prisma Client généré

✓ Validation Prisma verte

schema.prisma

migration user_management

Prisma Client mis à jour

Garantir qu'un utilisateur dispose systématiquement d'un environnement fonctionnel dès sa création.

À l'issue de cette étape :

✓ UserProfile créé automatiquement

✓ UserPreference créé automatiquement

✓ NotificationSetting créé automatiquement

✓ Seed enrichi

✓ Register enrichi

✓ Aucun compte incomplet

Après le Sprint 2-A.1 :

User
✓

UserProfile
✗

UserPreference
✗

NotificationSetting
✗

sont créés séparément.

Les appels :

GET /profile

GET /preferences

GET /notifications/settings

peuvent retourner :

NULL

et générer des erreurs.

Créer automatiquement :

UserProfile

UserPreference

NotificationSetting

lors :

Seed principal

Register utilisateur

src/modules/users/domain/services

user-factory.service.ts

Centraliser :

Création User

Création Profile

Création Preferences

Création Notifications

createDefaultUserEnvironment(
  userId: string
)

@Injectable()
export class UserFactoryService {
 
  constructor(
 
    private readonly prisma:
      PrismaService
  ) {}
 
  async createDefaultUserEnvironment(
 
    userId: string
  ) {
 
    await this.prisma.userProfile.create({
 
      data: {
 
        userId
      }
    });
 
    await this.prisma.userPreference.create({
 
      data: {
 
        userId,
 
        theme: 'light',
 
        language: 'fr',
 
        timezone:
          'Europe/Paris',
 
        dateFormat:
          'DD/MM/YYYY',
 
        currency: 'EUR'
      }
    });
 
    await this.prisma.notificationSetting.create({
 
      data: {
 
        userId,
 
        emailEnabled: true,
 
        pushEnabled: true,
 
        smsEnabled: false,
 
        marketingEnabled: false
      }
    });
  }
}

providers: [
 
  UserFactoryService
]

imports: [
 
  UsersModule
]

Dans :

AuthService

constructor(
 
  ...
 
  private readonly
    userFactoryService:
      UserFactoryService
)

const user =
  await this.prisma.user.create(...)

await this.userFactoryService
  .createDefaultUserEnvironment(
 
    user.id
  );

Create User

↓

Create Profile

↓

Create Preferences

↓

Create Notification Settings

↓

Assign Role

↓

Generate JWT

prisma/seed.ts

Ajouter :

const profileExists =
  await prisma.userProfile.findUnique({
 
    where: {
 
      userId: admin.id
    }
  });
 
if (!profileExists) {
 
  await prisma.userProfile.create({
 
    data: {
 
      userId: admin.id
    }
  });
}

const preferenceExists =
  await prisma.userPreference.findUnique({
 
    where: {
 
      userId: admin.id
    }
  });
 
if (!preferenceExists) {
 
  await prisma.userPreference.create({
 
    data: {
 
      userId: admin.id,
 
      language: 'fr',
 
      timezone:
        'Europe/Paris',
 
      currency: 'EUR'
    }
  });
}

const settingsExists =
  await prisma.notificationSetting.findUnique({
 
    where: {
 
      userId: admin.id
    }
  });
 
if (!settingsExists) {
 
  await prisma.notificationSetting.create({
 
    data: {
 
      userId: admin.id
    }
  });
}

npx prisma db seed

Starting seed...

Tenant created

Permissions created

Roles created

Admin created

Profile created

Preferences created

Notification settings created

Seed completed

npx prisma studio

User

↓

UserProfile

↓

UserPreference

↓

NotificationSetting

SELECT *
 
FROM "UserProfile";

SELECT *
 
FROM "UserPreference";

SELECT *
 
FROM "NotificationSetting";

POST /auth/register

Après inscription :

SELECT *
 
FROM "UserProfile"
 
WHERE "userId" =
'new-user-id';

1 ligne

Créer un événement métier :

UserCreated

UserCreated

↓

CreateUserProfile

↓

CreateUserPreferences

↓

CreateNotificationSettings

via :

Domain Events

CQRS

EventBus

afin de découpler complètement Auth et Users.

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

✓ UserProfile créé automatiquement

✓ UserPreference créé automatiquement

✓ NotificationSetting créé automatiquement

✓ Seed mis à jour

✓ Register mis à jour

✓ Aucun compte incomplet

UserFactoryService

AuthService enrichi

seed.ts enrichi

Création automatique du profil utilisateur

Implémenter le premier module métier complet de la plateforme.

À l'issue de cette étape :

✓ UsersModule

✓ UsersController

✓ UsersService

✓ DTO

✓ CRUD Utilisateurs

✓ RBAC

✓ Swagger

✓ Validation

src/modules/users

users

├── application
│
│   └── dto
│
│       ├── create-user.dto.ts
│       ├── update-user.dto.ts
│       ├── user-response.dto.ts
│       └── users-query.dto.ts
│
├── domain
│
│   └── services
│
│       └── users.service.ts
│
├── presentation
│
│   └── controllers
│
│       └── users.controller.ts
│
└── users.module.ts

application/dto/create-user.dto.ts

import {
  IsEmail,
  IsString,
  MinLength,
  IsOptional
} from 'class-validator';
 
export class CreateUserDto {
 
  @IsEmail()
  email: string;
 
  @MinLength(8)
  password: string;
 
  @IsString()
  firstName: string;
 
  @IsString()
  lastName: string;
 
  @IsOptional()
  phone?: string;
}

application/dto/update-user.dto.ts

import {
  IsOptional,
  IsString
} from 'class-validator';
 
export class UpdateUserDto {
 
  @IsOptional()
  @IsString()
  firstName?: string;
 
  @IsOptional()
  @IsString()
  lastName?: string;
 
  @IsOptional()
  @IsString()
  phone?: string;
 
  @IsOptional()
  @IsString()
  status?: string;
}

application/dto/user-response.dto.ts

export class UserResponseDto {
 
  id: string;
 
  tenantId: string;
 
  email: string;
 
  firstName: string;
 
  lastName: string;
 
  phone?: string;
 
  status: string;
 
  emailVerified: boolean;
 
  createdAt: Date;
}

application/dto/users-query.dto.ts

import {
  IsOptional,
  IsNumberString
} from 'class-validator';
 
export class UsersQueryDto {
 
  @IsOptional()
  search?: string;
 
  @IsOptional()
  @IsNumberString()
  page?: string;
 
  @IsOptional()
  @IsNumberString()
  limit?: string;
}

domain/services/users.service.ts

@Injectable()
export class UsersService {
 
  constructor(
 
    private readonly prisma:
      PrismaService,
 
    private readonly passwordService:
      PasswordService,
 
    private readonly userFactoryService:
      UserFactoryService
  ) {}
}

findAll()
 
findOne()
 
create()
 
update()
 
remove()

async findAll(
  query: UsersQueryDto
) {
 
  const page =
    Number(query.page ?? 1);
 
  const limit =
    Number(query.limit ?? 20);
 
  const skip =
    (page - 1) * limit;
 
  return this.prisma.user.findMany({
 
    skip,
 
    take: limit,
 
    where: {
 
      deletedAt: null
    },
 
    orderBy: {
 
      createdAt: 'desc'
    }
  });
}

async findOne(
  id: string
) {
 
  const user =
    await this.prisma.user.findUnique({
 
      where: { id }
    });
 
  if (!user) {
 
    throw new NotFoundException(
      'User not found'
    );
  }
 
  return user;
}

async create(
  dto: CreateUserDto
) {
 
  const tenant =
    await this.prisma.tenant.findUnique({
 
      where: {
 
        code: 'MAIN'
      }
    });
 
  const passwordHash =
    await this.passwordService.hash(
      dto.password
    );
 
  const user =
    await this.prisma.user.create({
 
      data: {
 
        tenantId: tenant.id,
 
        email: dto.email,
 
        passwordHash,
 
        firstName: dto.firstName,
 
        lastName: dto.lastName,
 
        phone: dto.phone,
 
        status: 'ACTIVE'
      }
    });
 
  await this.userFactoryService
    .createDefaultUserEnvironment(
      user.id
    );
 
  return user;
}

async update(
 
  id: string,
 
  dto: UpdateUserDto
) {
 
  await this.findOne(id);
 
  return this.prisma.user.update({
 
    where: { id },
 
    data: dto
  });
}

async remove(
  id: string
) {
 
  await this.findOne(id);
 
  return this.prisma.user.update({
 
    where: { id },
 
    data: {
 
      deletedAt:
        new Date(),
 
      status:
        'INACTIVE'
    }
  });
}

presentation/controllers/users.controller.ts

@ApiTags('Users')
 
@Controller('users')
 
@UseGuards(
 
  JwtAuthGuard,
 
  PermissionsGuard
)
 
export class UsersController {
 
  constructor(
 
    private readonly usersService:
      UsersService
  ) {}
}

@Get()
 
@Permissions(
  'users.read'
)

findAll(
 
  @Query()
  query: UsersQueryDto
) {
 
  return this.usersService
    .findAll(query);
}

@Get(':id')
 
@Permissions(
  'users.read'
)

findOne(
 
  @Param('id')
  id: string
) {
 
  return this.usersService
    .findOne(id);
}

@Post()
 
@Permissions(
  'users.create'
)

create(
 
  @Body()
  dto: CreateUserDto
) {
 
  return this.usersService
    .create(dto);
}

@Put(':id')
 
@Permissions(
  'users.update'
)

update(
 
  @Param('id')
  id: string,
 
  @Body()
  dto: UpdateUserDto
) {
 
  return this.usersService
    .update(
      id,
      dto
    );
}

@Delete(':id')
 
@Permissions(
  'users.delete'
)

remove(
 
  @Param('id')
  id: string
) {
 
  return this.usersService
    .remove(id);
}

users.module.ts

@Module({
 
  imports: [
 
    PrismaModule,
 
    AuthModule
  ],
 
  controllers: [
 
    UsersController
  ],
 
  providers: [
 
    UsersService,
 
    UserFactoryService
  ],
 
  exports: [
 
    UsersService
  ]
})
export class UsersModule {}

Les endpoints suivants doivent apparaître :

GET /users

GET /users/{id}

POST /users

PUT /users/{id}

DELETE /users/{id}

Doit pouvoir :

Créer

Modifier

Lister

Supprimer

des utilisateurs.

Doit recevoir :

{
  "statusCode": 403,
  "message": "Forbidden resource"
}

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

✓ UsersModule créé

✓ UsersController créé

✓ UsersService créé

✓ CRUD fonctionnel

✓ RBAC actif

✓ Swagger documenté

✓ Soft Delete opérationnel

UsersModule

UsersController

UsersService

CreateUserDto

UpdateUserDto

UserResponseDto

UsersQueryDto

Transformer le CRUD utilisateur basique en véritable service Enterprise.

À l'issue de cette étape :

✓ Pagination avancée

✓ Recherche multi-champs

✓ Tri dynamique

✓ Filtres

✓ Isolation Multi-Tenant

✓ Audit Logs

✓ Soft Delete sécurisé

✓ Réponses paginées

Le service actuel :

findAll()

ne gère que :

Pagination simple

et ne protège pas encore :

Isolation tenant

Recherche

Audit

Tri

users-query.dto.ts

import {
  IsOptional,
  IsString,
  IsNumberString
} from 'class-validator';
 
export class UsersQueryDto {
 
  @IsOptional()
  search?: string;
 
  @IsOptional()
  status?: string;
 
  @IsOptional()
  emailVerified?: string;
 
  @IsOptional()
  role?: string;
 
  @IsOptional()
  sortBy?: string;
 
  @IsOptional()
  sortOrder?: 'asc' | 'desc';
 
  @IsOptional()
  @IsNumberString()
  page?: string;
 
  @IsOptional()
  @IsNumberString()
  limit?: string;
}

application/dto/paginated-response.dto.ts

export class PaginatedResponseDto<T> {
 
  data: T[];
 
  page: number;
 
  limit: number;
 
  total: number;
 
  totalPages: number;
}

Aucun utilisateur ne doit voir :

Tenant A

↓

Tenant B

Dans le contrôleur :

@Req()
request

const tenantId =
  request.user.tenantId;

async findAll(
 
  tenantId: string,
 
  query: UsersQueryDto
)

const where: Prisma.UserWhereInput = {
 
  tenantId,
 
  deletedAt: null
};

if (query.search) {
 
  where.OR = [
 
    {
      email: {
        contains: query.search,
        mode: 'insensitive'
      }
    },
 
    {
      firstName: {
        contains: query.search,
        mode: 'insensitive'
      }
    },
 
    {
      lastName: {
        contains: query.search,
        mode: 'insensitive'
      }
    }
  ];
}

if (query.status) {
 
  where.status =
    query.status;
}

if (
 
  query.emailVerified !==
  undefined
 
) {
 
  where.emailVerified =
 
    query.emailVerified ===
    'true';
}

const page =
  Number(query.page ?? 1);
 
const limit =
  Number(query.limit ?? 20);
 
const skip =
  (page - 1) * limit;

const sortBy =
  query.sortBy ??
  'createdAt';
 
const sortOrder =
  query.sortOrder ??
  'desc';

orderBy: {
 
  [sortBy]:
    sortOrder
}

const total =
  await this.prisma.user.count({
 
    where
  });

const users =
  await this.prisma.user.findMany({
 
    where,
 
    skip,
 
    take: limit,
 
    orderBy: {
 
      [sortBy]:
        sortOrder
    }
  });

return {
 
  data: users,
 
  page,
 
  limit,
 
  total,
 
  totalPages:
 
    Math.ceil(
      total / limit
    )
};

async findOne(
 
  tenantId: string,
 
  id: string
)

const user =
  await this.prisma.user.findFirst({
 
    where: {
 
      id,
 
      tenantId,
 
      deletedAt: null
    }
  });

Impossible d'accéder à un utilisateur :

Autre tenant

await this.findOne(
  tenantId,
  id
);

avant toute modification.

await this.findOne(
  tenantId,
  id
);

avant suppression.

Le modèle :

AuditLog

sera créé lors de la Phase 2-I.

Créer :

shared/interfaces/audit.interface.ts

export interface AuditEvent {
 
  action: string;
 
  entityType: string;
 
  entityId: string;
 
  userId: string;
 
  timestamp: Date;
}

Après :

create()

this.logger.log({
 
  action: 'USER_CREATED',
 
  entityType: 'User',
 
  entityId: user.id
});

USER_UPDATED

USER_DELETED

findAll(
 
  @Req()
  req,
 
  @Query()
  query
) {
 
  return this.usersService.findAll(
 
    req.user.tenantId,
 
    query
  );
}

Pour :

findOne()

update()

remove()