Tymon\JWTAuth\JWTGuard

Complexity

Total Complexity

30

Size/Duplication

Total Lines	296
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	6

Test Coverage

Coverage

0%

Importance

Changes	4
Bugs	1	Features	0

20 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	user()	0	14	3
A	validate()	0	4	1
A	attempt()	0	16	3
A	logout()	0	7	1
A	refresh()	0	4	1
A	tokenById()	0	8	2
A	once()	0	10	2
A	onceUsingId()	0	10	2
A	byId()	0	4	1
A	getPayload()	0	4	1
A	setToken()	0	6	1
A	getProvider()	0	4	1
A	setProvider()	0	4	1
A	getUser()	0	4	1
A	getRequest()	0	4	2
A	setRequest()	0	6	1
A	getLastAttempted()	0	4	1
A	hasValidCredentials()	0	4	2
A	requireToken()	0	8	2

<?php

/*
 * This file is part of jwt-auth
 *
 * (c) Sean Tymon <tymon148@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Tymon\JWTAuth;

use Illuminate\Http\Request;
use Illuminate\Auth\GuardHelpers;
use Illuminate\Contracts\Auth\Guard;
use Illuminate\Contracts\Auth\UserProvider;
use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;

class JWTGuard implements Guard
{
    use GuardHelpers;

    /**
     * The user we last attempted to retrieve.
     *
     * @var \Illuminate\Contracts\Auth\Authenticatable
     */
    protected $lastAttempted;

    /**
     * The JWTAuth instance.
     *
     * @var \Tymon\JWTAuth\JWTAuth
     */
    protected $auth;

    /**
     * The request instance.
     *
     * @var \Illuminate\Http\Request
     */
    protected $request;

    public function __construct(JWTAuth $auth, UserProvider $provider, Request $request)

