Forem: Maico Orazio

Using Symfony Messenger to Manage Message Queues in Symfony

Maico Orazio — Mon, 06 May 2024 12:37:02 +0000

Symfony, the famous PHP framework, offers a wide range of powerful tools and components for developers of all levels. One of these tools is Symfony Messenger, a bundle that greatly simplifies message handling within Symfony applications.

What is Symfony Messenger?

Symfony Messenger is a bundle that provides everything you need to consume messages from a message queue. This approach is extremely useful for improving the performance of our applications by allowing us to separate heavy tasks and handle them through a separate worker.

Advantages of Message Queuing

Message queuing allows you to:

Improve application performance.
Handle heavy tasks asynchronously.
Maintain a fast response time for users.

If you are not familiar with message queuing, I recommend delving into the topic to fully understand its benefits.

Use Case

To better understand the usefulness of Symfony Messenger, let's consider a common use case: managing orders and shipments in an application.

Let's imagine having to perform several tasks every time an order is updated, such as:

Updating the order status on the website.
Sending a confirmation email to the user.
Perhaps, sending a notification via SMS.
Executing other internal scripts.

All these tasks require calls to different services, which can take a lot of time, and our goal is to have the shortest response time possible.

By using Symfony Messenger, we could delegate these tasks to a separate worker, significantly improving the overall performance of the application.

Introduction and Installation

To start using Symfony Messenger, we need to first install the package via Composer:

composer require symfony/messenger

This package provides everything needed to create and manage messages and message handlers within our application.

Messages and Handlers

The core of Symfony Messenger revolves around messages and message handlers. A message represents the data to be processed, while a message handler contains the logic to process that message.

For example, suppose we need to send a registration confirmation email to a user who has just registered on our site. We will create a message called SendRegistrationEmailMessage which will contain the user ID.

<?php

namespace App\Message;

class SendRegistrationEmailMessage
{
    public function __construct(
        private readonly int $userId
    ) {}

    public function getUserId(): int
    {
        return $this->userId;
    }
}

Instead of executing everything at the exact moment the registration request is sent, we will queue a message containing the user ID. This way, our controller no longer needs to handle an exception, and we could send a "OK" (200) response much faster.

Next, we will create a message handler called SendRegistrationEmailMessageHandler that will retrieve the user from the ID and send the confirmation email.

<?php

namespace App\MessageHandler;

use App\Entity\User;
use Symfony\Component\Messenger\Attribute\AsMessageHandler;

#[AsMessageHandler]
class SendRegistrationEmailMessageHandler
{
    public function __construct(
        private readonly EntityManagerInterface $entityManager
    ) {}

    public function __invoke(SendRegistrationEmailMessage $message): void
    {
        $user = $this->entityManager->getRepository(User::class)->find($message->getUserId());

        if (!$user instanceOf User) {
            // Handle entity not found case
        }

        // Send the email
    }
}

Symfony Messenger simplifies this process, allowing us to focus on business logic without worrying about implementation details.

Let's see how.

Symfony Messenger comes with a PHP attribute #[AsMessageHandler], so that Symfony considers this service as a message handler to route the correct messages to.

The type of the message to consume is declared in the __invoke method.
This means that for each message, we should create a message handler, with the correct type in the __invoke method, and the routing will be handled automatically by Symfony.

Message Transport and Routing

Symfony Messenger supports various types of transports:

AMQP services (like RabbitMQ).
Doctrine (storing messages in an SQL table).
Cache services (like Redis).

First of all, if we intend to use an AMQP protocol, we need to install the package:

> composer require symfony/amqp-messenger

If we intend to use Doctrine, we need to install the following:

> composer require symfony/doctrine-messenger

Finally, if we want to use Redis as our transport, this is the package we need to install:

> composere require symfony/redis-messenger

If you want to learn more about other transports, you can take a look at the relevant documentation.

We can easily configure the desired transport in the messenger.yaml configuration file, which we will find in config/packages along with all the other configuration files of installed packages.

The transport key contains all the configuration regarding message handling (consumption).

