Dingo API

https://github.com/api-ecosystem-for-laravel/dingo-api
Admin
Dingo API is a RESTful API package designed to help developers easily and quickly build APIs for the...
Tokens:22,418
Snippets:262
Trust Score:6.1
License:BSD-3-Clause
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install dependencies and run tests

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/blob/master/CONTRIBUTING.md

Install dependencies with Composer, then run the PHPUnit test suite. Requires Composer to be installed beforehand.

```bash
$ composer install
```

```bash
$ vendor/bin/phpunit
```

--------------------------------

### Define an action with @Get annotation

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/API-Blueprint-Documentation

Each action must be annotated with an HTTP verb annotation like `@Get`. The first parameter is the URI. This example defines a GET action for the root path.

```php
/**
 * Show all users
 *
 * Get a JSON representation of all the registered users.
 *
 * @Get("/")
 */
public function index()
{

}
```

--------------------------------

### Describe an action with PHPDoc

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/API-Blueprint-Documentation

Use short and long descriptions in the PHPDoc to describe an action (controller method). This example shows a method that returns all users.

```php
/**
 * Show all users
 *
 * Get a JSON representation of all the registered users.
 */
public function index()
{

}
```

--------------------------------

### Create GET Endpoint

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Creating-API-Endpoints

Creates a GET endpoint for a version group. The controller must be specified with its full namespace.

```php
$api->version('v1', function ($api) {
    $api->get('users/{id}', 'App\Api\Controllers\UserController@show');
});
```

--------------------------------

### Define a resource with base URI

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/API-Blueprint-Documentation

Add a `uri` parameter to the `@Resource` annotation to specify a base URI for the resource. This example sets the base URI to '/users'.

```php
/**
 * @Resource("Users", uri="/users")
 */
class UserController extends Controller
{

}
```

--------------------------------

### Example JSON error response

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Errors-And-Error-Responses

Shows the JSON representation returned when authentication fails after registering the custom exception handler.

```json
{
    "error": "Hey, what do you think you are doing!?"
}
```

--------------------------------

### Specify API versions with @Versions

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/API-Blueprint-Documentation

Use the `@Versions` annotation to specify which API versions an action responds to. This example restricts the action to version 'v1'.

```php
/**
 * Show all users
 *
 * Get a JSON representation of all the registered users.
 *
 * @Get("/")
 * @Versions({"v1"})
 */
public function index()
{

}
```

--------------------------------

### cURL request with Accept header

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Making-Requests-To-Your-API

Example cURL command to make a request to the API with the Accept header. Replace YOUR_SUBTYPE and the URL as needed. In strict mode, an invalid Accept header throws an unhandled BadRequestHttpException.

```bash
$ curl -v -H "Accept: application/vnd.YOUR_SUBTYPE.v1+json" http://example.app/users
```

--------------------------------

### Define a resource with @Resource annotation

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/API-Blueprint-Documentation

Use the `@Resource` annotation to define a resource. The first parameter is the resource identifier (name). This example defines a 'Users' resource without a base URI.

```php
/**
 * @Resource("Users")
 */
class UserController extends Controller
{

}
```

--------------------------------

### Make Internal GET Request

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Internal-Requests

Use the dispatcher to perform a GET request to an internal API endpoint.

```php
Route::get('/', function () use ($dispatcher) {
    $users = $dispatcher->get('api/users');

    return View::make('index')->with('users', $users);
});
```

--------------------------------

### Get Dispatcher Instance

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Internal-Requests

Obtain an instance of the Dingo API dispatcher to make internal requests.

```php
$dispatcher = app('Dingo\Api\Dispatcher');
```

--------------------------------

### Get API Router Instance

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Creating-API-Endpoints

Retrieves the API router instance from the container. Required before defining version groups and endpoints.

```php
$api = app('Dingo\Api\Routing\Router');
```

--------------------------------

### Retrieve Raw Response Object

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Internal-Requests

Prefix calls with raw to get the raw response object instead of the pre-transformed data.

```php
$response = $dispatcher->raw()->get('users');
```

--------------------------------

### Define a request with additional headers

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/API-Blueprint-Documentation

Add custom headers to a request using the `headers` parameter in `@Request`. This example adds an `X-Custom` header.

```php
/**
 * Register user
 *
 * Register a new user with a `username` and `password`.
 *
 * @Post("/")
 * @Versions({"v1"})
 * @Request({"username": "foo", "password": "bar"}, headers={"X-Custom": "FooBar"})
 */
public function store()
{

}
```

--------------------------------

### Configure OAuth 2.0 Authentication Provider in Service Provider Class

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Authentication

Registers the OAuth 2.0 provider within a Laravel service provider's boot method. Uses the Auth class and OAuth2 provider. Sets user and client resolvers similarly to the bootstrap example.

```php
namespace App\Providers;

use Dingo\Api\Auth\Auth;
use Dingo\Api\Auth\Provider\OAuth2;
use Illuminate\Support\ServiceProvider;

class OAuthServiceProvider extends ServiceProvider
{
    public function boot()
    {
        $this->app[Auth::class]->extend('oauth', function ($app) {
            $provider = new OAuth2($app['oauth2-server.authorizer']->getChecker());

            $provider->setUserResolver(function ($id) {
                // Logic to return a user by their ID.
            });

            $provider->setClientResolver(function ($id) {
                // Logic to return a client by their ID.
            });

            return $provider;
        });
    }

    public function register()
    {
        //
    }
}
```

