Bug fixes for hiding private data when handling errors

src/Concerns/Exceptions/Laravel/Api.php

@@ -9,6 +9,6 @@ trait Api
 {
     protected function convertValidationExceptionToResponse(ValidationException $e, $request)
     {
-        return $this->response($e);
+        return $this->prepareJsonResponse($request, $e);
     }
 }

src/Contracts/Responsable.php

@@ -6,6 +6,8 @@
 
 interface Responsable
 {
+    public static function hidePrivate(bool $hide): void;
+
     public static function allowWith(): void;
 
     public static function withoutWith(): void;

src/Exceptions/Laravel/BaseHandler.php

@@ -2,6 +2,7 @@
 
 namespace Helldar\ApiResponse\Exceptions\Laravel;
 
+use Helldar\ApiResponse\Services\Response;
 use Helldar\Support\Facades\Helpers\Arr;
 use Illuminate\Auth\AuthenticationException;
 use Illuminate\Foundation\Exceptions\Handler as ExceptionHandler;
@@ -40,14 +41,14 @@ protected function prepareJsonResponse($request, Throwable $e)
 
     protected function getExceptionMessage(Throwable $e)
     {
-        $converted = parent::convertExceptionToArray($e);
+        $converted = $this->convertExceptionToArray($e);
 
         return Arr::get($converted, 'message');
     }
 
     protected function getExceptionTrace(Throwable $e)
     {
-        $converted = parent::convertExceptionToArray($e);
+        $converted = $this->convertExceptionToArray($e);
 
         return ['info' => Arr::except($converted, 'message')];
     }
@@ -68,4 +69,24 @@ protected function response($data, int $status_code = null, array $with = [], ar
 
         return api_response($data, $status_code, $with, $headers);
     }
+
+    protected function convertExceptionToArray(Throwable $e)
+    {
+        return Response::$hide_private
+            ? ['message' => $this->isHttpException($e) ? $e->getMessage() : 'Server Error']
+            : [
+                'message'   => $e->getMessage(),
+                'exception' => get_class($e),
+                'file'      => $e->getFile(),
+                'line'      => $e->getLine(),
+                'trace'     => $this->getTrace($e),
+            ];
+    }
+
+    protected function getTrace(Throwable $e): array
+    {
+        return collect($e->getTrace())->map(static function ($trace) {
+            return Arr::except($trace, ['args']);
+        })->all();
+    }
 }

src/Exceptions/Laravel/Eight/ApiHandler.php

@@ -6,7 +6,6 @@
 use Helldar\ApiResponse\Exceptions\Laravel\BaseHandler;
 use Illuminate\Auth\AuthenticationException;
 use Illuminate\Contracts\Support\Responsable;
-use Illuminate\Http\Exceptions\HttpResponseException;
 use Illuminate\Routing\Router;
 use Illuminate\Validation\ValidationException;
 use Throwable;
@@ -37,9 +36,7 @@ public function render($request, Throwable $e)
             }
         }
 
