make resolvers return attempts

Baptouuuu · Baptouuuu · commit 3efd43270a3e · 2025-08-24T15:41:57.000+02:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -5,6 +5,7 @@
 ### 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
 
diff --git a/src/ViaAuthorization.php b/src/ViaAuthorization.php
@@ -30,7 +30,7 @@ public function __invoke(ServerRequest $request): Attempt
             ->find(Authorization::class)
             ->flatMap(static fn($header) => $header->values()->find(static fn() => true))
             ->keep(Instance::of(AuthorizationValue::class))
-            ->flatMap(fn($value) => ($this->resolve)($value))
-            ->attempt(static fn() => new \RuntimeException('Failed to resolve identity'));
+            ->attempt(static fn() => new \RuntimeException('Failed to resolve identity'))
+            ->flatMap(fn($value) => ($this->resolve)($value));
     }
 }
diff --git a/src/ViaAuthorization/NullResolver.php b/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'));
     }
 }
diff --git a/src/ViaAuthorization/Resolver.php b/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;
 }
diff --git a/src/ViaBasicAuthorization.php b/src/ViaBasicAuthorization.php
@@ -25,11 +25,11 @@ public function __invoke(ServerRequest $request): Attempt
             ->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));
 
                 return ($this->resolve)($user, $password);
-            })
-            ->attempt(static fn() => new \RuntimeException('Failed to resolve identity'));
+            });
     }
 }
diff --git a/src/ViaBasicAuthorization/NullResolver.php b/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'));
     }
 }
diff --git a/src/ViaBasicAuthorization/Resolver.php b/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;
 }
diff --git a/src/ViaForm.php b/src/ViaForm.php
@@ -26,7 +26,7 @@ public function __invoke(ServerRequest $request): Attempt
     {
         return Maybe::just($request)
             ->filter(static fn($request) => $request->method() === Method::post)
-            ->flatMap(fn($request) => ($this->resolve)($request->form()))
-            ->attempt(static fn() => new \RuntimeException('Failed to resolve identity'));
+            ->attempt(static fn() => new \RuntimeException('Failed to resolve identity'))
+            ->flatMap(fn($request) => ($this->resolve)($request->form()));
     }
 }
diff --git a/src/ViaForm/NullResolver.php b/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'));
     }
 }
diff --git a/src/ViaForm/Resolver.php b/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;
 }
diff --git a/src/ViaUrlAuthority.php b/src/ViaUrlAuthority.php
@@ -30,8 +30,6 @@ public function __invoke(ServerRequest $request): Attempt
             return Attempt::error(new \RuntimeException('No authentication provided'));
         }
 
-        return ($this->resolve)($user, $password)->attempt(
-            static fn() => new \RuntimeException('Failed to resolve identity'),
-        );
+        return ($this->resolve)($user, $password);
     }
 }
diff --git a/src/ViaUrlAuthority/NullResolver.php b/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'));
     }
 }
diff --git a/src/ViaUrlAuthority/Resolver.php b/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;
 }
diff --git a/tests/ViaAuthorizationTest.php b/tests/ViaAuthorizationTest.php
@@ -21,7 +21,7 @@
     Header\AuthorizationValue,
 };
 use Innmind\Url\Url;
-use Innmind\Immutable\Maybe;
+use Innmind\Immutable\Attempt;
 use PHPUnit\Framework\TestCase;
 
 class ViaAuthorizationTest extends TestCase
@@ -87,7 +87,7 @@ public function testInvokation()
             ->expects($this->once())
             ->method('__invoke')
             ->with($expected)
-            ->willReturn(Maybe::just($identity = $this->createMock(Identity::class)));
+            ->willReturn(Attempt::result($identity = $this->createMock(Identity::class)));
         $request = ServerRequest::of(
             Url::of('/'),
             Method::get,
diff --git a/tests/ViaBasicAuthorizationTest.php b/tests/ViaBasicAuthorizationTest.php
@@ -20,7 +20,7 @@
     Header\Authorization,
 };
 use Innmind\Url\Url;
-use Innmind\Immutable\Maybe;
+use Innmind\Immutable\Attempt;
 use PHPUnit\Framework\TestCase;
 
 class ViaBasicAuthorizationTest extends TestCase