The failure-transport key contains the name of the transport to be used in case of issues (exception thrown during handling).
If something goes wrong here, the stack trace and exception details will be saved in the message and can be retrieved later to be properly handled.

We can also configure the consumer to perform x retries before sending an error message to the "failed" queue and manage different priorities for each queue.

Finally, the routing part explains how to route a specific instance of the message to the transport.

Here is an example of how our configuration file for the above case might look:

framework:
    messenger:
        transports:
            registration_email:
                dsn: '%env(MESSENGER_TRANSPORT_DSN)%'
                failure_transport: registration_email_failed
                retry_strategy:
                    max_retries: 3
                    delay: 1000
                    multiplier: 2
                    max_delay: 0
                options:
                    exchange:
                        name: registration_email
                    queues:
                        registration_email: ~

            registration_email_failed:
                dsn: '%env(MESSENGER_TRANSPORT_DSN)%'
                options:
                    exchange:
                        name: registration_email_failed
                    queues:
                        registration_email_failed: ~

        routing:
            'App\Message\SendRegistrationEmailMessage': registration_email

Dispatching the Message

Dispatching a message is as simple as calling the MessageBus service provided by Symfony Messenger and passing the message to dispatch. The bus will take care of the rest, routing the message to the appropriate handler for processing.

Here's an example:

<?php

namespace App\Service;

use App\Message\SendEMailRegistrationEmailMessage;

class MyExampleService
{
    public function __construct(
        private readonly MessageBusInterface $messageBus
    ) {}

    public function doSomething(): void
    {
        // Any logic...

        $message = new SendEMailRegistrationEmailMessage($userId);

        # This will dispatch the message to the correct transport
        $this->messageBus->dispatch($message);
    }
}

Architecture

The architecture of Symfony Messenger is well-structured and involves the use of a publisher (controller, service, command, etc.) that sends a message to the bus. If the bus is synchronous, the message is consumed directly by a handler. If the bus is asynchronous, the message is sent via a transport to a queuing system, where it is processed by a separate worker.

If the transport is asynchronous, the message must be serialized in order to be interpreted and consumed correctly by the worker. Symfony natively supports two serialization modes:

PHP's native serialization.
Serialization via the Serializer component.

By default, PHP's native serialization is used, which represents the class itself of the message.

If another application consumes the same message queue, it may not have this class, so it will be impossible to deserialize the message. For this reason, we will use a more traditional exchange format. Usually JSON, but we could use XML, Protobuf, or any other interoperable serialization language.

Conclusion

Symfony Messenger is a powerful tool for message handling within Symfony applications. With its support for various transport types and its simple architecture, it allows us to improve application performance and provide a better user experience.

I hope this article has provided you with a comprehensive overview of Symfony Messenger and inspired you to use it in your future Symfony applications! If you want to receive updates on future articles, feel free to follow my account on Medium!

Good work! 👨‍💻

KeycloakClientBundle 2.0: added integration with Symfony's Security component

Maico Orazio — Wed, 24 Apr 2024 08:19:37 +0000

I am thrilled to announce the long-awaited release of version v2.0 of my Symfony bundle for Keycloak authentication, the KeycloakClientBundle!

In this new release, I has introduced a series of significant improvements, with a particular focus on integration with Symfony's Security component. Symfony's Security component offers a powerful and flexible framework for managing authentication, authorization, and other security aspects in Symfony applications. With KeycloakClientBundle v2.0, I has made it possible to directly integrate with Symfony's Security component for protecting the application's UI using the OAuth 2 authorization code flow. Now, you can enable Keycloak authentication directly through Symfony's firewall, leveraging the powerful security management features offered by the Security component.

Here are some of the key benefits and features of KeycloakClientBundle v2.0:

Full integration with Symfony's Security component: Enable Keycloak authentication through Symfony's firewall, using the OAuth 2 authorization code flow to protect the application's UI.
Performance enhancements: Optimizations to ensure greater efficiency and speed.
Bug fixes: Resolving issues reported by the community for an even more stable experience.

I can't wait for you to try out all the new features and improvements we've introduced in this version. For more information and to contribute to the project KeycloakClientBundle, visit our GitHub repository today!

