While working on a Symfony project with my team, I needed to inject specific Value Object instances into one of my services. The values themselves, in this particular case, needed to be set from values provided in our .env
file.
I could, of course, just pass the string
values directly into my service and have the service instantiate the Value Objects in the constructor, but I wanted to see if it was possible to configure it in the services.yaml
file and inject the fully-instantiated objects instead. This would allow me to pass those object instances to multiple services and not have to repeat the Value Object creation inside each.
Here's how I did it...
Background
Our application utilizes the Twilio SDK. We have various services wrapping the SDK calls, and they need to use our environment-specific configuration values (our company's API Key for each environment, etc.).
The Twilio API makes use of String Identifiers, or SID
s. Each type of SID
has a different 2-letter prefix associated with it, followed by 32 characters made up of the digits 0 through 9 and the letters A through F (upper and lowercase).
For example:
- A
ConferenceSid
has the prefixCF
and looks likeCFabcdef0123456789abcdef0123456789
- A
CallSid
has the prefixCA
and looks likeCAabcdef0123456789abcdef0123456789
- There are other types of
SID
s and they all use the same format, only differentiated by the prefix
I wanted to make sure the Value Objects for each SID
type validated that the passed-in value had the proper prefix for that SID
type, along with making sure the string was the correct length and was only made up of the allowed characters.
The Value Objects
Each of my SID
types use the same validation logic and functionality, only diffentiating by the SID
type's prefix, so it makes sense to create a base Trait. This could be an Abstract Class if you prefer. I don't need the concept of a TwilioStringIdentifier
in the app as a parameter type or anything like that, so I prefer a Trait over an Abstract Class here.
This Trait does define an abstract method getPrefixForSidType()
that each SID
type must implement, providing the proper prefix for that given type. It also performs the validation logic.
namespace App\Domain\Model\Twilio\Sid;
use Assert\Assert;
trait TwilioStringIdentifier
{
private readonly string $sid;
abstract private function getPrefixForSidType(): string;
public static function fromString(string $string): self
{
return new self($string);
}
public function __construct(string $sid)
{
Assert::that($sid)
->startsWith($this->getPrefixForSidType())
->length(34)
->regex('/^[a-zA-Z]{2}[0-9a-fA-F]{32}$/')
;
$this->sid = $sid;
}
public function asString(): string
{
return $this->sid;
}
}
The SID
classes
The Value Object classes representing each of the SID
types are simple. They just need to use
the TwilioStringIdentifier
Trait and to define the proper prefix via the getPrefixForSidType()
method.
namespace App\Domain\Model\Twilio\Sid;
final readonly class AccountSid
{
use TwilioStringIdentifier;
private function getPrefixForSidType(): string
{
return 'AC';
}
}
The other SID
type classes are identical except for their defined prefix.
Injecting the instantiated objects
Because these Value Objects will be used all throughout the application and with various values associated, and not just our company's global values, I needed a way to inject into services an object of a specific type that was already instantiated with the values defined in our .env
file
I knew that Symfony has the ability to define services to be instantiated via a Factory
but had never really seen (that I recall) anything about injecting an object that was the result of a method call from somewhere else. I also knew these Factory
methods could have arguments passed to them, I just wasn't sure how to do this with one Value Object instance.
Defining the Specific Value Object Instance
Symfony's service definition allows you to name each service. Typically it's done with the Service class' name:
App\Path\To\My\Service:
class: App\Path\To\My\Service
arguments: []
But, that service name doesn't have to match the class name. It could be app.my_service
or Foo\Bar\Baz\Service
or whatever.
So, what if I create a service with a unique name that is the instantiated instance of the Value Object I need? I could pass the .env
value in as the argument and then have that object instance to inject into my service classes!
services.yaml
# Create services named with a Global "namespace"
Global\Twilio\Sid\Account:
factory: ['App\Domain\Model\Twilio\Sid\AccountSid', 'fromString']
arguments: ['%env(TWILIO_ACCOUNT_SID)%']
Global\Twilio\Sid\Api:
factory: ['App\Domain\Model\Twilio\Sid\ApiSid', 'fromString']
arguments: ['%env(TWILIO_API_SID)%']
Global\Twilio\Sid\Application:
factory: ['App\Domain\Model\Twilio\Sid\ApplicationSid', 'fromString']
arguments: ['%env(TWILIO_APP_SID)%']
Then pass those services (objects) into my Twilio service via their named arguments:
App\Service\Vendor\Twilio\TwilioService:
arguments:
$accountSid: '@Global\Twilio\Sid\Account'
$apiSid: '@Global\Twilio\Sid\Api'
$applicationSid: '@Global\Twilio\Sid\Application'
$apiSecret: '%env(TWILIO_API_SECRET)%'
Now my service class can expect to receive the fully-instantiated Value Object instances:
TwilioService
namespace App\Service\Vendor\Twilio;
use App\Domain\Model\Twilio\Sid\AccountSid;
use App\Domain\Model\Twilio\Sid\ApiSid;
use App\Domain\Model\Twilio\Sid\ApplicationSid;
final readonly class TwilioService
{
public function __construct(
private AccountSid $accountSid,
private ApiSid $apiSid,
private ApplicationSid $applicationSid,
private string $apiSecret
) {}
}
Voila!
Symfony is flexible enough and intuitive enough that it was simple to figure out how to do this. Since I couldn't find a quick reference for doing this elsewhere, I thought I'd write this up as a reference for Future Me and anyone else who may need to do something similar
Cheers, and Happy Coding!
Top comments (0)