--------------------------------

### Retrieve authenticated user in a route closure

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Authentication

Within a protected route, use app('Dingo\Api\Auth\Auth')->user() to get the authenticated user.

```php
$api->version('v1', ['middleware' => 'api.auth'], function ($api) {
    $api->get('user', function () {
        $user = app('Dingo\Api\Auth\Auth')->user();

        return $user;
    });
});
```

--------------------------------

### Generate API documentation to file with --output-file

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Commands

Writes the generated documentation directly to a file instead of stdout.

```bash
$ php artisan api:docs --name Example --use-version v2 --output-file /path/to/documentation.md
```

--------------------------------

### Configure OAuth 2.0 Authentication Provider in Bootstrap File

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Authentication

Registers the OAuth 2.0 provider using the 'oauth' key. Sets user and client resolvers that receive an ID and should return the corresponding user or client instance. Place this in a service provider or bootstrap file.

```php
app('Dingo\Api\Auth\Auth')->extend('oauth', function ($app) {
   $provider = new Dingo\Api\Auth\Provider\OAuth2($app['oauth2-server.authorizer']->getChecker());

    $provider->setUserResolver(function ($id) {
        // Logic to return a user by their ID.
    });

    $provider->setClientResolver(function ($id) {
        // Logic to return a client by their ID.
    });

    return $provider;
});
```

--------------------------------

### Implement Dingo\Api\Contract\Transformer\Adapter with transform method

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Transformers

Create a class that implements the Adapter contract and defines the required transform method. The method receives $response, $transformer, Binding $binding, and Request $request. The transformation layer should return an array. The $binding parameter supports advanced features like meta data or callbacks, and $request provides access to the current HTTP request.

```php
use Dingo\Api\Http\Request;
use Dingo\Api\Transformer\Binding;
use Dingo\Api\Contract\Transformer\Adapter;

class MyCustomTransformer implements Adapter
{
    public function transform($response, $transformer, Binding $binding, Request $request)
    {
        // Make a call to your transformation layer to transformer the given response.
    }
}
```

--------------------------------

### Implement custom authentication provider with Provider interface

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Authentication

Create a class implementing Dingo\Api\Contract\Auth\Provider. The authenticate method receives the request and route; on failure throw UnauthorizedHttpException. Return the authenticated user on success.

```php
use Illuminate\Http\Request;
use Dingo\Api\Routing\Route;
use Dingo\Api\Contract\Auth\Provider;
use Symfony\Component\HttpKernel\Exception\UnauthorizedHttpException;

class CustomProvider implements Provider
{
    public function authenticate(Request $request, Route $route)
    {
        // Logic to authenticate the request.

        throw new UnauthorizedHttpException('Unable to authenticate with supplied username and password.');
    }
}
```

--------------------------------

### Generate API documentation with api:docs

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Commands

Generates API Blueprint 1A documentation from annotated controllers. Outputs to stdout by default. Available in Laravel 5.1+ and Lumen 5.1+.

```bash
$ php artisan api:docs --name Example --use-version v2
```

--------------------------------

### Publish Dingo API config for Laravel

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Installation

Publish the configuration file for Laravel. This step is optional if you don't need to make configuration changes.

```bash
php artisan vendor:publish --provider="Dingo\Api\Provider\LaravelServiceProvider"
```

--------------------------------

### Attach Files by Path

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Internal-Requests

Attach files using an array of file paths, with keys as file identifiers.

```php
$dispatcher->attach(['photo' => 'photos/me.jpg'])->post('photos');
```

--------------------------------

### Migrate from dingo/api to api-ecosystem-for-laravel/dingo-api using Composer

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/blob/master/readme.md

Use these Composer commands to switch from the original dingo/api package to this fork. The package namespaces remain unchanged, so only the composer.json dependencies need updating.

```bash
composer remove dingo/api
composer require api-ecosystem-for-laravel/dingo-api
```

--------------------------------

### Configure Fractal adapter in a service provider

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Transformers

Configures the Fractal adapter with a custom include key and separator. Place this in a service provider or bootstrap file to override the default options.

```php
$this->app['Dingo\Api\Transformer\Factory']->setAdapter(function ($app) {
     return new Dingo\Api\Transformer\Adapter\Fractal(new League\Fractal\Manager, 'include', ',');
});
```

--------------------------------

### Configure Custom Throttle in Config File

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Rate-Limiting

Shows how to register a custom throttle in the throttling configuration array, setting a limit of 200 requests and an expiration of 10 minutes.

```php
'throttling' => [
    'custom' => new CustomThrottle(['limit' => 200, 'expires' => 10])
]
```

--------------------------------

### Configure Fractal adapter in Lumen bootstrap

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Transformers

Configures the Fractal adapter with a custom include key and separator when using Lumen. Place this in your bootstrap file.

```php
app('Dingo\Api\Transformer\Factory')->setAdapter(function ($app) {
    return new Dingo\Api\Transformer\Adapter\Fractal(new League\Fractal\Manager, 'include', ',');
});
```

--------------------------------

### Configure HTTP Basic Authentication Provider

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Authentication

Registers the HTTP Basic authentication provider using the 'basic' key. The second parameter 'email' is the identifier used for authentication. Place this in a service provider or bootstrap file.