Thank you for your continued support and feedback. Stay tuned for further updates and future developments!

DTO vs VO in PHP

Maico Orazio — Sat, 10 Feb 2024 18:01:13 +0000

Data Transfer Objects (DTOs) and Value Objects (VOs) are particularly useful when working with dynamically typed languages like PHP, where switching to the use of more structured types is essential to improve the quality of our applications, as well as the readability of the code.

What is a DTO (Data Transfer Object)?

A DTO is an object that contains data and defines the structure of that data. The schema is defined by the names of the fields and their types.

It can only guarantee that all or some data are present, simply by relying on the rigidity of the programming language: if a constructor has a required string type parameter, you must pass a string to instantiate the object. However, a DTO does not provide any guarantee on the validity of that data: strings could be empty, integers could be negative, etc.

final class ADtoExample
{
    public function __construct(
        public readonly string $field,
        // ...
    ) {
    }
}

What is a VO (Value Object)?

A VO is an object that provides a guarantee of validity on the data it contains. They are immutable representations of data, aware of the specific domain business rules. They help us write more robust and readable code, minimizing bugs.

A value object is an object that represents a concept in the domain of an application. It is immutable, has no identity, and encapsulates a value.

final class AnVoExample
{
    private function __construct(
        private readonly string $value,
        // ...
    ) {
    }

    public static function fromValue(
        string $value
    ): self 
    {
        match (true) {
            empty($value) => throw new \InvalidArgumentException('value is empty'),
            default => true
        };
         return new self($value);
    }
}

A VO offers several advantages, including:

Domain specificity: They can be used to represent domain-specific values. For example, the EmailAddress class can be used to represent only email addresses.
Error reduction: They help to reduce errors because they encapsulate values and apply business rules.
Better clarity: They make the code clearer and more understandable.
Better testability: They are easier to test than primitive data types.

While a DTO deals with the structure of data, a VO also provides proof that the data meets expectations. When the VO class is used as a parameter, property, or return type, we know that we are dealing with a valid value.

How to use these types of objects?

DTO

A DTO should only be used in two places: where data enters the application or where data leaves the application. They help to encapsulate data, making it easier to manipulate and pass between different parts of the codebase.

Some examples:

When a controller receives an HTTP POST request, the request data can be in any form: we can use a DTO to have the data with a known schema (keys and types verified).
When we make an HTTP POST request to a web service: we can first collect the input data in a DTO and then serialize it into a request body that our HTTP client can send to the service.
For queries: we can use a DTO to represent the query result.
When we receive an HTTP GET request: we can first deserialize the API response into a DTO, so that we can apply a known schema to it instead of accessing the array keys directly and guessing the types.

VO

A VO is used whenever we want to verify that a value meets our expectations and do not want to verify it again.

They are particularly useful for representing the input and output data of an API. In this way, we can be sure that the data received from the API is valid and that the data sent to the API is correct.

We can also use it to create behaviors related to a particular value. For example, if we have a VO EmailAddress, we know that the value has already been verified to be a valid email address, so we do not need to check it again in other places. We can also add methods to the object that extract, for example, the username or hostname from the email address.

Let's take an example of an application where we need to manage prices. Without the use of VOs, our code might be full of functions that receive values (such as number amount and string currency) and each of them would have to repeat validation on the values to prevent errors. Skimping on these checks makes your code cleaner but introduces the risk of bugs. This is where VOs shine.

enum Currency : string
{
  case Dollar = 'USD';
  case Euro = 'EUR';
}

readonly class Price implements Stringable
{
  public function __construct(
    private float $amount,
    private Currency $currency
  )
  {
    match (true) {
      ($this->amount <= 0) => throw new InvalidPriceAmountException('amount is negative'),
      default => true
    };
  }

  public function __toString(): string
  {
    return number_format($this->amount, 2) . ' ' . $this->currency->value;
  }

  public function getAmount(): float
  {
    return $this->amount;
  }

  public function getCurrency(): string
  {
    return $this->currency->value;
  }
}

