wip

Author: binaryk

docs/docs/3.0/repository-pattern/field.md

@@ -1,12 +1,10 @@
 # Field
 
-Field is basically the model attribute representation. Each Field generally extend the Field class from the Restify. 
-This class ships a variety of mutators, interceptors, validators chaining methods you can use for defining your attribute
-according with your needed.
+Field is basically the model attribute representation. Each Field generally extends the `Binaryk\LaravelRestify\Fields\Field` class from the Laravel Restify. 
+This class ships a variety of mutators, interceptors, validators chaining methods you can use for defining your attribute.
 
 To add a field to a repository, we can simply add it to the repository's fields method. 
-Typically, fields may be created using their static make method. This method accepts the underlying database column as 
-argument: 
+Typically, fields may be created using their static `new` or `make` method. These methods accept the underlying database column as argument: 
 
 ```php
 
@@ -21,10 +19,10 @@ use Binaryk\LaravelRestify\Http\Requests\RestifyRequest;
 public function fields(RestifyRequest $request)
 {
     return [
-        Field::make('email')->rules('required')->storingRules('unique:users')->messages([
+        Field::new('email')->rules('required')->storingRules('unique:users')->messages([
             'required' => 'This field is required.',
         ]),
-        Field::make('password')->storeCallback(function ($value) {
+        Field::new('password')->storeCallback(function ($value) {
                 return Hash::make($value);
             })->rules('required')->storingRules('confirmed'),
     ];
@@ -33,31 +31,31 @@ public function fields(RestifyRequest $request)
 
 # Validation
 
-There is a gold rule saying - catch the exception as soon as possible on it's request way. 
+There is a gold rule saying - catch the exception as soon as possible on its request way. 
 Validations are the first bridge of your request information, it would be a good start to validate 
-your input so you don't have to worry about payload anymore.
+your input. So you don't have to worry about the payload anymore.
 
 ## Attaching rules
 
-Validation rules could be add by chaining the `rules` method to attach [validation rules](https://laravel.com/docs/validation#available-validation-rules)
+Validation rules could be adding by chaining the `rules` method to attach [validation rules](https://laravel.com/docs/validation#available-validation-rules)
 to the field: 
 
 ```php
-Field::make('email')->rules('required'),
+Field::new('email')->rules('required'),
 ```
 
 Of course, if you are leveraging Laravel's support for [validation rule objects](https://laravel.com/docs/validation#using-rule-objects), 
 you may attach those to resources as well:
 
 ```php
-Field::make('email')->rules('required', new CustomRule),
+Field::new('email')->rules('required', new CustomRule),
 ```
 
 Additionally, you may use [custom Closure rules](https://laravel.com/docs/validation#using-closures) 
 to validate your resource fields:
 
 ```php
-Field::make('email')->rules('required', function($attribute, $value, $fail) {
+Field::new('email')->rules('required', function($attribute, $value, $fail) {
     if (strtolower($value) !== $value) {
         return $fail('The '.$attribute.' field must be lowercase.');
     }
@@ -69,7 +67,7 @@ Field::make('email')->rules('required', function($attribute, $value, $fail) {
 If you would like to define rules that only apply when a resource is being storing, you may use the `storingRules` method:
 
 ```php
-Field::make('email')
+Field::new('email')
     ->rules('required', 'email', 'max:255')
     ->storingRules('unique:users,email');
 ```
@@ -79,24 +77,24 @@ Field::make('email')
 Likewise, if you would like to define rules that only apply when a resource is being updated, you may use the `updatingRules` method.
 
 ```php
-Field::make('email')->updatingRules('required', 'email');
+Field::new('email')->updatingRules('required', 'email');
 ```
 
 
 # Interceptors
-However the default storing process is done automatically, sometimes you may want to take the control over it. 
+However, the default storing process is automatically, sometimes you may want to take the control over it. 
 That's a breeze with Restify, since Field expose few useful chained helpers for that.
 
 ## Fill callback
 
 There are two steps before the value from the request is attached to model attribute. 
 Firstly it is get from the application request, and go to the `fillCallback` and secondly, 
-the value is transforming by the `storeCallback`. 
+the value is transforming by the `storeCallback` or `updateCallback`:
 
 You may intercept each of those with closures.
 
 ```php
-Field::make('title')
+Field::new('title')
     ->fillCallback(function (RestifyRequest $request, $model, $attribute) {
         $model->{$attribute} = strtoupper($request->get('title_from_the_request'));
 })
@@ -112,7 +110,52 @@ Another handy interceptor is the `storeCallback`, this is the step immediately b
 This interceptor may be useful for modifying the value passed through the `$request`.
 
 ```php
-Field::make('password')->storeCallback(function ($value) {
-        return Hash::make($value);
+Field::new('password')->storeCallback(function ($value) {
+        return Hash::new($value);
     });
 ```
+
+## Update callback
+
+```php
+Field::new('password')->updateCallback(function ($value) {
+        return Hash::new($value);
+    });
+```
+## Index Callback
+
+Sometimes you may want to transform some attribute from the database right before it is returned to the frontend.
+
+Transform the value for the index request:
+
+```php
+Field::new('password')->indexCallback(function ($value) {
+    return Hash::new($value);
+});
+```
+## Show callback
+
+Transform the value for the show request:
+
+```php
+Field::new('password')->showRequest(function ($value) {
+    return Hash::new($value);
+});
+```
+
+## Append Callback
+
+Very often there is necessary to store a field as `auth()->user()->id`. This field could not be passed from the 
+frontend:
+
+```php
+Field::new('user_id')->hidden()->append(auth()->user()->id);
+```
+
+or using a closure:
+
+```php
+Field::new('user_id')->hidden()->append(function(RestifyRequest $request, $model, $attribute) {
+    return auth()->user()->id;    
+});
+```

src/Repositories/Repository.php

@@ -535,7 +535,7 @@ public function index(RestifyRequest $request)
         })->values()->map(fn (self $repository) => $repository->serializeForIndex($request));
 
         return $this->response([
-            'meta' => $this->resolveIndexMainMeta($request) ?? RepositoryCollection::meta($paginator->toArray()),
+            'meta' => $this->resolveIndexMainMeta($request, $items) ?? RepositoryCollection::meta($paginator->toArray()),
             'links' => RepositoryCollection::paginationLinks($paginator->toArray()),
             'data' => $items,
         ]);
@@ -545,7 +545,7 @@ public function indexPaginator(RestifyRequest $request)
     {
     }
 
-    public function resolveIndexMainMeta(RestifyRequest $request)
+    public function resolveIndexMainMeta(RestifyRequest $request, Collection $items)
     {
         //
     }