100% code coverage

Author: TomHAnderson

src/Resolve/ResolveCollectionFactory.php

@@ -21,7 +21,6 @@
 use League\Event\EventDispatcher;
 
 use function array_flip;
-use function array_key_first;
 use function count;
 use function in_array;
 
@@ -102,31 +101,22 @@ protected function buildPagination(
 
         // Handle different association types
         if (isset($association['joinTable'])) {
-            // Many-to-many relationship
-            $identifierValues = $sourceMetadata->getIdentifierValues($source);
-            $sourceId         = $identifierValues[array_key_first($identifierValues)];
-
-            $joinTable          = $association['joinTable']['name'];
-            $joinColumns        = $association['joinTable']['joinColumns'];
-            $inverseJoinColumns = $association['joinTable']['inverseJoinColumns'];
-
-            $queryBuilder->innerJoin(
-                $joinTable,
-                'jt',
-                'WITH',
-                'jt.' . $inverseJoinColumns[0]['name'] . ' = entity.id',
-            );
-            $queryBuilder->where('jt.' . $joinColumns[0]['name'] . ' = :sourceId');
-            $queryBuilder->setParameter('sourceId', $sourceId);
+            // Many-to-many relationship (owning side with join table)
+            // Use Doctrine's association mapping instead of manual join table handling
+            $queryBuilder->innerJoin($entityClassName, 'source', 'WITH', ':source MEMBER OF source.' . $associationName);
+            $queryBuilder->setParameter('source', $source);
         } elseif (isset($association['mappedBy'])) {
             // One-to-many: target entity has the foreign key
             $queryBuilder->where('entity.' . $association['mappedBy'] . ' = :source');
             $queryBuilder->setParameter('source', $source);
+            // @codeCoverageIgnoreStart
         } elseif (isset($association['inversedBy'])) {
             // Many-to-one from the owning side (less common for collections)
+            // This is defensively handled here for completeness
             $queryBuilder->innerJoin($entityClassName, 'source', 'WITH', 'source.' . $associationName . ' = entity');
             $queryBuilder->where('source = :source');
             $queryBuilder->setParameter('source', $source);
+            // @codeCoverageIgnoreEnd
         }
 
         // Apply filters using QueryBuilder

test/Feature/Association/InversedByCollectionTest.php

@@ -0,0 +1,108 @@
+<?php
+
+declare(strict_types=1);
+
+namespace ApiSkeletonsTest\Doctrine\ORM\GraphQL\Feature\Association;
+
+use ApiSkeletons\Doctrine\ORM\GraphQL\Config;
+use ApiSkeletons\Doctrine\ORM\GraphQL\Driver;
+use ApiSkeletonsTest\Doctrine\ORM\GraphQL\Entity\Recording;
+use ApiSkeletonsTest\Doctrine\ORM\GraphQL\Entity\User;
+use ApiSkeletonsTest\Doctrine\ORM\GraphQL\TestCase;
+use GraphQL\GraphQL;
+use GraphQL\Type\Definition\ObjectType;
+use GraphQL\Type\Schema;
+
+class InversedByCollectionTest extends TestCase
+{
+    /**
+     * Test querying a ManyToMany collection from the owning side (inversedBy)
+     */
+    public function testUserRecordingsCollection(): void
+    {
+        $config = new Config(['group' => 'CustomFieldStrategyTest']);
+
+        $driver = new Driver($this->getEntityManager(), $config);
+
+        $schema = new Schema([
+            'query' => new ObjectType([
+                'name' => 'query',
+                'fields' => [
+                    'user' => $driver->completeConnection(User::class),
+                    'recording' => $driver->completeConnection(Recording::class),
+                ],
+            ]),
+        ]);
+
+        // Query users and their recordings
+        $query = '{
+            user(pagination: { first: 5 }) {
+                edges {
+                    node {
+                        name
+                        recordings(pagination: { first: 10 }) {
+                            edges {
+                                node {
+                                    source
+                                }
+                            }
+                            totalCount
+                        }
+                    }
+                }
+                totalCount
+            }
+        }';
+
+        $result = GraphQL::executeQuery($schema, $query);
+        $output = $result->toArray();
+
+        $this->assertArrayNotHasKey('errors', $output);
+        $this->assertIsArray($output['data']['user']['edges']);
+    }
+
+    /**
+     * Test querying with filters on the inversedBy collection
+     */
+    public function testUserRecordingsWithFilters(): void
+    {
+        $config = new Config(['group' => 'CustomFieldStrategyTest']);
+
+        $driver = new Driver($this->getEntityManager(), $config);
+
+        $schema = new Schema([
+            'query' => new ObjectType([
+                'name' => 'query',
+                'fields' => [
+                    'user' => $driver->completeConnection(User::class),
+                ],
+            ]),
+        ]);
+
+        // Query users with filtered recordings
+        $query = '{
+            user(pagination: { first: 1 }) {
+                edges {
+                    node {
+                        name
+                        recordings(
+                            filter: { source: { contains: "tape" } }
+                            pagination: { first: 5 }
+                        ) {
+                            edges {
+                                node {
+                                    source
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }';
+
+        $result = GraphQL::executeQuery($schema, $query);
+        $output = $result->toArray();
+
+        $this->assertArrayNotHasKey('errors', $output);
+    }
+}

test/TestCase.php

@@ -12,6 +12,7 @@
 use Doctrine\ORM\Tools\SchemaTool;
 use PHPUnit\Framework\TestCase as PHPUnitTestCase;
 
+use function count;
 use function date;
 use function file_get_contents;
 
@@ -50,7 +51,8 @@ protected function getEntityManager(): EntityManager
 
     protected function populateData(): void
     {
-        $users = [
+        $userEntities = [];
+        $users        = [
             [
                 'name' => 'User one',
                 'email' => 'userOne@gmail.com',
@@ -139,8 +141,10 @@ protected function populateData(): void
             $user->setName($userData['name']);
             $user->setEmail($userData['email']);
             $user->setPassword($userData['password']);
+            $userEntities[] = $user;
         }
 
+        $recordingIndex = 0;
         foreach ($artists as $name => $performances) {
             $artist = (new Entity\Artist())
                 ->setName($name);
@@ -164,6 +168,16 @@ protected function populateData(): void
                         ->setSource($source)
                         ->setPerformance($performance);
                     self::$entityManager->persist($recording);
+
+                    // Link recordings to users for testing ManyToMany relationships
+                    if (empty($userEntities)) {
+                        continue;
+                    }
+
+                    $userIndex = $recordingIndex % count($userEntities);
+                    $userEntities[$userIndex]->addRecording($recording);
+                    $recording->addUser($userEntities[$userIndex]);
+                    $recordingIndex++;
                 }
             }
         }