feat: adding fluent api for sortable

Author: binaryk

docs-v2/content/en/api/fields.md

@@ -251,6 +251,60 @@ $field = field('full_name', fn() => "$this->first_name $this->last_name");
 $isComputed = $field->computed(); // Returns: true
 ```
 
+## Sorting
+
+Fields can be made sortable, allowing API consumers to order results by field values.
+
+### Making Fields Sortable
+
+To make a field sortable, chain the `sortable()` method:
+
+```php
+public function fields(RestifyRequest $request)
+{
+    return [
+        field('name')->sortable(),
+        field('email')->sortable(),
+        field('created_at')->sortable(),
+        field('is_active')->sortable(),
+    ];
+}
+```
+
+### Sortable Column Configuration
+
+By default, the field's attribute name is used as the sortable column. You can specify a different column:
+
+```php
+field('full_name')->sortable('name'), // Use 'name' column for 'full_name' field
+```
+
+### Disabling Sorting
+
+You can disable sorting for a field that was previously made sortable:
+
+```php
+field('sensitive_data')->sortable(false),
+```
+
+### Conditional Sorting
+
+Make fields conditionally sortable based on request context:
+
+```php
+field('internal_score')->sortable(fn($request) => $request->user()->isAdmin()),
+```
+
+### Using Sortable Fields
+
+Once fields are marked as sortable, API consumers can use them in sort requests:
+
+```http
+GET /api/restify/users?sort=name
+GET /api/restify/users?sort=-created_at  # Descending
+GET /api/restify/users?sort=name,-created_at  # Multiple fields
+```
+
 ## Validation
 
 There is a golden rule that says - catch the exception as soon as possible on its request way.

docs-v2/content/en/index.md

@@ -30,46 +30,12 @@ This documentation is for the latest version of Laravel Restify. Please ensure y
 'Powerful Search',
 'JSON:API consistency',
 'GraphQL Schema Generation',
-'MCP (Model Context Protocol) Integration',
+'MCP (Model Context Protocol) Server Generation',
 'Customizable',
 'Laravel Compatible Authorization'
 ]">
 </list>
 
-## 🤖 AI-Powered Development with MCP
-
-Transform your existing Laravel Restify API into an **MCP-enabled powerhouse in minutes**! Laravel Restify's Model Context Protocol integration allows AI agents to interact directly with your API resources through structured tool interfaces.
-
-<alert type="success">
-
-**🔥 Transform Your API in Minutes!** Add one trait to your Repository class and register one route - that's it! Your entire API becomes AI-agent accessible with full security and authorization intact.
-
-</alert>
-
-**Quick Setup (2 steps):**
-
-1. **Add the trait to your Repository:**
-```php
-use Binaryk\LaravelRestify\MCP\Concerns\HasMcpTools;
-
-class PostRepository extends Repository
-{
-    use HasMcpTools; // ✨ This enables MCP for this resource
-}
-```
-
-2. **Register the MCP server in `routes/ai.php`:**
-```php
-use Laravel\Mcp\Facades\Mcp;
-use Binaryk\LaravelRestify\MCP\RestifyServer;
-
-Mcp::web('restify', RestifyServer::class)->middleware(['auth:sanctum']);
-```
-
-**That's it!** Your API is now AI-agent ready with automatic tool generation for CRUD operations, actions, and getters.
-
-[Learn more about MCP Integration →](/mcp)
-
 ## Accelerate Your Development
 
 Want to skip the boilerplate and launch faster? Our Restify Templates come with everything you need:

src/Commands/GenerateRepositoriesCommand.php

@@ -253,7 +253,7 @@ protected function analyzeModelFields(string $className): array
         return $fields;
     }
 
-    protected function mapColumnToRestifyField(string $column, string $columnType): string
+    protected function mapColumnToRestifyField(string $column, string $columnType): ?string
     {
         // Skip ID field as it's handled automatically
         if ($column === 'id') {
@@ -288,6 +288,7 @@ protected function mapColumnToRestifyField(string $column, string $columnType):
 
             case 'integer':
             case 'bigint':
+            case 'double':
             case 'smallint':
                 $field .= '->number()';
                 break;
@@ -308,7 +309,6 @@ protected function mapColumnToRestifyField(string $column, string $columnType):
 
             case 'decimal':
             case 'float':
-            case 'double':
                 $field .= '->number()';
                 break;
 

src/Commands/PolicyCommand.php

@@ -25,6 +25,8 @@ protected function buildClass($name)
 
         $class = $this->replaceQualifiedModel($class);
 
+        $class = $this->replaceUserImport($class);
+
         return $class;
     }
 
@@ -45,6 +47,21 @@ protected function replaceQualifiedModel($stub)
         return str_replace('{{ modelQualified }}', $this->guessQualifiedModel(), $stub);
     }
 
+    protected function replaceUserImport($stub)
+    {
+        $qualifiedModel = $this->guessQualifiedModel();
+        $userQualified = $this->rootNamespace().'Models\User';
+
+        // If the model being generated is the User model, don't duplicate the import
+        if ($qualifiedModel === $userQualified) {
+            // Remove the entire user import line since it would be duplicate
+            $stub = preg_replace('/use\s+\{\{\s*userQualified\s*\}\};\s*\n/', '', $stub);
+            return $stub;
+        }
+
+        return str_replace('{{ userQualified }}', $userQualified, $stub);
+    }
+
     protected function guessQualifiedModel(): string
     {
         $model = Str::singular(class_basename(Str::beforeLast($this->getNameInput(), 'Policy')));

src/Commands/RepositoryCommand.php

@@ -42,6 +42,9 @@ public function handle()
 
                 return false;
             }
+            
+            // Set force option to true since user confirmed override
+            $this->input->setOption('force', true);
         }
 
         if (parent::handle() === false && ! $this->option('force')) {
@@ -100,7 +103,8 @@ protected function buildClass($name)
         $stub = parent::buildClass($name);
 
         // Replace DummyRootNamespace placeholder
-        $stub = str_replace('DummyRootNamespace', $this->rootNamespace(), $stub);
+        $rootNamespace = rtrim($this->rootNamespace(), '\\');
+        $stub = str_replace('DummyRootNamespace', $rootNamespace, $stub);
 
         $stub = $this->replaceModel($stub, $this->guessBaseModelClass());
 
@@ -115,6 +119,9 @@ protected function buildClass($name)
             $stub = str_replace('{{ relationshipImports }}', '', $stub);
         }
 
+        // Clean up any double backslashes in the final stub
+        $stub = str_replace('\\\\', '\\', $stub);
+
         return $stub;
     }
 
@@ -142,7 +149,7 @@ protected function guessQualifiedModelName()
         }
 
         $model = Str::singular(class_basename(Str::before($this->getNameInput(), 'Repository')));
-        $defaultModelClass = str_replace('/', '\\', $this->rootNamespace().'/Models//'.$model);
+        $defaultModelClass = str_replace('/', '\\', $this->rootNamespace().'/Models/'.$model);
 
         // If default model exists, use it
         if (class_exists($defaultModelClass)) {
@@ -251,12 +258,22 @@ protected function getPath($name)
         if ($existingRepositoryPath && $existingRepositoryPath['pattern']) {
             // Apply the discovered pattern
             $modelBaseName = Str::before(class_basename($name), 'Repository');
-            $namespacedName = $existingRepositoryPath['namespace'].'\\'.$this->applyPathPattern(
-                $modelBaseName,
-                $existingRepositoryPath['pattern']
-            ).'\\'.$name;
-
-            return $this->laravel['path'].'/'.str_replace('\\', '/', str_replace($this->rootNamespace().'\\', '', $namespacedName)).'.php';
+            $patternPath = $this->applyPathPattern($modelBaseName, $existingRepositoryPath['pattern']);
+            
+            // Build the namespace path, avoiding duplication
+            $namespaceParts = [];
+            $baseNamespace = str_replace($this->rootNamespace().'\\', '', $existingRepositoryPath['namespace']);
+            if ($baseNamespace) {
+                $namespaceParts[] = $baseNamespace;
+            }
+            
+            if ($patternPath && !empty($patternPath)) {
+                $namespaceParts[] = str_replace('\\', '/', $patternPath);
+            }
+            
+            $namespaceParts[] = class_basename($name);
+            
+            return $this->laravel['path'].'/'.implode('/', $namespaceParts).'.php';
         }
 
         return parent::getPath($name);
@@ -268,11 +285,27 @@ protected function getDefaultNamespace($rootNamespace)
         $existingRepositoryPath = $this->findExistingRepositoryPath();
 
         if ($existingRepositoryPath) {
-            return $existingRepositoryPath['namespace'];
+            $namespace = $existingRepositoryPath['namespace'];
+            
+            // Apply pattern for the current model if needed
+            if ($existingRepositoryPath['pattern'] && $existingRepositoryPath['pattern'] !== 'flat') {
+                $modelBaseName = Str::before(class_basename($this->getNameInput()), 'Repository');
+                $patternPath = $this->applyPathPattern($modelBaseName, $existingRepositoryPath['pattern']);
+                
+                if ($patternPath && !empty($patternPath)) {
+                    // Only add pattern path if it doesn't already exist in namespace
+                    $patternPathNormalized = str_replace('/', '\\', $patternPath);
+                    if (!Str::endsWith($namespace, $patternPathNormalized)) {
+                        $namespace .= '\\' . $patternPathNormalized;
+                    }
+                }
+            }
+            
+            return $namespace;
         }
 
         // Fallback to default
-        return $rootNamespace.'\Restify';
+        return rtrim($rootNamespace, '\\').'\\Restify';
     }
 
     protected function replaceFields($stub)

src/Commands/SetupCommand.php

@@ -38,12 +38,11 @@ public function handle()
         $this->registerRestifyServiceProvider();
 
         $this->comment('Generating User Repository...');
-        $this->callSilent('restify:repository', ['name' => 'User']);
-        copy(__DIR__.'/stubs/user-repository.stub', app_path('Restify/UserRepository.php'));
+        $this->call(RepositoryCommand::class, ['name' => 'UserRepository']);
 
         if (! file_exists(app_path('Policies/UserPolicy.php'))) {
             app(Filesystem::class)->ensureDirectoryExists(app_path('Policies'));
-            copy(__DIR__.'/stubs/user-policy.stub', app_path('Policies/UserPolicy.php'));
+            $this->call(PolicyCommand::class, ['name' => 'UserPolicy']);
         }
 
         $this->setAppNamespace();

src/Commands/stubs/policy.stub

@@ -2,7 +2,7 @@
 
 namespace DummyNamespace;
 
-use App\Models\User;
+use {{ userQualified }};
 use Illuminate\Auth\Access\HandlesAuthorization;
 use {{ modelQualified }};
 

src/Eager/RelatedCollection.php

@@ -59,16 +59,16 @@ public function forBelongsToRelations(RestifyRequest $request): self
         })->filter(fn (EagerField $field) => $field->authorize($request));
     }
 
-    public function mapIntoSortable(): self
+    public function mapIntoSortable(RestifyRequest $request): self
     {
         return $this
             ->filter(fn ($key) => $key instanceof Sortable)
-            ->filter(fn (Sortable $field) => $field->isSortable())
-            ->map(function (Sortable $field) {
+            ->filter(fn (Sortable $field) => $field->isSortable($request))
+            ->map(function (Sortable $field) use ($request) {
                 $filter = SortableFilter::make();
 
                 if ($field instanceof BelongsTo || $field instanceof HasOne) {
-                    return $filter->usingRelation($field)->setColumn($field->qualifySortable());
+                    return $filter->usingRelation($field)->setColumn($field->qualifySortable($request));
                 }
 
                 return null;

src/Fields/BelongsTo.php

@@ -3,7 +3,6 @@
 namespace Binaryk\LaravelRestify\Fields;
 
 use Binaryk\LaravelRestify\Fields\Concerns\Attachable;
-use Binaryk\LaravelRestify\Fields\Concerns\CanSort;
 use Binaryk\LaravelRestify\Fields\Contracts\Sortable;
 use Binaryk\LaravelRestify\Http\Requests\RestifyRequest;
 use Illuminate\Database\Eloquent\Model;
@@ -12,7 +11,6 @@
 class BelongsTo extends EagerField implements Sortable
 {
     use Attachable;
-    use CanSort;
 
     public ?array $searchablesAttributes = null;
 

src/Fields/Concerns/CanSort.php

@@ -2,40 +2,46 @@
 
 namespace Binaryk\LaravelRestify\Fields\Concerns;
 
-use Illuminate\Support\Str;
+use Binaryk\LaravelRestify\Http\Requests\RestifyRequest;
 
 trait CanSort
 {
-    protected ?string $sortableColumn = null;
+    protected mixed $sortableColumn = null;
 
-    public function sortable(string $column): self
+    public function sortable(mixed $column = null): self
     {
-        $this->sortableColumn = $column;
+        if ($column === false) {
+            $this->sortableColumn = null;
 
-        return $this;
-    }
+            return $this;
+        }
 
-    public function isSortable(): bool
-    {
-        return ! is_null($this->sortableColumn);
-    }
+        if (is_callable($column)) {
+            $this->sortableColumn = $column;
 
-    public function qualifySortable(): ?string
-    {
-        if (! $this->isSortable()) {
-            return null;
+            return $this;
         }
 
-        if (Str::contains($this->sortableColumn, '.attributes')) {
-            return $this->sortableColumn;
-        }
+        $this->sortableColumn = is_string($column)
+            ? $column
+            : $this->getAttribute();
 
-        $table = $this->repositoryClass::newModel()->getTable();
+        return $this;
+    }
+
+    public function isSortable(RestifyRequest $request = null): bool
+    {
+        if (is_callable($this->sortableColumn)) {
+            $request = $request ?: app(RestifyRequest::class);
 
-        if (Str::contains($this->sortableColumn, '.') && Str::startsWith($this->sortableColumn, $table)) {
-            return $table.'.attributes.'.Str::after($this->sortableColumn, "$table.");
+            return (bool) call_user_func($this->sortableColumn, $request, $this);
         }
 
-        return $table.'.attributes.'.$this->sortableColumn;
+        return is_string($this->sortableColumn);
+    }
+
+    public function qualifySortable(RestifyRequest $request): ?string
+    {
+        return $this->sortableColumn;
     }
 }