Tymon\JWTAuth\JWTAuth

Complexity

Total Complexity

33

Size/Duplication

Total Lines	338
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Test Coverage

Coverage

92.59%

Importance

Changes	21
Bugs	3	Features	1

24 Methods

Rating	Name	Duplication	Size	Complexity
A	fromUser()	0	6	1
A	attempt()	0	8	2
A	authenticate()	0	10	2
A	toUser()	0	4	1
A	refresh()	0	6	1
A	invalidate()	0	6	1
A	checkOrFail()	0	4	1
A	check()	0	10	2
A	getToken()	0	12	3
A	getPayload()	0	6	1
A	getClaimsArray()	0	8	1
A	user()	0	4	1
A	__construct()	0	6	1
A	parseToken()	0	8	2
A	makePayload()	0	4	1
A	setToken()	0	6	2
A	requireToken()	0	6	2
A	setRequest()	0	6	1
A	manager()	0	4	1
A	parser()	0	4	1
A	factory()	0	4	1
A	blacklist()	0	4	1
A	__call()	0	8	2
A	unsetToken()	0	4	1

<?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 Tymon\JWTAuth\Support\CustomClaims;
use Tymon\JWTAuth\Contracts\JWTSubject;
use Tymon\JWTAuth\Contracts\Providers\Auth;
use Tymon\JWTAuth\Exceptions\JWTException;
use Tymon\JWTAuth\Http\TokenParser;

class JWTAuth
{
    use CustomClaims;

    /**
     * @var \Tymon\JWTAuth\Manager
     */
    protected $manager;

    /**
     * @var \Tymon\JWTAuth\Contracts\Providers\Auth
     */
    protected $auth;

    /**
     * @var \Tymon\JWTAuth\Http\TokenParser
     */
    protected $parser;

    /**
     * @var \Tymon\JWTAuth\Token
     */
    protected $token;

    /**
     * @param \Tymon\JWTAuth\Manager                   $manager
     * @param \Tymon\JWTAuth\Contracts\Providers\Auth  $auth
     * @param \Tymon\JWTAuth\Http\TokenParser          $parser
     */
    public function __construct(Manager $manager, Auth $auth, TokenParser $parser)
    {
        $this->manager = $manager;
        $this->auth = $auth;
        $this->parser = $parser;
    }

    /**
     * Generate a token using the user identifier as the subject claim.
     *
     * @param \Tymon\JWTAuth\Contracts\JWTSubject $user
     *
     * @return string
     */
    public function fromUser(JWTSubject $user)
    {
        $payload = $this->makePayload($user);

        return $this->manager->encode($payload)->get();
    }

    /**
     * Attempt to authenticate the user and return the token.
     *
     * @param array $credentials
     *
     * @return false|string
     */
    public function attempt(array $credentials)
    {
        if (! $this->auth->byCredentials($credentials)) {
            return false;
        }

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

    /**
     * Authenticate a user via a token.
     *
     * @return \Tymon\JWTAuth\Contracts\JWTSubject|false
     */
    public function authenticate()
    {
        $id = $this->getPayload()->get('sub');

        if (! $this->auth->byId($id)) {
            return false;
        }

        return $this->user();
    }

    /**
     * Alias for authenticate().
     *
     * @return \Tymon\JWTAuth\Contracts\JWTSubject|false
     */
    public function toUser()
    {
        return $this->authenticate();
    }

    /**
     * Refresh an expired token.
     *
     * @return string
     */
    public function refresh()
    {
        $this->requireToken();

        return $this->manager->customClaims($this->getCustomClaims())->refresh($this->token)->get();
    }

    /**
     * Invalidate a token (add it to the blacklist).
     *
     * @param  boolean  $forceForever
     *
     * @return boolean
     */
    public function invalidate($forceForever = false)
    {
        $this->requireToken();

        return $this->manager->invalidate($this->token, $forceForever);
    }

    /**
     * Alias to get the payload, and as a result checks that
     * the token is valid i.e. not expired or blacklisted
     *
     * @throws JWTException
     *
     * @return \Tymon\JWTAuth\Payload
     */
    public function checkOrFail()
    {
        return $this->getPayload();
    }

    /**
     * Check that the token is valid
     *
     * @return boolean
     */
    public function check()
    {
        try {
            $this->checkOrFail();
        } catch (JWTException $e) {
            return false;
        }

        return true;
    }

    /**
     * Get the token.
     *
     * @return false|Token
     */
    public function getToken()
    {
        if (! $this->token) {
            try {
                $this->parseToken();
            } catch (JWTException $e) {
                return false;
            }
        }

        return $this->token;
    }

    /**
     * Parse the token from the request.
     *
     * @throws \Tymon\JWTAuth\Exceptions\JWTException
     *
     * @return JWTAuth
     */
    public function parseToken()
    {
        if (! $token = $this->parser->parseToken()) {
            throw new JWTException('The token could not be parsed from the request');
        }

        return $this->setToken($token);

It seems like $token defined by $this->parser->parseToken() on line 195 can also be of type array; however, Tymon\JWTAuth\JWTAuth::setToken() does only seem to accept object<Tymon\JWTAuth\Token>|string, maybe add an additional type check?

    }

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

        return $this->manager->decode($this->token);
    }

