<?php // app/Http/Controllers/ExampleController.php

namespace App\Http\Controllers;

use App\Http\Requests\CreateExampleRequest;
use App\Http\Requests\ListExampleRequest;
use Appkr\Service\ExampleService;
use Illuminate\Http\JsonResponse;

class ExampleController extends Controller
{
    private $service;

    public function __construct(ExampleService $exampleService)
    {
        $this->service = $exampleService;
    }

    public function createExample(CreateExampleRequest $request): JsonResponse
    {
        $dto = $this->service->createExample($request->toDto());

        return new JsonResponse($dto);
    }

    public function listExamples(ListExampleRequest $request): JsonResponse
    {
        return new JsonResponse($this->service->listExamples($request->toDto()));
    }
}

<?php // app/Http/Middleware/TokenAuthenticate.php

namespace AppP\Http\Middleware;

use App\Models\User;
use Appkr\Infra\TokenException;
use Appkr\Infra\TokenExtractor;
use Appkr\Infra\TokenParser;
use Closure;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Ramsey\Uuid\Uuid;

class TokenAuthenticate
{
    private $tokenParser;

    public function __construct(TokenParser $tokenParser)
    {
        $this->tokenParser = $tokenParser;
    }

    public function handle(Request $request, Closure $next)
    {
        try {
            $jwtString = TokenExtractor::extract($request);
            if (!$jwtString) {
                throw TokenException::tokenNotProvided();
            }
            $token = $this->tokenParser->parse($jwtString);
        } catch (TokenException $e) {
            return new JsonResponse(
                ['message' => $e->getMessage(),], 
                $e->getStatusCode()
            );
        } catch (\Exception $e) {
            return new JsonResponse(['message' => 'Unknown exception',], 400);
        }

        $request->setUserResolver(function () use ($token) {
            $user = new User();
            $user->name = ($token->getUserName() instanceof Uuid) 
                ? $token->getUserName() 
                : Uuid::fromString(Uuid::NIL);
            return $user;
        });

        return $next($request);
    }
}

<?php // src/Infra/TokenExtractor.php

namespace Appkr\Infra;

use Illuminate\Http\Request;

class TokenExtractor
{
    public static function extract(Request $request): ?string
    {
        if (!$request->hasHeader('authorization')) {
            return null;
        }

        $authHeader = $request->header('authorization');
        $jwtString = preg_replace('/bearer\s/i', '', $authHeader);

        return $jwtString;
    }
}

<?php // src/Infra/TokenExtractor.php

namespace Appkr\Infra;

use Firebase\JWT\BeforeValidException;
use Firebase\JWT\ExpiredException;
use Firebase\JWT\SignatureInvalidException;

class TokenParser
{
    private $tokenKeyProvider;

    public function __construct(TokenKeyProvider $tokenKeyProvider)
    {
        $this->tokenKeyProvider = $tokenKeyProvider;
    }

    public function parse(string $jwtString): Token
    {
        $token = new Token();
        try {
            $token = Token::fromTokenString(
                $jwtString, 
                $this->tokenKeyProvider->getKey()
            );
        } catch (SignatureInvalidException $e) {
            throw TokenException::invalidSignature($e);
        } catch (BeforeValidException $e) {
            throw TokenException::beforeValid($e);
        } catch (ExpiredException $e) {
            throw TokenException::expired($e);
        } catch (UnexpectedValueException $e) {
            throw TokenException::invalidToken($e);
        }

        return $token;
    }
}

<?php

namespace Appkr\Infra\JhipsterUaa;

use Appkr\Infra\TokenKeyProvider;
use GuzzleHttp\Client as GuzzleClient;
use GuzzleHttp\Psr7\Request;
use GuzzleHttp\Psr7\Response;
use Illuminate\Support\Arr;
use Psr\Http\Client\ClientExceptionInterface;

class UaaTokenKeyProvider implements TokenKeyProvider
{
    private $httpClient;
    private $config;