You have injected the Request via parameter $request. This is generally not recommended as there might be multiple instances during a request cycle (f.e. when using sub-requests). Instead, it is recommended to inject the RequestStack and retrieve the current request each time you need it via getCurrentRequest().

    {
        $this->auth = $auth;
        $this->provider = $provider;
        $this->request = $request;
    }

    /**
     * Get the currently authenticated user.
     *
     * @return \Illuminate\Contracts\Auth\Authenticatable|null
     */
    public function user()
    {
        if (! is_null($this->user)) {
            return $this->user;
        }

        if (! $this->requireToken()->check()) {
            return null;
        }

        $id = $this->auth->getPayload()->get('sub');

        return $this->user = $this->provider->retrieveById($id);
    }

    /**
     * Validate a user's credentials.
     *
     * @param  array $credentials
     *
     * @return boolean
     */
    public function validate(array $credentials = [])
    {
        return $this->attempt($credentials, false);

The expression $this->attempt($credentials, false); of type string|boolean adds the type string to the return on line 81 which is incompatible with the return type declared by the interface Illuminate\Contracts\Auth\Guard::validate of type boolean.

    }

    /**
     * Attempt to authenticate the user using the given credentials and return the token.
     *
     * @param  array  $credentials
     *
     * @return boolean
     */
    public function attempt(array $credentials = [], $login = true)
    {
        $this->lastAttempted = $user = $this->provider->retrieveByCredentials($credentials);

        if ($this->hasValidCredentials($user, $credentials)) {
            if ($login) {
                $this->setUser($user);

It seems like $user defined by $this->provider->retrieveByCredentials($credentials) on line 93 can be null; however, Illuminate\Auth\GuardHelpers::setUser() does not accept null, maybe add an additional type check?

                return $this->auth->fromUser($user);

$user is of type object<Illuminate\Contracts\Auth\Authenticatable>|null, but the function expects a object<Tymon\JWTAuth\Contracts\JWTSubject>.

            }

            return true;
        }

        return false;
    }

    /**
     * Logout the user, thus invalidating the token.
     *
     * @param  boolean  $forceForever
     *
     * @return void
     */
    public function logout($forceForever = false)
    {
        $this->requireToken()->invalidate($forceForever);

        $this->user = null;
        $this->auth->unsetToken();
    }

    /**
     * Refresh the token
     *
     * @return  string
     */
    public function refresh()
    {
        return $this->requireToken()->refresh();
    }

    /**
     * Create a new token by User id
     *
     * @param   mixed  $id
     *
     * @return  string|null
     */
    public function tokenById($id)
    {
        if (! is_null($user = $this->provider->retrieveById($id))) {
            return $this->auth->fromUser($user);

$user is of type object<Illuminate\Contracts\Auth\Authenticatable>, but the function expects a object<Tymon\JWTAuth\Contracts\JWTSubject>.

        }

        return null;
    }

    /**
     * Log a user into the application using their credentials.
     *
     * @param  array $credentials
     *
     * @return boolean
     */
    public function once(array $credentials = [])
    {
        if ($this->validate($credentials)) {
            $this->setUser($this->lastAttempted);

            return true;
        }

        return false;
    }

    /**
     * Log the given User into the application.
     *
     * @param  mixed $id
     *
     * @return boolean
     */
    public function onceUsingId($id)
    {
        if (! is_null($user = $this->provider->retrieveById($id))) {
            $this->setUser($user);

            return true;
        }

        return false;
    }

    /**
     * Alias for onceUsingId
     *
     * @param   mixed  $id
     *
     * @return  boolean
     */
    public function byId($id)
    {
        return $this->onceUsingId($id);
    }

    /**
     * Get the raw Payload instance.
     *
     * @return \Tymon\JWTAuth\Payload
     */
    public function getPayload()
    {
        return $this->auth->getPayload();
    }

    /**
     * Set the token.
     *
     * @param  Token|string  $token
     *
     * @return JWTGuard
     */
    public function setToken($token)
    {
        $this->auth->setToken($token);

        return $this;
    }

    /**
     * Get the user provider used by the guard.
     *
     * @return \Illuminate\Contracts\Auth\UserProvider
     */
    public function getProvider()
    {
        return $this->provider;
    }

    /**
     * Set the user provider used by the guard.
     *
     * @param  \Illuminate\Contracts\Auth\UserProvider  $provider
     *
     * @return void
     */
    public function setProvider(UserProvider $provider)
    {
        $this->provider = $provider;
    }

    /**
     * Return the currently cached user.
     *
     * @return \Illuminate\Contracts\Auth\Authenticatable|null
     */
    public function getUser()
    {
        return $this->user;
    }

    /**
     * Get the current request instance.
     *
     * @return \Symfony\Component\HttpFoundation\Request
     */
    public function getRequest()
    {
        return $this->request ?: Request::createFromGlobals();
    }

    /**
     * Set the current request instance.
     *
     * @param  \Symfony\Component\HttpFoundation\Request  $request
     *
     * @return $this
     */
    public function setRequest(Request $request)

You have injected the Request via parameter $request. This is generally not recommended as there might be multiple instances during a request cycle (f.e. when using sub-requests). Instead, it is recommended to inject the RequestStack and retrieve the current request each time you need it via getCurrentRequest().

    {
        $this->request = $request;

        return $this;
    }

    /**
     * Get the last user we attempted to authenticate.
     *
     * @return \Illuminate\Contracts\Auth\Authenticatable
     */
    public function getLastAttempted()
    {
        return $this->lastAttempted;
    }

    /**
     * Determine if the user matches the credentials.
     *
     * @param  mixed  $user
     * @param  array  $credentials
     *
     * @return boolean
     */
    protected function hasValidCredentials($user, $credentials)
    {
        return ! is_null($user) && $this->provider->validateCredentials($user, $credentials);
    }

    /**
     * Ensure that a token is available in the request
     *
     * @throws \Symfony\Component\HttpKernel\Exception\BadRequestHttpException
     *
     * @return \Tymon\JWTAuth\JWTAuth
     */
    protected function requireToken()
    {
        if (! $this->auth->getToken()) {
            throw new BadRequestHttpException($e->getMessage());
        }

        return $this->auth;
    }
}