    /**
     * Create a Payload instance.
     *
     * @param \Tymon\JWTAuth\Contracts\JWTSubject $user
     *
     * @return \Tymon\JWTAuth\Payload
     */
    public function makePayload(JWTSubject $user)
    {
        return $this->factory()->customClaims($this->getClaimsArray($user))->make();
    }

    /**
     * Build the claims array and return it
     *
     * @param \Tymon\JWTAuth\Contracts\JWTSubject $user
     *
     * @return array
     */
    protected function getClaimsArray(JWTSubject $user)
    {
        return array_merge(
            ['sub' => $user->getJWTIdentifier()],
            $this->customClaims,
            $user->getJWTCustomClaims()
        );
    }

    /**
     * Get the authenticated user
     *
     * @return \Tymon\JWTAuth\Contracts\JWTSubject
     */
    public function user()
    {
        return $this->auth->user();
    }

    /**
     * Set the token.
     *
     * @param  Token|string  $token
     *
     * @return JWTAuth
     */
    public function setToken($token)
    {
        $this->token = $token instanceof Token ? $token : new Token($token);

        return $this;
    }

    /**
     * Remove the current token.
     */
    public function unsetToken()
    {
        $this->token = null;
    }

    /**
     * Ensure that a token is available.
     *
     * @throws \Tymon\JWTAuth\Exceptions\JWTException
     */
    protected function requireToken()
    {
        if (! $this->token) {
            throw new JWTException('A token is required');
        }
    }

    /**
     * Set the request instance.
     *
     * @param \Illuminate\Http\Request $request
     *
     * @return JWTAuth
     */
    public function setRequest(Request $request)
    {
        $this->parser->setRequest($request);

        return $this;
    }

    /**
     * Get the Manager instance.
     *
     * @return \Tymon\JWTAuth\Manager
     */
    public function manager()
    {
        return $this->manager;
    }

    /**
     * Get the TokenParser instance
     *
     * @return \Tymon\JWTAuth\Http\TokenParser
     */
    public function parser()
    {
        return $this->parser;
    }

    /**
     * Get the Payload Factory
     *
     * @return \Tymon\JWTAuth\Factory
     */
    public function factory()
    {
        return $this->manager->getPayloadFactory();
    }

    /**
     * Get the Blacklist
     *
     * @return \Tymon\JWTAuth\Blacklist
     */
    public function blacklist()
    {
        return $this->manager->getBlacklist();
    }

    /**
     * Magically call the JWT Manager.
     *
     * @param string $method
     * @param array  $parameters
     *
     * @return mixed
     *
     * @throws \BadMethodCallException
     */
    public function __call($method, $parameters)
    {
        if (method_exists($this->manager, $method)) {
            return call_user_func_array([$this->manager, $method], $parameters);
        }

        throw new \BadMethodCallException("Method [$method] does not exist.");
    }
}