Empty Response about slim-jwt-auth HOT 4 CLOSED

<?php

require __DIR__ . "/vendor/autoload.php";

$app = new Slim\App([
    "settings"  => [
        "determineRouteBeforeAppMiddleware" => true,
        "displayErrorDetails" => true
    ]
]);

$app->add(new \Slim\Middleware\JwtAuthentication([
    "secret" => "supersecretkeyyoushouldnotcommittogithub"
]));

$app->get("/", function($request, $response, $arguments) {
    print_r($response);
});

$app->run();

<?php

$app->group('/user', function () use ($app){
    $app->get('', '\App\User\Controller\UserController');
})->add(new Slim\Middleware\JwtAuthentication([
    "secret" => getenv('JWT_SECRET'),
]));

/**
     * Call the middleware
     *
     * @param \Psr\Http\Message\RequestInterface $request
     * @param \Psr\Http\Message\ResponseInterface $response
     * @param callable $next
     * @return \Psr\Http\Message\ResponseInterface
     */
    public function __invoke(RequestInterface $request, ResponseInterface $response, callable $next)
    {
        $scheme = $request->getUri()->getScheme();
        $host = $request->getUri()->getHost();

        /* If rules say we should not authenticate call next and return. */
        if (false === $this->shouldAuthenticate($request)) {
            return $next($request, $response);
        }

        /* HTTP allowed only if secure is false or server is in relaxed array. */
        if ("https" !== $scheme && true === $this->options["secure"]) {
            if (!in_array($host, $this->options["relaxed"])) {
                $message = sprintf(
                    "Insecure use of middleware over %s denied by configuration.",
                    strtoupper($scheme)
                );
                throw new \RuntimeException($message);
            }
        }

        **/* If token cannot be found return with 401 Unauthorized. */
        if (false === $token = $this->fetchToken($request)) {
            return $this->error($request, $response, [
                "message" => $this->message
            ])->withStatus(401);
        }**

        /* If token cannot be decoded return with 401 Unauthorized. */
        if (false === $decoded = $this->decodeToken($token)) {
            return $this->error($request, $response, [
                "message" => $this->message,
                "token" => $token
            ])->withStatus(401);
        }

        /* If callback returns false return with 401 Unauthorized. */
        if (is_callable($this->options["callback"])) {
            $params = ["decoded" => $decoded];
            if (false === $this->options["callback"]($request, $response, $params)) {
                return $this->error($request, $response, [
                    "message" => $this->message ? $this->message : "Callback returned false"
                ])->withStatus(401);
            }
        }

        /* Add decoded token to request as attribute when requested. */
        if ($this->options["attribute"]) {
            $request = $request->withAttribute($this->options["attribute"], $decoded);
        }

        /* Everything ok, call next middleware and return. */
        return $next($request, $response);
    }

public function error(RequestInterface $request, ResponseInterface $response, $arguments)
    {
        if (is_callable($this->options["error"])) {
            $handler_response = $this->options["error"]($request, $response, $arguments);
            if (is_a($handler_response, "\Psr\Http\Message\ResponseInterface")) {
                return $handler_response;
            }
        }
        return $response;
    }

public function error(RequestInterface $request, ResponseInterface $response, $arguments)
    {
        if (is_callable($this->options["error"])) {
            $handler_response = $this->options["error"]($request, $response, $arguments);
            if (is_a($handler_response, "\Psr\Http\Message\ResponseInterface")) {
                return $handler_response;
            }
        } else {
           return $response->withJson($arguments);
        }
    }

<?php
namespace Base\Jwt;

use Psr\Http\Message\ServerRequestInterface as Request;
use Psr\Http\Message\ResponseInterface as Response;

class Error
{
    static function withJson(Request $request, Response $response, $arguments) : Response
    {
        return $response->withJson($arguments);
    }
}

<?php

$app->group('/user', function () use ($app){
    $app->get('', '\App\User\Controller\UserController');
})->add(new Slim\Middleware\JwtAuthentication([
    "secret" => getenv('JWT_SECRET'),
    "error" => '\Base\Jwt\Error::withJson'
]));

$app->add(new \Slim\Middleware\JwtAuthentication([
    "secret" => "supersecretkeyyoushouldnotcommittogithub",
    "error" => function ($request, $response, $arguments) {
        $data["status"] = "error";
        $data["message"] = $arguments["message"];
        return $response
            ->withHeader("Content-Type", "application/json")
            ->write(json_encode($data, JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT));
    }
]));