Merge pull request #4 from kjsoftware/develop

V1

Author: thuijbers

README.md

@@ -7,6 +7,17 @@
 
 This package allows you to filter, sort and include eloquent relations based on a request. The `QueryBuilder` used in this package extends Laravel's default Eloquent builder. This means all your favorite methods and macros are still available. Query parameter names follow the [JSON API specification](http://jsonapi.org/) as closely as possible.
 
+## Caching foreign keys
+Add this line to your composer.json file to cache foreign keys. This will allow the query builder to automatically detect foreign keys without having to make a database call.
+These foreign keys will always be included in select statements, which will prevent a loss of potential relations.
+```json
+"scripts": {
+    "post-update-cmd": [
+        "@php artisan query-builder:cache-foreign-keys"
+    ],
+}
+```
+
 ## Basic usage
 
 ### Filter a query based on a request: `/users?filter[name]=John`:

composer.json

@@ -24,7 +24,8 @@
         "illuminate/database": "^9.0|^10.0",
         "illuminate/http": "^9.0|^10.0",
         "illuminate/support": "^9.0|^10.0",
-        "spatie/laravel-package-tools": "^1.11"
+        "spatie/laravel-package-tools": "^1.11",
+        "doctrine/dbal": "^3.5"
     },
     "require-dev": {
         "ext-json": "*",

src/AllowedField.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace Spatie\QueryBuilder;
+
+use Illuminate\Support\Collection;
+use Spatie\QueryBuilder\Filters\Filter;
+
+class AllowedField
+{
+    protected string $name;
+    protected Collection $internalNames;
+
+    public function __construct(string $name, string|array $internalName = null)
+    {
+        $this->name = $name;
+
+        $this->internalNames = collect($internalName);
+    }
+
+
+    public static function setFilterArrayValueDelimiter(string $delimiter = null): void
+    {
+        if (isset($delimiter)) {
+            QueryBuilderRequest::setFilterArrayValueDelimiter($delimiter);
+        }
+    }
+
+    public static function partial(string $name, $internalNames = null, bool $addRelationConstraint = true, string $arrayValueDelimiter = null): self
+    {
+        static::setFilterArrayValueDelimiter($arrayValueDelimiter);
+        return new static($name, $internalNames);
+    }
+
+    public function getName(): string
+    {
+        return $this->name;
+    }
+
+    public function getInternalNames(): Collection
+    {
+        return $this->internalNames;
+    }
+}

src/App/Console/Commands/CacheForeignKeys.php

@@ -0,0 +1,72 @@
+<?php
+
+namespace Spatie\QueryBuilder\App\Console\Commands;
+
+use Illuminate\Console\Command;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Support\Facades\Cache;
+use Illuminate\Support\Facades\File;
+use Illuminate\Support\Facades\Schema;
+use Illuminate\Support\Str;
+use ReflectionClass;
+
+class CacheForeignKeys extends Command
+{
+
+    protected $signature = 'query-builder:cache-foreign-keys';
+
+    protected $description = 'Cache foreign keys for the QueryBuilder package.';
+
+    public function __invoke(): void
+    {
+        $modelsDirectory = app_path('Models');
+
+        $files = File::allFiles($modelsDirectory);
+
+        $foreignKeys = [];
+        $this->info('Fetching all models in App\Models...' . PHP_EOL);
+
+        foreach ($files as $file) {
+            // Build the full class name
+            $fullClassName = 'App\\Models' . '\\' . $file->getRelativePath() . '\\' . pathinfo($file->getRelativePathname(), PATHINFO_FILENAME);
+            $fullClassName = Str::replace('/', '\\', $fullClassName);
+
+            // Check if the class exists
+            if (class_exists($fullClassName) && is_subclass_of($fullClassName, Model::class)) {
+                // Create a ReflectionClass instance
+                $reflectionClass = new ReflectionClass($fullClassName);
+
+                // Check if the class is instantiable
+                if ($reflectionClass->isInstantiable()) {
+                    // Instantiate the class
+                    $instance = $reflectionClass->newInstance();
+                    $table = $instance->getTable();
+
+                    // Get all foreign keys for the table
+                    $tableForeignKeys = Schema::getConnection()->getDoctrineSchemaManager()->listTableForeignKeys($table);
+
+                    // Add the foreign keys to the array
+                    $foreignKeys[$table] = array_reduce($tableForeignKeys, function ($carry, $foreignKey) {
+                        return array_merge($carry, $foreignKey->getLocalColumns());
+                    }, []);
+
+                    // Add the primary key to the array
+                    $foreignKeys[$table][] = $instance->getKeyName();
+                } else {
+                    $this->error("The class $fullClassName is not instantiable.");
+                }
+            } else {
+                $this->warn("The class $fullClassName does not exist or does not extend " . Model::class . '.');
+            }
+        }
+        $this->info(PHP_EOL . 'Cached foreign keys for ' . count($foreignKeys) . ' tables.');
+
+        Cache::forever('QUERY_BUILDER_FKS', $foreignKeys);
+    }
+
+    public static function getForTable(string $table): array
+    {
+        return Cache::get('QUERY_BUILDER_FKS')[$table] ?? [];
+    }
+
+}

src/Concerns/AddsFieldsToQuery.php

@@ -4,13 +4,15 @@
 
 use Illuminate\Support\Collection;
 use Illuminate\Support\Str;
+use Spatie\QueryBuilder\AllowedField;
+use Spatie\QueryBuilder\App\Console\Commands\CacheForeignKeys;
 use Spatie\QueryBuilder\Exceptions\AllowedFieldsMustBeCalledBeforeAllowedIncludes;
 use Spatie\QueryBuilder\Exceptions\InvalidFieldQuery;
 use Spatie\QueryBuilder\Exceptions\UnknownIncludedFieldsQuery;
 
 trait AddsFieldsToQuery
 {
-    protected ?Collection $allowedFields = null;
+    public ?Collection $allowedFields = null;
 
     public function allowedFields($fields): static
     {
@@ -20,10 +22,13 @@ public function allowedFields($fields): static
 
         $fields = is_array($fields) ? $fields : func_get_args();
 
-        $this->allowedFields = collect($fields)
-            ->map(function (string $fieldName) {
-                return $this->prependField($fieldName);
-            });
+        $this->allowedFields = collect($fields)->map(function ($field) {
+            if ($field instanceof AllowedField) {
+                return $field;
+            }
+
+            return AllowedField::partial($field);
+        });
 
         $this->ensureAllFieldsExist();
 
@@ -32,57 +37,76 @@ public function allowedFields($fields): static
         return $this;
     }
 
-    protected function addRequestedModelFieldsToQuery()
+    protected function addRequestedModelFieldsToQuery(): void
     {
         $modelTableName = $this->getModel()->getTable();
 
-        $modelFields = $this->request->fields()->get($modelTableName);
+        $requestFields = $this->request->fields()->map(function ($field) {
+            return $field->name;
+        });
+
+        $modelFields = $this->allowedFields->mapWithKeys(function (AllowedField $field) {
+            return [
+                $field->getName() => $field->getInternalNames()->toArray()
+            ];
+        });
+
+        if ($requestFields->count() > 0) {
+            // If fields are requested, only select those
+            $modelFields = $modelFields->filter(function ($internalName, $name) use ($requestFields) {
+                return $requestFields->contains($name);
+            })->toArray();
+        } else {
+            // If no fields are requested, select all allowed fields
+            $modelFields = $modelFields->toArray();
+        }
 
         if (empty($modelFields)) {
             return;
         }
 
+        // Flatten array
+        $modelFields = array_unique(array_merge(...array_values($modelFields)));
+
+        // Prepend the fields with the table name
         $prependedFields = $this->prependFieldsWithTableName($modelFields, $modelTableName);
 
         $this->select($prependedFields);
     }
 
     public function getRequestedFieldsForRelatedTable(string $relation): array
     {
-        $table = Str::plural(Str::snake($relation)); // TODO: make this configurable
+        $table = Str::plural(Str::snake($relation));
 
         $fields = $this->request->fields()->mapWithKeys(function ($fields, $table) {
             return [$table => $fields];
         })->get($table);
 
-        if (! $fields) {
+        if (!$fields) {
             return [];
         }
 
-        if (! $this->allowedFields instanceof Collection) {
+        if (!$this->allowedFields instanceof Collection) {
             // We have requested fields but no allowed fields (yet?)
-
             throw new UnknownIncludedFieldsQuery($fields);
         }
 
         return $fields;
     }
 
-    protected function ensureAllFieldsExist()
+    protected function ensureAllFieldsExist(): void
     {
-        $requestedFields = $this->request->fields()
-            ->map(function ($fields, $model) {
-                $tableName = $model;
+        // Map fieldnames from object
+        $allowedFields = $this->allowedFields->map(function (AllowedField $field) {
+            return $field->getName();
+        });
 
-                return $this->prependFieldsWithTableName($fields, $tableName);
-            })
-            ->flatten()
-            ->unique();
+        $requestedFields = $this->request->fields();
 
-        $unknownFields = $requestedFields->diff($this->allowedFields);
+        $unknownFields = $requestedFields->pluck('name')->diff($allowedFields);
 
         if ($unknownFields->isNotEmpty()) {
-            throw InvalidFieldQuery::fieldsNotAllowed($unknownFields, $this->allowedFields);
+            throw InvalidFieldQuery::fieldsNotAllowed($unknownFields, $allowedFields);
         }
     }
 
@@ -95,16 +119,20 @@ protected function prependFieldsWithTableName(array $fields, string $tableName):
 
     protected function prependField(string $field, ?string $table = null): string
     {
-        if (! $table) {
+        if (!$table) {
             $table = $this->getModel()->getTable();
         }
 
         if (Str::contains($field, '.')) {
             // Already prepended
-
             return $field;
         }
 
         return "{$table}.{$field}";
     }
+
+    public function getAllowedFields(): ?Collection
+    {
+        return $this->allowedFields;
+    }
 }

src/Concerns/FiltersQuery.php

@@ -2,6 +2,7 @@
 
 namespace Spatie\QueryBuilder\Concerns;
 
+use Illuminate\Support\Collection;
 use Spatie\QueryBuilder\AllowedFilter;
 use Spatie\QueryBuilder\Exceptions\InvalidFilterQuery;
 
@@ -78,4 +79,9 @@ protected function ensureAllFiltersExist()
             throw InvalidFilterQuery::filtersNotAllowed($diff, $allowedFilterNames);
         }
     }
+
+    public function getAllowedFilters(): ?Collection
+    {
+        return $this->allowedFilters;
+    }
 }

src/Concerns/SortsQuery.php

@@ -2,22 +2,18 @@
 
 namespace Spatie\QueryBuilder\Concerns;
 
+use Illuminate\Support\Collection;
 use Spatie\QueryBuilder\AllowedSort;
 use Spatie\QueryBuilder\Exceptions\InvalidSortQuery;
+use Spatie\QueryBuilder\QueryBuilder;
 
 trait SortsQuery
 {
-    /** @var \Illuminate\Support\Collection */
+    /** @var Collection */
     protected $allowedSorts;
 
     public function allowedSorts($sorts): static
     {
-        if ($this->request->sorts()->isEmpty()) {
-            // We haven't got any requested sorts. No need to parse allowed sorts.
-
-            return $this;
-        }
-
         $sorts = is_array($sorts) ? $sorts : func_get_args();
 
         $this->allowedSorts = collect($sorts)->map(function ($sort) {
@@ -36,19 +32,19 @@ public function allowedSorts($sorts): static
     }
 
     /**
-     * @param array|string|\Spatie\QueryBuilder\AllowedSort $sorts
+     * @param array|string|AllowedSort $sorts
      *
-     * @return \Spatie\QueryBuilder\QueryBuilder
+     * @return QueryBuilder
      */
     public function defaultSort($sorts): static
     {
         return $this->defaultSorts(func_get_args());
     }
 
     /**
-     * @param array|string|\Spatie\QueryBuilder\AllowedSort $sorts
+     * @param array|string|AllowedSort $sorts
      *
-     * @return \Spatie\QueryBuilder\QueryBuilder
+     * @return QueryBuilder
      */
     public function defaultSorts($sorts): static
     {
@@ -113,4 +109,9 @@ protected function ensureAllSortsExist(): void
             throw InvalidSortQuery::sortsNotAllowed($unknownSorts, $allowedSortNames);
         }
     }
+
+    public function getAllowedSorts(): ?Collection
+    {
+        return $this->allowedSorts;
+    }
 }

src/Mappings/Column.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace Spatie\QueryBuilder\Mappings;
+
+class Column
+{
+    /**
+     * Create a new currency instance.
+     *
+     * @param  string  $name
+     * @return void
+     */
+    function __construct(string $name)
+    {
+        $this->name = $name;
+    }
+
+}