Forem: Peter Hrobar

Supercharge Laravel’s validation with value objects

Peter Hrobar — Tue, 13 Jun 2023 09:18:32 +0000

Laravel is a popular PHP framework that provides a robust and flexible validation system for handling user input and ensuring data integrity.

Laravel’s validation system allows you to define validation rules for incoming data and easily validate it against those rules.

The validation system in Laravel offers several features and benefits:

Convenient syntax: Laravel provides a fluent and expressive syntax for defining validation rules. You can specify the rules directly in your controller or form request classes.
Rule-based validation: You can define validation rules for various types of input data, such as strings, numbers, dates, emails, and more. Laravel offers a wide range of built-in validation rules that cover common use cases. For example, you can validate that a field is required, has a specific length, matches a regular expression, or exists in a database table.
Custom validation rules: Laravel allows you to define your own custom validation rules. This feature is handy when you have specific validation requirements unique to your application.
Error messages: When validation fails, Laravel automatically generates helpful error messages that you can display to the user. You can easily access these error messages and display them in your views.
Conditional validation: Laravel’s validation system supports conditional validation rules. You can specify that certain rules should only be applied if specific conditions are met. For example, you can validate a field as required only if another field has a certain value.
Form request validation: Laravel encourages the use of form request classes, which encapsulate the validation logic for a specific form or request. These classes centralize the validation rules, making your code more organized and maintainable.
Validation with database integration: Laravel allows you to validate input against your database records. You can perform unique rule validation to ensure that a value is unique in a specific table column.

Overall, Laravel’s validation system provides a convenient and powerful way to validate user input, enforce data integrity, and handle validation errors in a structured manner. It helps in improving the security, reliability, and user experience of your applications.

In programming, a value object is a concept from domain-driven design (DDD) that represents an immutable object whose equality is based on its attribute values rather than its identity. A value object’s main purpose is to encapsulate a set of related attributes or values into a single logical unit.

In PHP, value objects can be implemented as classes with private properties and getter methods, ensuring that the internal state cannot be modified once the object is created. Value objects typically have no identity and are compared based on their attribute values. This means that two value objects with the same attribute values are considered equal.

Here are some benefits of using value objects in PHP or any other programming language:

Clarity and expressiveness: By using value objects, you can give meaningful names to the data structures in your domain model. Value objects represent concepts and behaviours within your application, making the code more expressive and self-explanatory.
Immutability: Value objects are immutable, meaning their state cannot be changed after creation. This immutability guarantees that the data they hold remains consistent and cannot be accidentally modified. Immutability also simplifies reasoning about code since you don’t have to worry about unexpected changes to objects.
Encapsulation and data integrity: Value objects encapsulate related attributes, ensuring that the internal state is always valid and consistent. You can enforce business rules and constraints within the value object’s methods, ensuring that the object remains in a valid state.
Simplified comparisons: Value objects provide a natural way to compare objects based on their attribute values. You can easily check if two value objects are equal without having to compare individual attributes manually.
Domain-specific behaviour: Value objects can encapsulate behaviour related to the attributes they represent. By adding methods to value objects, you can define behaviour specific to the domain concept they represent. This helps in keeping the behaviour and the data it operates on closely related and self-contained.
Code reuse: By using value objects, you can reuse them across different parts of your application or even across multiple projects. Value objects are self-contained units of behaviour and data, making them easily reusable and testable.
Strong typing and type safety: Value objects provide a way to create strongly typed data structures in dynamically typed languages like PHP. By defining value objects with specific attribute types, you can ensure that the data passed into and returned from your methods is of the correct type.

Overall, using value objects in PHP and other programming languages brings clarity, immutability, encapsulation, and domain-specific behaviour to your code. They help in creating more expressive and maintainable code that accurately represents the concepts and constraints of your domain model.

Laravel’s validation system is flexible enough to handle various types of input, including value objects. Value objects can be used as inputs for validation rules, allowing you to validate and enforce rules specific to the attributes of the value object.

To use value objects in Laravel validation, you can follow these steps:

