docs: remove docker compose commands & use bash codeblocks over console

Author: vinceAmstoutz

admin/getting-started.md

@@ -8,14 +8,14 @@ Otherwise, follow this guide.
 
 If you don't have an existing React Application, create one using [Create React App](https://create-react-app.dev/):
 
-```console
+```bash
 npm init react-app my-admin
 cd my-admin
 ```
 
 Then, install the `@api-platform/admin` library:
 
-```console
+```bash
 npm install @api-platform/admin
 ```
 
@@ -57,9 +57,8 @@ nelmio_cors:
 
 Clear the cache to apply this change:
 
-```console
-docker compose exec php \
-    bin/console cache:clear --env=prod
+```bash
+bin/console cache:clear --env=prod
 ```
 
 Your new administration interface is ready! Type `npm start` to try it!

core/bootstrap.md

@@ -3,7 +3,7 @@
 You may want to run a minimal version of API Platform. This one file runs API Platform (without GraphQL, Eloquent, Doctrine MongoDB...).
 It requires the following Composer packages:
 
-```console
+```bash
 composer require \
     api-platform/core \
     phpdocumentor/reflection-docblock \

core/elasticsearch.md

@@ -14,7 +14,7 @@ Be careful, API Platform only supports Elasticsearch >= 7.11.0 < 8.0.
 
 To enable the reading support for Elasticsearch, simply require the Elasticsearch-PHP package using Composer:
 
-```console
+```bash
 composer require elasticsearch/elasticsearch:^7.11
 ```
 

core/file-upload.md

@@ -24,9 +24,8 @@ api_platform:
 
 Install the bundle with the help of Composer:
 
-```console
-docker compose exec php \
-    composer require vich/uploader-bundle
+```bash
+composer require vich/uploader-bundle
 ```
 
 This will create a new configuration file that you will need to slightly change

core/getting-started.md

@@ -22,7 +22,7 @@ Basically, it is a Symfony edition packaged with the best tools to develop a RES
 Alternatively, you can use [Composer](https://getcomposer.org/) to install the standalone bundle in an existing Symfony Flex
 project:
 
-```console
+```bash
 composer require api
 ```
 
@@ -252,7 +252,7 @@ Serialization, OpenAPI, and hydra docs are generated from these metadata directl
 
 First, create a migration class for the `products` table:
 
-```console
+```bash
  php artisan make:migration create_products_table
 ```
 
@@ -277,7 +277,7 @@ Open the generated migration class (`database/migrations/<timestamp>_create_prod
 
 Finally, execute the migration:
 
-```console
+```bash
 php artisan migrate
 ```
 

core/graphql.md

@@ -12,8 +12,8 @@ Once enabled, you have nothing to do: your schema describing your API is automat
 
 To enable GraphQL and its IDE (GraphiQL and GraphQL Playground) in your API, simply require the `api-platform/graphql` package using Composer:
 
-```console
-    composer require api-platform/graphql
+```bash
+composer require api-platform/graphql
 ```
 
 You can now use GraphQL at the endpoint: `https://localhost:8443/graphql`.

core/json-schema.md

@@ -9,16 +9,14 @@ The generated schema can be used with libraries such as [react-json-schema-form]
 
 To export the schema corresponding to an API Resource, run the following command:
 
-```console
-docker compose exec php \
-    bin/console api:json-schema:generate 'App\Entity\Book'
+```bash
+bin/console api:json-schema:generate 'App\Entity\Book'
 ```
 
 To see all options available, try:
 
-```console
-docker compose exec php \
-    bin/console help api:json-schema:generate
+```bash
+bin/console help api:json-schema:generate
 ```
 
 ## Overriding the JSON Schema Specification

core/jwt.md

@@ -1,7 +1,10 @@
 # JWT Authentication
 
