wip POC autocomplete endpoint / closure

Author: antoine

src/Form/Fields/SharpFormAutocompleteRemoteField.php

@@ -2,10 +2,13 @@
 
 namespace Code16\Sharp\Form\Fields;
 
+use Closure;
 use Code16\Sharp\Form\Fields\Formatters\AutocompleteFormatter;
 use Code16\Sharp\Form\Fields\Utils\IsSharpFormAutocompleteField;
 use Code16\Sharp\Form\Fields\Utils\SharpFormAutocompleteCommonField;
 use Code16\Sharp\Utils\Fields\IsSharpFieldWithLocalization;
+use Illuminate\Contracts\View\View;
+use Illuminate\Support\Facades\Blade;
 
 class SharpFormAutocompleteRemoteField
     extends SharpFormField
@@ -19,6 +22,8 @@ class SharpFormAutocompleteRemoteField
     protected int $searchMinChars = 1;
     protected string $dataWrapper = '';
     protected int $debounceDelay = 300;
+    protected ?Closure $queryResultsCallback = null;
+    protected View|string $template;
 
     public static function make(string $key): self
     {
@@ -27,6 +32,29 @@ public static function make(string $key): self
 
         return $instance;
     }
+    
+    public function queryResultsUsing(Closure $closure): self
+    {
+        $this->queryResultsCallback = $closure;
+
+        return $this;
+    }
+    
+    public function setTemplate(View|string $template): self
+    {
+        $this->template = $template;
+        
+        return $this;
+    }
+    
+    public function render(array $data): string
+    {
+        if (is_string($this->template)) {
+            return Blade::render($this->template, $data);
+        }
+        
+        return $this->template->with($data)->render();
+    }
 
     public function setRemoteEndpoint(string $remoteEndpoint): self
     {
@@ -96,6 +124,31 @@ public function setDataWrapper(string $dataWrapper): self
 
         return $this;
     }
+    
+    public function dataWrapper(): string
+    {
+        return $this->dataWrapper;
+    }
+    
+    public function remoteEndpoint(): string
+    {
+        return $this->remoteEndpoint;
+    }
+    
+    public function remoteMethod(): string
+    {
+        return $this->remoteMethod;
+    }
+    
+    public function remoteSearchAttribute(): string
+    {
+        return $this->remoteSearchAttribute;
+    }
+    
+    public function getQueryResultsCallback(): ?Closure
+    {
+        return $this->queryResultsCallback;
+    }
 
     protected function validationRules(): array
     {

src/Http/Controllers/Api/ApiAutocompleteController.php

@@ -0,0 +1,80 @@
+<?php
+
+namespace Code16\Sharp\Http\Controllers\Api;
+
+use Code16\Sharp\Form\Fields\SharpFormAutocompleteRemoteField;
+use Illuminate\Contracts\Http\Kernel;
+use Illuminate\Http\Client\Response;
+use Illuminate\Http\Request;
+use Illuminate\Support\Arr;
+use Illuminate\Support\Facades\Http;
+use Illuminate\Validation\ValidationException;
+
+class ApiAutocompleteController extends ApiController
+{
+    public function index(string $entityKey, string $autocompleteFieldKey)
+    {
+        $entity = $this->entityManager->entityFor($entityKey);
+        
+        sharp_check_ability(
+            'view',
+            $entityKey,
+        );
+        
+        $form = $entity->getFormOrFail(sharp_normalize_entity_key($entityKey)[1]);
+        
+        $field = $form->findFieldByKey($autocompleteFieldKey);
+        
+        if(!$field instanceof SharpFormAutocompleteRemoteField) {
+            throw ValidationException::withMessages([
+                'autocompleteFieldKey' => 'Unknown remote autocomplete field : '.$autocompleteFieldKey,
+            ]);
+        }
+        
+        request()->validate([
+            'endpoint' => ['nullable', 'starts_with:'.str($field->remoteEndpoint())->before('{{')],
+            'search' => ['required', 'string'],
+        ]);
+        
+        if($callback = $field->getQueryResultsCallback()) {
+            $data = $callback(request()->input('search'));
+        } else {
+            if(str($field->remoteEndpoint())->startsWith('/')) {
+                $response = app()->handle(
+                    tap(Request::create(
+                        uri: url($field->remoteEndpoint()),
+                        method: $field->remoteMethod(),
+                        parameters: [
+                            $field->remoteSearchAttribute() => request()->input('search'),
+                        ],
+                        cookies: request()->cookies->all(),
+                    ), function(Request $request) use($field) {
+                        $request->headers->set('Accept', 'application/json');
+                    })
+                );
+                
+                $data = json_decode($response->getContent());
+            } else {
+                $pendingRequest = Http::createPendingRequest()
+                    ->acceptJson()
+                    ->throw()
+                    ->withQueryParameters([
+                        $field->remoteSearchAttribute() => request()->input('search'),
+                    ]);
+                if($field->remoteMethod() === 'POST') {
+                    $apiResponse = $pendingRequest->post(request()->input('endpoint'));
+                } else {
+                    $apiResponse = $pendingRequest->get(request()->input('endpoint'));
+                }
+                $data = $apiResponse->json();
+            }
+        }
+
+        return response()->json([
+            'data' => collect(Arr::get($data, $field->dataWrapper() ?: null))->map(fn ($item) => [
+                ...$item,
+                '_html' => $field->render($item),
+            ]),
+        ]);
+    }
+}