$price = new Price(15, '$'); // Invalid Argument Exception
$price = new Price(0, Currency::Dollar); // InvalidPriceAmountException

$price = new Price(29.99, Currency::Dollar); // OK
echo $price; // 29.99 USD

Every time you want to represent a price in your code, you can create a Price VO and trust the internal validation performed during instantiation. This means that for the lifecycle of that object in your code, you don't need to revalidate it wherever it's passed between functions.

Conclusions

In conclusion, DTO and VO are two design patterns that are useful for improving code quality and readability in PHP.

DTOs are objects that contain data and define the structure of that data. They are useful for transferring data between different parts of an application.

VOs are objects that provide assurance of data validity. They are useful for representing domain-specific values and applying business rules.

Good work! 👨‍💻

KeycloakClientBundle: A Symfony Bundle for Integrating with Keycloak

Maico Orazio — Sat, 14 Oct 2023 10:03:35 +0000

Keycloak is an open source identity and access management (IAM) solution that provides single sign-on (SSO), user management, and role-based access control (RBAC). It is a popular choice for enterprise applications that need to securely manage user access.

KeycloakClientBundle is a Symfony bundle that makes it easy to integrate your Symfony application with Keycloak.

It provides a set of services and classes that allow you to authenticate users against Keycloak, retrieve user information, and manage user roles.

Features

KeycloakClientBundle includes the following features:

User authentication: The bundle provides a service that allows you to authenticate users against Keycloak.
User information: The bundle provides a service that allows you to retrieve user information from Keycloak.
User roles: The bundle provides a service that allows you to manage user roles in Keycloak.

Please refer to the documentation on the repository page for how to proceed with installation and use.

Learn more and contribute to the project on GitHub.

Date Analysis Using date_parse() and date_parse_from_format() Functions

Maico Orazio — Mon, 09 Oct 2023 15:30:00 +0000

The date_parse() function is used to obtain detailed information about a specific date.

This function returns an associative array containing more details about the parsed date, or it returns false in case of an error. It accepts a single argument specifying the date in a format accepted by the strtotime() function.

$date_parsed = date_parse('2023-06-22T07:30:09+01:00');
print_r($date_parsed);

The example given above returns the following information:

Array
(
    [year] => 2023
    [month] => 6
    [day] => 22
    [hour] => 7
    [minute] => 30
    [second] => 9
    [fraction] => 0
    [warning_count] => 0
    [warnings] => Array
        (
        )

    [error_count] => 0
    [errors] => Array
        (
        )

    [is_localtime] => 1
    [zone_type] => 1
    [zone] => 3600
    [is_dst] => 
)

We can perform date analysis starting from a specific format.

The date_parse_from_format() function is used to obtain detailed information about the specified date based on the specified format.

The date_parse_from_format() function accepts, as its first argument, a string representing the format and then the date. It returns, like date_parse(), an associative array of detailed information about the date in the specified format, or it returns false in case of an error.

$date_parsed = date_parse_from_format('d/m/Y H:i:s T', '22/06/2023 07:30:09 Europe/Rome');
print_r($date_parsed);

The example given above returns the following information:

Array
(
    [year] => 2023
    [month] => 6
    [day] => 22
    [hour] => 7
    [minute] => 30
    [second] => 9
    [fraction] => 0
    [warning_count] => 0
    [warnings] => Array
        (
        )

    [error_count] => 0
    [errors] => Array
        (
        )

    [is_localtime] => 1
    [zone_type] => 3
    [tz_id] => Europe/Rome
)

If we try to specify an incorrect format, we get an incorrect result where the related errors are also listed in errors.

$date_parsed = date_parse_from_format('Y-m-d H:i:s T', '22/06/2023 07:30:09 Europe/Rome');
print_r($date_parsed);

Array
(
    [year] => 22
    [month] => 6
    [day] => 20
    [hour] => 23
    [minute] => 7
    [second] => 30
    [fraction] => 0
    [warning_count] => 0
    [warnings] => Array
        (
        )

    [error_count] => 8
    [errors] => Array
        (
            [2] => Unexpected data found.
            [5] => Unexpected data found.
            [10] => Unexpected data found.
            [16] => Trailing data
        )

    [is_localtime] => 1
    [zone_type] => 0
)

