v13 docs

docs/architecture-concepts/container.md

@@ -26,10 +26,10 @@ In summary, a Container represents a cohesive set of related functionalities.
 It can be a specific feature or a wrapper around a RESTful API resource.
 
 To generate new containers along with all their [components](components.md),
-you may use the `apiato:generate:container` interactive command:
+you may use the `apiato:make:container` interactive command:
 
 ```
-php artisan apiato:generate:container
+php artisan apiato:make:container
 ```
 
 ## Composer Dependencies
@@ -48,8 +48,8 @@ The choice of location depends on what is most relevant and convenient for your
 
 Each Container has the option to include a `readme.md` file at its root, which serves to explain the Container's purpose and how to use it.
 
-To generate new readme files, you may use the `apiato:generate:readme` interactive command:
+To generate new readme files, you may use the `apiato:make:readme` interactive command:
 
 ```
-php artisan apiato:generate:readme
+php artisan apiato:make:readme
 ```

docs/components/main-components/actions.md

@@ -12,10 +12,10 @@ tags:
 Actions serve as the embodiment of the application's Use Cases,
 encapsulating the various operations that users or software can execute within the application.
 
-To generate new actions you may use the `apiato:generate:action` interactive command:
+To generate new actions you may use the `apiato:make:action` interactive command:
 
 ```shell
-php artisan apiato:generate:action
+php artisan apiato:make:action
 ```
 
 Additionally, to retrieve a list of the existing actions in your Apiato application,

docs/components/main-components/controllers.md

@@ -16,10 +16,10 @@ tags:
 serving the requested data and constructing the corresponding response.
 
 To generate new controllers
-you may use the `apiato:generate:controller` interactive command:
+you may use the `apiato:make:controller` interactive command:
 
 ```
-php artisan apiato:generate:controller
+php artisan apiato:make:controller
 ```
 
 ## Definition & Principles
