Google Grant Type in Laravel with Socialite, log in with Google API

  'google' => [
    'api_key' => env('GOOGLE_API_KEY'),
    'client_id' => env('GOOGLE_CLIENT_ID'),
    'client_secret' => env('GOOGLE_CLIENT_SECRET'),
    'redirect' => env('GOOGLE_REDIRECT')
    ]

<?php

namespace App\Grants;

use App\User;
use DateInterval;
use Google\Exception;
use GuzzleHttp\Exception\ClientException;
use Illuminate\Database\Eloquent\ModelNotFoundException;
use Illuminate\Support\Facades\Validator;
use Illuminate\Validation\ValidationException;
use Laravel\Socialite\Facades\Socialite;
use League\OAuth2\Server\Grant\AbstractGrant;
use League\OAuth2\Server\Repositories\RefreshTokenRepositoryInterface;
use League\OAuth2\Server\ResponseTypes\ResponseTypeInterface;
use Psr\Http\Message\ServerRequestInterface;

class GoogleGrant extends AbstractGrant
{
    public function __construct(
        RefreshTokenRepositoryInterface $refreshTokenRepository
    ) {
        $this->refreshTokenRepository = $refreshTokenRepository;
    }

    /**
     * @inheritDoc
     * @return string
     */
    public function getIdentifier(): string
    {
        return 'google';
    }

    /**
     * @inheritDoc
     *
     * @param ServerRequestInterface $request
     * @param ResponseTypeInterface $responseType
     * @param DateInterval $accessTokenTTL
     * @return ResponseTypeInterface
     * @throws
     */
    public function respondToAccessTokenRequest(
        ServerRequestInterface $request,
        ResponseTypeInterface  $responseType,
        DateInterval $accessTokenTTL
    ): ResponseTypeInterface {
        $client = $this->validateClient($request);
        $scopes = $this->validateScopes($this->getRequestParameter('scope', $request));

        $user = $this->validateUser($request);

        // Finalize the requested scopes
        $scopes = $this->scopeRepository
            ->finalizeScopes($scopes, $this->getIdentifier(), $client, $user->getAuthIdentifier());

        // Issue and persist new tokens
        $accessToken = $this->issueAccessToken($accessTokenTTL, $client, $user->getAuthIdentifier(), $scopes);
        $refreshToken = $this->issueRefreshToken($accessToken);

        // Inject tokens into response
        $responseType->setAccessToken($accessToken);
        $responseType->setRefreshToken($refreshToken);

        return $responseType;
    }

    /**
     * Validate the request content and generate mapped user
     *
     * @param ServerRequestInterface $request
     * @return User
     * @throws GoogleLoginFailure
     * @throws ValidationException
     * @throws Exception
     */
    public function validateUser(ServerRequestInterface $request): User
    {
        $validator = Validator::make($request->getParsedBody(), [
            'access_token' => 'required'
        ]);

        $validator->validate();

        try {
            $user = Socialite::driver('google')->userFromToken($request->getParsedBody()['access_token']);
        } catch (ClientException $clientException) {
            throw new ClientException($clientException);
        }

        /**
         * @var $authUser User
         */
        try {
            return User::where('email', $user->email)->firstOrFail();
        } catch (ModelNotFoundException $ex) {
             abort(401, 'Custom message');
            throw new ModelNotFoundException('custom message');
        }
    }
}

  try {
            $this->app->make(AuthorizationServer::class)
                ->enableGrantType(
                    $this->googleGrant(),
                    Passport::tokensExpireIn()
                );
        } catch (LogicException $exception) {
            return;
        }

   /**
     * Returns GoogleGrant instance
     *
     * @return GoogleGrant
     * @throw
     * @throws Exception
     * @throws ContainerExceptionInterface
     */
    protected function googleGrant(): GoogleGrant
    {
        $this->app->singleton(GoogleGrant::class, function () {
            $googleGrant = new GoogleGrant($this->app->make(RefreshTokenRepository::class));
            $googleGrant->setRefreshTokenTTL(Passport::refreshTokensExpireIn());
            return $googleGrant;
        });

        try {
            return $this->app->get(GoogleGrant::class);
        } catch (NotFoundExceptionInterface $e) {
            throw new Exception($e);
        }
    }