\'Laravel piloté par domaine\' crée d'excellents systèmes évolutifs et puissants

Dans l'univers en constante expansion du développement logiciel, créer des systèmes évolutifs, maintenables et puissants n'est pas une mince affaire. Avec autant de cadres, d'outils et de modèles en lice pour attirer votre attention, il est facile de se sentir comme un voyageur de l'espace perdu, en orbite sans direction. Mais n’ayez crainte, cher collègue développeur ! ? Le référentiel Domain-Driven Laravel est là pour vous guider à travers le cosmos du développement d'API RESTful, en utilisant la méthodologie Domain-Driven Design (DDD).

https://github.com/oskhar/domain-driven-laravel

oskhar / laravel piloté par domaine

? ? Un modèle Laravel 11.x préconfiguré conçu pour faciliter le développement d'applications Web suivant les principes de conception pilotée par domaine (DDD).

Laravel piloté par domaine ? ?

Une architecture robuste, évolutive et flexible pour développer des API RESTful avec Laravel en utilisant les principes de conception pilotée par domaine (DDD).

Présentation

Laravel est un excellent framework pour créer des applications puissantes, offrant un ensemble riche de fonctionnalités et une syntaxe claire. Cependant, à mesure que les projets deviennent de plus en plus complexes, il est facile pour la base de code de devenir ingérable. L'absence d'un modèle architectural clair peut conduire à un mélange de responsabilités, rendant le code plus difficile à maintenir et à faire évoluer.

Ce référentiel présente un moyen de structurer les projets Laravel en utilisant les principes de Domain-Driven Design (DDD), permettant une meilleure organisation, évolutivité et séparation des préoccupations. L'approche présentée ici s'inspire des meilleures pratiques et vise à résoudre les défis du monde réel de manière pratique et maintenable.

L'objectif est de fournir une base solide pour créer des applications Laravel qui le sont.

• ? Facile à comprendre. Une base de code bien organisée avec des limites claires.
• ?️ Maintenable. Suivez les principes DDD…

Voir sur GitHub

Dans cet article, nous explorerons la galaxie de ce remarquable package Laravel, découvrirons ses fonctionnalités uniques et verrons pourquoi il est parfait pour les développeurs cherchant à créer des systèmes sophistiqués. Attachez votre ceinture, cowboy de l'espace, car nous sommes sur le point de décoller ! ?

Structure des répertoires : https://github.com/oskhar/domain-driven-laravel/blob/main/docs/project-structure.md

Qu'est-ce que Laravel piloté par domaine ?

"Laravel piloté par domaine ? ?" est une approche structurée pour créer des API RESTful à l'aide de Laravel, centrée sur les principes de Domain-Driven Design (DDD). Ce package vous permet de structurer votre application de manière logique en regroupant la logique métier associée en domaines, ce qui rend votre système plus facile à faire évoluer et à maintenir.

En tirant parti de l'architecture robuste de Laravel avec la puissance organisationnelle de DDD, ce référentiel aide les développeurs à créer des API bien organisées qui sont aussi efficaces que puissantes.

Pourquoi la conception basée sur le domaine ?

Domain-Driven Design fournit une structure claire pour séparer les préoccupations et organiser votre application en parties gérables et compréhensibles. Il se concentre sur la définition du domaine principal et de la logique de domaine (le cœur de votre logique métier) et maintient votre application modulaire.

Imaginez que votre système soit organisé comme des planètes en orbite autour d'une étoile, chacune avec un objectif bien défini et une connexion avec le système plus vaste. Avec DDD, vous disposerez de domaines tels que la gestion des utilisateurs, la gestion des produits, etc., chacun gérant sa propre attraction gravitationnelle dans l'écosystème des API.

La vraie magie de "Domain-Driven Laravel ? ?" est dans sa mise en œuvre réfléchie de ces concepts, transformant Laravel en une machine bien huilée de domaines interconnectés. Vous pouvez désormais créer des applications évolutives et prêtes à affronter les complexités du monde réel.

Le pouvoir de la gestion des erreurs : rire à travers le cosmos ?

Si vous êtes comme la plupart des développeurs, vous avez rencontré votre part de messages d'erreur. Mais avez-vous déjà eu un gestionnaire d'erreurs qui vous insulte pour avoir commis une erreur ? Bienvenue dans le monde de "Domain-Driven Laravel ? ?", où la gestion des erreurs n'est pas seulement fonctionnelle, elle est personnelle et hilarante !

Ce dépôt offre un mécanisme intégré de gestion des erreurs qui non seulement renvoie les codes d'état HTTP attendus, mais vous réprimande également pour vos erreurs. Décomposons certaines de ces réponses :

