Better error handling

CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [Unreleased]
+
+### Changed
+
+- `Innmind\HttpAuthentication\Authenticator::__invoke()` now returns an `Innmind\Immutable\Attempt`
+- All resolvers now return an `Innmind\Immutable\Attempt`
+
 ## 4.0.0 - 2023-11-01
 
 ### Changed

composer.json

@@ -16,6 +16,7 @@
     },
     "require": {
         "php": "~8.2",
+        "innmind/immutable": "~5.18",
         "innmind/http": "~7.0"
     },
     "autoload": {

src/Any.php

@@ -6,7 +6,7 @@
 use Innmind\Http\ServerRequest;
 use Innmind\Immutable\{
     Sequence,
-    Maybe,
+    Attempt,
 };
 
 final class Any implements Authenticator
@@ -22,12 +22,12 @@ public function __construct(Authenticator ...$authenticators)
         $this->authenticators = Sequence::of(...$authenticators);
     }
 
-    public function __invoke(ServerRequest $request): Maybe
+    public function __invoke(ServerRequest $request): Attempt
     {
-        /** @var Maybe<Identity> */
+        /** @var Attempt<Identity> */
         return $this->authenticators->reduce(
-            Maybe::nothing(),
-            static fn(Maybe $identity, $authenticate) => $identity->otherwise(
+            Attempt::error(new \LogicException('No authenticator defined')),
+            static fn(Attempt $identity, $authenticate) => $identity->recover(
                 static fn() => $authenticate($request),
             ),
         );

src/Authenticator.php

@@ -4,12 +4,12 @@
 namespace Innmind\HttpAuthentication;
 
 use Innmind\Http\ServerRequest;
-use Innmind\Immutable\Maybe;
+use Innmind\Immutable\Attempt;
 
 interface Authenticator
 {
     /**
-     * @return Maybe<Identity>
+     * @return Attempt<Identity>
      */
-    public function __invoke(ServerRequest $request): Maybe;
+    public function __invoke(ServerRequest $request): Attempt;
 }

src/ValidateAuthorizationHeader.php

@@ -7,7 +7,7 @@
     ServerRequest,
     Header\Authorization,
 };
-use Innmind\Immutable\Maybe;
+use Innmind\Immutable\Attempt;
 
 final class ValidateAuthorizationHeader implements Authenticator
 {
@@ -18,7 +18,7 @@ public function __construct(Authenticator $authenticate)
         $this->authenticate = $authenticate;
     }
 
-    public function __invoke(ServerRequest $request): Maybe
+    public function __invoke(ServerRequest $request): Attempt
     {
         if (!$request->headers()->contains('Authorization')) {
             return ($this->authenticate)($request);
@@ -27,6 +27,7 @@ public function __invoke(ServerRequest $request): Maybe
         return $request
             ->headers()
             ->find(Authorization::class)
+            ->attempt(static fn() => new \RuntimeException('No Authorization header'))
             ->flatMap(fn() => ($this->authenticate)($request));
     }
 }

src/ViaAuthorization.php

@@ -10,7 +10,7 @@
     Header\AuthorizationValue,
 };
 use Innmind\Immutable\{
-    Maybe,
+    Attempt,
     Predicate\Instance,
 };
 
@@ -23,13 +23,14 @@ public function __construct(Resolver $resolve)
         $this->resolve = $resolve;
     }
 
-    public function __invoke(ServerRequest $request): Maybe
+    public function __invoke(ServerRequest $request): Attempt
     {
         return $request
             ->headers()
             ->find(Authorization::class)
             ->flatMap(static fn($header) => $header->values()->find(static fn() => true))
             ->keep(Instance::of(AuthorizationValue::class))
+            ->attempt(static fn() => new \RuntimeException('Failed to resolve identity'))
             ->flatMap(fn($value) => ($this->resolve)($value));
     }
 }

src/ViaAuthorization/NullResolver.php

@@ -5,13 +5,13 @@
 
 use Innmind\HttpAuthentication\Identity;
 use Innmind\Http\Header\AuthorizationValue;
-use Innmind\Immutable\Maybe;
+use Innmind\Immutable\Attempt;
 
 final class NullResolver implements Resolver
 {
-    public function __invoke(AuthorizationValue $value): Maybe
+    public function __invoke(AuthorizationValue $value): Attempt
     {
-        /** @var Maybe<Identity> */
-        return Maybe::nothing();
+        /** @var Attempt<Identity> */
+        return Attempt::error(new \LogicException('Not implemented'));
     }
 }