Good work 👨‍💻

In PHP, function parameters

Maico Orazio — Fri, 06 Oct 2023 15:30:00 +0000

In this article, we will discuss function arguments, default values, type unions, argument unpacking, pass by value or reference, and finally, introduced in PHP 8, named arguments.

To define function parameters

We can define function parameters within the parentheses of the function definition.

function foo($x, $y) 
{
    return $x * $y;
}

When we call the foo() function, we need to pass two arguments.

echo foo(5, 10); // 50

Parameters are the variables listed in the function definition, while arguments are the actual values we pass to the function when we invoke it; in the example above, $x and $y are the function's parameters, and 5 and 10 are the passed arguments, i.e., the values assigned to the parameters of the foo() function.

Type Hinting

Type Hinting is a feature introduced by PHP starting from version 5, which allows specifying the type of object/data passed as an argument to a function or method.

Starting from PHP version 7, in addition to the weak mode, there is also the strict mode. By enabling this mode, we force PHP to interpret variable types, and if the type is not satisfied, we will receive a fatal error.

So, if in the example above, we want to be more restrictive and accept only the int type and no others, we should declare it at the top of the code using the declare statement followed by strict_types=1.

declare(strict_types=1);

function foo(int $x, int $y) 
{
    return $x * $y;
}

Now, if we try to pass an argument of type float or string, we will receive an error.

echo foo(5.0, '10');
// Fatal error: Uncaught TypeError: foo(): Argument #1 must be of type int, float given, called in ...

Union of types

Starting from PHP version 8, it is possible to accept multiple data types. We can specify type unions using the | character.

declare(strict_types=1);

function foo(int|float $x, int|float $y) 
{
    return $x * $y;
}
echo foo(5.0, 10); // 50

In this case, we can invoke the foo() function by passing both integers and decimals as arguments.

Default values

For every parameter listed in the function definition, it is necessary to pass an argument; otherwise, we will receive a fatal error.

echo foo(5.0); 
// Fatal error: Uncaught ArgumentCountError: Too few arguments to function foo(), 1 passed in ...

It is possible to set default values for parameters to assign a value in case it is not passed as an argument.

declare(strict_types=1);

function foo(int|float $x, int|float $y = 10) 
{
    return $x * $y;
}
echo foo(5.0); // 50

You can assign scalar arrays and null values as default values, but not a function call or an object; it must be a constant expression.

Another important thing is that optional parameters must be defined after any required parameter.

Pass arguments by value vs by reference

As a default, arguments for required parameters are passed by value. You can specify to pass an argument by reference using the & character in the parameter definition.

For example, let's define a foo() function that takes 2 arguments and returns the multiplication of the arguments, dividing the first argument by 2 if it is an even number.

declare(strict_types=1);

function foo(int|float $x, int|float $y): int|float 
{
    if ($x % 2 === 0) {
        $x /= 2;
    }
    return $x * $y;
}

$a = 6.0;
$b = 7;
echo foo($a, $b); // 21
var_dump($a, $b); // float(6) int(7)

We have mentioned that by default, arguments are passed by value. In fact, modifying the value of $x ($x /= 2;), which is the first argument passed to the function, does not affect the original variable $a, which still holds the value float(6).

If we change the definition of the first argument to pass the reference to the variable $a, in this case, modifying the parameter $x also affects the value of the original variable $a.

declare(strict_types=1);

function foo(int|float &$x, int|float $y): int|float 
{
    if ($x % 2 === 2) {
        $x /= 2;
    }
    return $x * $y;
}

$a = 6.0
$b = 7;
echo foo($a, $b); // 21
var_dump($a, $b); // float(3) int(7)

Decompression of topics

We want to define a function that returns the sum of 2 or more arguments. We can change the function definition as we add an argument, or we can use the spread operator that will capture any arguments passed to the function in an array.

declare(strict_types=1);

