🔎 Searching improvements (#84)

* Cleanup Bakery facade

* Fix searching on collection queries

* Apply fixes from StyleCI

* Implement marking fields as searchable

* Apply fixes from StyleCI

Author: erikgaal

src/Bakery.php

@@ -65,24 +65,4 @@ public function graphiql($route, $headers = [])
             ['endpoint' => route($route), 'headers' => $headers]
         );
     }
-
-    /**
-     * Get the type instances of Bakery.
-     *
-     * @return array
-     */
-    public function getTypeInstances()
-    {
-        return $this->typeInstances;
-    }
-
-    /**
-     * Set the type instances.
-     *
-     * @param array $typeInstances
-     */
-    public function setTypeInstances(array $typeInstances)
-    {
-        $this->typeInstances = $typeInstances;
-    }
 }

src/Eloquent/ModelSchema.php

@@ -171,6 +171,16 @@ public function isIndexable()
         return $this->indexable;
     }
 
+    /**
+     * Returns if the schema is searchable.
+     *
+     * @return bool
+     */
+    public function isSearchable()
+    {
+        return $this->getSearchableFields()->merge($this->getSearchableRelationFields())->isNotEmpty();
+    }
+
     /**
      * Return the typename of the model schema.
      *
@@ -231,6 +241,30 @@ public function getFillableFields(): Collection
         });
     }
 
+    /**
+     * The fields that can be used in fulltext search.
+     *
+     * @return \Illuminate\Support\Collection
+     */
+    public function getSearchableFields(): Collection
+    {
+        return $this->getFields()->filter(function (Field $field) {
+            return $field->isSearchable();
+        });
+    }
+
+    /**
+     * The relation fields that can be used in fulltext search.
+     *
+     * @return \Illuminate\Support\Collection
+     */
+    public function getSearchableRelationFields(): Collection
+    {
+        return $this->getRelationFields()->filter(function (Field $field) {
+            return $field->isSearchable();
+        });
+    }
+
     /**
      * The fields that can be used to look up this model.
      *

src/Fields/Field.php

@@ -56,6 +56,11 @@ class Field
      */
     protected $fillable = true;
 
+    /**
+     * @var bool
+     */
+    protected $searchable = false;
+
     /**
      * @var bool
      */
@@ -329,6 +334,29 @@ public function isFillable(): bool
         return $this->fillable;
     }
 
+    /**
+     * Set if the field is searchable.
+     *
+     * @param bool $searchable
+     * @return \Bakery\Fields\Field
+     */
+    public function searchable(bool $searchable = true): self
+    {
+        $this->searchable = $searchable;
+
+        return $this;
+    }
+
+    /**
+     * Return if the field is searchable.
+     *
+     * @return bool
+     */
+    public function isSearchable(): bool
+    {
+        return $this->searchable;
+    }
+
     /**
      * Set if the field is unique.
      *

src/Queries/EloquentCollectionQuery.php

@@ -59,9 +59,12 @@ public function args(): array
             'page' => $this->registry->int()->nullable(),
             'count' => $this->registry->int()->nullable(),
             'filter' => $this->registry->type($this->modelSchema->typename().'Filter')->nullable(),
-            'search' => $this->registry->type($this->modelSchema->typename().'RootSearch')->nullable(),
         ]);
 
+        if ($this->modelSchema->isSearchable()) {
+            $args->put('search', $this->registry->type($this->modelSchema->typename().'RootSearch')->nullable());
+        }
+
         if (! empty($this->modelSchema->getFields())) {
             $args->put('orderBy', $this->registry->type($this->modelSchema->typename().'OrderBy')->nullable());
         }

src/Support/Facades/Bakery.php

@@ -4,22 +4,6 @@
 
 use Illuminate\Support\Facades\Facade;
 
-/**
- * @method static \Bakery\Types\Definitions\ReferenceType string
- * @method static \Bakery\Types\Definitions\ReferenceType int
- * @method static \Bakery\Types\Definitions\ReferenceType boolean
- * @method static \Bakery\Types\Definitions\ReferenceType float
- * @method static \Bakery\Types\Definitions\ReferenceType ID
- * @method static \Bakery\Types\Definitions\EloquentType model(string $definition)
- * @method static \Bakery\Types\Definitions\EloquentType collection(string $definition)
- * @method static \Bakery\Types\Definitions\ReferenceType list(string $definition)
- * @method static \Bakery\Types\Definitions\ReferenceType type(string $definition)
- * @method static \Bakery\Types\Definitions\PolymorphicField polymorphic(array $definitions)
- * @method static \GraphQL\Type\Definition\NamedType resolve(string $definition)
- * @method static \Bakery\Eloquent\ModelSchema getModelSchema(string $class)
- * @method static bool hasSchemaForModel(\Illuminate\Database\Eloquent\Model|string $model)
- * @method static \Bakery\Eloquent\ModelSchema getSchemaForModel(\Illuminate\Database\Eloquent\Model|string $model)
- */
 class Bakery extends Facade
 {
     protected static function getFacadeAccessor()

src/Support/Schema.php

@@ -202,10 +202,13 @@ protected function getModelTypes(): Collection
                       ->push(new Types\CollectionFilterType($this->registry, $schema))
                       ->push(new Types\CollectionOrderByType($this->registry, $schema));
 
+                if ($schema->isSearchable()) {
+                    $types->push(new Types\CollectionSearchType($this->registry, $schema));
+                }
+
                 if ($schema->isIndexable()) {
                     $types->push(new Types\EntityCollectionType($this->registry, $schema))
-                          ->push(new Types\CollectionRootSearchType($this->registry, $schema))
-                          ->push(new Types\CollectionSearchType($this->registry, $schema));
+                          ->push(new Types\CollectionRootSearchType($this->registry, $schema));
                 }
 
                 if ($schema->isMutable()) {

src/Traits/SearchesQueries.php

@@ -23,6 +23,11 @@ trait SearchesQueries
      */
     protected function applySearch(Builder $query, array $args)
     {
+        // If the query is empty, we don't need to perform any search.
+        if (empty($args['query'])) {
+            return $query;
+        }
+
         /** @var \Illuminate\Database\Connection $connection */
         $connection = DB::connection();
 
@@ -75,7 +80,7 @@ protected function applyRelationalSearch(Builder $query, Model $model, string $r
         $this->joinRelation($query, $relation, 'left');
 
         foreach ($fields as $key => $value) {
-            $schema = Bakery::getSchemaForModel(get_class($related));
+            $schema = $this->registry->getSchemaForModel($related);
 
             $relations = $schema->getRelationFields();
             if ($relations->keys()->contains($key)) {

src/Types/CollectionRootSearchType.php

@@ -24,7 +24,7 @@ public function name(): string
     public function fields(): array
     {
         return [
-            'query' => $this->registry->field($this->registry->string()),
+            'query' => $this->registry->field($this->registry->string())->nullable(),
             'fields' => $this->registry->field($this->modelSchema->typename().'Search'),
         ];
     }

src/Types/CollectionSearchType.php

@@ -3,7 +3,7 @@
 namespace Bakery\Types;
 
 use Bakery\Fields\Field;
-use Bakery\Types\Definitions\EloquentType;
+use Bakery\Fields\EloquentField;
 use Bakery\Types\Definitions\EloquentInputType;
 
 class CollectionSearchType extends EloquentInputType
@@ -25,18 +25,16 @@ public function name(): string
      */
     public function fields(): array
     {
-        $fields = collect($this->modelSchema->getFields());
-
-        $fields->each(function (Field $field, $name) use (&$fields) {
-            $fields->put($name, $this->registry->field($this->registry->boolean())->nullable());
+        $fields = $this->modelSchema->getSearchableFields()->map(function (Field $field) {
+            return $this->registry->field($this->registry->boolean())->nullable();
         });
 
-        foreach ($this->modelSchema->getRelationFields() as $relation => $field) {
-            if ($field instanceof EloquentType) {
-                $fields[$relation] = $this->registry->field($field->getName().'Search')->nullable();
-            }
-        }
+        $relations = $this->modelSchema->getSearchableRelationFields()->map(function (EloquentField $field) {
+            $searchTypeName = $field->getName().'Search';
+
+            return $this->registry->field($searchTypeName)->nullable();
+        });
 
-        return $fields->toArray();
+        return $fields->merge($relations)->toArray();
     }
 }

tests/Stubs/Schemas/ArticleSchema.php

@@ -14,16 +14,16 @@ public function fields(): array
     {
         return [
             'slug' => Field::string()->unique(),
-            'title' => Field::string(),
-            'content' => Field::string(),
+            'title' => Field::string()->searchable(),
+            'content' => Field::string()->searchable(),
             'created_at' => Field::type('Timestamp')->fillable(false),
         ];
     }
 
     public function relations(): array
     {
         return [
-            'user' => Field::model(UserSchema::class)->nullable(),
+            'user' => Field::model(UserSchema::class)->nullable()->searchable(),
             'tags' => Field::collection(TagSchema::class)->nullable(),
             'category' => Field::model(CategorySchema::class)->nullable(),
             'comments' => Field::collection(CommentSchema::class),

tests/Stubs/Schemas/UserSchema.php

@@ -14,8 +14,8 @@ class UserSchema extends ModelSchema
     public function fields(): array
     {
         return [
-            'name' => Field::string(),
-            'email' => Field::string()->unique(),
+            'name' => Field::string()->searchable(),
+            'email' => Field::string()->unique()->searchable(),
             'type' => Field::string()->canStoreWhen('setType'),
             'password' => Field::string()->canSeeWhen('readPassword'),
             'secret_information' => Field::string()

tests/Types/CollectionSearchTypeTest.php

@@ -0,0 +1,42 @@
+<?php
+
+namespace Bakery\Tests\Types;
+
+use Bakery\Tests\TestCase;
+use Bakery\Types\CollectionSearchType;
+use Bakery\Tests\Stubs\Schemas\ArticleSchema;
+use Bakery\Tests\Fixtures\IntegrationTestSchema;
+
+class CollectionSearchTypeTest extends TestCase
+{
+    /** @test */
+    public function it_generates_search_fields_for_string_scalar_fields()
+    {
+        $schema = new IntegrationTestSchema();
+        $schema->toGraphQLSchema();
+        $type = new CollectionSearchType($schema->getRegistry(), new ArticleSchema($schema->getRegistry()));
+
+        $actual = $type->resolveFields();
+        $this->assertArrayHasKey('title', $actual);
+        $this->assertArrayHasKey('content', $actual);
+
+        $this->assertArrayNotHasKey('slug', $actual);
+        $this->assertArrayNotHasKey('created_at', $actual);
+    }
+
+    /** @test */
+    public function it_generates_search_fields_for_relation_fields()
+    {
+        $schema = new IntegrationTestSchema();
+        $schema->toGraphQLSchema();
+        $type = new CollectionSearchType($schema->getRegistry(), new ArticleSchema($schema->getRegistry()));
+
+        $actual = $type->resolveFields();
+        $this->assertArrayHasKey('user', $actual);
+
+        $this->assertArrayNotHasKey('tags', $actual);
+        $this->assertArrayNotHasKey('category', $actual);
+        $this->assertArrayNotHasKey('comments', $actual);
+        $this->assertArrayNotHasKey('upvotes', $actual);
+    }
+}