@@ -37,7 +37,6 @@ Read [**Porto SAP Documentation (#Controllers)**](https://github.com/Mahmoudz/Po
   - MUST extend the `App\Ship\Parents\Controllers\WebController` class.
 - Controllers:
   - MUST only call the `run` or `transactionalRun` method of Actions.
-  - SHOULD pass the Request object to the Action instead of passing data from the request.
 
 ## Folder Structure
 
@@ -96,113 +95,28 @@ class Controller extends WebController
 }
 ```
 
-:::tip
-In case you want to handle the same Action differently based on the UI type (e.g., API, Web, CLI), you can set the
-UI on Action with `setUI` method.
+## Response
 
-```php
-$action = app(Action::class);
-$action->setUI('web');
-```
+You can use the `Apiato\Support\Facades\Response` facade to create a new response object.
 
-and get the UI in your Action with `getUI` method.
+The `Response` class extends `Spatie\Fractal\Fractal` to enhance its functionality for API responses.
+It adds methods for resource key management, meta information, and standardized HTTP responses.
 
-```php
-$action->getUI(); // will return 'web'
-```
+:::info Further Reading
+For more detailed information,
+please refer to [Fractal](https://fractal.thephpleague.com/transformers/) and [Laravel Fractal Wrapper](https://github.com/spatie/laravel-fractal) documentations.
 :::
 
-## Response Helpers Methods
-
-### transform
-This method is incredibly useful and will be used in most cases.
+Here are some examples of how to use the `Response` facade:
 
-- The first required parameter accepts data as an object or a Collection of objects.
-- The second required parameter is the transformer class.
-- The third optional parameter allows you to specify the [includes](transformers.md#including-relationships) that should be returned in the response.
-- The fourth optional parameter lets you include metadata in the response. This metadata will be returned under the `meta` key in the `custom` key.
-
-```php
-// With Includes
-$this->transform($resource, ResourceTransformer::class, ['foo', 'bar']);
-```
 ```php
-// With Meta
-$this->transform($resource, ResourceTransformer::class, meta: ['foo' => 'bar', 'baz' => 1]);
+Response::create($user)->transformWith(UserTransformer::class)->json(null, 200);
 
-// Response
-{
-  "data": {},
-  "meta": {
-    "include": [...],
-    "custom": {
-      "foo": "bar",
-      "baz": 1
-    },
-    "pagination": {}
-  }
-}
-```
-### withMeta
-This method enables you to add metadata to the response,
-and it MUST be used in conjunction with the `transform` method.
-This is different from the `meta` parameter in the `transform` method.
-This metadata will be returned directly under the `meta` key.
-
-You can use this method in conjunction with the `meta` parameter in the `transform` method.
-
-```php
-$metaData = ['foo' => 999, 'bar'];
+Response::create()->transformWith(UserTransformer::class)->ok($user);
 
-$this->withMeta($metaData)->transform($sample, SampleTransformer::class, meta: ['foo' => 'bar', 'baz' => 1]);
+Response::create($user, UserTransformer::class)->created();
 
-// Response
-{
-  "data": {},
-	"meta": {
-	  "foo": 999,
-	  "0": "bar",
-	  "include": [...],
-	  "custom": {
-	    "foo": "bar",
-	    "baz": 1
-	  },
-	  "pagination": {}
-  }
-}
-```
+Response::create($user, UserTransformer::class)->parseIncludes(['permissions'])->toArray();
 
-### json
-This method allows you to pass an array of data that will be represented as JSON.
-```php
-$this->json($data)
-```
-
-### created
-This method allows you to return a response with a `201` status code.
-```php
-$this->created($data)
-```
-
-### deleted
-This method allows you to return a response with a `202` status code.
-```php
-$this->deleted($deletedModel)
-
-// Response
-{
-  "message": "Model (1) Deleted Successfully."
-}
-```
-
-### accepted
-This method allows you to return a response with a `202` status code.
-```php
-$this->accepted($data)
-```
-
-### noContent
-This method allows you to return a response with a `204` status code.
-```php
-$this->noContent()
+Response::ok();
 ```

docs/components/main-components/exceptions.md

@@ -9,10 +9,10 @@ tags:
 
 Exceptions are used to handle errors and exceptions in the application.
 
-To generate new exceptions you may use the `apiato:generate:exception` interactive command:
+To generate new exceptions, you may use the `apiato:make:exception` interactive command:
 
 ```
-php artisan apiato:generate:exception
+php artisan apiato:make:exception
 ```
 
 ## Definition & Principles
@@ -23,9 +23,10 @@ Read [**Porto SAP Documentation (#Exceptions)**](https://github.com/Mahmoudz/Por
 
 - All container-specific Exceptions MUST be placed in the `app/Containers/{Section}/{Container}/Exceptions` directory.
 - All general Exceptions MUST be placed in the `app/Ship/Exceptions` directory.
-- All Exceptions MUST extend the `App\Ship\Parents\Exceptions\Exception` class.
+- All application Exceptions MUST extend the `App\Ship\Parents\Exceptions\Exception` class.
   - The parent extension SHOULD be aliased as `ParentException`.
-- Every Exception MUST have at least two properties: `code` and `message`.
+- All Http Exceptions MUST extend the `App\Ship\Parents\Exceptions\HttpException` class.
+  - The parent extension SHOULD be aliased as `ParentHttpException`.
 
 ## Folder Structure
 
@@ -47,57 +48,4 @@ app
 
 ## Code Example
 
-You can override those values while throwing the error.
-
-```php
-use App\Ship\Parents\Exceptions\Exception as ParentException;
-
-class DemoException extends ParentException
-{
-    protected $code = Response::HTTP_CONFLICT;
-    protected $message = 'This is a demo exception.';
-}
-```
-
-## Helpers Methods
-
-### withErrors
-
-```php
-// Example 1
-throw (new AccountFailedException())->withErrors(['email' => 'The email has already been taken.']);
-// Example 2
-throw (new AccountFailedException())->withErrors(['email' => ['The email has already been taken.', 'Another message']]);
-```
-
-You can also use translation strings.
-Translation strings are automatically translated if the translations are found.
-To handle localization, you can use the [Localization Container](../../pacakges/localization.md).
-
-```php
-// Example 1
-throw (new AccountFailedException())->withErrors(['email' => 'appSection@user::exceptions.email-taken']);
-// Example 2
-throw (new AccountFailedException())->withErrors(['email' => 'appSection@user::exceptions.email-taken', 'Another not translated message']);
-```
-
-Response:
-```json
-{
-  "message": "The exception error message.",
-  "errors": {
-    "email": [
-      "The email has already been taken.",
-      "Another not translated message"
-    ]
-  }
-}
-```
-### debug
-
-The `debug` method is used for logging error messages during debugging and development.
-The `debug` method accepts `string` or `\Exception` instance
-
-```php
-throw (new AccountFailedException())->debug($e);
-```
+Exceptions are defined exactly as you would define them in Laravel.

docs/components/main-components/models.md

@@ -13,10 +13,10 @@ and providing an abstraction for interacting with that data.
 They encapsulate the business logic and rules associated with the data,
 as well as facilitate the communication with the underlying database.
 
-To generate new models you may use the `apiato:generate:model` interactive command:
+To generate new models you may use the `apiato:make:model` interactive command:
 
 ```
-php artisan apiato:generate:model
+php artisan apiato:make:model
 ```
 
 ## Definition & Principles
@@ -48,19 +48,20 @@ app
 
 Models are defined exactly as you would define them in Laravel.
 
-## Model Trait
+## Custom Models {#custom-models}
 
 If your model does not extend the `App\Ship\Parents\Models\Model` or the `App\Ship\Parents\Models\UserModel` class,
-it is essential to incorporate the `ModelTrait` trait into your model.
+it is essential to implement the `ResourceKeyAware` interface
+and use the `InteractsWithApiato` trait in your model.
 By doing so, your model will benefit from various functionalities provided by the trait,
 such as hash ids and other features necessary for proper integration with the framework.
 
 ```php
-use Apiato\Core\Traits\ModelTrait;
+use Apiato\Core\Models\InteractsWithApiato;
+use Apiato\Http\Resources\ResourceKeyAware;
 
-class Demo
+class Demo implements ResourceKeyAware
 {
-    use ModelTrait;
-    ...
+    use InteractsWithApiato;
 }
 ```