```php
app('Dingo\Api\Auth\Auth')->extend('basic', function ($app) {
   return new Dingo\Api\Auth\Provider\Basic($app['auth'], 'email');
});
```

--------------------------------

### Respond with a created response

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Responses

Returns a 201 Created response with the created method. Optionally you can pass a location for the created resource as the first parameter.

```php
return $this->response->created();
```

--------------------------------

### Set cursor via Fractal callback

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Transformers

Uses the Fractal callback to interact with the resource after creation. Here it sets a cursor for pagination. The callback receives the resource (Item or Collection) and the Fractal Manager.

```php
return $this->collection($users, new UserTransformer, [], function ($resource, $fractal) {
    $resource->setCursor($cursor);
});
```

--------------------------------

### Respond with a created response and location

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Responses

Returns a 201 Created response with a location header. The location is passed as the first parameter to the created method.

```php
return $this->response->created($location);
```

--------------------------------

### Register JSONP formatter in configuration file

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Responses

Swaps the default JSON formatter for the JSONP formatter in the 'formats' configuration array. The callback parameter defaults to 'callback' in the query string.

```php
'formats' => [
    'json' => 'Dingo\Api\Http\Response\Format\Jsonp'
]
```

--------------------------------

### Define a resource with description

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/API-Blueprint-Documentation

Provide a description of the resource in the PHPDoc before the `@Resource` annotation. This description is used in the generated documentation.

```php
/**
 * User resource representation.
 *
 * @Resource("Users", uri="/users")
 */
class UserController extends Controller
{

}
```

--------------------------------

### Configure JWT Authentication Provider in Service Provider

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Authentication

Registers the JWT authentication provider using the 'jwt' key. Requires the tymon/jwt-auth package. Place this in a service provider or bootstrap file.

```php
app('Dingo\Api\Auth\Auth')->extend('jwt', function ($app) {
   return new Dingo\Api\Auth\Provider\JWT($app['Tymon\JWTAuth\JWTAuth']);
});
```

--------------------------------

### Accept header format for versioning

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Making-Requests-To-Your-API

Defines the Accept header format to request a specific API version. Replace YOUR_SUBTYPE with your configured subtype and adjust the version and format as needed. If the format is invalid, the default format from configuration is used.

```http
Accept: application/vnd.YOUR_SUBTYPE.v1+json
```

--------------------------------

### Generate API routes table with api:routes

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Commands

Lists all API routes in a table, similar to Laravel's route:list. Available in Laravel 5.1+.

```bash
$ php artisan api:routes
```

--------------------------------

### Configure API_STANDARDS_TREE in .env

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Configuration

Sets the standards tree for media type registration. Use 'vnd' for publicly distributed projects, 'prs' for non-commercial, or 'x' for local/private environments.

```dotenv
API_STANDARDS_TREE=vnd
```

--------------------------------

### Custom Throttle Class Implementation

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Rate-Limiting

Defines a custom throttle by extending the abstract Throttle class and implementing the match method. The method must return true or false based on custom conditions.

```php
use Illuminate\Container\Container;
use Dingo\Api\Http\RateLimit\Throttle\Throttle;

class CustomThrottle extends Throttle
{
    public function match(Container $app)
    {
        // Perform some logic here and return either true or false depending on whether
        // your conditions for the throttle matched.
    }
}
```

--------------------------------

### Configure default response format in .env

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Configuration

Sets the default response format to JSON in the .env file. This is the default format and is registered by default.

```plaintext
API_DEFAULT_FORMAT=json
```

--------------------------------

### Configure API_VERSION in .env

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Configuration

Sets the default API version used as a fallback when no version is supplied and as the default for generating API documentation.

```dotenv
API_VERSION=v1
```

--------------------------------

### Define Same Endpoint for Multiple Versions

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Creating-API-Endpoints

Defines the same URI for two different versions, each returning a different controller response. This is possible because endpoints are grouped per version.

```php
$api->version('v1', function ($api) {
    $api->get('users/{id}', 'App\Api\V1\Controllers\UserController@show');
});

$api->version('v2', function ($api) {
    $api->get('users/{id}', 'App\Api\V2\Controllers\UserController@show');
});
```

--------------------------------

### Respond with no content

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Responses

Returns a 204 No Content response using the noContent method.

```php
return $this->response->noContent();
```

--------------------------------

### Respond with an array

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Responses

Returns a basic array response using the response builder's array method. The element is converted to an array before passing.

```php
class UserController extends BaseController
{
	public function show($id)
	{
		$user = User::findOrFail($id);

		return $this->response->array($user->toArray());
	}
}
```

--------------------------------

### Respond with a collection of items

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Responses

Returns a collection of items using the collection method with a transformer.

```php
class UserController extends BaseController
{
	public function index()
	{
		$users = User::all();

		return $this->response->collection($users, new UserTransformer);
	}
}
```

--------------------------------

### Register custom auth provider via Auth extend

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Authentication

Use the Auth facade's extend method from a bootstrap file or service provider to register the custom provider.

```php
app('Dingo\Api\Auth\Auth')->extend('custom', function ($app) {
    return new CustomProvider;
});
```

--------------------------------

### Enable Rate Limiting on Specific Routes

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Rate-Limiting

Shows how to apply the 'api.throttle' middleware to individual routes within a version group, leaving other routes unthrottled.