$exceptions->render(
    fn(QueryException $exception, $request) => ($response)(
        APIResponseData::from([
            "status" => false,
            "errors" => [
                "Bro wrote the wrong database query. Backend skills issue.",
                $exception->getMessage()
            ]
        ]),
        APIStatusEnum::INTERNAL_SERVER_ERROR
    )
);

Au moment où vous effectuez une mauvaise requête dans la base de données, vous serez accueilli par une réponse du type :

"Bro wrote the wrong database query. Backend skills issue."

Au lieu d'un message d'erreur typique et sec, le système vous incite à améliorer vos compétences backend, parfois avec un peu d'attitude !

Les autres réponses incluent :

• La structure du tableau a mal tourné :
  

  "Ayyo, looks like your backend messed up the array structure."
  

• Appel de mauvaise méthode :
  

  "Are you sure backend bro? The method you called doesn't exist."
  

• Exception non définie :
  

  "Your backend is dumb, bro."
  

Cette approche unique vous fournit non seulement des informations utiles, mais ajoute une touche amusante à votre expérience de débogage. Il transforme ces erreurs redoutées en moments de légèreté, vous rappelant que même dans l'immensité du code, un peu d'humour peut faire beaucoup de chemin.

Structure de réponse.

Grâce à la structure bien définie de la réponse API, toutes les erreurs, y compris celles personnalisées, suivront un format cohérent. La classe APIResponseData garantit que la réponse est structurée comme ceci :

class APIResponseData extends Data
{
    public function __construct(
        readonly ?bool $status = true,
        readonly ?string $message,
        readonly mixed $data = null,
        /** @var array<string> */
        readonly ?array $errors,
        readonly ?PaginationData $pagination,
        readonly ?APIMetaData $meta,
    ) {
    }
}

Voici à quoi pourrait ressembler une erreur interne du serveur 500 :

// Example 500 Internal Server Error
{
    "status": false,
    "message": "Galactic disruption. An unexpected cosmic event occurred!",
    "errors": [
        "Bro wrote the wrong database query. Backend skills issue",
        "{{ Query error messages specifically }}"
    ],
    "meta": {
        "request_id": "string",
        "response_size": "integer|byte"
    }
}

Cette structure apporte clarté et cohérence, garantissant que chaque réponse, qu'elle soit un succès ou un échec, est prévisible et facile à gérer du côté client.

Messages par défaut : Sagesse cosmique ?

Une autre fonctionnalité intéressante de ce référentiel est la gestion des messages par défaut pour les réponses API. Si vous oubliez de définir un message dans votre réponse, vous n'obtiendrez pas seulement une solution de secours générique : vous recevrez un message sur le thème galactique qui donnera à votre API l'impression d'être un voyage à travers les étoiles.

Voici un exemple des messages par défaut :

• 200 SUCCÈS : "Succès ! Votre demande a atterri en toute sécurité sur Terre."
• 201 CRÉÉ : "Nouvelle entité lancée dans le cosmos."
• 400 BAD_REQUEST : "Votre demande a dévié de sa trajectoire et n'a pas pu échapper à la gravité terrestre !"
• 401 NON AUTORISÉ : "Vos informations d'identification ne passent pas le portier cosmique!"
• 404 NOT_FOUND : "Les données que vous recherchez dépassent les limites de l'espace !"
• 500 INTERNAL_SERVER_ERROR : "Perturbation galactique. Un événement cosmique inattendu s'est produit!"

Ces réponses thématiques ne donnent pas seulement une saveur amusante à votre API, elles expliquent également plus clairement aux clients et aux utilisateurs ce qui se passe sous le capot.

For example, if your request hits a 404, instead of a boring "Not Found" message, you’ll receive a cosmic-themed error:

"The data you're seeking is beyond the bounds of space!"

This approach not only enriches the developer experience but also makes the API more user-friendly. Your clients and users will enjoy these little touches of humor and personality.

Going Beyond: What Else Makes This Repository Stellar? ?

"Domain-Driven Laravel ? ?" isn't just about humor and cosmic messages. It's a fully fleshed-out package that makes it easier to manage your Laravel applications using DDD principles. Let’s take a look at some of the other key features:

1. Modular Domain Design.

With a clean and modular architecture, you can easily organize your application into domains, each with its own logic and responsibility. This separation allows for better scaling, testing, and maintenance.

2. Built-in API Response Management.

Handling API responses is a breeze with a consistent structure that ensures all responses are formatted correctly. Whether you’re returning success, error, or validation messages, the built-in API response handler will make sure everything is in its right place.