Create your value object: Define a class for your value object, encapsulating the related attributes and behaviour. Ensure that the value object is immutable and implements appropriate methods for accessing its attribute values.
Prepare the input data: Before performing validation, you need to extract the attribute values from your value object and prepare them for validation. You can create an array or use Laravel’s toArray() method to convert the value object to an array representation.
Define validation rules: In your validation rules, you can use the extracted attribute values from the value object as inputs. You can specify the rules directly in your controller or form request classes, similar to how you would validate other input data.
Perform validation: Use Laravel’s validation mechanism, such as the Validator class or form request validation, to perform the validation. Pass the extracted attribute values as the input data to be validated.

My data object represents a connection point:

<?php

namespace App\ValueObjects;
use Illuminate\Contracts\Support\Arrayable;

final class ConnectionPoint implements Arrayable {

    const MAX_PORT_NUMBER = 288;

    // Full format for a connection point: Z199S01P010
    const FORMAT = "Z([0-9]{3})S([0-9]{2})P([0-9]{3})";

    private function __construct(
            private int $zone,
            private int $stripe,
            private int $port,
            private string $name
        ) 
    { }

The class implements the Arrayable interface since we are connecting this with an Eloquent model. In the application we will create a fresh instance of the model from time to time.

There are only two ways to instantiate our value object:

using a static conversion method to create a new connection point object
or creating an empty connection point object

public static function fromString(string $name = ''): self {
        $parts = preg_match("/^".self::FORMAT."$/si", $name, $matches);

        if ($parts === 0 || $parts === false) {
            throw new \InvalidArgumentException(__("Invalid name argument has been passed: {$name}."));
        }

        list($name, $zone, $stripe, $port) = $matches;

        // Additional checking can be added here if required
        // I just removed mine, since it is not relevant for the topic

        return new self($zone, $stripe, $port, $name);
}

public static function createEmpty(): self {
        return new self(0, 0, 0, '');
}

The class is immutable and only allows getting out of data using getter methods and comparing objects to each other:

public function equals(ConnectionPoint $connectionPoint): bool {
        return $this->hasSameName($connectionPoint) &&
               $this->hasSameZone($connectionPoint) &&
               $this->hasSameStripe($connectionPoint) &&
               $this->hasSamePort($connectionPoint);
}

Now, let us get to the fun part. Let us connect our value object with an Eloquent model. For this Laravel provides a flexible casting system.

In the context of Laravel’s Eloquent ORM (Object-Relational Mapping), casting refers to the process of transforming the data retrieved from a database into native PHP data types and vice versa.

Eloquent allows you to define casts for specific attributes of your model, enabling you to work with attribute values consistently and conveniently.

To create a custom cast run the following artisan command:

php artisan make:cast ConnectionPointCast

The new cast class will be placed in your app/Casts directory.

In our custom cast class, we define a getter, a setter and a compare method:

class ConnectionPointCast implements CastsAttributes
{
    public function get($model, string $key, $value, array $attributes)
    {
        $f = fn($value) => $value instanceof ConnectionPoint;

        return match($value) {
            $f($value) => $value,
            null => ConnectionPoint::createEmpty(),
            default => ConnectionPoint::fromString((string) $value)
        };
    }

    public function set($model, string $key, $value, array $attributes)
    {
        // do not forget, that value objects are immutable!
        if ($value instanceof ConnectionPoint) {
            return $value->getName();
        }

        return (ConnectionPoint::fromString((string) $value))->getName();
    }

    public function compare($value, $originalValue)
    {
        $value = ConnectionPoint::fromString((string) $value);
        $originalValue = ConnectionPoint::fromString((string) $originalValue);

        return $value->equals($originalValue);
    }

}

I use the compare method to make sure that in the application when we call getDirty() on our model then the various model instances are compared correctly.

As a final step in the Eloquent model, you have to define the custom cast by adding them to the $casts property:

protected $casts = [
        'start' => ConnectionPointCast::class,
        'end' => ConnectionPointCast::class
];

Now, let us continue with Laravel validation. To make our value object work with Laravel, we need to create a custom validation object (you might use a closure as well as part of your validation, but if you are re-using these then it is simpler to put them into their class).

Use the make:rule Artisan command to generate a new custom validation class. Specify the desired name for your custom rule. For example, let's create a rule called ConnectionPointCompare:

php artisan make:rule ConnectionPointCompare --invokable

This will create our new rule in the app/Rules directory of your project.

Our custom rule implements the DataAwareRule and the ValidatorAwareRule interfaces as well, since we need to get access to the validator and its data in our validation logic. You might, or might not need these in your code.

<?php

namespace App\Rules;

use Illuminate\Contracts\Validation\DataAwareRule;
use Illuminate\Contracts\Validation\InvokableRule;
use Illuminate\Contracts\Validation\ValidatorAwareRule;
use InvalidArgumentException;
use App\ValueObjects\ConnectionPoint;

class ConnectionPointCompare implements DataAwareRule, InvokableRule, ValidatorAwareRule
{