-        if ($e instanceof HttpResponseException) {
-            return $this->response($e);
-        } elseif ($e instanceof AuthenticationException) {
+        if ($e instanceof AuthenticationException) {
             return $this->response($e, 403);
         } elseif ($e instanceof ValidationException) {
             return $this->convertValidationExceptionToResponse($e, $request);

src/Services/Response.php

@@ -5,17 +5,22 @@
 use Helldar\ApiResponse\Contracts\Parseable;
 use Helldar\ApiResponse\Contracts\Resolver as ResolverContract;
 use Helldar\ApiResponse\Contracts\Responsable;
+use Helldar\ApiResponse\Contracts\Wrapper;
 use Helldar\ApiResponse\Support\Parser;
 use Helldar\ApiResponse\Wrappers\Error;
 use Helldar\ApiResponse\Wrappers\Resolver;
 use Helldar\ApiResponse\Wrappers\Success;
 use Helldar\Support\Concerns\Makeable;
+use Illuminate\Http\Resources\Json\JsonResource;
 use Symfony\Component\HttpFoundation\JsonResponse;
 
 final class Response implements Responsable
 {
     use Makeable;
 
+    /** @var bool */
+    public static $hide_private = true;
+
     /** @var bool */
     public static $allow_with = true;
 
@@ -34,6 +39,11 @@ final class Response implements Responsable
     /** @var array */
     protected $headers = [];
 
+    public static function hidePrivate(bool $hide = true): void
+    {
+        self::$hide_private = $hide;
+    }
+
     public static function allowWith(): void
     {
         self::$allow_with = true;
@@ -47,11 +57,19 @@ public static function withoutWith(): void
     public static function wrapped(): void
     {
         self::$wrap = true;
+
+        if (class_exists(JsonResource::class)) {
+            JsonResource::wrap('data');
+        }
     }
 
     public static function withoutWrap(): void
     {
         self::$wrap = false;
+
+        if (class_exists(JsonResource::class)) {
+            JsonResource::withoutWrapping();
+        }
     }
 
     public function with(array $with = []): Responsable
@@ -103,13 +121,13 @@ protected function getParser(): Parseable
             ->resolve();
     }
 
-    protected function getWrapped(Parseable $parser)
+    protected function getWrapped(Parseable $parser): Wrapper
     {
         $wrapper = $this->getWrapper($parser);
 
         return $wrapper::make()
             ->wrap(self::$wrap)
-            ->allowWith(self::$allow_with)
+            ->allowWith(! $this->isHidePrivate($parser) && $this->isAllowWith())
             ->parser($parser)
             ->resolver($this->resolver());
     }
@@ -128,4 +146,14 @@ protected function resolver(): ResolverContract
     {
         return Resolver::make();
     }
+
+    protected function isHidePrivate(Parseable $parser): bool
+    {
+        return $parser->isError() && self::$hide_private;
+    }
+
+    protected function isAllowWith(): bool
+    {
+        return self::$allow_with;
+    }
 }

tests/Fixtures/Concerns/Laravel/Exceptionable.php

@@ -2,7 +2,6 @@
 
 namespace Tests\Fixtures\Concerns\Laravel;
 
-use Exception;
 use Illuminate\Foundation\Http\Middleware\CheckForMaintenanceMode;
 use Illuminate\Foundation\Http\Middleware\PreventRequestsDuringMaintenance;
 
@@ -28,17 +27,6 @@ protected function removeDownFile(): void
         @unlink(storage_path('framework/down'));
     }
 
-    protected function setRoutes($app): void
-    {
-        $app['router']->get('/foo', static function () {
-            return api_response('ok');
-        })->middleware($this->getMaintenanceMiddleware());
-
-        $app['router']->get('/bar', static function () {
-            throw new Exception('Foo Bar');
-        })->middleware($this->getMaintenanceMiddleware());
-    }
-
     protected function getMaintenanceMiddleware(): string
     {
         return $this->isSeven()

tests/Fixtures/Concerns/Laravel/Requests.php

@@ -17,6 +17,11 @@ protected function requestBar(): Response
         return $this->request('/bar');
     }
 
+    protected function requestBaz(): Response
+    {
+        return $this->request('/baz');
+    }
+
     protected function request(string $uri): Response
     {
         return $this->response(

tests/Fixtures/Concerns/Responsable.php

@@ -2,11 +2,28 @@
 
 namespace Tests\Fixtures\Concerns;
 
+use Exception;
 use Tests\Fixtures\Entities\Response;
+use Tests\Fixtures\Exceptions\FooHttpException;
 
 /** @mixin \Tests\Laravel\TestCase */
 trait Responsable
 {
+    protected function setRoutes($app): void
+    {
+        $app['router']->get('/foo', static function () {
+            return api_response('ok', null, ['foo' => 'Foo']);
+        })->middleware($this->getMaintenanceMiddleware());
+
+        $app['router']->get('/bar', static function () {
+            throw new Exception('Foo Bar');
+        })->middleware($this->getMaintenanceMiddleware());
+
+        $app['router']->get('/baz', static function () {
+            throw new FooHttpException('Foo Http');
+        })->middleware($this->getMaintenanceMiddleware());
+    }
+
     protected function response($data = null, int $status_code = null, array $with = []): Response
     {
         return new Response($data, $status_code, $with);

tests/Fixtures/Contracts/Testable.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace Tests\Fixtures\Contracts;
+
+interface Testable
+{
+    public function testInstance();
+
+    public function testType();
+
+    public function testStructureSuccess();
+
+    public function testStructureErrors();
+
+    public function testStatusCode();
+}

tests/Fixtures/Entities/Response.php

@@ -32,7 +32,10 @@ public function getStatusCode(): int
         return $this->response->getStatusCode();
     }
 
-    public function instance(): JsonResponse
+    /**
+     * @return mixed|\Symfony\Component\HttpFoundation\JsonResponse|\Illuminate\Testing\TestResponse||null
+     */
+    public function instance()
     {
         return $this->response;
     }

tests/Fixtures/Exceptions/FooException.php

@@ -8,6 +8,6 @@ final class FooException extends Exception
 {
     public function __construct(string $message)
     {
-        parent::__construct($message, 405);
+        parent::__construct($message, 502);
     }
 }

tests/Fixtures/Exceptions/FooHttpException.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Tests\Fixtures\Exceptions;
+
+use Symfony\Component\HttpKernel\Exception\HttpException;
+
+final class FooHttpException extends HttpException
+{
+    public function __construct(string $message, int $status_code = 403)
+    {
+        parent::__construct($status_code, $message);
+    }
+}

tests/Fixtures/Laravel/Resources/Bar.php

@@ -13,4 +13,9 @@ public function toArray($request)
             'qwerty' => $this->bar,
         ];
     }
+
+    public function with($request)
+    {
+        return ['baz' => 'Baz'];
+    }
 }

tests/Fixtures/Laravel/Resources/Foo.php

@@ -13,6 +13,12 @@ public function toArray($request)
             'foo' => $this->foo,
 
             'bar' => Bar::make($this->bar),
+        ];
+    }
+
+    public function with($request)
+    {
+        return [
             'baz' => Bar::make($this->whenLoaded('bar')),
         ];
     }

