Canis\Lumen\Jwt\BaseGuard

Complexity

Total Complexity

38

Size/Duplication

Total Lines	259
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Test Coverage

Coverage

100%

Importance

Changes	9
Bugs	1	Features	0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	getAdapterFactoryClass()	0	16	4
A	getAdapterFactory()	0	10	2
A	getProcessor()	0	4	1
A	getGenerator()	0	4	1
A	getProvider()	0	4	1
A	refresh()	0	9	3
A	refreshToken()	0	10	3
A	universalUserLogin()	0	13	4
B	user()	0	17	5
A	getBearerToken()	0	9	2
A	validate()	0	8	2
A	hasValidCredentials()	0	4	2
A	setRequest()	0	4	1
A	getRequest()	0	4	1
A	attempt()	0	11	3
A	generateToken()	0	11	2

<?php
/**
 * @copyright Copyright (c) 2016 Canis.io
 * @license   MIT
 */
namespace Canis\Lumen\Jwt;

use Illuminate\Http\Request;
use Illuminate\Auth\GuardHelpers;
use Illuminate\Contracts\Auth\Factory as AuthFactory;
use Illuminate\Contracts\Auth\UserProvider;
use Illuminate\Contracts\Auth\Guard as GaurdContract;
use Canis\Lumen\Jwt\Exceptions\InvalidTokenException;
use Canis\Lumen\Jwt\Exceptions\InvalidAdapterException;
use Canis\Lumen\Jwt\Contracts\AdapterFactory as AdapterFactoryContract;
use Canis\Lumen\Jwt\Contracts\Processor as ProcessorContract;
use Canis\Lumen\Jwt\Contracts\Subject as SubjectContract;

abstract class BaseGuard
    implements GaurdContract, GuardInterface

The implements keyword must be on the same line as the class name

