Kotlin i niejednoznaczny null

    fun findById(userId: String): UserProfile? {
        return mongoTemplate.findOne(userIdQuery(userId), UserProfile::class.java)
    }

@Service
class AuthenticationService(private val userRepository: UserRepository,
                            private val tokenProvider: JwtTokenProvider,
                            private val passwordEncoder: PasswordEncoder) {

    fun authenticate(input: AuthenticationInput): String? {
        val user = userRepository.findByEmail(input.email)
        require(user != null ) {"User ${input.email} was not found"}
        require(validPassword(input.password, user.password)) {"Password is incorrect"}
        return tokenProvider.createToken(user.id);
    }

    fun validPassword(providedPassword: String, actualPassword: String): Boolean {
        return passwordEncoder.matches(providedPassword, actualPassword);
    }
}

@Document
data class UserProfile(
        @Id
        val id: String? = null,
        val email: String,
        val password: String,
}

    fun validPassword(providedPassword: String, actualPassword: String): Boolean =
        passwordEncoder.matches(providedPassword, actualPassword)
    

    // a nawet 
    fun validPassword(providedPassword: String, actualPassword: String) =
        passwordEncoder.matches(providedPassword, actualPassword) // ale niekoniecznie najlepsze w publicznych metodach

public class OperationResult<T> {
    private final Either<List<Error>, T> result;

    private OperationResult(Either<List<Error>, T> result) {
        this.result = result;
    }

    public static OperationResult<Success> success(String message) {
        return new OperationResult<>(Either.right(new Success(message)));
    }

    public static <T> OperationResult<T> success(T object) {
        return new OperationResult<>(Either.right(object));
    }

    public static <T> OperationResult<T> failure(Seq<Error> errors) {
        return new OperationResult<>(Either.left(errors.toJavaList()));
    }

    public static <T> OperationResult<T> failure(Error... errors) {
        return new OperationResult<>(Either.left(Arrays.asList(errors)));
    }

    public Either<List<Error>, T> getResult() {
        return result;
    }    
}

    public OperationResult<AuthenticationResult> authenticate(AuthenticationInput command) {
        return userRepository.findByEmail(command.getEmail())
                .map(user -> validatePassword(user, command))
                .orElseGet(() -> failure(Error.USER_NOT_FOUND));
    }

    private OperationResult<AuthenticationResult> validatePassword(User user, AuthenticationInput command) {
        return passwordEncoder.matches(command.getPassword(), user.getPassword()) ?
                success(authenticationToken(user)) :
                failure(Error.INCORRECT_PASSWORD);
    }

    private AuthenticationResult authenticationToken(User user) {
        return new AuthenticationResult(tokenProvider.createToken(user.getId()));
    }

class AuthenticationService(
    private val userRepository: UserRepository
) {
    fun authenticate(input: AuthenticationInput): AuthenticationResult =
        userRepository.findByEmail(input.email)
            ?.let { user -> if (passwordValid(input.password, user.password)) AuthenticationResult.Ok else AuthenticationResult.IncorrectPassword }
            ?: AuthenticationResult.UserNotFound

    private fun passwordValid(givenPassword: String, userPassword: Any): Boolean {
        TODO("Not yet implemented")
    }
}

sealed class AuthenticationResult {
    object Ok : AuthenticationResult()
    object UserNotFound : AuthenticationResult()
    object IncorrectPassword : AuthenticationResult()
}