function sum(...$numbers): int|float 
{
    $sum = 0;
    foreach ($numbers as $number) {
        $sum += $number;
    }
    return $sum;
    //return array_sum($numbers);
}

$a = 6.0
$b = 7;
echo sum($a, $b, 10, 25); // 48

You can use the spread operator even after a fixed number of parameters, in which case only the arguments passed after the fixed ones will be added to the array.

declare(strict_types=1);

function sum(int|float &$x, int|float $y, ...$numbers): int|float 
{
    return $x + $y + array_sum($numbers);
}

$a = 6.0
$b = 7;
echo sum($a, $b, 10, 25); // 48

In the example above, $x and $y are equal to 6.0 and 7, respectively, and all the remaining arguments passed to the function are captured within the $numbers array.

We can specify the type of the extra arguments passed to the function.

declare(strict_types=1);

function sum(int|float &$x, int|float $y, int|float...$numbers): int|float 
{
    return $x + $y + array_sum($numbers);
}

$a = 6.0
$b = 7;
echo sum($a, $b, 10, 25, '8');
// Fatal error: Uncaught TypeError: sum(): Argument #5 must be of type int|float, string given, called in ...

In this case, we receive an error because the last argument passed to the function is a string.

The spread operator can also be used to unpack an array into the list of arguments to be passed to a function.

declare(strict_types=1);

function sum(int|float &$x, int|float $y, int|float...$numbers): int|float 
{
    return $x + $y + array_sum($numbers);
}

$a = 6.0
$b = 7;
$numbers = [10, 25, 8];
echo sum($a, $b, ...$numbers); // 56

named arguments

In PHP 8.0, we have the ability to specify the name of the argument to be passed to the function, regardless of the order listed in the function definition.

Let's define a function where, if the first parameter $x is divisible by the second parameter $y, it returns their division; otherwise, it returns the value of $x.

declare(strict_types=1);

function foo(int &$x, int $y): int 
{
    if ($x % $y === 0) {
        return $x / $y;
    }
    return $x;
}

$a = 6
$b = 3;
echo foo($a, $b); // 2

What happens if we change the order of the arguments passed to the function?

echo foo($b, $a); // 3

We get the value of $b because it's no longer divisible. This new feature in PHP 8 effectively allows us to name the argument to indicate the value of the respective parameter declared in the function, regardless of the order.

echo foo(y: $b, x: $a); // 2

This feature proves to be very useful in various use cases. For example, if we want to change the order of parameter definitions, we would have to search throughout the code where the function is used and update the order of how we pass arguments. With named arguments, we no longer need to worry about updating existing functions because the order is not important. However, if we change the name of a parameter, we still need to update the name in every part of the code where it is used.

Another very valid use case is when you have a series of parameters with default values. For example, PHP has a function called setcookie() that has many parameters with default values. If we wanted to pass only the name and the last argument, we would still have to pass all the others defined before the last one.

/*
method signature
setcookie (
 string $name,
 string $value = "",
 int $expires = 0,
 string $path = "",
 string $domain = "",
 bool $secure = false,
 bool $httponly = false,
) : bool
*/

setcookie('test', '', 0, '', '', false, true);
// named arguments
setcookie(name: 'test', httponly: true);

Passing the same argument multiple times results in an error because it overwrites the previous argument.

echo foo(x: $b, x: $a);
// Fatal error: Uncaught Error: Named parameter $x overwrites previous argoument in ...

You can combine named arguments with positional arguments as long as the named arguments come after the positional ones.

echo foo($a, y: $b); // 2

Passing x again conflicts because we already have an argument for the $x parameter.

echo foo($a, x: $b);
// Fatal error: Uncaught Error: Named parameter $x overwrites previous argoument in ...

Another thing to note is that if we use argument unpacking and the array contains keys, those keys will be treated as argument names.

$arr = ['y': 3, 'x' => 6];
echo foo(...$arr); // 2

Good work 👨‍💻

How to test a private service in Symfony

Maico Orazio — Wed, 04 Oct 2023 15:30:00 +0000

In Symfony 3.4, they made all services private by default, which means you can no longer call $this->get('my_service_id') in your controllers to quickly obtain a service.

