Standardized how inlined or regular specs are applied to query builders

module/Rest/src/ApiKey/Role.php

@@ -21,21 +21,22 @@ class Role
         self::DOMAIN_SPECIFIC => 'Domain only',
     ];
 
-    public static function toSpec(ApiKeyRole $role, bool $inlined, ?string $context = null): Specification
+    public static function toSpec(ApiKeyRole $role, ?string $context = null): Specification
     {
-        if ($role->name() === self::AUTHORED_SHORT_URLS) {
-            $apiKey = $role->apiKey();
-            return $inlined ? Spec::andX(new BelongsToApiKeyInlined($apiKey)) : new BelongsToApiKey($apiKey, $context);
-        }
+        return match ($role->name()) {
+            self::AUTHORED_SHORT_URLS => new BelongsToApiKey($role->apiKey(), $context),
+            self::DOMAIN_SPECIFIC => new BelongsToDomain(self::domainIdFromMeta($role->meta()), $context),
+            default => Spec::andX(),
+        };
+    }
 
-        if ($role->name() === self::DOMAIN_SPECIFIC) {
-            $domainId = self::domainIdFromMeta($role->meta());
-            return $inlined
-                ? Spec::andX(new BelongsToDomainInlined($domainId))
-                : new BelongsToDomain($domainId, $context);
-        }
-
-        return Spec::andX();
+    public static function toInlinedSpec(ApiKeyRole $role): Specification
+    {
+        return match ($role->name()) {
+            self::AUTHORED_SHORT_URLS => Spec::andX(new BelongsToApiKeyInlined($role->apiKey())),
+            self::DOMAIN_SPECIFIC => Spec::andX(new BelongsToDomainInlined(self::domainIdFromMeta($role->meta()))),
+            default => Spec::andX(),
+        };
     }
 
     public static function domainIdFromMeta(array $meta): string

module/Rest/src/ApiKey/Spec/WithApiKeySpecsEnsuringJoin.php

@@ -11,8 +11,11 @@ use Shlinkio\Shlink\Rest\Entity\ApiKey;
 
 class WithApiKeySpecsEnsuringJoin extends BaseSpecification
 {
-    public function __construct(private ?ApiKey $apiKey, private string $fieldToJoin = 'shortUrls')
-    {
+    public function __construct(
+        private ?ApiKey $apiKey,
+        private string $fieldToJoin = 'shortUrls',
+        private bool $inlined = false,
+    ) {
         parent::__construct();
     }
 
@@ -20,7 +23,7 @@ class WithApiKeySpecsEnsuringJoin extends BaseSpecification
     {
         return $this->apiKey === null || $this->apiKey->isAdmin() ? Spec::andX() : Spec::andX(
             Spec::join($this->fieldToJoin, 's'),
-            $this->apiKey->spec(false, $this->fieldToJoin),
+            $this->inlined ? $this->apiKey->inlinedSpec() : $this->apiKey->spec($this->fieldToJoin),
         );
     }
 }

module/Rest/src/Entity/ApiKey.php

@@ -96,9 +96,15 @@ class ApiKey extends AbstractEntity
         return $this->key;
     }
 
-    public function spec(bool $inlined = false, ?string $context = null): Specification
+    public function spec(?string $context = null): Specification
     {
-        $specs = $this->roles->map(fn (ApiKeyRole $role) => Role::toSpec($role, $inlined, $context))->getValues();
+        $specs = $this->roles->map(fn (ApiKeyRole $role) => Role::toSpec($role, $context))->getValues();
+        return Spec::andX(...$specs);
+    }
+
+    public function inlinedSpec(): Specification
+    {
+        $specs = $this->roles->map(fn (ApiKeyRole $role) => Role::toInlinedSpec($role))->getValues();
         return Spec::andX(...$specs);
     }
 

module/Rest/test/ApiKey/RoleTest.php

@@ -21,39 +21,50 @@ class RoleTest extends TestCase
      * @test
      * @dataProvider provideRoles
      */
-    public function returnsExpectedSpec(ApiKeyRole $apiKeyRole, bool $inlined, Specification $expected): void
+    public function returnsExpectedSpec(ApiKeyRole $apiKeyRole, Specification $expected): void
     {
-        self::assertEquals($expected, Role::toSpec($apiKeyRole, $inlined));
+        self::assertEquals($expected, Role::toSpec($apiKeyRole));
     }
 
     public function provideRoles(): iterable
     {
         $apiKey = ApiKey::create();
 
-        yield 'inline invalid role' => [new ApiKeyRole('invalid', [], $apiKey), true, Spec::andX()];
-        yield 'not inline invalid role' => [new ApiKeyRole('invalid', [], $apiKey), false, Spec::andX()];
-        yield 'inline author role' => [
+        yield 'invalid role' => [new ApiKeyRole('invalid', [], $apiKey), Spec::andX()];
+        yield 'author role' => [
             new ApiKeyRole(Role::AUTHORED_SHORT_URLS, [], $apiKey),
-            true,
-            Spec::andX(new BelongsToApiKeyInlined($apiKey)),
-        ];
-        yield 'not inline author role' => [
-            new ApiKeyRole(Role::AUTHORED_SHORT_URLS, [], $apiKey),
-            false,
             new BelongsToApiKey($apiKey),
         ];
-        yield 'inline domain role' => [
-            new ApiKeyRole(Role::DOMAIN_SPECIFIC, ['domain_id' => '123'], $apiKey),
-            true,
-            Spec::andX(new BelongsToDomainInlined('123')),
-        ];
-        yield 'not inline domain role' => [
+        yield 'domain role' => [
             new ApiKeyRole(Role::DOMAIN_SPECIFIC, ['domain_id' => '456'], $apiKey),
-            false,
             new BelongsToDomain('456'),
         ];
     }
 
+    /**
+     * @test
+     * @dataProvider provideInlinedRoles
+     */
+    public function returnsExpectedInlinedSpec(ApiKeyRole $apiKeyRole, Specification $expected): void
+    {
+        self::assertEquals($expected, Role::toInlinedSpec($apiKeyRole));
+    }
+
+    public function provideInlinedRoles(): iterable
+    {
+        $apiKey = ApiKey::create();
+
+        yield 'invalid role' => [new ApiKeyRole('invalid', [], $apiKey), Spec::andX()];
+        yield 'author role' => [
+            new ApiKeyRole(Role::AUTHORED_SHORT_URLS, [], $apiKey),
+            Spec::andX(new BelongsToApiKeyInlined($apiKey)),
+        ];
+        yield 'domain role' => [
+            new ApiKeyRole(Role::DOMAIN_SPECIFIC, ['domain_id' => '123'], $apiKey),
+            Spec::andX(new BelongsToDomainInlined('123')),
+        ];
+    }
+
     /**
      * @test
      * @dataProvider provideMetasWithDomainId