@@ -108,7 +108,7 @@ public function testInvokation()
             ->expects($this->once())
             ->method('__invoke')
             ->with('foo', 'bar')
-            ->willReturn(Maybe::just($identity = $this->createMock(Identity::class)));
+            ->willReturn(Attempt::result($identity = $this->createMock(Identity::class)));
         $request = ServerRequest::of(
             Url::of('/'),
             Method::get,
diff --git a/tests/ViaFormTest.php b/tests/ViaFormTest.php
@@ -16,7 +16,7 @@
     ProtocolVersion,
 };
 use Innmind\Url\Url;
-use Innmind\Immutable\Maybe;
+use Innmind\Immutable\Attempt;
 use PHPUnit\Framework\TestCase;
 
 class ViaFormTest extends TestCase
@@ -63,7 +63,7 @@ public function testInvokation()
             ->expects($this->once())
             ->method('__invoke')
             ->with($request->form())
-            ->willReturn(Maybe::just($identity = $this->createMock(Identity::class)));
+            ->willReturn(Attempt::result($identity = $this->createMock(Identity::class)));
 
         $this->assertSame($identity, $authenticate($request)->match(
             static fn($identity) => $identity,
diff --git a/tests/ViaUrlAuthorityTest.php b/tests/ViaUrlAuthorityTest.php
@@ -16,7 +16,7 @@
     Method,
     ProtocolVersion,
 };
-use Innmind\Immutable\Maybe;
+use Innmind\Immutable\Attempt;
 use PHPUnit\Framework\TestCase;
 
 class ViaUrlAuthorityTest extends TestCase
@@ -62,7 +62,7 @@ public function testInvokation()
             ->expects($this->once())
             ->method('__invoke')
             ->with($user, $password)
-            ->willReturn(Maybe::just($identity = $this->createMock(Identity::class)));
+            ->willReturn(Attempt::result($identity = $this->createMock(Identity::class)));
         $request = ServerRequest::of(
             $url,
             Method::get,

Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ public function __invoke(ServerRequest $request): Attempt`
`30`	`30`	`->find(Authorization::class)`
`31`	`31`	`->flatMap(static fn($header) => $header->values()->find(static fn() => true))`
`32`	`32`	`->keep(Instance::of(AuthorizationValue::class))`
`33`		`- ->flatMap(fn($value) => ($this->resolve)($value))`
`34`		`- ->attempt(static fn() => new \RuntimeException('Failed to resolve identity'));`
	`33`	`+ ->attempt(static fn() => new \RuntimeException('Failed to resolve identity'))`
	`34`	`+ ->flatMap(fn($value) => ($this->resolve)($value));`
`35`	`35`	`}`
`36`	`36`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,13 +5,13 @@`
`5`	`5`
`6`	`6`	`use Innmind\HttpAuthentication\Identity;`
`7`	`7`	`use Innmind\Http\Header\AuthorizationValue;`
`8`		`-use Innmind\Immutable\Maybe;`
	`8`	`+use Innmind\Immutable\Attempt;`
`9`	`9`
`10`	`10`	`final class NullResolver implements Resolver`
`11`	`11`	`{`
`12`		`- public function __invoke(AuthorizationValue $value): Maybe`
	`12`	`+ public function __invoke(AuthorizationValue $value): Attempt`
`13`	`13`	`{`
`14`		`- /** @var Maybe<Identity> */`
`15`		`- return Maybe::nothing();`
	`14`	`+ /** @var Attempt<Identity> */`
	`15`	`+ return Attempt::error(new \LogicException('Not implemented'));`
`16`	`16`	`}`
`17`	`17`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,12 +5,12 @@`
`5`	`5`
`6`	`6`	`use Innmind\HttpAuthentication\Identity;`
`7`	`7`	`use Innmind\Http\Header\AuthorizationValue;`
`8`		`-use Innmind\Immutable\Maybe;`
	`8`	`+use Innmind\Immutable\Attempt;`
`9`	`9`
`10`	`10`	`interface Resolver`
`11`	`11`	`{`
`12`	`12`	`/**`
`13`		`- * @return Maybe<Identity>`
	`13`	`+ * @return Attempt<Identity>`
`14`	`14`	`*/`
`15`		`- public function __invoke(AuthorizationValue $value): Maybe;`
	`15`	`+ public function __invoke(AuthorizationValue $value): Attempt;`
`16`	`16`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,11 +25,11 @@ public function __invoke(ServerRequest $request): Attempt`
`25`	`25`	`->headers()`
`26`	`26`	`->find(Authorization::class)`
`27`	`27`	`->filter(static fn($header) => $header->scheme() === 'Basic')`
	`28`	`+ ->attempt(static fn() => new \RuntimeException('Failed to resolve identity'))`
`28`	`29`	`->flatMap(function($header) {`
`29`	`30`	`[$user, $password] = \explode(':', \base64_decode($header->parameter(), true));`
`30`	`31`
`31`	`32`	`return ($this->resolve)($user, $password);`
`32`		`- })`
`33`		`- ->attempt(static fn() => new \RuntimeException('Failed to resolve identity'));`
	`33`	`+ });`
`34`	`34`	`}`
`35`	`35`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,13 +4,13 @@`
`4`	`4`	`namespace Innmind\HttpAuthentication\ViaBasicAuthorization;`
`5`	`5`
`6`	`6`	`use Innmind\HttpAuthentication\Identity;`
`7`		`-use Innmind\Immutable\Maybe;`
	`7`	`+use Innmind\Immutable\Attempt;`
`8`	`8`
`9`	`9`	`final class NullResolver implements Resolver`
`10`	`10`	`{`
`11`		`- public function __invoke(string $user, string $password): Maybe`
	`11`	`+ public function __invoke(string $user, string $password): Attempt`
`12`	`12`	`{`
`13`		`- /** @var Maybe<Identity> */`
`14`		`- return Maybe::nothing();`
	`13`	`+ /** @var Attempt<Identity> */`
	`14`	`+ return Attempt::error(new \LogicException('Not implemented'));`
`15`	`15`	`}`
`16`	`16`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,12 +4,12 @@`
`4`	`4`	`namespace Innmind\HttpAuthentication\ViaBasicAuthorization;`
`5`	`5`
`6`	`6`	`use Innmind\HttpAuthentication\Identity;`
`7`		`-use Innmind\Immutable\Maybe;`
	`7`	`+use Innmind\Immutable\Attempt;`
`8`	`8`
`9`	`9`	`interface Resolver`
`10`	`10`	`{`
`11`	`11`	`/**`
`12`		`- * @return Maybe<Identity>`
	`12`	`+ * @return Attempt<Identity>`
`13`	`13`	`*/`
`14`		`- public function __invoke(string $user, string $password): Maybe;`
	`14`	`+ public function __invoke(string $user, string $password): Attempt;`
`15`	`15`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ public function __invoke(ServerRequest $request): Attempt`
`26`	`26`	`{`
`27`	`27`	`return Maybe::just($request)`
`28`	`28`	`->filter(static fn($request) => $request->method() === Method::post)`
`29`		`- ->flatMap(fn($request) => ($this->resolve)($request->form()))`
`30`		`- ->attempt(static fn() => new \RuntimeException('Failed to resolve identity'));`
	`29`	`+ ->attempt(static fn() => new \RuntimeException('Failed to resolve identity'))`
	`30`	`+ ->flatMap(fn($request) => ($this->resolve)($request->form()));`
`31`	`31`	`}`
`32`	`32`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,13 +5,13 @@`
`5`	`5`
`6`	`6`	`use Innmind\HttpAuthentication\Identity;`
`7`	`7`	`use Innmind\Http\ServerRequest\Form;`
`8`		`-use Innmind\Immutable\Maybe;`
	`8`	`+use Innmind\Immutable\Attempt;`
`9`	`9`
`10`	`10`	`final class NullResolver implements Resolver`
`11`	`11`	`{`
`12`		`- public function __invoke(Form $form): Maybe`
	`12`	`+ public function __invoke(Form $form): Attempt`
`13`	`13`	`{`
`14`		`- /** @var Maybe<Identity> */`
`15`		`- return Maybe::nothing();`
	`14`	`+ /** @var Attempt<Identity> */`
	`15`	`+ return Attempt::error(new \LogicException('Not implemented'));`
`16`	`16`	`}`
`17`	`17`	`}`