3. Error Handling that Learns.

While the humorous error handling adds personality, it also comes with a solid system that tracks and logs exceptions in a way that helps you debug and improve your code.

4. Advanced Middleware.

The repository includes advanced middleware implementations that ensure all parts of your application are in sync with the domain rules and API structure. With these middleware hooks, you can ensure that your application always behaves as expected.

5. Integration with Spatie's Packages.

Leverage the power of Spatie’s robust Laravel packages for roles, permissions, and data handling. This repo comes with pre-configured support for Spatie’s tools, giving you the best of both worlds: the organization of DDD and the strength of Laravel’s best packages.

Simple Usage: Focus on Domain Actions ?️

When working with the repository, simplicity is key. The goal is for developers to focus purely on domain actions without worrying about infrastructure concerns. This clear separation of responsibilities ensures that each domain handles its own business logic while leaving shared services and external integrations to other layers.

1. Stay Focused on Domain Actions.

In this structure, all core logic related to a specific domain is encapsulated in Actions. You don’t need to think about cross-domain interactions or infrastructure concerns—just focus on building the actions that power your domain. For example, an action like CreateUserAction lives entirely within the User domain and manages user creation. You can call this action from a controller or another action, keeping your code concise and easy to manage.

namespace Domain\User\Actions;

use Domain\User\Models\User;

class CreateUserAction
{
    public function execute(array $userData): User
    {
        return User::create($userData);
    }
}

This straightforward action does its job without needing to handle infrastructure-level details like logging, caching, or external API calls. Those concerns are dealt with in the Infrastructure layer or the Shared domain, keeping your actions clean and single-focused.

2. Shared Domain for Cross-Cutting Concerns.

Any service that spans across multiple domains, such as authentication, logging, or notifications, can be placed in the Shared domain. This prevents domain entanglement and ensures that the logic stays modular and focused.

For example, a notification service can live in the Shared domain, allowing any domain to trigger notifications without duplicating code.

namespace Domain\Shared\Services;

class NotificationService
{
    public function sendNotification(UserData $user, string $message): bool
    {
        // Logic for sending notifications
    }
}

Any domain that needs to notify users can simply call this service, ensuring that the NotificationService is consistent across the application.

3. Infrastructure for External Integrations.

The Infrastructure layer handles external services and integrations. This includes third-party APIs, payment gateways, or database configurations. By keeping external integrations here, your domain actions remain focused on business logic without worrying about how the external world works.

For instance, a payment gateway service could be handled in Infrastructure, keeping payment logic separate from core domain actions.

namespace Infrastructure\Services;

class PaymentGatewayService
{
    public function processPayment(PaymentDetailsData $details): mixed
    {
        // Payment processing logic
    }
}

With this structure, domain actions can call on external services when needed, but the bulk of the integration code is abstracted away, keeping your business logic clean and independent.

4. Flexibility with Interfaces.

To enhance the repository's flexibility and error prevention, developers who are comfortable using interfaces can incorporate a dedicated Interfaces folder. This addition provides a structured way to manage potential changes, such as migrations or dependency removals, without impacting the core functionality. The minimalist design of this repository ensures that it remains adaptable to various development needs, and the use of interfaces aligns with this principle by offering a safeguard against unforeseen changes.

app
├── Console                     # Custom Artisan commands
├── Domain                      # Core domain logic and business rules
├── Infrastructure              # Infrastructure-related code
└── Interfaces                  # Additional Folder

This approach allows developers to define contracts for their actions, services, or any other components that may evolve over time, ensuring that the code remains stable and maintainable across different stages of development.

5. No Domain Interference.

One of the core principles of "Domain-Driven Laravel ? ?" is that each domain should remain isolated from others. Domains should not interfere with each other’s logic or responsibilities. If multiple domains need to share services or data, those services should either be abstracted into the Shared domain or handled in Infrastructure.

This ensures that no domain unintentionally “leaks” logic or affects the behavior of another. It makes your codebase easier to maintain and scale as each domain evolves independently.

Conclusion: Take Your Laravel Development to the Stars ?

If you’re ready to build Laravel applications that are not only scalable and powerful but also fun to work with, "Domain-Driven Laravel ? ?" is the repository for you. It combines the elegance of Domain-Driven Design with Laravel's strength, all while adding a dash of cosmic humor ?

Whether you’re a seasoned developer or just getting started with DDD, this package will help you organize your code, streamline your APIs, and provide a delightful development experience.

So what are you waiting for? Head over to the Domain-Driven Laravel ? ? repository, and start building systems that are out of this world!

May your code always compile, and your APIs always return a 200! ?✨

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!