This change was made because direct usage of services from the container is considered a bad practice. That's why controllers allow services to be injected using Type Hinting in their methods and constructors.

The only remaining inconvenience is that when running tests, we get the following:

> bin/phpunit
# Symfony\Component\DependencyInjection\Exception\ServiceNotFoundException: The "App\Service\S" service or alias has
# been removed or inlined when the container was compiled. You should either make it public, or stop using the container
# directly and use dependency injection instead.

Problem

We want to create a service and test it before integrating it with the rest of the project (standard TDD approach).

I have a repository R that implements the RInterface interface. The RInterface interface is used in the S service (type hinted constructor). The S service is used in the C controller (again, as a constructor parameter).

When we run the test for the S service...

class STest extends KernelTestCase
{
    public function testGetItems(): void
    {
        self::bootKernel();
        $container = self::$kernel->getContainer();

        $service = $container->get(S::class);
        // ... other
    }
}

We see the following message:

> bin/phpunit
# Symfony\Component\DependencyInjection\Exception\ServiceNotFoundException: The "App\Service\S" service or alias has
# been removed or inlined when the container was compiled. You should either make it public, or stop using the container
# directly and use dependency injection instead.

Reason

The service can be integrated when certain conditions are met.

To check if the S service is present in the test container, we type the following command:

> bin/console debug:container 'App\Service\S' --env=test

Here is the message we will see:

Information for Service "App\Core\Service\S"
=========================================================

 ---------------- ---------------------------------
  Option           Value
 ---------------- ---------------------------------
  Service ID       App\Service\S
  Class            App\Service\S
  Tags             -
  Public           no
  Synthetic        no
  Lazy             no
  Shared           yes
  Abstract         no
  Autowired        yes
  Autoconfigured   yes
 ---------------- ---------------------------------

As mentioned in the received message when running the test, the S service appears as private (Public: no). It's important to note that due to how the Symfony container works, unused services are removed from the container. This means that if you have a private service not used by any other service, Symfony removes it, and you cannot retrieve it from the container.

Solution

The solution is to explicitly define the S service as public so that Symfony does not remove it. The most appropriate solution would be to create a public alias only in the test environment for the service you want to test.

# config/services_test.yaml
services:
  test_alias.service:s:
    alias: 'App\Service\S'
    public: true

Good work 👨‍💻

PHP Match Expression - Match vs Switch

Maico Orazio — Mon, 02 Oct 2023 15:30:00 +0000

The Match expression is essentially the same as the Switch statement and was introduced in PHP 8.

The keyword is match, so let's recreate the switch statement below:

$paymentStatus = 1;

switch ($paymentStatus) {
  case 1:
    echo 'Paid';
    break;
  case 2:
  case 3:
    echo 'Payment Declined';
    break;
  case 0:
    echo 'Pending Payment';
    break;
  default:
    echo 'Unknown Payment Status';
    break;
}

Inside the curly braces, we form pairs of values where the key is the individual conditional expression, and the value is the return expression.

$paymentStatusDisplay = match ($paymentStatus) {
  1 => 'Paid',
  2,3 => 'Payment Declined',
  0 => 'Pending Payment',
  default => 'Unknown Payment Status',
};
echo $paymentStatusDisplay;

Let's talk about the differences

The first difference is that the match expression is actually an expression and evaluates to a value, so it can be assigned to a variable. It can be practically any type of expression; for example, we could use a function that returns a value.

The second difference is that switch requires the use of break to avoid some unexpected outcomes, such as the evaluation of other case statements, while the match statement returns a value once a match is found.

The third difference is that in the switch statement, the default value is not required, whereas a fatal error is generated in match if a corresponding match is not found in any of the listed cases and the default value is not specified.

The fourth difference is that the match expression performs a strict comparison while the switch statement performs loose comparison. Both sides are expressions, and we could have complex expressions, function calls, logical operators used within a conditional expression.

$paymentStatus = false;
// switch print 'Pending Payment'
// match print 'Unknown Payment Status'

