encoders:
     App\Entity\Local\User: sha512

<?php

namespace App\Security;

use App\Entity\Local\User;
use Symfony\Component\Security\Core\Encoder\EncoderFactoryInterface;

class PasswordUpdater
{
    private $encoderFactory;

    public function __construct(EncoderFactoryInterface $encoderFactory)
    {
        $this->encoderFactory = $encoderFactory;
    }

    /**
     * @param User $user
     * */
    public function hashPassword(User $user)
    {
        $plainPassword = $user->getPlainPassword();

        if (empty($plainPassword)) {
            return;
        }

        $encoder = $this->encoderFactory->getEncoder($user);
        $hashedPassword = $encoder->encodePassword($plainPassword, $user->getSalt());
        $user->setPassword($hashedPassword);
        $user->eraseCredentials();
    }
}

public function loginAction(
        UserActivityDto $userActivityDto, 
        ConstraintViolationListInterface $validationErrors, 
        TranslatorInterface $translator, 
        UserPasswordHasherInterface $encoder, 
        UserTokenService $tokenService, 
        CaptchaService $captchaService, 
        Request $request
    ): Response
    {
        // Check constraints validation list
        $this->securityService->checkValidationErrors($validationErrors);
        
        // Get user from email of login field
        /** @var \App\Entity\Local\User $user */
        $user = $this->userRepo->findOneBy([
            'email'   => $userActivityDto->email,
            'enabled' => true])
        ;
        
        // Check login and password
        if (!$user || !$encoder->isPasswordValid($user, $userActivityDto->password))
        {
            throw new ValidationException($translator->trans('user.authentication_failed'));
        }

     password_hashers:
        App\Entity\Local\User:
            algorithm: sha512

<?php

declare(strict_types=1);

namespace App\Security;

use App\Entity\Local\User;

use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface;

final class PasswordUpdater
{
    public function __construct(
        private readonly UserPasswordHasherInterface $passwordHasher,
    ) {}

    public function hashPassword(User $user): void
    {
        // Get the new password.
        $plainPassword = $user->getPlainPassword();

        // Stop if there is no new password.
        if ($plainPassword === null || $plainPassword === '') 
        {
            return;
        }

        // Hash the new password.
        $hashedPassword = $this->passwordHasher->hashPassword(
            $user,
            $plainPassword
        );

        // Set the new password.
        $user->setPassword($hashedPassword);
        $user->eraseCredentials();
    }
}

public function loginAction(
        Request $request
    ): Response
    {
        // Data deserialization.
        $userActivityDto = $this->serializer->deserialize(
            $request->getContent(),
            UserActivityDto::class,
            'json'
        );

        // Stop if any validation error.
        $this->securityService->checkValidationErrors(
            $this->validatorService->validate($userActivityDto)
        );

        // Get user from email of login field
        /** @var User|null $user */
        $user = $this->userRepository->findOneBy([
            'email'   => $userActivityDto->email,
            'enabled' => true
        ]);

        // Check login and password.
        if (
            !$user 
            || !$this->passwordHasher->isPasswordValid(
                $user, 
                $userActivityDto->password
            )
        )
        {
            return $this->json(
                [
                    'errors' => 
                    [
                        [
                            'property_path' => 'password',
                            'message'       => $this->translator->trans('user.authentication_failed')
                        ]
                    ]
                ], 
                Response::HTTP_BAD_REQUEST
            );
        }