List of keys you can use in a Symfony services.yaml

Here’s a comprehensive list of keys you can use in a Symfony services.yaml file, along with brief descriptions for each:

1. Global Configuration Keys

• parameters: Defines reusable parameters throughout the service definitions.

2. Service Definitions Keys

• services: Main section where you define services.

Service Configuration Keys

• class: The class name of the service being defined (if using the shorthand syntax).
• arguments: Dependencies passed to the service constructor.
• tags: Metadata tags for the service (e.g., event listeners, commands).
• factory: Specifies a factory method to create the service.
• decorates: Replaces a service with a decorated version.
• bind: Specifies parameters for specific arguments in the constructor.
• autowire: Automatically injects dependencies into services.
• autoconfigure: Automatically configures services based on their interfaces or parent classes.

3. Parameter Configuration Keys

• default_logger: Example of a parameter that can hold configuration values.
• log_file: Default log file location or similar configuration values.

4. Service-Specific Configuration Keys

• public: Determines whether the service can be accessed from outside the service container (default is true in Symfony 4.0 and later).
• shared: Indicates if the service is a singleton (default is true).

5. Service Factory Configuration Keys

• factory: Specifies the method that should be called to instantiate the service.

6. Service Alias Configuration Keys

• aliases: Allows you to create aliases for services, enabling you to refer to a service by a different name.

7. Tags Configuration Keys

• name: The name of the tag.
• priority: Sets the priority of the tag, determining the order in which tagged services are processed.
• attributes: Custom attributes that can be added to tags.

8. Additional Keys for Configuration

• calls: Specifies methods that should be called on the service after it is constructed.
• factory: Specifies a method that should be called to create the service.
• deprecated: Marks a service as deprecated.
• class: Defines the class name of the service being defined (if using shorthand syntax).

Example services.yaml with All Keys

Here’s a fictive example of how these keys can be used in a services.yaml file:

parameters:
    default_logger: '%env(APP_DEFAULT_LOGGER)%'
    log_file: 'app.log'

services:
    App\Service\Logger\LoggerInterface: '@=service(parameter("default_logger"))'  

    App\Service\Logger\DatabaseLogger:
        class: App\Service\Logger\DatabaseLogger
        arguments:
            $entityManager: '@doctrine.orm.entity_manager'
        tags:
            - { name: 'logger' }

    App\Service\Logger\FileLogger:
        class: App\Service\Logger\FileLogger
        arguments:
            $logFile: '%log_file%'
        public: false  # Example of service visibility

    App\Service\UserService:
        autowire: true
        autoconfigure: true
        arguments:
            $logger: '@=service(parameter("default_logger"))'

    App\EventListener\SomeEventListener:
        tags:
            - { name: 'kernel.event_listener', event: 'kernel.request', method: 'onKernelRequest' }

    App\Service\SomeService:
        decorates: 'original.service.id'
        factory: ['@some.factory.service', 'create']

Summary of Keys

• Global Keys: parameters
• Service Keys: services, class, arguments, tags, factory, decorates, bind, autowire, autoconfigure, public, shared, aliases, calls, deprecated

This list and the example configuration should provide you with a comprehensive overview of the configuration keys available in Symfony's service container. If you need any further details or examples, feel free to ask!