src/ViaAuthorization/Resolver.php

@@ -5,12 +5,12 @@
 
 use Innmind\HttpAuthentication\Identity;
 use Innmind\Http\Header\AuthorizationValue;
-use Innmind\Immutable\Maybe;
+use Innmind\Immutable\Attempt;
 
 interface Resolver
 {
     /**
-     * @return Maybe<Identity>
+     * @return Attempt<Identity>
      */
-    public function __invoke(AuthorizationValue $value): Maybe;
+    public function __invoke(AuthorizationValue $value): Attempt;
 }

src/ViaBasicAuthorization.php

@@ -8,7 +8,7 @@
     ServerRequest,
     Header\Authorization,
 };
-use Innmind\Immutable\Maybe;
+use Innmind\Immutable\Attempt;
 
 final class ViaBasicAuthorization implements Authenticator
 {
@@ -19,12 +19,13 @@ public function __construct(Resolver $resolve)
         $this->resolve = $resolve;
     }
 
-    public function __invoke(ServerRequest $request): Maybe
+    public function __invoke(ServerRequest $request): Attempt
     {
         return $request
             ->headers()
             ->find(Authorization::class)
             ->filter(static fn($header) => $header->scheme() === 'Basic')
+            ->attempt(static fn() => new \RuntimeException('Failed to resolve identity'))
             ->flatMap(function($header) {
                 [$user, $password] = \explode(':', \base64_decode($header->parameter(), true));
 

src/ViaBasicAuthorization/NullResolver.php

@@ -4,13 +4,13 @@
 namespace Innmind\HttpAuthentication\ViaBasicAuthorization;
 
 use Innmind\HttpAuthentication\Identity;
-use Innmind\Immutable\Maybe;
+use Innmind\Immutable\Attempt;
 
 final class NullResolver implements Resolver
 {
-    public function __invoke(string $user, string $password): Maybe
+    public function __invoke(string $user, string $password): Attempt
     {
-        /** @var Maybe<Identity> */
-        return Maybe::nothing();
+        /** @var Attempt<Identity> */
+        return Attempt::error(new \LogicException('Not implemented'));
     }
 }

src/ViaBasicAuthorization/Resolver.php

@@ -4,12 +4,12 @@
 namespace Innmind\HttpAuthentication\ViaBasicAuthorization;
 
 use Innmind\HttpAuthentication\Identity;
-use Innmind\Immutable\Maybe;
+use Innmind\Immutable\Attempt;
 
 interface Resolver
 {
     /**
-     * @return Maybe<Identity>
+     * @return Attempt<Identity>
      */
-    public function __invoke(string $user, string $password): Maybe;
+    public function __invoke(string $user, string $password): Attempt;
 }

src/ViaForm.php

@@ -8,7 +8,10 @@
     ServerRequest,
     Method,
 };
-use Innmind\Immutable\Maybe;
+use Innmind\Immutable\{
+    Maybe,
+    Attempt,
+};
 
 final class ViaForm implements Authenticator
 {
@@ -19,10 +22,11 @@ public function __construct(Resolver $resolve)
         $this->resolve = $resolve;
     }
 
-    public function __invoke(ServerRequest $request): Maybe
+    public function __invoke(ServerRequest $request): Attempt
     {
         return Maybe::just($request)
             ->filter(static fn($request) => $request->method() === Method::post)
+            ->attempt(static fn() => new \RuntimeException('Failed to resolve identity'))
             ->flatMap(fn($request) => ($this->resolve)($request->form()));
     }
 }

src/ViaForm/NullResolver.php

@@ -5,13 +5,13 @@
 
 use Innmind\HttpAuthentication\Identity;
 use Innmind\Http\ServerRequest\Form;
-use Innmind\Immutable\Maybe;
+use Innmind\Immutable\Attempt;
 
 final class NullResolver implements Resolver
 {
-    public function __invoke(Form $form): Maybe
+    public function __invoke(Form $form): Attempt
     {
-        /** @var Maybe<Identity> */
-        return Maybe::nothing();
+        /** @var Attempt<Identity> */
+        return Attempt::error(new \LogicException('Not implemented'));
     }
 }

src/ViaForm/Resolver.php

@@ -5,12 +5,12 @@
 
 use Innmind\HttpAuthentication\Identity;
 use Innmind\Http\ServerRequest\Form;
-use Innmind\Immutable\Maybe;
+use Innmind\Immutable\Attempt;
 
 interface Resolver
 {
     /**
-     * @return Maybe<Identity>
+     * @return Attempt<Identity>
      */
-    public function __invoke(Form $form): Maybe;
+    public function __invoke(Form $form): Attempt;
 }

src/ViaStorage.php

@@ -5,7 +5,7 @@
 
 use Innmind\HttpAuthentication\ViaStorage\Storage;
 use Innmind\Http\ServerRequest;
-use Innmind\Immutable\Maybe;
+use Innmind\Immutable\Attempt;
 
 final class ViaStorage implements Authenticator
 {
@@ -18,12 +18,13 @@ public function __construct(Authenticator $authenticate, Storage $storage)
         $this->storage = $storage;
     }
 
-    public function __invoke(ServerRequest $request): Maybe
+    public function __invoke(ServerRequest $request): Attempt
     {
         return $this
             ->storage
             ->get($request)
-            ->otherwise(
+            ->attempt(static fn() => new \RuntimeException('Identity not in storage'))
+            ->recover(
                 fn() => ($this->authenticate)($request)->map(
                     function($identity) use ($request) {
                         $this->storage->set($request, $identity);

src/ViaUrlAuthority.php

@@ -9,7 +9,7 @@
     User,
     Password,
 };
-use Innmind\Immutable\Maybe;
+use Innmind\Immutable\Attempt;
 
 final class ViaUrlAuthority implements Authenticator
 {
@@ -20,14 +20,14 @@ public function __construct(Resolver $resolve)
         $this->resolve = $resolve;
     }
 
-    public function __invoke(ServerRequest $request): Maybe
+    public function __invoke(ServerRequest $request): Attempt
     {
         $user = $request->url()->authority()->userInformation()->user();
         $password = $request->url()->authority()->userInformation()->password();
 
         if ($user->equals(User::none()) && $password->equals(Password::none())) {
-            /** @var Maybe<Identity> */
-            return Maybe::nothing();
+            /** @var Attempt<Identity> */
+            return Attempt::error(new \RuntimeException('No authentication provided'));
         }
 
         return ($this->resolve)($user, $password);

src/ViaUrlAuthority/NullResolver.php

@@ -8,13 +8,13 @@
     User,
     Password,
 };
-use Innmind\Immutable\Maybe;
+use Innmind\Immutable\Attempt;
 
 final class NullResolver implements Resolver
 {
-    public function __invoke(User $user, Password $password): Maybe
+    public function __invoke(User $user, Password $password): Attempt
     {
-        /** @var Maybe<Identity> */
-        return Maybe::nothing();
+        /** @var Attempt<Identity> */
+        return Attempt::error(new \LogicException('Not implemented'));
     }
 }

src/ViaUrlAuthority/Resolver.php

@@ -8,12 +8,12 @@
     User,
     Password,
 };
-use Innmind\Immutable\Maybe;
+use Innmind\Immutable\Attempt;
 
 interface Resolver
 {
     /**
-     * @return Maybe<Identity>
+     * @return Attempt<Identity>
      */
-    public function __invoke(User $user, Password $password): Maybe;
+    public function __invoke(User $user, Password $password): Attempt;
 }

tests/AnyTest.php

@@ -14,7 +14,7 @@
     ProtocolVersion,
 };
 use Innmind\Url\Url;
-use Innmind\Immutable\Maybe;
+use Innmind\Immutable\Attempt;
 use PHPUnit\Framework\TestCase;
 
 class AnyTest extends TestCase
@@ -55,17 +55,17 @@ public function testInvokation()
             ->expects($this->once())
             ->method('__invoke')
             ->with($request)
-            ->willReturn(Maybe::nothing());
+            ->willReturn(Attempt::error(new \Exception));
         $notImplemented
             ->expects($this->once())
             ->method('__invoke')
             ->with($request)
-            ->willReturn(Maybe::nothing());
+            ->willReturn(Attempt::error(new \Exception));
         $expected
             ->expects($this->once())
             ->method('__invoke')
             ->with($request)
-            ->willReturn(Maybe::just($identity = $this->createMock(Identity::class)));
+            ->willReturn(Attempt::result($identity = $this->createMock(Identity::class)));
         $notCalled
             ->expects($this->never())
             ->method('__invoke');