Dependencies

Configure services, dependency injection, and tagging.

Complete services.yaml

# Resources/config/services.yaml
services:
    _defaults:
        autowire: true
        autoconfigure: true

    # Namespace auto-registration
    Plugins\MyPlugin\:
        resource: '../../src/'
        exclude:
            - '../../src/Entity/'
            - '../../src/Migrations/'

    # Bootstrap (must be public)
    Plugins\MyPlugin\Bootstrap:
        public: true

    # Controllers
    Plugins\MyPlugin\Controller\:
        resource: '../../src/Controller/'
        tags: ['controller.service_arguments']

    # CRUD Controllers (must be public + tagged)
    Plugins\MyPlugin\Controller\Admin\:
        resource: '../../src/Controller/Admin/'
        tags: ['controller.service_arguments']
        public: true

    # Widgets (must be tagged)
    Plugins\MyPlugin\Widget\:
        resource: '../../src/Widget/'
        tags: ['widget']

    # Payment Providers (must be tagged + public)
    Plugins\MyPlugin\Provider\:
        resource: '../../src/Provider/'
        tags: ['payment.provider']
        public: true

    # Event Subscribers (NO kernel.event_subscriber tag!)
    Plugins\MyPlugin\EventSubscriber\:
        resource: '../../src/EventSubscriber/'
        public: true

    # Cron Tasks (must be tagged)
    Plugins\MyPlugin\CronTask\:
        resource: '../../src/CronTask/'
        tags: ['plugin.cron_task']

    # Commands (auto-discovered by Symfony)
    Plugins\MyPlugin\Command\:
        resource: '../../src/Command/'
        tags: ['console.command']

    # Custom Services
    Plugins\MyPlugin\Service\MyService:
        arguments:
            $apiKey: '%env(MY_PLUGIN_API_KEY)%'

Tagging Requirements

Component	Tag	Public?	Notes
Bootstrap	None	✅ Yes	Must be public
Controllers	controller.service_arguments	No	Standard controllers
CRUD Controllers	controller.service_arguments	✅ Yes	EasyAdmin controllers
Widgets	widget	No	Dashboard/page widgets
Payment Providers	payment.provider	✅ Yes	Payment integrations
Event Subscribers	None	✅ Yes	DO NOT tag with kernel.event_subscriber
Cron Tasks	plugin.cron_task	No	Scheduled tasks
Commands	console.command	No	CLI commands
Tabs	None	No	Registered via EventSubscriber

Dependency Injection

Constructor Injection

<?php
namespace Plugins\MyPlugin\Service;

use Psr\Log\LoggerInterface;
use Doctrine\ORM\EntityManagerInterface;

class MyService
{
    public function __construct(
        private readonly LoggerInterface $logger,
        private readonly EntityManagerInterface $entityManager,
        private readonly PluginSettingService $pluginSettings,
    ) {}

    public function doSomething(): void
    {
        $this->logger->info('Doing something');
        // ...
    }
}

Method Injection

use Symfony\Component\HttpFoundation\RequestStack;

#[Route('/process', name: 'process')]
public function process(RequestStack $requestStack): Response
{
    $request = $requestStack->getCurrentRequest();
    // ...
}

Service Aliases

services:
    # Alias for easier injection
    my_plugin.api_client:
        alias: Plugins\MyPlugin\Service\ApiClient
        public: true

Service Decoration

services:
    # Decorate core service
    Plugins\MyPlugin\Service\DecoratedService:
        decorates: 'core.some_service'
        arguments:
            $decorated: '@.inner'

Environment Variables

Define in services.yaml

services:
    Plugins\MyPlugin\Service\MyService:
        arguments:
            $apiKey: '%env(MY_PLUGIN_API_KEY)%'
            $apiEndpoint: '%env(default:default_endpoint:MY_PLUGIN_ENDPOINT)%'

Set in .env

MY_PLUGIN_API_KEY=your_key_here
MY_PLUGIN_ENDPOINT=https://api.example.com