-> [JSON Web Token (JWT)](https://jwt.io/) is a JSON-based open standard ([RFC 7519](https://tools.ietf.org/html/rfc7519)) for creating access tokens that assert some number of claims. For example, a server could generate a token that has the claim "logged in as admin" and provide that to a client. The client could then use that token to prove that he/she is logged in as admin.
-> The tokens are signed by the server's key, so the server is able to verify that the token is legitimate. The tokens are designed to be compact, URL-safe and usable especially in web browser single sign-on (SSO) context.
+> [JSON Web Token (JWT)](https://jwt.io/) is a JSON-based open standard ([RFC 7519](https://tools.ietf.org/html/rfc7519)) for creating access tokens that assert
+> some number of claims. For example, a server could generate a token that has the claim "logged in as admin" and
+> provide that to a client. The client could then use that token to prove that he/she is logged in as admin.
+> The tokens are signed by the server's key, so the server is able to verify that the token is legitimate. The tokens
+> are designed to be compact, URL-safe and usable especially in web browser single sign-on (SSO) context.
 >
 > ―[Uncyclopedia](https://en.wikipedia.org/wiki/JSON_Web_Token)
 
@@ -13,14 +16,20 @@ API Platform allows to easily add a JWT-based authentication to your API using [
 
 We begin by installing the bundle:
 
-```console
-docker compose exec php \
-    composer require lexik/jwt-authentication-bundle
+```bash
+composer require lexik/jwt-authentication-bundle
 ```
+Then we need to generate the public and private keys used for signing JWT tokens.
 
-Then we need to generate the public and private keys used for signing JWT tokens. If you're using the [API Platform distribution](../symfony/index.md), you may run this from the project's root directory:
+You can use LexikJWTAuthenticationBundle to generate them using:
 
-```console
+```bash
+php bin/console lexik:jwt:generate-keypair
+```
+
+Or if you're using the [API Platform distribution with Symfony](../symfony/index.md), you may run this from the project's root directory:
+
+```bash
 docker compose exec php sh -c '
     set -e
     apt-get install openssl
@@ -30,13 +39,15 @@ docker compose exec php sh -c '
 '
 ```
 
-Note that the `setfacl` command relies on the `acl` package. This is installed by default when using the API Platform docker distribution but may need to be installed in your working environment in order to execute the `setfacl` command.
-
-This takes care of keypair creation (including using the correct passphrase to encrypt the private key), and setting the correct permissions on the keys allowing the web server to read them.
+Note that the `setfacl` command relies on the `acl` package. This is installed by default when using the API Platform
+docker distribution but may need to be installed in your working environment in order to execute the `setfacl` command.
 
-Since these keys are created by the `root` user from a container, your host user will not be able to read them during the `docker compose build caddy` process. Add the `config/jwt/` folder to the `api/.dockerignore` file so that they are skipped from the result image.
+This takes care of keypair creation (including using the correct passphrase to encrypt the private key), and setting the
+correct permissions on the keys allowing the web server to read them.
 
-If you want the keys to be auto generated in `dev` environment, see an example in the [docker-entrypoint script of api-platform/demo](https://github.com/api-platform/demo/blob/master/api/docker/php/docker-entrypoint.sh).
+Since these keys are created by the `root` user from a container, your host user will not be able to read them during
+the `docker compose build caddy` process. Add the `config/jwt/` folder to the `api/.dockerignore` file so that they are
+skipped from the result image.
 
 The keys should not be checked in to the repository (i.e. it's in `api/.gitignore`). However, note that a JWT token could
 only pass signature validation against the same pair of keys it was signed with. This is especially relevant in a production

core/messenger.md

@@ -11,9 +11,8 @@ Many transports are supported to dispatch messages to async consumers, including
 
 To enable the support of Messenger, install the library:
 
-```console
-docker compose exec php \
-    composer require messenger
+```bash
+composer require symfony/messenger
 ```
 
 ## Dispatching a Resource through the Message Bus

core/mongodb.md

@@ -18,7 +18,7 @@ the legacy [mongo](https://secure.php.net/manual/en/book.mongo.php) extension.
 
 If the `mongodb` PHP extension is not installed yet, [install it beforehand](https://secure.php.net/manual/en/mongodb.installation.pecl.php).
 
-If you are using the [API Platform Distribution](../symfony/index.md), modify the `Dockerfile` to add the extension:
+Or if you are using the [API Platform Distribution with Symfony](../symfony/index.md), modify the `Dockerfile` to add the extension:
 
 ```diff
 # api/Dockerfile
@@ -36,7 +36,7 @@ If you are using the [API Platform Distribution](../symfony/index.md), modify th
 
 Then rebuild the `php` image:
 
-```console
+```bash
 docker compose build php
 ```
 
@@ -64,12 +64,11 @@ services:
 # ...
 ```
 
-Once the extension is installed, to enable the MongoDB support, require the [Doctrine MongoDB ODM bundle](https://github.com/doctrine/DoctrineMongoDBBundle)
+In all cases, enable the MongoDB support by requiring the [Doctrine MongoDB ODM bundle](https://github.com/doctrine/DoctrineMongoDBBundle)
 package using Composer:
 
-```console
-docker compose exec php \
-    composer require doctrine/mongodb-odm-bundle
+```bash
+composer require doctrine/mongodb-odm-bundle
 ```
 
 Execute the contrib recipe to have it already configured.

core/openapi.md

@@ -19,37 +19,32 @@ You can also dump an OpenAPI specification for your API.
 
 OpenAPI, JSON format:
 
-```console
-docker compose exec php \
-    bin/console api:openapi:export
+```bash
+bin/console api:openapi:export
 ```
 
 OpenAPI, YAML format:
 
-```console
-docker compose exec php \
-    bin/console api:openapi:export --yaml
+```bash
+bin/console api:openapi:export --yaml
 ```
 
 Create a file containing the specification:
 
-```console
-docker compose exec php \
-    bin/console api:openapi:export --output=swagger_docs.json
+```bash
+bin/console api:openapi:export --output=swagger_docs.json
 ```
 
 If you want to use the old OpenAPI v2 (Swagger) JSON format, use:
 
-```console
-docker compose exec php \
-    bin/console api:swagger:export
+```bash
+bin/console api:swagger:export
 ```
 
 It is also possible to use OpenAPI v3.0.0 format:
 
-```console
-docker compose exec php \
-    bin/console api:openapi:export --spec-version=3.0.0
+```bash
+bin/console api:openapi:export --spec-version=3.0.0
 ```
 
 ## Overriding the OpenAPI Specification

core/performance.md

@@ -456,14 +456,14 @@ services:
 
 2. Add your Blackfire.io ID and server token to your `.env` file at the root of your project (be sure not to commit this to a public repository):
 
-```console
+```bash
 BLACKFIRE_SERVER_ID=xxxxxxxxxx
 BLACKFIRE_SERVER_TOKEN=xxxxxxxxxx
 ```
 
 Or set it in the console before running Docker commands:
 
-```console
+```bash
 export BLACKFIRE_SERVER_ID=xxxxxxxxxx
 export BLACKFIRE_SERVER_TOKEN=xxxxxxxxxx
 ```
@@ -483,7 +483,7 @@ export BLACKFIRE_SERVER_TOKEN=xxxxxxxxxx
 
 4. Rebuild and restart all your containers
 
-```console
+```bash
 docker compose build
 docker compose up --wait
 ```

core/state-processors.md

@@ -26,7 +26,7 @@ process the data for a given resource will be used.
 ### Custom State Processor with Symfony
 If the [Symfony MakerBundle](https://symfony.com/doc/current/bundles/SymfonyMakerBundle) is installed in your project, you can use the following command to generate a custom state processor easily:
 
-```console
+```bash
 bin/console make:state-processor
 ```
 
@@ -81,7 +81,7 @@ class BlogPost {}
 
 ### Custom State Processor with Laravel
 Using [Laravel Artisan Console](https://laravel.com/docs/artisan), you can generate a custom state processor easily with the following command:
-```console
+```bash
 php artisan make:state-processor
 ```
 

core/state-providers.md

@@ -34,7 +34,7 @@ Note, that if your entity is not Doctrine-related or Eloquent-related, you need
 If the [Symfony MakerBundle](https://symfony.com/doc/current/bundles/SymfonyMakerBundle) is installed in your project,
 you can use the following command to generate a custom state provider easily:
 
-```console
+```bash
 bin/console make:state-provider
 ```
 
@@ -145,7 +145,7 @@ class BlogPost {}
 
 Using [Laravel Artisan Console](https://laravel.com/docs/artisan), you can generate a custom state provider easily with the following command:
 
-```console
+```bash
 php artisan make:state-provider
 ```
 

core/testing.md

@@ -16,9 +16,8 @@ Reuse them to run, for instance, SQL queries or requests to external APIs direct
 
 Install the `symfony/http-client` and `symfony/browser-kit` packages to enabled the API Platform test client:
 
-```console
-docker compose exec php \
-    composer require symfony/browser-kit symfony/http-client
+```bash
+composer require symfony/browser-kit symfony/http-client
 ```
 
 To use the testing client, your test class must extend the `ApiTestCase` class: