wip

Author: iamgergo

resources/views/fields/relation-option.blade.php

@@ -1,6 +1,6 @@
 <div class="file-list-item">
     <div class="file-list-item__column">
-        <span id="{{ $attrs->get('id') }}" class="file-list-item__name">{!! $label !!}</span>
+        <span id="{{ $attrs->get('id') }}">{!! $label !!}</span>
         <input type="hidden" name="{{ $attrs->get('name') }}" value="{{ $attrs->get('value') }}">
     </div>
     @unless($attrs->get('readonly') || $attrs->get('disabled'))

resources/views/fields/relation.blade.php

@@ -56,7 +56,7 @@ class="btn btn--primary btn--lg btn--block"
                 <template x-for="(item, index) in items" :key="item.value">
                     <li class="file-list-item">
                         <div class="file-list-item__column">
-                            <span class="file-list-item__name" x-html="item.label"></span>
+                            <span x-html="item.label"></span>
                         </div>
                         <div class="file-list-item__actions">
                             <div class="form-group form-group--vertical-check">

src/Fields/MorphTo.php

@@ -4,6 +4,9 @@
 
 namespace Cone\Root\Fields;
 
+use Closure;
+use Cone\Root\Fields\Select as SelectField;
+use Cone\Root\Filters\Select;
 use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Eloquent\Relations\MorphTo as EloquentRelation;
@@ -20,6 +23,11 @@ class MorphTo extends BelongsTo
      */
     protected string $template = 'root::fields.relation';
 
+    /**
+     * Indicates whether the field is async.
+     */
+    protected bool $async = true;
+
     /**
      * The morph types.
      */
@@ -36,24 +44,61 @@ public function getRelation(Model $model): EloquentRelation
     /**
      * {@inheritdoc}
      */
-    public function filters(Request $request): array
+    public function async(bool $value = true): static
     {
-        $filters = parent::filters($request);
+        return $this;
+    }
+
+    /**
+     * Get the morph types.
+     */
+    public function getTypes(): array
+    {
+        return $this->types;
+    }
 
-        if ($this->isAsync()) {
-            $typeFilter = Select::make(__('Type'), 'type')
-                ->options(array_map(
+    /**
+     * {@inheritdoc}
+     */
+    public function filters(Request $request): array
+    {
+        $typeFilter = new class($this) extends Select
+        {
+            public function __construct(protected MorphTo $field)
+            {
+                parent::__construct('type');
+            }
+
+            public function getName(): string
+            {
+                return __('Type');
+            }
+
+            public function apply(Request $request, Builder $query, mixed $value): Builder
+            {
+                return $query;
+            }
+
+            public function options(Request $request): array
+            {
+                return array_map(
                     static function (string $type): string {
                         return __(Str::of($type)->classBasename()->headline()->value());
                     },
-                    array_combine($this->types, $this->types)
-                ))
-                ->toFilter();
-
-            array_unshift($filters, $typeFilter);
-        }
+                    array_combine($this->field->getTypes(), $this->field->getTypes())
+                );
+            }
+
+            public function toField(): SelectField
+            {
+                return parent::toField()
+                    ->value(function (Request $request, Model $model): ?string {
+                        return $model->getAttribute($this->field->getRelation($model)->getMorphType());
+                    });
+            }
+        };
 
-        return $filters;
+        return array_merge([$typeFilter], parent::filters($request));
     }
 
     /**
@@ -73,6 +118,59 @@ public function resolveRelatableQuery(Request $request, Model $model): Builder
         return parent::resolveRelatableQuery($request, $model);
     }
 
+    /**
+     * Map the async searchable fields.
+     */
+    protected function mapAsyncSearchableFields(Request $request): Fields
+    {
+        $fields = new Fields;
+
+        foreach ($this->getSearchableColumns() as $type => $columns) {
+            foreach ($columns as $column) {
+                $field = Hidden::make($this->getRelationName(), sprintf('%s:%s', $type, $column))
+                    ->searchable(callback: function (Request $request, Builder $query, mixed $value, string $attribute): Builder {
+                        [$type, $column] = explode(':', $attribute);
+
+                        return match ($query->getModel()::class) {
+                            $type => $query->where($query->qualifyColumn($column), 'like', "%{$value}%", 'or'),
+                            default => $query,
+                        };
+                    });
+
+                $fields->push($field);
+            }
+        }
+
+        return $fields;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function searchable(bool|Closure $value = true, ?Closure $callback = null, array $columns = ['id']): static
+    {
+        $columns = match (true) {
+            array_is_list($columns) => array_fill_keys($this->types, $columns),
+            default => $columns,
+        };
+
+        return parent::searchable($value, $callback, $columns);
+    }
+
+    /**
+     * Resolve the filter query.
+     */
+    public function resolveSearchQuery(Request $request, Builder $query, mixed $value): Builder
+    {
+        if (! $this->isSearchable()) {
+            return parent::resolveSearchQuery($request, $query, $value);
+        }
+
+        return call_user_func_array($this->searchQueryResolver, [
+            $request, $query, $value, $this->getSearchableColumns(),
+        ]);
+    }
+
     /**
      * {@inheritdoc}
      */
@@ -95,7 +193,10 @@ public function resolveHydrate(Request $request, Model $model, mixed $value): vo
      */
     public function newOption(Model $related, string $label): Option
     {
-        return new Option(sprintf('%s:%s', $related::class, $related->getKey()), $label);
+        return new Option(
+            sprintf('%s:%s', $related::class, $related->getKey()),
+            sprintf('%s (%s)', $label, __(Str::of($related::class)->classBasename()->headline()->value()))
+        );
     }
 
     /**

src/Fields/Relation.php

@@ -94,7 +94,7 @@ abstract class Relation extends Field implements Form
     /**
      * Indicates whether the field is async.
      */
-    protected ?bool $async = false;
+    protected bool $async = false;
 
     /**
      * Determine if the field is computed.
@@ -492,10 +492,7 @@ public function filters(Request $request): array
         $fields = $this->resolveFields($request)->authorized($request);
 
         $searchables = match (true) {
-            $this->isAsync() => new Fields(array_map(
-                fn (string $column): Hidden => Hidden::make($this->getRelationName(), $column)->searchable(),
-                $this->getSearchableColumns()
-            )),
+            $this->isAsync() => $this->mapAsyncSearchableFields($request),
             default => $fields->searchable(),
         };
 
@@ -510,6 +507,17 @@ public function filters(Request $request): array
         ]));
     }
 
+    /**
+     * Map the async searchable fields.
+     */
+    protected function mapAsyncSearchableFields(Request $request): Fields
+    {
+        return new Fields(array_map(
+            fn (string $column): Hidden => Hidden::make($this->getRelationName(), $column)->searchable(),
+            $this->getSearchableColumns()
+        ));
+    }
+
     /**
      * Handle the callback for the field resolution.
      */