Use in PHP

class MyService
{
    public function __construct(
        private readonly string $apiKey,
        private readonly string $apiEndpoint,
    ) {}
}

Plugin Dependencies (composer.json)

External Packages

{
    "name": "my-plugin/my-plugin",
    "description": "My awesome PteroCA plugin",
    "type": "pteroca-plugin",
    "require": {
        "php": ">=8.2",
        "guzzlehttp/guzzle": "^7.0",
        "monolog/monolog": "^3.0"
    },
    "autoload": {
        "psr-4": {
            "Plugins\\MyPlugin\\": "src/"
        }
    }
}

Installing Dependencies

cd plugins/my-plugin
composer install

Declaring in plugin.json

{
    "composer_dependencies": {
        "guzzlehttp/guzzle": "^7.0",
        "monolog/monolog": "^3.0"
    }
}

Plugin-to-Plugin Dependencies

{
    "requires": {
        "base-plugin": "^1.0",
        "other-plugin": ">=2.0.0"
    }
}

PteroCA will ensure dependencies are installed and enabled before your plugin.

Lazy Services

For services that are expensive to instantiate:

services:
    Plugins\MyPlugin\Service\HeavyService:
        lazy: true

Factory Services

Create services dynamically:

<?php
namespace Plugins\MyPlugin\Factory;

class ApiClientFactory
{
    public function __construct(
        private readonly PluginSettingService $settings,
    ) {}

    public function create(): ApiClient
    {
        $apiKey = $this->settings->get('my-plugin', 'api_key');
        $endpoint = $this->settings->get('my-plugin', 'api_endpoint');

        return new ApiClient($apiKey, $endpoint);
    }
}

services:
    Plugins\MyPlugin\Factory\ApiClientFactory: ~

    Plugins\MyPlugin\Service\ApiClient:
        factory: ['@Plugins\MyPlugin\Factory\ApiClientFactory', 'create']

Service Locator

Access services dynamically:

use Psr\Container\ContainerInterface;

class MyService
{
    public function __construct(
        private readonly ContainerInterface $container,
    ) {}

    public function getService(string $id): mixed
    {
        return $this->container->get($id);
    }
}

Compiler Passes

For advanced service manipulation (rarely needed):

<?php
namespace Plugins\MyPlugin\DependencyInjection\Compiler;

use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
use Symfony\Component\DependencyInjection\ContainerBuilder;

class CustomCompilerPass implements CompilerPassInterface
{
    public function process(ContainerBuilder $container): void
    {
        // Custom service manipulation
    }
}

Debugging Services

# List all plugin services
docker exec pteroca_web_dev php bin/console debug:container | grep MyPlugin

# Check specific service
docker exec pteroca_web_dev php bin/console debug:container Plugins\\MyPlugin\\Service\\MyService

# Verify autowiring
docker exec pteroca_web_dev php bin/console debug:autowiring | grep MyPlugin

Common Issues

Service Not Found

Problem: "Service not found"

Solutions:

1. Check namespace matches directory structure (PSR-4)

2. Ensure service is in src/ directory

3. Clear cache: php bin/console cache:clear

4. Verify services.yaml excludes are correct

Circular Reference

Problem: "Circular reference detected"

Solution: Use lazy loading or refactor to break dependency cycle

services:
    Plugins\MyPlugin\Service\ServiceA:
        lazy: true

Service Not Public

Problem: "Service is private"

Solution: Mark as public in services.yaml

services:
    Plugins\MyPlugin\Bootstrap:
        public: true

Best Practices

1. Use autowiring for standard dependencies

2. Keep services focused - single responsibility

3. Inject interfaces not concrete classes when possible

4. Use constructor injection over method injection

5. Mark services as final unless designed for extension

6. Document constructor parameters for clarity

Related Guides

• Bootstrap & Lifecycle - Bootstrap service

• Controllers & Routes - Controller services

• Payment Providers - Provider registration

• Event System - Event subscriber registration