tests/Laravel/Parsers/Exception/NoWithDataHideTest.php

@@ -0,0 +1,53 @@
+<?php
+
+namespace Tests\Laravel\Parsers\Exception;
+
+use Illuminate\Testing\TestResponse;
+use Tests\Fixtures\Concerns\Laravel\Requests;
+use Tests\Laravel\TestCase;
+
+final class NoWithDataHideTest extends TestCase
+{
+    use Requests;
+
+    protected $with = false;
+
+    public function testInstance()
+    {
+        $this->assertTrue($this->requestFoo()->instance() instanceof TestResponse);
+        $this->assertTrue($this->requestBar()->instance() instanceof TestResponse);
+        $this->assertTrue($this->requestBaz()->instance() instanceof TestResponse);
+    }
+
+    public function testType()
+    {
+        $this->assertJson($this->requestFoo()->getRaw());
+        $this->assertJson($this->requestBar()->getRaw());
+        $this->assertJson($this->requestBaz()->getRaw());
+    }
+
+    public function testStructureSuccess()
+    {
+        $this->assertSame(['data' => 'ok'], $this->requestFoo()->getJson());
+    }
+
+    public function testStructureErrors()
+    {
+        $this->assertSame(
+            ['error' => ['type' => 'Exception', 'data' => 'Whoops! Something went wrong.']],
+            $this->requestBar()->getJson()
+        );
+
+        $this->assertSame(
+            ['error' => ['type' => 'FooHttpException', 'data' => 'Foo Http']],
+            $this->requestBaz()->getJson()
+        );
+    }
+
+    public function testStatusCode()
+    {
+        $this->assertSame(200, $this->requestFoo()->getStatusCode());
+        $this->assertSame(500, $this->requestBar()->getStatusCode());
+        $this->assertSame(403, $this->requestBaz()->getStatusCode());
+    }
+}