feat(auth): durcir la création du mot de passe via token

Squash de develop vers master pour intégrer verify-token/create-password avec TTL strict, usage unique atomique et invalidation explicite du token.

Made-with: Cursor

backend/src/routes/auth/auth.service.ts

@@ -137,6 +137,116 @@ export class AuthService {
         }
     }
 
+    async verifyCreatePasswordToken(token: string) {
+        const cleanedToken = token?.trim();
+        if (!cleanedToken) {
+            throw new BadRequestException('Token manquant');
+        }
+
+        const user = await this.usersRepo.findOne({
+            where: { token_creation_mdp: cleanedToken },
+            select: ['id', 'token_creation_mdp_expire_le', 'password'],
+        });
+
+        if (!user) {
+            throw new NotFoundException('Token invalide, expiré, ou déjà utilisé.');
+        }
+
+        if (user.password) {
+            throw new NotFoundException('Token invalide, expiré, ou déjà utilisé.');
+        }
+
+        if (!user.token_creation_mdp_expire_le || user.token_creation_mdp_expire_le <= new Date()) {
+            // Invalidation explicite d'un token expiré pour éviter toute réutilisation ultérieure.
+            await this.usersRepo
+                .createQueryBuilder()
+                .update(Users)
+                .set({
+                    token_creation_mdp: () => 'NULL',
+                    token_creation_mdp_expire_le: () => 'NULL',
+                })
+                .where('id = :id', { id: user.id })
+                .execute();
+            throw new NotFoundException('Token invalide, expiré, ou déjà utilisé.');
+        }
+
+        return {
+            valid: true,
+            message: 'Token valide',
+        };
+    }
+
+    async createPasswordWithToken(token: string, plainPassword: string) {
+        const cleanedToken = token?.trim();
+        if (!cleanedToken) {
+            throw new BadRequestException('Token manquant');
+        }
+
+        const existingUser = await this.usersRepo.findOne({
+            where: {
+                token_creation_mdp: cleanedToken,
+            },
+            select: ['id', 'password', 'token_creation_mdp_expire_le'],
+        });
+
+        if (!existingUser) {
+            throw new NotFoundException('Token invalide, expiré, ou déjà utilisé.');
+        }
+
+        if (existingUser.password) {
+            throw new NotFoundException('Token invalide, expiré, ou déjà utilisé.');
+        }
+
+        if (
+            !existingUser.token_creation_mdp_expire_le ||
+            existingUser.token_creation_mdp_expire_le <= new Date()
+        ) {
+            await this.usersRepo
+                .createQueryBuilder()
+                .update(Users)
+                .set({
+                    token_creation_mdp: () => 'NULL',
+                    token_creation_mdp_expire_le: () => 'NULL',
+                })
+                .where('id = :id', { id: existingUser.id })
+                .execute();
+            throw new NotFoundException('Token invalide, expiré, ou déjà utilisé.');
+        }
+
+        const sel = await bcrypt.genSalt(12);
+        const hashedPassword = await bcrypt.hash(plainPassword, sel);
+
+        // Usage unique atomique : une seule requête UPDATE avec garde-fous.
+        const updateResult = await this.usersRepo
+            .createQueryBuilder()
+            .update(Users)
+            .set({
+                password: hashedPassword,
+                token_creation_mdp: () => 'NULL',
+                token_creation_mdp_expire_le: () => 'NULL',
+                statut: StatutUtilisateurType.ACTIF,
+                changement_mdp_obligatoire: false,
+            })
+            .where('token_creation_mdp = :token', { token: cleanedToken })
+            .andWhere('token_creation_mdp_expire_le > NOW()')
+            .andWhere('password IS NULL')
+            .execute();
+
+        if (!updateResult.affected) {
+            this.logger.warn(
+                '[createPasswordWithToken] Token non consommé (course concurrente ou token invalidé)',
+            );
+            throw new NotFoundException('Token invalide, expiré, ou déjà utilisé.');
+        }
+
+        this.logger.log('[createPasswordWithToken] Mot de passe initial créé avec succès');
+
+        return {
+            message: 'Mot de passe créé avec succès. Vous pouvez maintenant vous connecter.',
+            userId: existingUser.id,
+        };
+    }
+
     /**
      * Inscription utilisateur OBSOLÈTE - Utiliser inscrireParentComplet() ou registerAM()
      * @deprecated