test: rewrite join call sites to the utopia-php/query 0.7 single form

CR-10/CR-11 (codemod, rename rules restricted to Joins, JoinAlias and
CompileExpressions) rewrote the joins to Query::join($t, 'alias',
[Query::on(...)]) and getJoinAlias() to getAlias(). Joins without an alias
got the j<n> alias 7.x generated for them; the two the codemod could not
place (a join chosen by match()) take j0, their position in the read.

By hand:
- 0.6 column-form Query objects built with `new Query(...)` and dynamic
  Query::$method() joins move to ON lists.
- ON lists holding search, vector, limit and other non-conditions now
  throw in the factory (BUG-05). QueryValidationTest asserts that refusal
  and keeps checking the read paths with a hand-built join; the
  IndexedQueries, JoinedAttributes and FlatAggregate cases build theirs by
  hand to keep exercising the validator and builder refusals.
- The column-form-only messages (no right column, non-string column) are
  checked through an on() condition; the adapter now reports both as
  'Join ON requires left and right columns'.
- JoinChainTest: joins are keyed by alias; the table fallback is gone.

Preserved-behaviour files (M6) change only in the join call form.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: abnegate

tests/e2e/Adapter/Scopes/AggregationTests.php

@@ -905,7 +905,7 @@ public function testInnerJoinBasic(): void
         $this->createCustomers($database, 'ij_customers');
 
         $results = $database->find('ij_orders', [
-            Query::join('ij_customers', 'customer_uid', '$id'),
+            Query::join('ij_customers', 'j0', [Query::on('customer_uid', '$id')]),
             Query::count('*', 'total'),
         ]);
 
