Merge branch 'v3'

Author: AlexVanderbist

src/AllowedFilter.php

@@ -46,7 +46,7 @@ public function filter(QueryBuilder $query, $value)
             return;
         }
 
-        ($this->filterClass)($query, $valueToFilter, $this->internalName);
+        ($this->filterClass)($query->getEloquentBuilder(), $valueToFilter, $this->internalName);
     }
 
     public static function exact(

src/AllowedInclude.php

@@ -61,7 +61,13 @@ public static function count(string $name, ?string $internalName = null): Collec
 
     public function include(QueryBuilder $query): void
     {
-        ($this->includeClass)($query, $this->internalName);
+        if (property_exists($this->includeClass, 'getRequestedFieldsForRelatedTable')) {
+            $this->includeClass->getRequestedFieldsForRelatedTable = function (...$args) use ($query) {
+                return $query->getRequestedFieldsForRelatedTable(...$args);
+            };
+        }
+
+        ($this->includeClass)($query->getEloquentBuilder(), $this->internalName);
     }
 
     public function getName(): string

src/AllowedSort.php

@@ -41,7 +41,7 @@ public function sort(QueryBuilder $query, ?bool $descending = null): void
     {
         $descending = $descending ?? ($this->defaultDirection === SortDirection::DESCENDING);
 
-        ($this->sortClass)($query, $descending, $this->internalName);
+        ($this->sortClass)($query->getEloquentBuilder(), $descending, $this->internalName);
     }
 
     public static function field(string $name, ?string $internalName = null): self

src/Exceptions/InvalidSubject.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace Spatie\QueryBuilder\Exceptions;
+
+use InvalidArgumentException;
+
+class InvalidSubject extends InvalidArgumentException
+{
+    public static function make($subject)
+    {
+        return new static(
+            sprintf(
+                'Subject %s is invalid.',
+                is_object($subject)
+                    ? sprintf('class `%s`', get_class($subject))
+                    : sprintf('type `%s`', gettype($subject))
+            )
+        );
+    }
+}

src/Includes/IncludedRelationship.php

@@ -2,11 +2,15 @@
 
 namespace Spatie\QueryBuilder\Includes;
 
+use Closure;
 use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Support\Collection;
 
 class IncludedRelationship implements IncludeInterface
 {
+    /** @var Closure|null */
+    public $getRequestedFieldsForRelatedTable;
+
     public function __invoke(Builder $query, string $relationship)
     {
         $relatedTables = collect(explode('.', $relationship));
@@ -15,7 +19,9 @@ public function __invoke(Builder $query, string $relationship)
             ->mapWithKeys(function ($table, $key) use ($query, $relatedTables) {
                 $fullRelationName = $relatedTables->slice(0, $key + 1)->implode('.');
 
-                $fields = $query->getRequestedFieldsForRelatedTable($fullRelationName);
+                if ($this->getRequestedFieldsForRelatedTable) {
+                    $fields = ($this->getRequestedFieldsForRelatedTable)($fullRelationName);
+                }
 
                 if (empty($fields)) {
                     return [$fullRelationName];

src/QueryBuilder.php

@@ -2,94 +2,143 @@
 
 namespace Spatie\QueryBuilder;
 
-use Illuminate\Database\Eloquent\Builder;
+use ArrayAccess;
+use Illuminate\Database\Eloquent\Builder as EloquentBuilder;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\Relation;
 use Illuminate\Http\Request;
+use Illuminate\Support\Collection;
+use Illuminate\Support\Traits\ForwardsCalls;
 use Spatie\QueryBuilder\Concerns\AddsFieldsToQuery;
 use Spatie\QueryBuilder\Concerns\AddsIncludesToQuery;
 use Spatie\QueryBuilder\Concerns\AppendsAttributesToResults;
 use Spatie\QueryBuilder\Concerns\FiltersQuery;
 use Spatie\QueryBuilder\Concerns\SortsQuery;
+use Spatie\QueryBuilder\Exceptions\InvalidSubject;
 
-class QueryBuilder extends Builder
+/**
+ * @mixin EloquentBuilder
+ */
+class QueryBuilder implements ArrayAccess
 {
     use FiltersQuery,
         SortsQuery,
         AddsIncludesToQuery,
         AddsFieldsToQuery,
-        AppendsAttributesToResults;
+        AppendsAttributesToResults,
+        ForwardsCalls;
 
-    /** @var \Spatie\QueryBuilder\QueryBuilderRequest */
+    /** @var QueryBuilderRequest */
     protected $request;
 
-    /**
-     * QueryBuilder constructor.
-     *
-     * @param \Illuminate\Database\Eloquent\Builder|\Illuminate\Database\Eloquent\Relations\Relation $builder
-     * @param null|\Illuminate\Http\Request $request
-     */
-    public function __construct($builder, ?Request $request = null)
+    /** @var EloquentBuilder|Relation */
+    protected $subject;
+
+    public function __construct($subject, ?Request $request = null)
+    {
+        $this->initializeSubject($subject)
+            ->initializeRequest($request ?? app(Request::class));
+    }
+
+    protected function initializeSubject($subject): self
     {
-        parent::__construct(clone $builder->getQuery());
+        throw_unless(
+            $subject instanceof EloquentBuilder || $subject instanceof Relation,
+            InvalidSubject::make($subject)
+        );
+
+        $this->subject = $subject;
 
-        $this->initializeFromBuilder($builder);
+        return $this;
+    }
 
+    protected function initializeRequest(?Request $request = null): self
+    {
         $this->request = $request
             ? QueryBuilderRequest::fromRequest($request)
             : app(QueryBuilderRequest::class);
+
+        return $this;
     }
 
-    /**
-     * Create a new QueryBuilder for a request and model.
-     *
-     * @param string|\Illuminate\Database\Eloquent\Builder|\Illuminate\Database\Eloquent\Relations\Relation $baseQuery Model class or base query builder
-     * @param \Illuminate\Http\Request $request
-     *
-     * @return \Spatie\QueryBuilder\QueryBuilder
-     */
-    public static function for($baseQuery, ?Request $request = null): self
+    public function getEloquentBuilder(): EloquentBuilder
     {
-        if (is_string($baseQuery)) {
-            /** @var Builder $baseQuery */
-            $baseQuery = $baseQuery::query();
+        if ($this->subject instanceof EloquentBuilder) {
+            return $this->subject;
         }
 
-        return new static($baseQuery, $request ?? app(Request::class));
+        if ($this->subject instanceof Relation) {
+            return $this->subject->getQuery();
+        }
+
+        throw InvalidSubject::make($this->subject);
+    }
+
+    public function getSubject()
+    {
+        return $this->subject;
     }
 
     /**
-     * {@inheritdoc}
+     * @param EloquentBuilder|Relation|string $subject
+     * @param Request|null $request
+     * @return static
      */
-    public function get($columns = ['*'])
+    public static function for($subject, ?Request $request = null): self
     {
-        $results = parent::get($columns);
+        if (is_subclass_of($subject, Model::class)) {
+            $subject = $subject::query();
+        }
+
+        return new static($subject, $request);
+    }
 
-        if ($this->request->appends()->isNotEmpty()) {
-            $results = $this->addAppendsToResults($results);
+    public function __call($name, $arguments)
+    {
+        $result = $this->forwardCallTo($this->subject, $name, $arguments);
+
+        if ($result === $this->subject) {
+            return $this;
+        }
+
+        if ($result instanceof Model) {
+            $this->addAppendsToResults(collect([$result]));
+        }
+
+        if ($result instanceof Collection) {
+            $this->addAppendsToResults($result);
         }
 
-        return $results;
+        return $result;
     }
 
-    /**
-     * Add the model, scopes, eager loaded relationships, local macro's and onDelete callback
-     * from the $builder to this query builder.
-     *
-     * @param \Illuminate\Database\Eloquent\Builder $builder
-     */
-    protected function initializeFromBuilder(Builder $builder)
+    public function __get($name)
     {
-        $this
-            ->setModel($builder->getModel())
-            ->setEagerLoads($builder->getEagerLoads());
+        return $this->subject->{$name};
+    }
 
-        $builder->macro('getProtected', function (Builder $builder, string $property) {
-            return $builder->{$property};
-        });
+    public function __set($name, $value)
+    {
+        $this->subject->{$name} = $value;
+    }
 
-        $this->scopes = $builder->getProtected('scopes');
+    public function offsetExists($offset)
+    {
+        return isset($this->subject[$offset]);
+    }
 
-        $this->localMacros = $builder->getProtected('localMacros');
+    public function offsetGet($offset)
+    {
+        return $this->subject[$offset];
+    }
 
-        $this->onDelete = $builder->getProtected('onDelete');
+    public function offsetSet($offset, $value)
+    {
+        $this->subject[$offset] = $value;
+    }
+
+    public function offsetUnset($offset)
+    {
+        unset($this->subject[$offset]);
     }
 }