{
    use GuardHelpers;

    const JWT_GUARD_CLAIM = 'grd';

    /**
     * @var string
     */
    protected $id;

    /**
     * @var Request
     */
    protected $request;

    /**
     * Constructor
     *
     * @param UserProvider $provider
     * @param Request      $request
     */
    public function __construct($id, UserProvider $provider, Request $request)
    {
        $this->request = $request;
        $this->provider = $provider;
        $this->id = $id;
    }

    /**
     * Returns the adapter class name to use
     *
     * @return string
     */
    public function getAdapterFactoryClass()
    {
        $config = config('jwt');
        if (!isset($config['adapter'])) {
            $config['adapter'] = 'lcobucci';
        }
        if (class_exists($config['adapter'])) {
            $factoryClass = $config['adapter'];
        } else {
            $factoryClass = 'Canis\Lumen\Jwt\Adapters\\' . ucfirst($config['adapter']) . '\Factory';
            if (!class_exists($factoryClass)) {
                throw new InvalidAdapterException("{$config['adapter']} is not available");
            }
        }
        return $factoryClass;
    }

    /**
     * Returns the adapter factory object
     *
     * @return AdapterFactoryContract
     */
    protected function getAdapterFactory()
    {
        static $factory;
        if (!isset($factory)) {
            $config = config('jwt');
            $factoryClass = $this->getAdapterFactoryClass();
            $factory = new $factoryClass($config);
        }
        return $factory;
    }

    /**
     * Returns a token processor from the adapter factory
     *
     * @return ProcessorContract
     */
    protected function getProcessor()
    {
        return $this->getAdapterFactory()->getProcessor();
    }

    /**
     * Returns a token generator from the adapter factory
     *
     * @return GeneratorContract
     */
    protected function getGenerator()
    {
        return $this->getAdapterFactory()->getGenerator();
    }

    /**
     * Gets the provider
     *
     * @return UserProvider
     */
    public function getProvider()
    {
        return $this->provider;
    }


    /**
     * @inheritdoc
     */
    public function refresh(AuthFactory $auth)
    {
        $token = $this->getBearerToken(true);
        if ($token !== false && $token->hasClaim(static::JWT_GUARD_CLAIM)) {
            $guard = $token->getClaim(static::JWT_GUARD_CLAIM);
            return $auth->guard($guard)->refreshToken($token);
        }
        return false;
    }

    /**
     * Refresh the token 
     * @param  Token  $token
     * @return Token|boolean  New token or false if old token can't be verified
     */
    public function refreshToken(Token $token)
    {
        $user = $this->getProvider()->retrieveById($token->getClaim('sub'));
        $claimValidation = [static::JWT_GUARD_CLAIM => $this->id];
        if (!($user instanceof SubjectContract)
            || !$token->ensureClaimValues(array_merge($user->getJWTClaimValidation(), $claimValidation))) {
            return false;
        }
        return $this->generateToken($user);
    }

    /**
     * @inheritdoc
     */
    public function universalUserLogin(AuthFactory $auth)
    {
        $token = $this->getBearerToken();
        $guard = false;
        if ($token !== false && $token->hasClaim(static::JWT_GUARD_CLAIM)) {
            $guard = $token->getClaim(static::JWT_GUARD_CLAIM);
            $user = $auth->guard($guard)->user();
            if ($user === null) {
                $guard = false;
            }
        }
        return $guard;
    }

    /**
     * @inheritdoc
     */
    public function user()
    {
        if (!is_null($this->user)) {
            return $this->user;
        }
        $user = null;
        $token = $this->getBearerToken();
        if ($token !== false) {
            $user = $this->getProvider()->retrieveById($token->getClaim('sub'));
            $claimValidation = [static::JWT_GUARD_CLAIM => $this->id];
            if (!($user instanceof SubjectContract)
                || !$token->ensureClaimValues(array_merge($user->getJWTClaimValidation(), $claimValidation))) {
                $user = null;
            }
        }
        return $this->user = $user;
    }

    /**
     * @inheritdoc
     */
    public function getBearerToken($isRefresh = false)
    {
        $token = $this->request->bearerToken();
        if (empty($token)) {
            return false;
        }
        $processor = $this->getProcessor();
        return $processor($token, $isRefresh);
    }

    /**
     * @inheritdoc
     */
    public function validate(array $credentials = [])
    {
        $user = $this->getProvider()->retrieveByCredentials($credentials);
        if ($this->hasValidCredentials($user, $credentials)) {

It seems like $user defined by $this->getProvider()->retrieveByCredentials($credentials) on line 203 can also be of type object<Illuminate\Contracts\Auth\Authenticatable>; however, Canis\Lumen\Jwt\BaseGuard::hasValidCredentials() does only seem to accept object<Canis\Lumen\Jwt\Authenticatable>|null, maybe add an additional type check?

            return true;
        }
        return false;
    }

    /**
     * Determine if the user matches the credentials.
     *
     * @param  Authenticatable|null  $user
     * @param  array  $credentials
     * @return bool
     */
    protected function hasValidCredentials($user, $credentials)
    {
        return !is_null($user) && $this->getProvider()->validateCredentials($user, $credentials);
    }

    /**
     * Sets the Request
     *
     * @param Request $request
     */
    public function setRequest(Request $request)
    {
        $this->request = $request;
    }

    /**
     * Gets the request
     *
     * @return Request
     */
    public function getRequest()
    {
        return $this->request;
    }

    /**
     * Attempt to authenticate a user using the given credentials.
     *
     * @param  array  $credentials
     * @return bool|Token
     */
    public function attempt(array $credentials = [])
    {
        $user = $this->getProvider()->retrieveByCredentials($credentials);
        if ($this->hasValidCredentials($user, $credentials)) { 

It seems like $user defined by $this->getProvider()->retrieveByCredentials($credentials) on line 250 can also be of type object<Illuminate\Contracts\Auth\Authenticatable>; however, Canis\Lumen\Jwt\BaseGuard::hasValidCredentials() does only seem to accept object<Canis\Lumen\Jwt\Authenticatable>|null, maybe add an additional type check?

            if (!($user instanceof SubjectContract)) {
                throw new InvalidTokenException("Unable to generate token");
            }
            return $this->generateToken($user);
        }
        return false;
    }

    /**
     * Generate a new token
     * 
     * @param  SubjectContract $user
     * @return Token
     */
    private function generateToken(SubjectContract $user)
    {
        $tokenGenerator = $this->getGenerator();
        $claims = $user->getJWTClaims();
        $claims['sub'] = $user->getJWTSubject();
        $claims[static::JWT_GUARD_CLAIM] = $this->id;
        if (!($token = $tokenGenerator($claims))) {
            throw new InvalidTokenException("Unable to generate token");
        }
        return $token;
    }
}