Drupal: Core Solutions, Custom APIs & Symfony Collaboration

Discover the content-centric power of Drupal and how well it integrates with Symfony. Examine similar code snippets and the mutually beneficial relationship between the two frameworks.

When starting a project, one of the most important decisions to make is the right backend option. Created in 2000 by Dries Buytaert, an undergrad at the University of Antwerp, Drupal has developed from a message board into a major player in content-focused backend development. Being open source and having an active and welcoming community, as well as a flexible architecture, Drupal is used in a wide range of industries, including government, education, media, and enterprise. Companies like NASA, Pfizer, and the Grammy Awards all use Drupal as their CMS of choice.

What is Drupal?

It is an open-source content management system with many out-of-the box features that makes it simple for developers to quickly create, organize, and share digital content. Its modular architecture makes it simple for programmers to incorporate new features, expanding its applicability for a variety of uses. That results in more than 50,000 free, community contributed modules that extend and customize Drupal functionality and over 3,000 free themes that change the look and feel of Drupal.

Some of Drupal’s main uses cases are:

1. Content Management Systems (CMS): The main use for which Drupal was developed. Great option for websites and applications needing advanced content management features.

2. Social Networking Platforms: Having highly configurable and customizable user roles and permissions makes Drupal a great choice for building community-driven applications.

3. E-commerce: The Drupal Commerce module, one of the most popular community contributed modules, provides a powerful platform for creating scalable and feature-rich online stores.

4. Government and Enterprise Solutions: Drupal is a great choice for large-scale enterprise and government projects due to its security and scalability. Even the White House used Drupal at one point.

Some of the companies/brands using Drupal:

• NASA


• Tesla


• Purina


• The British Royal Family


• Pfizer


• Grammy Awards


• The Economist

Drupal’s Architecture – Quick Overview

Since Drupal was initially developed as a CMS, its architecture is heavily centered around content. Because of this, it’s the perfect choice for applications that need strong content management. Drupal does a great job in providing a content-first viewpoint, from complex content modeling to smooth data organization. Drupal’s flexibility is demonstrated by its ability to provide both headless and non-headless solutions.

In a standard, monolithic scenario, Drupal serves as a complete solution, taking care of both content management and content presentation. However, in a headless configuration, Drupal keeps the two separate, giving developers the freedom to use the front-end technologies of their choice while delivering flexibility for a wide range of project requirements through standard REST based APIs. This flexibility makes it an amazing tool that can handle a wide range of project requirements thanks to its content-first approach.

Symfony: Customization and Modularity

Somewhat similar to Drupal, Symfony is defined by its component-based design and modular architecture. Because of this modularity, developers are able to modify the backend API to meet very specific, individual demands. Symfony’s flexibility allows developers to create robust APIs with total control.

Drupal’s Out-of-the-Box REST API Options vs. Custom Solutions

In a basic installation, Drupal includes modules (JSON:API/RESTful Web Services) that provide an efficient RESTful API that offers an extensive collection of endpoints for things like users, nodes, and taxonomy terms. If basic REST functionality satisfies the requirements, an off-the-shelf solution is a practical option. In a setting where time is of the essence and deadlines are tight, it’s a great choice because of its quick setup and ease of configuration.

On the other hand, when projects require a more complex and custom solution, a custom REST API might be needed. Developers can customize solutions so that the API endpoints, responses, and authentication methods are suited to the particular requirements of the project. This is especially helpful when working with complicated data structures, special authentication techniques, or when following an API standard is essential.

Code comparison

Let’s assume you have an endpoint that retrieves and returns all “Player” entities associated with Real Madrid and of Spanish nationality as a JSON response.

In Drupal the code would look something like the following.

// Drupal Code Snippet

use Symfony\Component\HttpFoundation\JsonResponse;



// Assuming you are inside a Drupal controller method

public function fetchPlayersAction() {

    $entity = 'player'; // Assuming content type machine name is 'player'

    

    // Query nodes based on properties

    $players = \Drupal::entityTypeManager()

        ->getStorage('node')

        ->loadByProperties([

            'type' => $entity,

            'field_team' => 'Real Madrid',

            'field_nationality' => 'Spanish',

        ]);



    // Extract relevant data from players

    $response = [];

    foreach ($players as $player) {

        $response[] = [

            'name' => $player->label(),

            'nationality' => $player->get('field_nationality')->value,

            // Add other relevant fields as needed

        ];

    }



    // Return API response

    return new JsonResponse($response);

}

The same functionality in Symfony:

// Symfony Code Snippet

use Symfony\Component\HttpFoundation\JsonResponse;

use App\Entity\Player;



// Assuming you are inside a Symfony controller method

public function fetchPlayersAction()

{

    $players = $this->getDoctrine()

        ->getRepository(Player::class)

        ->findBy([

            'team' => 'Real Madrid',

            'nationality' => 'Spanish',

        ]);



    // Extract relevant data from players

    $response = [];

    foreach ($players as $player) {

        $response[] = [

            'name' => $player->getName(),

            'nationality' => $player->getNationality(),

            // Add other relevant fields as needed

        ];

    }



    // Return API response

    return new JsonResponse($response);

}

Drupal’s Synergy with Symfony

As of version 8.0, which was released in November 2015, Drupal introduced the integration of Symfony components in its architecture. This addition greatly expanded Drupal’s capabilities, giving it a modern and modular base. This connection gives developers the option to incorporate Symfony-specific features into Drupal projects with ease. In the above code we can see this connection in the shared use of Symfony’s JsonResponse component. The integration not only enhances Drupal’s developer experience but also allows them to transition easily between Drupal and Symfony projects.

Conclusion

Comparing Drupal to Symfony for backend API development reveals a complex environment where each framework has particular advantages. Symfony’s modularity and customisation features suit projects requiring precise management, whereas Drupal’s content-centric approach and integrated solutions excel in situations requiring quick development. Drupal’s assimilation of Symfony components is an example of cooperative evolution that gives developers a flexible toolkit. The decision between Drupal and Symfony ultimately comes down to project requirements and development philosophies, demonstrating how fluid and integrated current PHP backend programming is.