One thing to note is that the match expression does not deprecate the switch statement as it still has its use cases. For example, match returns a value once a match is found, whereas with switch, you can execute multiple statements.

Good work 👨‍💻

Using array_merge in a PHP loop is considered bad practice

Maico Orazio — Sat, 30 Sep 2023 09:56:42 +0000

To use the array_merge function in a for / foreach / while loop, do the following:

$arraysToMerge = [ [1, 2], [2, 3], [5, 8] ];

$arraysMerged = [];
foreach($arraysToMerge as $array) {
    $arraysMerged = array_merge($arraysMerged, $array);
}

is a poor practice 😱 because it is a performance drain (especially on memory).

Since PHP 5.6, there is a new operator, the spread operator,

$arraysToMerge = [ [1, 2], [2, 3], [5,8] ];

$arraysMerged = array_merge([], ...$arraysToMerge);
print_r($arraysMerged);

output

Array
(
    [0] => 1
    [1] => 2
    [2] => 2
    [3] => 3
    [4] => 5
    [5] => 8
)

which automatically expands the array without the need to loop through it.

No more performance issues
No for / foreach / while loops
Processed in a single line of code.

A more complex example can be represented by the following case:

I have a list of students
For each of them, I need to retrieve their used books
I need to store them in a new array structure

It is possible to use the spread operator, but an intermediate process is required:

// student data model
$students = [['id'=>1],['id'=>2],['id'=>3]];

// retrieve used books by student ID
function searchUsedBooksByStudent($id) {
    $books = [];
    $books[1] = ['italian', 'history'];
    $books[2] = ['mathematics'];
    $books[3] = ['latin'];
    if (isset($books[$id])) {
        return $books[$id];
    }
    return [];
}


$arrayUsedBooks = [];
foreach ($students as $student) {
    $books = searchUsedBooksByStudent($student['id']);
    if ($books) {
      $arrayUsedBooks[] = $books;
    }
}
$arraysMerged = array_merge([], ...$arrayUsedBooks);
print_r($arraysMerged);

output

 Array
(
    [0] => italian
    [1] => history
    [2] => mathematics
    [3] => latin
)

I hope these examples are helpful. Now, look at your code to see what you can improve!

Good work 👨‍💻

Guida ai React Hooks

Maico Orazio — Fri, 11 Dec 2020 08:00:00 +0000

Se fai un lavoro come il mio, l’approfondimento è una delle regole da seguire nel quotidiano. Nell’ultimo periodo mi è capitato di approfondire i React Hooks e ho deciso di scrivere per il blog dell’azienda in cui lavoro una guida su questo tema. La guida ai React Hooks , divisa in 3 parti nella quale ho presentato alcuni hooks di uso più comune e qualche altro utile al fine di migliorare le prestazioni delle vostre app in React.

Grazie agli Hooks siamo in grado di usare lo stato nei componenti funzionali stateless senza creare necessariamente un componente di classe per utilizzarlo

Nella prima parte della guida ai React Hook approfondisco il perché e il come sono stati introdotti gli hooks e l’utilizzo dei più comuni useState e useEffect.

L’ hook useState consente di gestire lo stato locale nei componente funzionali.

L’ hook useEffect viene utilizzato per gestire gli effetti collaterali nei componenti funzionali.

Nella seconda parte della guida ai React Hooks presento altri due hooks utili alla gestione dello stato.

L’ hook useReducer può essere utilizzato in alternativa a useState, è ideale per la gestione di stato e transazioni di stato più complessi.

L’ hook useContext ti fa risparmiare lo stress di dover fare affidamento su un consumer Context e ha un’API più semplice rispetto all’API di render props.

Nell’ultima parte della guida ai React Hooks introduco altri due hooks utili per ottimizzare le prestazioni delle app in React.

L’ hook useMemo usato per memorizzare i valori.

L’ hook useCallback usato per memorizzare le funzioni.

All’interno della guida ho condiviso esempi di codice per ogni hook illustrato e per i quali ho inserito i link ai relativi repository.

Buona lettura!

The post Guida ai React Hooks appeared first on MaiNick Web.