```php
$api->version('v1', function ($api) {
    $api->get('user', ['middleware' => 'api.throttle', function () {
        // This route requires authentication.
    }]);

    $api->get('posts', function () {
        // This route does not require authentication.
    });
});
```

--------------------------------

### Name a Route

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Creating-API-Endpoints

Registers a named route using the 'as' key, similar to Laravel's routing. The 'uses' key specifies the controller action.

```php
$api->get('users/{id}', ['as' => 'users.index', 'uses' => 'Api\V1\UserController@show']);
```

--------------------------------

### Add dingo/blueprint to composer.json

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Installation

Optionally add the dingo/blueprint package for API doc generation. This is considered legacy and is not supported.

```json
"require": {
    "dingo/blueprint": "~0.4"
}
```

--------------------------------

### Define Version Group for Multiple Versions

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Creating-API-Endpoints

Defines a version group that responds to multiple versions by passing an array of version strings.

```php
$api->version(['v1', 'v2'], function ($api) {

});
```

--------------------------------

### Define Version Group with Attributes

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Creating-API-Endpoints

Defines a version group with additional attributes, such as middleware, passed as the second parameter.

```php
$api->version('v1', ['middleware' => 'foo'], function ($api) {

});
```

--------------------------------

### Filter API routes by version with --versions

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Commands

Filters the API routes table to show only routes for the specified version.

```bash
$ php artisan api:routes --versions v1
```

--------------------------------

### Attach Files with Meta Data

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Internal-Requests

Attach files with associated meta data (path, mime, size) for more accuracy.

```php
$dispatcher->attach([
    'photo' => [
        'path' => 'photos/me.jpg',
        'mime' => 'image/jpeg',
        'size' => '49430'
    ]
])->post('photos');
```

--------------------------------

### Configure API_NAME in .env

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Configuration

Sets the API name used as a default when generating documentation with the API Blueprint command.

```dotenv
API_NAME=My API
```

--------------------------------

### Create listener for ResponseWasMorphed event

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Responses

Listens for the ResponseWasMorphed event to add pagination links to the Link header. Checks for pagination meta and sets the header with next and previous links. Not production ready; only a demonstration.

```php
use Dingo\Api\Event\ResponseWasMorphed;

class AddPaginationLinksToResponse
{
	public function handle(ResponseWasMorphed $event)
	{
		if (isset($event->content['meta']['pagination'])) {
			$links = $event->content['meta']['pagination']['links'];

			$event->response->headers->set(
				'link',
				sprintf('<%s>; rel="next", <%s>; rel="prev"', $links['links']['next'], $links['links']['previous'])
			);
		}
	}
}
```

--------------------------------

### Configure custom auth provider in config/api.php

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Authentication

Add the provider class to the 'auth' array in config/api.php under a custom key (e.g., 'custom').

```php
'auth' => [
    'custom' => 'CustomProvider',
],
```

--------------------------------

### Return a single user as JSON response

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Responses

Return a single user using findOrFail in the show method. The response is automatically formatted as JSON with the Content-Type header set to application/json.

```php
class UserController
{
	public function show($id)
	{
		return User::findOrFail($id);
	}
}
```

--------------------------------

### @Parameters annotation for query string parameters

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/API-Blueprint-Documentation

Defines query string parameters at the action level using the @Parameters annotation. Each @Parameter specifies a name, description, and default value. Parameters can be defined at the resource level or action level; if defined at the resource level, they must be defined for each action or on the resource.

```php
/**
 * Show all users
 *
 * Get a JSON representation of all the registered users.
 *
 * @Get("/{?page,limit}")
 * @Versions({"v1"})
 * @Parameters({
 *      @Parameter("page", description="The page of results to view.", default=1),
 *      @Parameter("limit", description="The amount of results per page.", default=10)
 * })
 */
public function index()
{

}
```

--------------------------------

### Add dingo/api to composer.json

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Installation

Add the dingo/api package to your composer.json file. Run composer update after modifying the file. You may need to set your minimum-stability to dev.

```json
"require": {
    "dingo/api": "^4.0"
}
```

--------------------------------

### Set resource key with response builder item

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Transformers

Returns a single item with a custom resource key using the response builder's item method. The key parameter customizes the Fractal resource key.

```php
return $this->item($user, new UserTransformer, ['key' => 'user']);
```

--------------------------------

### Bind ScopeFactoryInterface in AppServiceProvider

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Known-Issues

Add this binding to the register() method of your AppServiceProvider to resolve the error 'Target [League\Fractal\ScopeFactoryInterface] is not instantiable while building [Dingo\Api\Transformer\Adapter\Fractal, League\Fractal\Manager]'.

```php
    public function register()
    {
        $this->app->bind("League\\Fractal\\ScopeFactoryInterface", "\\League\\Fractal\\ScopeFactory");
        //
    }
```

--------------------------------

### Enable debug mode in .env

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Configuration

Enables debug mode in the .env file, which populates the 'debug' key in generic error responses with stack trace details.

```plaintext
API_DEBUG=true
```

--------------------------------

### Configure API_PREFIX in .env

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Configuration

Sets the URL prefix for the API. A prefix or subdomain is required, but only one; avoid version numbers here because versioning is handled via the Accept header.

```dotenv
API_PREFIX=api
```

--------------------------------

### Register JSONP formatter with Dingo\Api\Http\Response::addFormatter

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Configuration