    protected $data = [];
    protected $validator;


    public function __invoke($attribute, $value, $fail)
    {
        try {
            $start = ConnectionPoint::fromString((string) $value);
            try {
                $end = ConnectionPoint::fromString((string) $this->data['end']);
                if (!$start->compare($end))
                    $fail('validation.connection_point_compare')->translate();
            } catch (InvalidArgumentException $e) {
                $attributeName = __('validation.attributes.' . 'end');
                $errorMessage = __('validation.connection_point_format', [
                    'attribute' => $attributeName,
                    'value' => $this->data['end']
                ]);
                $this->validator->errors()->add('end', $errorMessage);
            }
        } catch (InvalidArgumentException $e) {
            $fail('validation.connection_point_format')->translate([
                'value' => $value,
            ]);
        }
    }

    public function setData($data): self {
        $this->data = $data;
        return $this;
    }

    public function setValidator($validator): self {
        $this->validator = $validator;
        return $this;
    }

}

You can see the power of data objects in the example code:

if we can not instantiate our start connection point then we immediately throw an exception with the relevant error message,
then we try to do the same for our end connection point. Please notice how we use the validator object and the validation data to access other attributes and their values,
if we were able to instantiate both connection points then we are ready to compare them. compare() is a method of our value object class that I’m not going to detail here,
if everything works as expected then we are fine, otherwise, we throw the relevant exception.

By using value objects in Laravel validation, you can ensure that the input data adheres to the rules specific to the attributes of the value object, promoting data integrity and validation consistency within your application.

The final part is to integrate our custom validation rules into the validation process.

There are many way to use validation in Laravel. You can find the detailed documentation for your Laravel version here: [(https://laravel.com/docs/9.x/validation#custom-validation-rules)]

'start' => [
    'bail',
    'required',
     new ConnectionPointFormat,
     new ConnectionPointLocation,
     new ConnectionPointCompare,
],
'end' => [
     'bail',
     'required',
     new ConnectionPointFormat,
     new ConnectionPointLocation,
],

As you can see we can chain our validation rules just like any other rule. I use the bail keyword so after the first unsuccessful validation check the rest is not executed.

If I have to change the format of a connection point I have to do it in only one place in the entire application and everything else will still work without modification.

If I would like to change the way I compare these connection points, the validation system will follow ‘automagically’.

Value objects and custom validation provides an elegant and easy way to maintain clarity and expressiveness, encapsulation and data integrity and promotes code reuse throughout your Laravel application.

Just like I promised you at the beginning of this article.

Chaining events in Laravel

Peter Hrobar — Wed, 17 May 2023 06:59:59 +0000

The Laravel event management system provides a flexible and powerful mechanism for implementing event-driven architecture in your application. It promotes decoupling, modularity, reusability, and testability while allowing for easy extensibility and adaptability.

In Laravel, an event is a class that represents a specific occurrence or action that takes place within your application.

Events serve as a way to notify other parts of your application when something significant happens.

Events allow for a decoupled and flexible architecture by separating the logic that triggers an event from the logic that handles the event. This means that different components of your application can be loosely coupled and unaware of each other, making it easier to add or remove functionality without directly modifying existing code.

When an event is fired in Laravel, it triggers a sequence of actions. These actions can include executing event listeners, sending notifications, updating data, logging, or any other logic you define.

To create an event run the following artisan command:

php artisan make:event CableStatusChanged

This command generates an event class file in the app/Events directory. You can then define properties and methods within this class to encapsulate the data and behavior associated with the event.

The below code snippet is an example of the CableStatusChange event. It receives its parameters through the constructor and stores them as public properties.

<?php

namespace App\Events;

use App\Models\Cable;
use Illuminate\Broadcasting\InteractsWithSockets;
use Illuminate\Broadcasting\PrivateChannel;
use Illuminate\Foundation\Events\Dispatchable;
use Illuminate\Queue\SerializesModels;

class CableStatusChanged
{
    use Dispatchable, InteractsWithSockets, SerializesModels;

    /**
     * Create a new event instance.
     *
     * @return void
     */
    public function __construct(public Cable $cable, public int $cablePairStatusId) {

    }

}

Once you have created an event you need to create an event listener.

Event listeners are responsible for responding to events and performing actions based on those events.

When an event is fired in Laravel, it will be dispatched to its corresponding listeners. The listeners can then execute code or perform tasks in response to the event. This allows for the decoupling of different components within your application, making it easier to add or remove functionality without directly modifying the code that triggers the event.

To create an event listener in Laravel, you can use the artisan command make:listener like this:

php artisan make:listener ChangeCableStatus --event=CableStatusChanged

After running the command, Laravel will generate a new listener class file in the app/Listeners directory. You can find and modify this file to define the logic for handling the event. Within the listener class, you'll typically implement the handle() method, which contains the code that should be executed when the event is fired.

Once you’ve created an event listener, you need to register it in your application. This can be done in the EventServiceProvider class, located in the app/Providers directory. Inside the listen property of the service provider, you can specify the events and their corresponding listeners:

class EventServiceProvider extends ServiceProvider
{
    /**
     * The event to listener mappings for the application.
     *
     * @var array<class-string, array<int, class-string>>
     */
    protected $listen = [
        CableStatusChanged::class => [
            ChangeCableStatus::class,
            RegisterCableStatusChange::class,
        ]
    ];

}

In the above example, you can see how to chain listeners for the same event.

Chaining listeners allows you to define multiple listeners that will be executed sequentially when the event is fired. Each listener in the chain can perform its actions or handle different aspects of the event.

It is important to remember that the order of listeners in the chain matters. If ChangeCableStatus modifies the event data or cancels the event, subsequent listeners may receive different data or not be executed at all. Therefore, it’s important to consider the order of listeners when chaining them.

By chaining listeners, you can create a modular and flexible event-driven system in Laravel, where different listeners can handle specific aspects of an event or perform different tasks in response to the same event.

class ChangeCableStatus {
    /**
     * Handle the event.
     *
     * @param  \App\Events\CableStatusChanged  $event
     * @return void
     */
    public function handle(CableStatusChanged $event) {
        $event->cable->connection_points()
            ->get()
            ->each
            ->update(['cable_pair_status_id' => $event->cablePairStatusId]);
    }

}

The event listener in the example above receives the event and updates the application database accordingly.

The reason for using each() method is to enable record-level logging for mass updates in the application.

In Laravel, you can fire an event using the event() helper function or the Event facade. Here's how you can fire an event using the Eventfacade:

$cablePairStatusIdIsDirty &&
    CableStatusChanged::dispatch($this->cable, $this->cablePairStatusId);

In both cases, you’re creating a new instance of the event class (CableStatusChanged) and passing any necessary data as its constructor arguments.

As a summary let me highlight the advantages of Laravel’s event management system:

Decoupled Architecture: Events allow for a decoupled architecture by separating the code that triggers an event from the code that handles the event. This promotes loose coupling between different components of your application, making it easier to modify or extend functionality without directly modifying existing code.
Modularity and Reusability: Events provide a modular and reusable approach to handling specific occurrences or actions within your application. You can define events and their corresponding listeners, allowing you to add or remove listeners as needed. This promotes code organization and reusability across different parts of your application.
Flexibility: With event-driven architecture, your application becomes more flexible and adaptable. By firing events and attaching listeners, you can easily introduce new features or change existing behavior by adding or modifying event listeners. This promotes scalability and makes it easier to maintain and evolve your application over time.
Improved Testability: Events make it easier to write unit tests for specific functionality within your application. You can test event listeners independently, ensuring they respond appropriately to events and perform the expected actions. This improves the overall testability and maintainability of your codebase.
Event Sourcing and Logging: Laravel events can be used for event sourcing, where events are stored and used to rebuild the application state. This enables auditing, historical tracking, and undo/redo functionality. Events can also be logged to provide a comprehensive record of important occurrences in your application, facilitating debugging and troubleshooting.
Asynchronous Processing: Laravel’s event system supports asynchronous event handling, allowing listeners to be processed asynchronously. This can be particularly useful when dealing with time-consuming or resource-intensive tasks, as it offloads the processing to a background queue, improving performance and responsiveness.

Testing with phpbench

Peter Hrobar — Tue, 16 May 2023 06:19:30 +0000

Non-functional requirements are often forgotten aspects of code development.

One of the most well-known non-functional requirements is application performance.

If your application is dealing with a large number of users then this can be translated to various things, typically front-end response time.

Today, it’s no longer a cliché that your competition is just one click away on the Internet.

A couple of months back I had to re-write one of my old applications using Laravel and Livewire.

The application is used to document the cabling layout in a data center. One key feature is the listing of the routes between the connectivity devices. For this purpose, the software uses graph search algorithms, which can explore the paths between the devices and print all the cables along the paths.

Originally I used a BFS-based approach that was quick enough and worked well in an unweighted and undirected graph.

I wanted to explore other approaches, such as incorporating weights into the pathfinding functionality of the application and testing various alternatives to BFS.

In my previous article, I wrote about an algorithm I have developed to find the shortest path between two nodes in a weighted graph. I used Dijkstra’s algorithm with my priority queue to accomplish this.

I also come up with a bidirectional search algorithm based on ChatGPT-generated pseudo-code. ChatGPT provided its version in Python so I had to rewrite the code to PHP but this was much simpler than I thought.

PHP rocks again …. please contact me if you are interested in the final code of bidirectional search in PHP.

After obtaining all three algorithms for comparison, I needed to select a tool that could assist me in comparing their performance.

An obvious choice was phpbench since it is relatively simple to use and in many aspects, it is similar to phpunit.

As the phpbench documentation states:

“PHPBench is a benchmark runner for PHP analogous to PHPUnit but for performance rather than correctness”.

After installing phpbench in my project I created a class file that contains my performance test cases:

/**
 * @BeforeMethods({"setUp"})
 */
class GraphTraversalBench
{

    private array $fullGraph = [];

    private int $start, $end;
    private $app;

    protected function initializeGraph(): array { ... }

    public function setUp() {

        ...

        $this->fullGraph = $this->initializeGraph();

        // Select start and end device randomly ...
        $this->start = array_rand($this->fullGraph);

        do {
            $this->end = array_rand($this->fullGraph);
        } while ($this->end === $this->start);

    }

    public function benchBFS()
    {
        (new Graph(graph: $this->fullGraph))->breadthFirstSearch($this->start, $this->end);
    }

    public function benchDijkstraWithPriorityQueue()
    {
        (new Graph(graph: $this->fullGraph))->dijkstraWithPriorityQueue($this->start, $this->end);
    }

    public function benchBidirectionalSearch()
    {
        (new Graph(graph: $this->fullGraph))->bidirectionalSearch($this->start, $this->end);
    }

}

The code is straightforward:

first, we set up all the class variables so all test methods can use the same graph (fullGraph) with the same start and end nodes,
then we create a new instance of our Graph and call each search method one by one.

When we run our tests we specify the number of revs and iterations on the command line.

Since we pick a random start and end node for our testing we define a relatively high number of revs and a relatively low number of iterations.

As you can see in the figure below we tested 25 pairs of nodes with all 3 algorithms and we run each algorithm a 100 times for the same start and end nodes.

Benchmarking results for various path finding algorithms

The final results are not surprising.

The bidirectional search algorithm is a basically doing a BFS from the start and the end nodes respectively so this should be the quickest amongst the tested ones.

BFS is also very quick since we know the start and the end nodes (during testing it was using a non-weighted version of our graph).

Dijkstra’s algorithm on the other hand is much slower than the other two even with a priority queue based implementation.

This is due to the fact that it not only finds the path between the two given nodes but it also take into consideration the weight of the edges connecting them.

Since I was happy with it’s performance I decided to keep the original version of my BFS code.

With the given results I can easily translate the performance implications of switching to an other algorithm that can provide the advantages of using a weighted graph as well.

Finding the shortest path in a weighted graph with PHP

Peter Hrobar — Fri, 12 May 2023 14:13:58 +0000

A simple implementation of Dijkstra’s algorithm in PHP

In my last article I shared my code for searching a path in a graph using breath first search.

BFS works well if the graph is not weighted. By the way if the weight is 1 (or any other constant) for each edge then BFS is basically finding the same path like Dijkstra’s algorithm.

My implementation allows to select a method that calculates the edge weight so anybody can check the above statement … :-)

What if our graph has weights for each edge that needs to be taken into consideration?

Let’s just imagine the road network with the cities as vertexes and the roads as edges.

If we have to find the shortest path between two cities then obviously the weight of the edge (e.g. the distance between the cities) does matter.

In my use-case (a datacenter with network devices and cables connecting them) a weight can be also specified. Just think about the OSPF protocol that is also using Dijkstra’s algorithm.

I have selected a minimum priority queue based approach since it is somewhat quicker that a regular set based solution. I will compare the performance of these algorithms in my next article.

Unfortunately, neither PHP nor the Ds\PriorityQueue or SplPriorityQueue packages come equipped with a minimum priority queue data structure that meets the stated requirements (as outlined below).

So I wrote my own PriorityQueue class that implements the 3 methods needed:

add_with_priority(): adds an item (in our case a vertex) to the priority queue with a priority,
decrease_priority(): decrease the priority of an item,
extract_min(): returns the item with the smallest priority from the queue.

My solution is array based but I do not need anything fancier than that.

The code is pretty straightforward:

public function dijkstraWithPriorityQueue(int $origin, int $destination) {

    $this->origin = $origin;
    $this->destination = $destination;

    $dist = [];
    $dist[$origin] = 0;

    $q = new MyPriorityQueue();

    foreach(array_keys($this->graph) as $vertex) {
        if ($vertex !== $origin) {
            $dist[$vertex] = self::$infinite;
            $this->setParent($vertex, null);
            $q->append($vertex, self::$infinite);
        }
    }

    $q->add_with_priority($origin, 0);

    while($q->count()) {
        $u = $q->extract_min();
        if ($u === $destination || $u === 0)
            break; // if we found our destination or there is no such route ...
        foreach($this->getAdjacentEdgesInSet($u, $q) as $v) {
            $alt = $dist[$u] + $this->graphEdges($u, $v, $this->getDistance(...));
            if ($alt < $dist[$v]) {
                $dist[$v] = $alt;
                $this->setParent($v, $u);
                $q->decrease_priority($v, $alt);
            }
        }
    }

    $this->setRoute($this->extractRoute());

    return $this;

}

Let us go through the code line-by-line:

We set our origin and destination vertexes.
Then we initiate a destination matrix holding the current distance between the given node and our origin vertex ($origin).
We create a new instance of my priority queue implementation and set the distance and the parent node for each vertex and append them to the queue. The append() method simply adds the vertexes to the end of the queue without checking their priority, so it is basically an O(1) operation. In our case it is absolutely ok since we know that all vertexes have a priority of self::$infinite.
After the initialisation we add our origin vertex to the priority queue with the smallest priority.
Then we cycle through our queue extracting the smallest priority item with extract_min().
If we found one and it is not our destination vertex then we check it’s adjacent vertexes which are still in our priority queue.
The variable $alt holds the length of the path from the $origin vertex to the neighbour vertex $v if it were to go through $u. If this path is shorter than the current shortest path recorded for $v, that current path is replaced with this $alt path, the parent for $v is set to the current vertex $u and the priority of $v is decreased to $alt in our priority queue. These steps are the most important parts of Dijkstra’s algorithm.
At the end of the method we extract and set the route if any was found.

An interesting part of the code is the way we calculate the weigth of an edge between vertexes $u and $v.

For this we call:

$this->graphEdges($u, $v, $this->getDistance(...));

The graphEdges method takes the vertexes and a callable. The callable is then used to calculate the weight.

private function getDistance(int $u, int $v): int {
    return $this->graph[$u][$v] ?? self::$infinite;
}

With this approach we can easily swap-in a new method to calculate the actual weight and use for example the below one to turn our Dijkstra method into something that resembles a close variant to BFS:

private static function alwaysReturnOne(int $u, int $v): int {
    return 1;
}

That's all folks. I hope you enjoyed this article.

In my next post I will compare the execution time of my BFS, simple queue based Dijkstra and the priority queue based Dijkstra algorithms.

The power of PHP and Laravel

Peter Hrobar — Mon, 24 Apr 2023 18:51:38 +0000

Decomposition of a code snippet to show-case the usage of anonymous functions, macros and higher-order functions …

When it comes to the popularity of programming languages I never really understand when people are talking about how certain languages are superior to others.

I always thought that there are problems that we need to solve as programmers and we have tools that are best suited than others for the given job.

One of the languages I’m using for quite a while is PHP. I know, I know … Python, Java, C++ and others are better, more secure, they use strict type control and many other things.

But actually when you combine PHP 8.x with a powerful framework like Laravel, there are not many tools that are easier to learn and use for web application development.

A couple of months back I started to re-write an application that I have created many-many years ago. It was originally written in PHP 5.x with a lot of client side Javascript and a MySQL backend. A typical set-up one would say.

I knew from the beginning that I will use an MVC framework to reduce development time so I took a look on what was out there.

It turned out that Laravel with PHP 8.x and Laravel Forge worked like a charm for me. I finished the project way quicker than expected and managed to improve and optimise the application in many places.

In this article I’m not going to show you how I re-wrote my application.

I’m only trying to prove why PHP is still one of the most popular programming language for certain tasks.

The code snippet that I chose for my demonstration is a function that calculates the edges of a graph. To put this into context: edges are network cables connecting nodes, which are actual network devices in a data center.

Now, let see the code snippet:

public static function populateCablesList(): Builder {

    return count(self::$route)
        ? array_reduce(self::createTuples(),
            fn($q, $tuple) => $q->filterRouteSegment($tuple),
            Cable::query()->with(['cable_type', 'cd_start', 'cd_end', 'owner'])
          )
        : Cable::query()->whereNull('id'); // Return an empty result

}

Let’s go through the above code line-by-line.

As you can see the function is returning a Laravel Eloquent Builder instance that we can use in other parts of our application to return the relevant Cable models. These models then can be used for formatted reports, data tables, data exports etc.

If there is a route between point ‘a’ and ‘b’ than our static property $route contains the vertexes or nodes of that route otherwise $route is an empty array.

Based on whether we have a route in our graph:

we either return a query that will return all Cable models on the given route or
an Eloquent query that will return an empty Laravel collection.

As you can see we are using the higher order PHP function array_reduce to process our $route.

The static function createTuples in our case will generate tuples using the vertexes of our route and pass them over to the array_reduce function.

To give you an example: if $route contains a, b and c vertexes then createTuples will return the following tuples: [a, b] and [b, c].

The anonymous function will take the actual tuple, generate the required SQL query statement and attach it to the query builder instance. This is basically how we are ‘reducing’ the tuples into a Laravel Eloquent query.

To generate the required SQL query statement we are using a Laravel macro called filterRouteSegment.

As you can see it generates an SQL WHERE clause using the actual tuple (our Cable model does not have a direction therefore we need to check it’s connection points at it’s start and end node as well).

Builder::macro('filterRouteSegment',
            fn($tuple) =>
            $this->orWhere(function ($builder) use ($tuple) {
                $builder->where(function ($query) use ($tuple) {
                    $query->where('start', $tuple->start)->where('end', $tuple->end);
                })->orWhere(function ($query2) use ($tuple) {
                    $query2->where('start', $tuple->end)->where('end', $tuple->start);
                });
            })
        );

The last parameter to our higher-order function is it’s initial value.

It is important to note that in our case we are using eager loading the avoid the classical N+1 problem when loading model relationship data in Laravel.

With the above example we have demonstrated the use of higher order functions, macros and anonymous functions in PHP together with Laravel.

With these ‘tools’ we were able to solve a seemingly complex problem with just a few lines of code that is also very easy to read and understand.