    public function __construct(GuzzleClient $httpClient, array $config)
    {
        $this->httpClient = $httpClient;
        $this->config = $config;
    }

    public function getKey(): string
    {
        return $this->getTokenKey()->getKey()->getValue();
    }

    public function getTokenKey(): TokenKeyResponse
    {
        $request = new Request('GET', Arr::get($this->config, 'token_key_path'));
        $response = new Response();
        try {
            $response = $this->httpClient->sendRequest($request);
        } catch (ClientExceptionInterface $e) {
        }

        return TokenKeyResponse::fromJsonString($response->getBody());
    }
}

<?php // app/Providers/OAuth2ServiceProvider.php

namespace App\Providers;

use Appkr\Infra\JhipsterUaa\UaaTokenKeyProvider;
use Appkr\Infra\TokenKeyProvider;
use Appkr\Infra\TokenParser;
use GuzzleHttp\Client as GuzzleClient;
use Illuminate\Contracts\Config\Repository as ConfigRepository;
use Illuminate\Contracts\Foundation\Application;
use Illuminate\Support\Arr;
use Illuminate\Support\ServiceProvider;

class OAuth2ServiceProvider extends ServiceProvider
{
    public function register()
    {
        $this->registerTokenKeyProvider();
        $this->registerTokenParser();
    }
    
    private function registerTokenKeyProvider()
    {
        $this->app->bind(TokenKeyProvider::class, function (Application $app) {
            $config = $app->make(ConfigRepository::class)->get('oauth2.jhipster');
            $httpClient = new GuzzleClient([
                'base_uri' => Arr::get($config, 'base_uri'),
                'timeout' => 0,
            ]);
            return new UaaTokenKeyProvider($httpClient, $config);
        });
    }

    private function registerTokenParser()
    {
        $this->app->bind(TokenParser::class, function (Application $app) {
            return new TokenParser($app->make(TokenKeyProvider::class));
        });
    }   
}

<?php // src/Infra/JhipsterUaa/CacheableTokenKeyProvider.php

namespace Appkr\Infra\JhipsterUaa;

use Appkr\Infra\TokenKeyProvider;
use Illuminate\Contracts\Cache\Repository;

class CacheableTokenKeyProvider implements TokenKeyProvider
{
    const CACHE_KEY = 'oauth2.token_key';
    const CACHE_TTL_SECONDS = 60 * 60 * 24; // 24시간

    private $delegate;
    private $cacheRepository;

    public function __construct(
        TokenKeyProvider $delegate, 
        Repository $cacheRepository
    ) {
        $this->delegate = $delegate;
        $this->cacheRepository = $cacheRepository;
    }

    public function getKey(): string
    {
        return $this->getTokenKey()->getKey()->getValue();
    }

    public function getTokenKey(): TokenKeyResponse
    {
        $self = $this;
        return $this->cacheRepository->remember(
            self::CACHE_KEY, 
            self::CACHE_TTL_SECONDS, 
            function () use ($self) {
                return $self->delegate->getTokenKey();
            }
        );
    }
}

<?php // app/Providers/OAuth2ServiceProvider.php

use Appkr\Infra\JhipsterUaa\CacheableTokenKeyProvider;
use Illuminate\Contracts\Cache\Repository as CacheRepository;
// 생략 ...

class OAuth2ServiceProvider extends ServiceProvider
{
    public function register()
    {
        // 생략 ...
    }
    
    private function registerTokenKeyProvider()
    {
        $this->app->bind(TokenKeyProvider::class, function (Application $app) {
            $config = $app->make(ConfigRepository::class)->get('oauth2.jhipster');
            $httpClient = new GuzzleClient([
                'base_uri' => Arr::get($config, 'base_uri'),
                'timeout' => 0,
            ]);
            $innerProvider = new UaaTokenKeyProvider($httpClient, $config);
            $cacheRepository = $app->make(CacheRepository::class);

            return new CacheableTokenKeyProvider($innerProvider, $cacheRepository);
        });
    }
}