Registers a custom JSONP formatter for the 'json' format. This should be done in a published configuration file, a service provider, or the bootstrap file.

```php
Dingo\Api\Http\Response::addFormatter('json', new Dingo\Api\Http\Response\Format\Jsonp);
```

--------------------------------

### Configure JWT Authentication Provider in config/api.php

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Authentication

Adds the JWT provider to the 'auth' configuration array in the config/api.php file. This is an alternative to registering it in a service provider.

```php
'auth' => [
    'jwt' => 'Dingo\Api\Auth\Provider\JWT',
],
```

--------------------------------

### Register Lumen service provider

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Installation

Register the required service provider in bootstrap/app.php for Lumen.

```php
$app->register(Dingo\Api\Provider\LumenServiceProvider::class);
```

--------------------------------

### Route Specific Throttling with limit and expires Options

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Rate-Limiting

Sets a request limit of 100 with an expiration of 5 minutes for a single route using the 'limit' and 'expires' options.

```php
$api->version('v1', function ($api) {
    $api->get('users', ['middleware' => 'api.throttle', 'limit' => 100, 'expires' => 5, function () {
        return User::all();
    }]);
});
```

--------------------------------

### Change Rate Limiting Key with setRateLimiter

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Rate-Limiting

Registers a custom resolver to change the default rate limiting key from the client's IP address. The resolver receives the application container and request instance, and must return a string key.

```php
app('Dingo\Api\Http\RateLimit\Handler')->setRateLimiter(function ($app, $request) {
    return $app['example']->getRateLimiterKey();
});
```

--------------------------------

### Configure API_DOMAIN in .env

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Configuration

Sets the domain for the API as an alternative to a prefix. Only one of prefix or domain is required.

```dotenv
API_DOMAIN=api.myapp.com
```

--------------------------------

### Configure API_STRICT in .env

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Configuration

Disables strict mode. When enabled, clients must send the Accept header and an invalid header throws an unhandled BadRequestHttpException.

```dotenv
API_STRICT=false
```

--------------------------------

### Apply scopes to a controller with Helpers trait

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/OAuth-2.0

Apply scopes to a controller by using the 'scopes' method from the Dingo\Api\Routing\Helpers trait. Without a second parameter, the scope applies to all methods in the controller.

```php
use Dingo\Api\Routing\Helpers;

class UserController extends Controller
{
    use Helpers;

    public function __construct()
    {
        $this->scopes('read_user_data');
    }
}
```

--------------------------------

### Respond with an array using a transformer

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Responses

Returns an array response with a transformer. The second parameter accepts a transformer instance for array responses.

```php
class UserController extends BaseController
{
	public function show($id)
	{
                $setOfThings = [ 'a' => 1, 'b' => 2 ];

		return $this->response->array($setOfThings, new ArbitraryTransformer);
	}
}
```

--------------------------------

### Group Level Throttling with limit and expires Options

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Rate-Limiting

Applies a limit of 100 requests and 5-minute expiration to all routes within a version group. The limit applies per route, not to the group as a whole.

```php
$api->version('v1', ['middleware' => 'api.throttle', 'limit' => 100, 'expires' => 5], function ($api) {
    $api->get('users', function () {
        return User::all();
    });

    $api->get('posts', function () {
        return Post::all();
    });
});
```

--------------------------------

### Target Specific Domain

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Internal-Requests

Use the on method to target a specific domain for the internal request.

```php
$dispatcher->on('api.example.com')->get('users');
```

--------------------------------

### Configure API_NAME with quotes in .env

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Configuration

Alternative form of API_NAME when the name contains spaces; wrap the value in quotes.

```dotenv
API_NAME="My API"
```

--------------------------------

### Register Custom Throttle in Lumen Bootstrap

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Rate-Limiting

Registers a custom throttle using the extend method on the rate limit handler, typically in a Lumen bootstrap file.

```php
app('Dingo\Api\Http\RateLimit\Handler')->extend(new CustomThrottle(['limit' => 200, 'expires' => 10]));
```

--------------------------------

### Attach Uploaded Files

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Internal-Requests

Attach an array of UploadedFile instances to an internal POST request.

```php
$dispatcher->attach(Input::files())->post('photos');
```

--------------------------------

### Use Helpers Trait for Internal Requests

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Internal-Requests

If your controller uses the Dingo\Api\Routing\Helpers trait, you can use the $api property to make internal requests.

```php
use Dingo\Api\Routing\Helpers;

class HomeController extends Controller
{
    use Helpers;

    public function index()
    {
        $users = $this->api->get('users');

        return view('index')->with('users', $users);
    }
}
```

--------------------------------

### Retrieve authenticated user in a controller using Helpers trait

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Authentication

Use the $auth property provided by the Dingo\Api\Routing\Helpers trait to access the authenticated user in a controller.

```php
use Dingo\Api\Routing\Helpers;
use Illuminate\Routing\Controller;

class UserController extends Controller
{
    use Helpers;

    public function __construct()
    {
        $this->middleware('api.auth');
    }

    public function index()
    {
        $user = $this->auth->user();

        return $user;
    }
}
```

--------------------------------

### Enable Rate Limiting on All Routes in a Version Group

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Rate-Limiting

Enables rate limiting for all routes within a version group by adding the 'api.throttle' middleware to the group's middleware array.

