Feat: Accept Builder argument (#3)

* Feat: Accept Builder argument

* Doc: Update README

Author: mpyw

README.md

@@ -131,7 +131,7 @@ Builder::hasByNonDependentSubquery(
 | Feature | [`mpyw/eloquent-has-by-join`](https://github.com/mpyw/eloquent-has-by-join) | `mpyw/eloquent-has-by-non-dependent-subquery` |
 |:----|:---:|:---:|
 | Minimum Laravel version | 5.6 | 5.8 |
-| Argument of optional constraints | `Illuminate\Database\Eloquent\Builder` | `Illuminate\Database\Eloquent\Relations\*` |
+| Argument of optional constraints | `Illuminate\Database\Eloquent\Builder` | `Illuminate\Database\Eloquent\Relations\*`<br>(`Builder` can be also accepted by specifying argument type) |
 | [Compoships](https://github.com/topclaudy/compoships) support | ✅ | ❌ |
 | No subqueries | ✅ | ❌<br>(Performance depends on database optimizers) |
 | No table collisions | ❌<br>(Sometimes you need to give aliases) | ✅ |

src/HasByNonDependentSubqueryMacro.php

@@ -89,7 +89,7 @@ protected function apply($relationMethod, string $whereInMethod, ?callable ...$c
                 function (Relation $query) use ($relationMethods, $whereInMethod, $constraints) {
                     // Apply optional constraints
                     if ($currentConstraints = \array_shift($constraints)) {
-                        $currentConstraints($query);
+                        $currentConstraints($this->adjustArgumentTypeOfOptionalConstraints($currentConstraints, $query));
                     }
                     // Apply relations nested under
                     if ($relationMethods) {
@@ -133,4 +133,23 @@ protected function applyForCurrentRelation(string $relationMethod, string $where
         }
         $this->query->{$whereInMethod}($keys->getQualifiedSourceKeyName(), $relation->getQuery());
     }
+
+    /**
+     * From v1.1:
+     *   Relation will be automatically converted to Builder to prevent common mistakes on demand.
+     *
+     * @param  callable                                                                               $constraint
+     * @param  \Illuminate\Database\Eloquent\Relations\Relation                                       $relation
+     * @return \Illuminate\Database\Eloquent\Builder|\Illuminate\Database\Eloquent\Relations\Relation
+     */
+    protected function adjustArgumentTypeOfOptionalConstraints(callable $constraint, Relation $relation)
+    {
+        $reflection = ReflectionCallable::from($constraint);
+
+        return $reflection->getNumberOfParameters() > 0
+            && ($parameter = $reflection->getParameters()[0])->hasType()
+            && \is_a($parameter->getType()->getName(), Builder::class, true)
+            ? $relation->getQuery()
+            : $relation;
+    }
 }

src/ReflectionCallable.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace Mpyw\EloquentHasByNonDependentSubquery;
+
+use Closure;
+use ReflectionFunction;
+use ReflectionMethod;
+
+/**
+ * Class ReflectionCallable
+ */
+class ReflectionCallable
+{
+    /** @noinspection PhpDocMissingThrowsInspection */
+
+    /**
+     * @param  callable                              $callable
+     * @return \ReflectionFunction|\ReflectionMethod
+     */
+    public static function from(callable $callable)
+    {
+        if (\is_string($callable) && \strpos($callable, '::')) {
+            $callable = \explode('::', $callable);
+        } elseif (!$callable instanceof Closure && \is_object($callable)) {
+            $callable = [$callable, '__invoke'];
+        }
+
+        /* @noinspection PhpUnhandledExceptionInspection */
+        return $callable instanceof Closure || \is_string($callable)
+            ? new ReflectionFunction($callable)
+            : new ReflectionMethod($callable[0], $callable[1]);
+    }
+}

tests/Test.php

@@ -2,20 +2,25 @@
 
 namespace Mpyw\EloquentHasByNonDependentSubquery\Tests;
 
+use DateTime;
 use DomainException;
+use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Database\Eloquent\Relations\BelongsTo;
 use Illuminate\Database\Eloquent\Relations\BelongsToMany;
 use Illuminate\Database\Eloquent\Relations\HasManyThrough;
 use Illuminate\Database\Eloquent\Relations\Relation;
 use Illuminate\Support\Str;
 use Mpyw\EloquentHasByNonDependentSubquery\EloquentHasByNonDependentSubqueryServiceProvider;
+use Mpyw\EloquentHasByNonDependentSubquery\ReflectionCallable;
 use Mpyw\EloquentHasByNonDependentSubquery\Tests\Models\Category;
 use Mpyw\EloquentHasByNonDependentSubquery\Tests\Models\Comment;
 use Mpyw\EloquentHasByNonDependentSubquery\Tests\Models\Post;
 use Mpyw\EloquentHasByNonDependentSubquery\Tests\Models\Tag;
 use Mpyw\EloquentHasByNonDependentSubquery\Tests\Models\User;
 use NilPortugues\Sql\QueryFormatter\Formatter;
 use Orchestra\Testbench\TestCase as BaseTestCase;
+use ReflectionFunction;
+use ReflectionMethod;
 
 class Test extends BaseTestCase
 {
@@ -691,6 +696,34 @@ public function testOrDoesntHave(): void
         );
     }
 
+    public function testAcceptBuilderArgument(): void
+    {
+        $this->assertQueryEquals(
+            <<<'EOD'
+            select
+                *
+            from
+                "comments"
+            where
+                "comments"."post_id" in (
+                    select
+                        "posts"."id"
+                    from
+                        "posts"
+                    where
+                        "posts"."deleted_at" is not null
+                )
+EOD
+            ,
+            Comment::query()->hasByNonDependentSubquery(
+                'post',
+                function (Builder $query) {
+                    $query->onlyTrashed();
+                }
+            )->withTrashed()
+        );
+    }
+
     public function testMultiColumnRelation(): void
     {
         $this->expectException(DomainException::class);
@@ -714,4 +747,19 @@ public function testMorphToRelation(): void
 
         Comment::query()->hasByNonDependentSubquery('commentable');
     }
+
+    public function testReflectionCallable(): void
+    {
+        $this->assertInstanceOf(ReflectionFunction::class, ReflectionCallable::from('strpos'));
+        $this->assertInstanceOf(ReflectionFunction::class, ReflectionCallable::from(function () {}));
+
+        $this->assertInstanceOf(ReflectionMethod::class, ReflectionCallable::from('DateTime::createFromFormat'));
+        $this->assertInstanceOf(ReflectionMethod::class, ReflectionCallable::from([DateTime::class, 'createFromFormat']));
+        $this->assertInstanceOf(ReflectionMethod::class, ReflectionCallable::from([new DateTime(), 'format']));
+        $this->assertInstanceOf(ReflectionMethod::class, ReflectionCallable::from(new class() {
+            public function __invoke()
+            {
+            }
+        }));
+    }
 }