@@ -927,7 +927,7 @@ public function testInnerJoinWithGroupBy(): void
         $this->createCustomers($database, 'ij_grp_c');
 
         $results = $database->find('ij_grp_o', [
-            Query::join('ij_grp_c', 'customer_uid', '$id'),
+            Query::join('ij_grp_c', 'j0', [Query::on('customer_uid', '$id')]),
             Query::sum('total', 'total_spent'),
             Query::count('*', 'order_count'),
             Query::groupBy(['customer_uid']),
@@ -960,7 +960,7 @@ public function testInnerJoinWithFilter(): void
         $this->createCustomers($database, 'ij_filt_c');
 
         $results = $database->find('ij_filt_o', [
-            Query::join('ij_filt_c', 'customer_uid', '$id'),
+            Query::join('ij_filt_c', 'j0', [Query::on('customer_uid', '$id')]),
             Query::equal('status', ['completed']),
             Query::sum('total', 'revenue'),
             Query::groupBy(['customer_uid']),
@@ -992,7 +992,7 @@ public function testInnerJoinWithHaving(): void
         $this->createCustomers($database, 'ij_hav_c');
 
         $results = $database->find('ij_hav_o', [
-            Query::join('ij_hav_c', 'customer_uid', '$id'),
+            Query::join('ij_hav_c', 'j0', [Query::on('customer_uid', '$id')]),
             Query::sum('total', 'total_spent'),
             Query::groupBy(['customer_uid']),
             Query::having([Query::greaterThan('total_spent', 1000)]),
@@ -1019,7 +1019,7 @@ public function testInnerJoinProductReviewStats(): void
         $this->createReviews($database, 'ij_prs_r');
 
         $results = $database->find('ij_prs_p', [
-            Query::join('ij_prs_r', '$id', 'product_uid'),
+            Query::join('ij_prs_r', 'j0', [Query::on('$id', 'product_uid')]),
             Query::count('*', 'review_count'),
             Query::avg('score', 'avg_score'),
             Query::groupBy(['name']),
@@ -1052,7 +1052,7 @@ public function testLeftJoinBasic(): void
         $this->createReviews($database, 'lj_basic_r');
 
         $results = $database->find('lj_basic_p', [
-            Query::leftJoin('lj_basic_r', '$id', 'product_uid'),
+            Query::leftJoin('lj_basic_r', 'j0', [Query::on('$id', 'product_uid')]),
             Query::count('*', 'review_count'),
             Query::groupBy(['name']),
         ]);
@@ -1086,7 +1086,7 @@ public function testLeftJoinWithFilter(): void
         $this->createOrders($database, 'lj_filt_o');
 
         $results = $database->find('lj_filt_p', [
-            Query::leftJoin('lj_filt_o', '$id', 'product_uid'),
+            Query::leftJoin('lj_filt_o', 'j0', [Query::on('$id', 'product_uid')]),
             Query::equal('category', ['electronics']),
             Query::count('*', 'order_count'),
             Query::sum('quantity', 'total_qty'),
@@ -1119,7 +1119,7 @@ public function testLeftJoinCustomerOrderSummary(): void
         $this->createOrders($database, 'lj_cos_o');
 
         $results = $database->find('lj_cos_c', [
-            Query::leftJoin('lj_cos_o', '$id', 'customer_uid'),
+            Query::leftJoin('lj_cos_o', 'j0', [Query::on('$id', 'customer_uid')]),
             Query::count('*', 'order_count'),
             Query::groupBy(['name']),
         ]);
@@ -1187,7 +1187,7 @@ public function testJoinAggregationWithPermissionsGrouped(): void
         $database->getAuthorization()->addRole(Role::user('viewer')->toString());
 
         $results = $database->find('jp_apg_o', [
-            Query::join('jp_apg_c', 'customer_uid', '$id'),
+            Query::join('jp_apg_c', 'j0', [Query::on('customer_uid', '$id')]),
             Query::sum('amount', 'total'),
             Query::count('*', 'cnt'),
             Query::groupBy(['customer_uid']),
@@ -1248,7 +1248,7 @@ public function testLeftJoinPermissionFiltered(): void
         $database->getAuthorization()->addRole(Role::user('tester')->toString());
 
         $results = $database->find('jp_ljpf_p', [
-            Query::leftJoin('jp_ljpf_r', '$id', 'product_uid'),
+            Query::leftJoin('jp_ljpf_r', 'j0', [Query::on('$id', 'product_uid')]),
             Query::count('*', 'review_count'),
             Query::groupBy(['name']),
         ]);
@@ -2111,10 +2111,10 @@ public function testMainAttributeAggregatedUnderItsOwnNameOverAJoinIsReadFromThe
         }
 
         foreach ([
-            'inner join' => [Query::join($joined, 'link', 'link', '=', 'other'), 10, 1],
-            'left join' => [Query::leftJoin($joined, 'link', 'link', '=', 'other'), 30, 2],
-            'right join' => [Query::rightJoin($joined, 'link', 'link', '=', 'other'), 10, 2],
-            'full outer join' => [Query::fullOuterJoin($joined, 'link', 'link', '=', 'other'), 30, 3],
+            'inner join' => [Query::join($joined, 'other', [Query::on('link', 'link')]), 10, 1],
+            'left join' => [Query::leftJoin($joined, 'other', [Query::on('link', 'link')]), 30, 2],
+            'right join' => [Query::rightJoin($joined, 'other', [Query::on('link', 'link')]), 10, 2],
+            'full outer join' => [Query::fullOuterJoin($joined, 'other', [Query::on('link', 'link')]), 30, 3],
         ] as $type => [$join, $total, $rows]) {
             $own = $database->find($main, [$join, Query::sum('score', 'score')]);
             $this->assertCount(1, $own, $type);
@@ -2208,7 +2208,7 @@ public function testSelectNextToAnAggregateMustNameAGroupedAttribute(): void
         if ($database->getAdapter()->supports(Capability::Joins)) {
             $orders = 'agg_select_ungrouped_orders';
             $this->createOrders($database, $orders);
-            $product = Query::join($collection, 'product_uid', '$id', '=', 'product');
+            $product = Query::join($collection, 'product', [Query::on('product_uid', '$id')]);
 
             foreach ([
                 ['product.name', [$product, Query::count('*', 'total'), Query::groupBy(['status']), Query::select(['product.name'])]],
@@ -2293,7 +2293,7 @@ public function testRelationshipWildcardsNextToAnAggregateAddNothingToTheRows():
             $this->assertSame(['status', 'total'], $this->sortedAttributeNames($groups[0]));
 
             if ($adapter->supports(Capability::Joins)) {
-                $joined = $database->find($customers, [Query::fullOuterJoin($accounts, 'account', '$id', '=', 'owned'), Query::count('*', 'total'), Query::select($selects)]);
+                $joined = $database->find($customers, [Query::fullOuterJoin($accounts, 'owned', [Query::on('account', '$id')]), Query::count('*', 'total'), Query::select($selects)]);
                 $this->assertCount(1, $joined);
                 $this->assertSame(['total'], $this->sortedAttributeNames($joined[0]));
                 $this->assertSame(3, $this->intAttribute($joined[0], 'total'));
@@ -2335,8 +2335,8 @@ public function testGroupedSelectReturnsEachGroupOnceWithItsAggregate(): void
             $this->createOrders($database, $orders);
 
             foreach ([
-                'inner join' => [Query::join($collection, 'product_uid', '$id', '=', 'product'), [2, 3, 5]],
-                'full outer join' => [Query::fullOuterJoin($collection, 'product_uid', '$id', '=', 'product'), [3, 3, 5]],
+                'inner join' => [Query::join($collection, 'product', [Query::on('product_uid', '$id')]), [2, 3, 5]],
+                'full outer join' => [Query::fullOuterJoin($collection, 'product', [Query::on('product_uid', '$id')]), [3, 3, 5]],
             ] as $type => [$product, $totals]) {
                 $groups = $database->find($orders, [$product, Query::count('*', 'total'), Query::groupBy(['product.category']), Query::select(['product.category']), Query::orderAsc('product.category')]);
                 $this->assertSame(['books', 'clothing', 'electronics'], \array_map(fn (Document $group): mixed => $group->getAttribute('category'), $groups), $type);

tests/e2e/Adapter/Scopes/AttributeTests.php

@@ -458,8 +458,8 @@ public function testDottedAttributeKeysBesideJoinAliases(): void
         ));
         $database->createDocument($orders, new Document(['$id' => 'o1', 'personId' => 'a', 'total' => 7]));
 
-        $join = Query::join($orders, '$id', 'personId', '=', 'ord');
-        $leftJoin = Query::leftJoin($orders, '$id', 'personId', '=', 'ord');
+        $join = Query::join($orders, 'ord', [Query::on('$id', 'personId')]);
+        $leftJoin = Query::leftJoin($orders, 'ord', [Query::on('$id', 'personId')]);
 
         $this->assertSame(['a'], $this->sortedIds($database->find($collection, [$join, Query::equal('dots.name', ['v'])])));
         $this->assertSame(1, $database->count($collection, [$join, Query::equal('dots.name', ['v'])]));

tests/e2e/Adapter/Scopes/DocumentTests.php

@@ -10407,8 +10407,8 @@ public function testSumResolvesABareNameOnlyAJoinDeclares(): void
             }
             $database->createDocument($extras, new Document(['$id' => 'a', '$permissions' => [], 'code' => 'a', 'price' => 100]));
 
-            $item = Query::join($items, 'item', 'code', '=', 'it');
-            $extra = Query::join($extras, 'item', 'code', '=', 'ex');
+            $item = Query::join($items, 'it', [Query::on('item', 'code')]);
+            $extra = Query::join($extras, 'ex', [Query::on('item', 'code')]);
 
             $this->assertEquals(40, $database->sum($orders, 'price', [$item]));
             $this->assertEquals(40, $database->sum($orders, 'it.price', [$item]));
@@ -10474,7 +10474,7 @@ public function testJoinedGroupSharingAMainGroupNameKeepsItsQualifiedName(): voi
                 return \array_map(static fn (Document $document): array => $document->getArrayCopy(), $documents);
             };
 
-            foreach (['join' => Query::join($items, 'item', 'code', '=', 'it'), 'full outer join' => Query::fullOuterJoin($items, 'item', 'code', '=', 'it')] as $case => $join) {
+            foreach (['join' => Query::join($items, 'it', [Query::on('item', 'code')]), 'full outer join' => Query::fullOuterJoin($items, 'it', [Query::on('item', 'code')])] as $case => $join) {
                 $this->assertEquals(
                     [['orders' => 2, 'name' => 'x', 'it.name' => 'apple'], ['orders' => 1, 'name' => 'y', 'it.name' => 'banana']],
                     $rows($database->find($orders, [$join, Query::count('*', 'orders'), Query::groupBy(['name', 'it.name']), Query::orderAsc('name')])),
@@ -10538,8 +10538,8 @@ public function testJoinWildcardSelectAndBareJoinedOrder(): void
             }
             $database->createDocument($extras, new Document(['$id' => 'a', '$permissions' => [], 'code' => 'a', 'price' => 100]));
 
-            $item = Query::join($items, 'item', 'code', '=', 'it');
-            $extra = Query::join($extras, 'item', 'code', '=', 'ex');
+            $item = Query::join($items, 'it', [Query::on('item', 'code')]);
+            $extra = Query::join($extras, 'ex', [Query::on('item', 'code')]);
             $ids = static function (array $documents): array {
                 /** @var array<Document> $documents */
                 return \array_map(static fn (Document $document): string => $document->getId(), $documents);
@@ -10554,7 +10554,7 @@ public function testJoinWildcardSelectAndBareJoinedOrder(): void
             $this->assertNull($rows[1]->getAttribute('quantity'));
 
             $this->assertSame(['o2', 'o1', 'o3'], $ids($database->find($orders, [$item, Query::orderDesc('price'), Query::orderAsc('$id')])));
-            $this->assertSame(['o2', 'o1', 'o3'], $ids($database->find($orders, [Query::fullOuterJoin($items, 'item', 'code', '=', 'it'), Query::orderDesc('price'), Query::orderAsc('$id')])));
+            $this->assertSame(['o2', 'o1', 'o3'], $ids($database->find($orders, [Query::fullOuterJoin($items, 'it', [Query::on('item', 'code')]), Query::orderDesc('price'), Query::orderAsc('$id')])));
             $this->assertSame(['o2', 'o1', 'o3'], $ids($database->find($orders, [$item, Query::orderDesc('name'), Query::orderAsc('$id')])), 'a name the main collection declares reads the main table');
             $this->assertEquals(
                 [['orders' => 1, 'code' => 'b'], ['orders' => 2, 'code' => 'a']],