```php
$api->version('v1', ['middleware' => 'api.throttle'], function ($api) {
    // Routes within this version group will require authentication.
});
```

--------------------------------

### List of Dingo resource exceptions

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Errors-And-Error-Responses

Lists the generic resource exceptions provided by Dingo API, each returning an HTTP 422 status code. These exceptions allow passing validation errors.

```php
Dingo\Api\Exception\DeleteResourceFailedException
Dingo\Api\Exception\ResourceException
Dingo\Api\Exception\StoreResourceFailedException
Dingo\Api\Exception\UpdateResourceFailedException
```

--------------------------------

### Register event listener in EventServiceProvider

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Responses

Registers the ResponseWasMorphed event listener in the $listen array. This enables the listener to run on all responses that contain pagination links.

```php
protected $listen = [
    'Dingo\Api\Event\ResponseWasMorphed' => [
    	'App\Listeners\AddPaginationLinksToResponse'
    ]
];
```

--------------------------------

### Base Controller using Dingo Helpers trait

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Responses

Base controller that uses Dingo\Api\Routing\Helpers and extends Laravel's base Controller, enabling the $response property on all API controllers that extend it.

```php
use Dingo\Api\Routing\Helpers;
use Illuminate\Routing\Controller;

class BaseController extends Controller
{
	use Helpers;
}
```

--------------------------------

### Require authentication on all routes in a version group

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Authentication

Apply the 'api.auth' middleware to the version group to require authentication for all routes within it.

```php
$api->version('v1', ['middleware' => 'api.auth'], function ($api) {
    // Routes within this version group will require authentication.
});
```

--------------------------------

### Send Data with Internal Request

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Internal-Requests

Send data along with an internal POST request using the with method.

```php
$dispatcher->with(['name' => 'Jason', 'location' => 'Australia'])->post('users');
```

--------------------------------

### Respond with paginated items

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Responses

Returns a paginated collection of items using the paginator method with a transformer.

```php
class UserController extends BaseController
{
	public function index()
	{
		$users = User::paginate(25);

		return $this->response->paginator($users, new UserTransformer);
	}
}
```

--------------------------------

### Set multiple meta data items on response

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Responses

Sets an array of meta data on an item response using the setMeta method, instead of chaining multiple addMeta calls.

```php
return $this->response->item($user, new UserTransformer)->setMeta($meta);
```

--------------------------------

### Register custom throttle with Dingo RateLimit Handler

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Configuration

Registers a custom throttle, here the built-in Authenticated throttle. Rate limiting is disabled by default; use this in a service provider or bootstrap file.

```php
$app['Dingo\Api\Http\RateLimit\Handler']->extend(function ($app) {
    return new Dingo\Api\Http\RateLimit\Throttle\Authenticated;
});
```

--------------------------------

### Return all users as JSON response

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Responses

Return a collection of users from the index method. The User model extends Eloquent Model, which can be formatted as an array, so the response is automatically converted to JSON.

```php
class UserController
{
	public function index()
	{
		return User::all();
	}
}
```

--------------------------------

### Send Data as Second Parameter

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Internal-Requests

Alternatively, pass data as the second parameter to the post method (and other HTTP verbs).

```php
$dispatcher->post('users', ['name' => 'Jason', 'location' => 'Australia']);
```

--------------------------------

### Set custom error format with Dingo\Api\Exception\Handler::setErrorFormat

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Configuration

Configures the generic error response format. Must be set in a published configuration file or the bootstrap file. The placeholders are replaced with actual error details.

```php
$app['Dingo\Api\Exception\Handler']->setErrorFormat([
    'error' => [
        'message' => ':message',
        'errors' => ':errors',
        'code' => ':code',
        'status_code' => ':status_code',
        'debug' => ':debug'
    ]
]);
```

--------------------------------

### Allow only specific authentication providers on a route

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Authentication

Use the 'providers' key in the route options to restrict which authentication providers are allowed for that route.

```php
$api->version('v1', function ($api) {
    $api->get('user', ['middleware' => 'api.auth', 'providers' => ['basic', 'oauth'], function () {
        // This route requires authentication.
    }]);
});
```

--------------------------------

### Configure API_SUBTYPE in .env

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Configuration

Sets the subtype, typically a short lowercase name of your application or project.

```dotenv
API_SUBTYPE=myapp
```

--------------------------------

### Require authentication on controller methods

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Authentication

Use the middleware method in the controller constructor to apply 'api.auth' to all methods or a subset using the 'only' option.

```php
class UserController extends Illuminate\Routing\Controller
{
    use Helpers;

    public function __construct()
    {
        $this->middleware('api.auth');

        // Only apply to a subset of methods.
        $this->middleware('api.auth', ['only' => ['index']]);
    }

    public function index()
    {
        //
    }

    public function posts()
    {
        //
    }
}
```

--------------------------------

### Extend Dingo API Auth with JWT provider

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Configuration

Registers a custom authentication provider (e.g., 'oauth') using JWT. Place in a service provider or bootstrap file for more complex configuration.

```php
$app['Dingo\Api\Auth\Auth']->extend('oauth', function ($app) {
   return new Dingo\Api\Auth\Provider\JWT($app['Tymon\JWTAuth\JWTAuth']);
});
```

--------------------------------

### Define a request with @Request (JSON array)

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/API-Blueprint-Documentation

Use an annotation array in `@Request` to send JSON. The content type defaults to `application/json`.

```php
/**
 * Register user
 *
 * Register a new user with a `username` and `password`.
 *
 * @Post("/")
 * @Versions({"v1"})
 * @Request({"username": "foo", "password": "bar"})
 */
public function store()
{

}
```

--------------------------------

### Respond with built-in errors

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Responses

Shows the different built-in error methods: error for generic errors with a custom message and status code, and errorNotFound, errorBadRequest, errorForbidden, errorInternal, errorUnauthorized for common HTTP errors, each with an optional message parameter.

```php
// A generic error with custom message and status code.
return $this->response->error('This is an error.', 404);

// A not found error with an optional message as the first parameter.
return $this->response->errorNotFound();

// A bad request error with an optional message as the first parameter.
return $this->response->errorBadRequest();

// A forbidden error with an optional message as the first parameter.
return $this->response->errorForbidden();

// An internal error with an optional message as the first parameter.
return $this->response->errorInternal();

// An unauthorized error with an optional message as the first parameter.
return $this->response->errorUnauthorized();
```

--------------------------------

### Extend Authorization abstract class for custom provider

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Authentication

Extend Dingo\Api\Auth\Provider\Authorization to handle Authorization header tokens. Use validateAuthorizationHeader to check the header, and implement getAuthorizationMethod to return the token type (e.g., 'mac').

```php

use Illuminate\Http\Request;
use Dingo\Api\Routing\Route;
use Dingo\Api\Auth\Provider\Authorization;
use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
use Symfony\Component\HttpKernel\Exception\UnauthorizedHttpException;

class CustomProvider extends Authorization
{
    public function authenticate(Request $request, Route $route)
    {
        $this->validateAuthorizationHeader($request);

        // If the authorization header passed validation we can continue to authenticate.
        // If authentication then fails we must throw the UnauthorizedHttpException.
    }

    public function getAuthorizationMethod()
    {
        return 'mac';
    }
}
```

--------------------------------

### Authenticate for Single Request

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Internal-Requests

Use the once method to authenticate as a given user for a single request only.

```php
$dispatcher->be(auth()->user())->once()->get('posts');
```

--------------------------------

### Catch InternalHttpException from internal request

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Internal-Requests

Shows how to handle an InternalHttpException thrown when an error response is returned from an internal request. The first block is an endpoint that returns a 404 error using the response builder; the second block catches the exception and retrieves the response.

```php
public function show($id)
{
    return $this->response->errorNotFound('Could not find the user.');
}
```

```php
try {
    app('Dingo\Api\Dispatcher')->get('users/1');
} catch (Dingo\Api\Exception\InternalHttpException $e) {
    // We can get the response here to check the status code of the error or response body.
    $response = $e->getResponse();
}
```

--------------------------------

### Respond with a single item

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Responses

Returns a single item response using the item method with a transformer.

```php
class UserController extends BaseController
{
	public function show($id)
	{
		$user = User::findOrFail($id);

		return $this->response->item($user, new UserTransformer);
	}
}
```

--------------------------------

### Filter API routes by scopes with --scopes

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Commands

Filters the API routes table to show only routes that require the specified scopes. Multiple --scopes flags can be used.

```bash
$ php artisan api:routes --scopes read_user_data --scopes write_user_data
```

--------------------------------

### Pretend to Be Authenticated User

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Internal-Requests

Authenticate internal requests as a given user using the be method.

```php
$dispatcher->be(auth()->user())->get('posts');
```

--------------------------------

### Change serializer via Fractal callback

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Transformers

Uses the Fractal callback to change the serializer per response. When not passing a resource key, the callback can be passed as the third parameter.

```php
return $this->collection($users, new UserTransformer, function ($resource, $fractal) {
    $fractal->setSerializer(new CustomSerializer);
});
```

--------------------------------

### Require authentication on specific routes

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Authentication

Apply 'api.auth' middleware to individual routes to protect only those routes, leaving others unprotected.

```php
$api->version('v1', function ($api) {
    $api->get('user', ['middleware' => 'api.auth', function () {
        // This route requires authentication.
    }]);

    $api->get('posts', function () {
        // This route does not require authentication.
    });
});
```

--------------------------------

### Register a transformer for a class

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Transformers

Registers a transformer for a class so that returning the class (e.g., a model) directly from a route automatically runs it through the transformer. Also applies to collections and paginators of that class.

```php
app('Dingo\Api\Transformer\Factory')->register('User', 'UserTransformer');
```

--------------------------------

### Identify multiple requests with identifier

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/API-Blueprint-Documentation

When an action responds differently to multiple requests, use the `identifier` parameter in `@Request` to distinguish them.

```php
/**
 * Register user
 *
 * Register a new user with a `username` and `password`.
 *
 * @Post("/")
 * @Versions({"v1"})
 * @Request({"username": "foo", "password": "bar"}, identifier="A")
 */
public function store()
{

}
```

--------------------------------

### @Parameters with type and required attributes

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/API-Blueprint-Documentation

Shows how to define additional parameter attributes: type and required. The @Parameter annotation includes type="integer" and required=true, along with description and default.

```php
/**
 * @Parameters({
 *      @Parameter("example", type="integer", required=true, description="This is an example.", default=1)
 * })
 */
public function index()
{

}
```

--------------------------------

### Target Specific API Version

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Internal-Requests

Use the version method to target a specific API version for the internal request.

```php
$dispatcher->version('v2')->get('users');
```

--------------------------------

### Set Fractal adapter with JsonApiSerializer

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Configuration

Configures the response transformer adapter to use Fractal with the JsonApiSerializer. Fractal is the default transformer; this is for more complex configuration in a service provider or bootstrap file.

```php
$app['Dingo\Api\Transformer\Factory']->setAdapter(function ($app) {
    $fractal = new League\Fractal\Manager;

    $fractal->setSerializer(new League\Fractal\Serializer\JsonApiSerializer);

    return new Dingo\Api\Transformer\Adapter\Fractal($fractal);
});
```

--------------------------------

### Catch ConflictHttpException from internal request

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Internal-Requests

Shows how to throw a ConflictHttpException in an endpoint and catch it when making an internal request. The first block is the endpoint that throws the exception; the second block is the internal call that must catch it.

```php
public function store()
{
    throw new Symfony\Component\HttpKernel\Exception\ConflictHttpException('We got a conflict!');
}
```

```php
try {
    app('Dingo\Api\Dispatcher')->with($payload)->post('users');
} catch (Symfony\Component\HttpKernel\Exception\ConflictHttpException $e) {
    // Do something here, like return with an error.
}
```

--------------------------------

### Throw StoreResourceFailedException with validation errors

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Errors-And-Error-Responses

Throws a StoreResourceFailedException with validation errors when creating a user fails validation, resulting in an HTTP 422 response with the given JSON body.

```php
$api->version('v1', function ($api) {
    $api->post('users', function () {
        $rules = [
            'username' => ['required', 'alpha'],
            'password' => ['required', 'min:7']
        ];

        $payload = app('request')->only('username', 'password');

        $validator = app('validator')->make($payload, $rules);

        if ($validator->fails()) {
            throw new Dingo\Api\Exception\StoreResourceFailedException('Could not create new user.', $validator->errors());
        }

        // Create user as per usual.
    });
});
```

```json
{
    "message": "Could not create new user.",
    "status_code": 422,
    "errors": {
        "username": [
            "The username field is required."
        ],
        "password": [
            "The password field is required."
        ]
    }
}
```

--------------------------------

### Define Version Group for Single Version

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Creating-API-Endpoints

Defines a version group for a single version. Endpoints registered inside the closure are scoped to that version.

```php
$api->version('v1', function ($api) {

});
```

--------------------------------

### Cache API routes with api:cache

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Commands

Caches API routes alongside main application routes. Also runs route:cache automatically. Available in Laravel 5.1+.

```bash
$ php artisan api:cache
```

--------------------------------

### Apply scopes to specific controller methods in Dingo API

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/OAuth-2.0

Control which controller methods a scope applies to using the second parameter of the 'scopes' method. Accepts a method name, a pipe-separated string, an array, or the 'except' and 'only' keys to include or exclude specific methods.

```php
use Dingo\Api\Routing\Helpers;

class UserController extends Controller
{
    use Helpers;

    public function __construct()
    {
        // Only apply to the index method.
        $this->scopes('read_user_data', 'index');

        // Apply to every method except the store method.
        $this->scopes('read_user_data', ['except' => 'store']);

        // Apply only to the store method.
        $this->scopes('write_user_data', ['only' => ['store']]);
    }

    public function index()
    {
        //
    }

    public function store()
    {
        //
    }
}
```

--------------------------------

### Generate URL for Named Route

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Creating-API-Endpoints

Generates a URL for a named route. A version must be supplied so the URL is generated based on the route within that version.

```php
app('Dingo\Api\Routing\UrlGenerator')->version('v1')->route('users.index');
```

--------------------------------

### Define a request with @Request (form-encoded)

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/API-Blueprint-Documentation

Use `@Request` to define a request body. For `POST` requests, you can use a string body and set the content type to `application/x-www-form-urlencoded`.

```php
/**
 * Register user
 *
 * Register a new user with a `username` and `password`.
 *
 * @Post("/")
 * @Versions({"v1"})
 * @Request("username=foo&password=bar", contentType="application/x-www-form-urlencoded")
 */
public function store()
{

}
```

--------------------------------

### Add additional headers to response

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Responses

Adds a custom header to an item response using the withHeader method.

```php
return $this->response->item($user, new UserTransformer)->withHeader('X-Foo', 'Bar');
```

--------------------------------

### Define a response with @Response

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/API-Blueprint-Documentation

Use `@Response` to define the status code, body, and content type. The body can be an annotation array encoded as JSON. Use curly braces for arrays of objects.

```php
/**
 * Register user
 *
 * Register a new user with a `username` and `password`.
 *
 * @Post("/")
 * @Versions({"v1"})
 * @Request({"username": "foo", "password": "bar"})
 * @Response(200, body={"id": 10, "username": "foo"})
 */
public function store()
{

}
```

--------------------------------

### Nest Regular Group Inside Version Group

Source: https://github.com/api-ecosystem-for-laravel/dingo-api/wiki/Creating-API-Endpoints

Nests a regular group inside a version group to apply additional customization, such as middleware, to specific endpoints.

```php
$api->version('v1', function ($api) {
    $api->group(['middleware' => 'foo'], function ($api) {
        // Endpoints registered here will have the "foo" middleware applied.
    });
});
```
Tokens:
Raw