genesisdistrib / foundation

v0.5.0-alpha 2026-09-16 01:23 UTC

Requires

• php: ^8.3

Requires (Dev)

• phpunit/phpunit: ^12.0

MIT

• Thierry Cornaire

Published on Packagist.org on 2026-09-16 03:21 UTC

README

Les mécanismes architecturaux pour construire des applications durables.

Genesis Foundation constitue la fondation backend de l'écosystème Genesis.

Son objectif est de fournir un ensemble limité de mécanismes architecturaux explicites, réutilisables et testables permettant de construire des applications qui restent compréhensibles, maintenables et extensibles dans le temps.

Genesis Foundation n'est pas une application.

Elle ne contient pas de logique métier.

Les applications possèdent leurs concepts métier et utilisent Genesis Foundation pour fournir les mécanismes architecturaux nécessaires à leur exécution.

Philosophie

Genesis Foundation suit un principe simple :

L'architecture vient d'abord. L'implémentation vient ensuite.

Le projet privilégie :

• les dépendances explicites plutôt que les comportements cachés ;
• les contrats plutôt que les détails d'implémentation ;
• la composition plutôt que les classes trop importantes ;
• une exécution prévisible plutôt que la magie du framework ;
• des composants petits et spécialisés plutôt que l'accumulation de fonctionnalités ;
• la maintenabilité à long terme plutôt que la facilité à court terme.

Prérequis

Genesis Foundation nécessite :

• PHP 8.3 ou supérieur ;
• Composer.

Le développement et la validation utilisent PHPUnit 12.

Installation

Genesis Foundation est actuellement en cours de développement.

Installez les dépendances du projet avec Composer :

composer install

Architecture

Genesis Foundation est organisée autour de composants indépendants et d'un runtime léger chargé de les assembler.

La Foundation actuelle comprend :

• Configuration
• Container
• Input
• Validator
• Routing
• HTTP
• View

Le démarrage de l'application est assuré par la couche Bootstrap.

Le runtime Genesis gère le cycle de vie des composants enregistrés.

Composants

Configuration

Charge les fichiers de configuration PHP externes et permet d'accéder aux valeurs de configuration grâce à la notation par points.

La configuration reste extérieure au code du framework.

Container

Assure l'enregistrement et la récupération explicites des services partagés.

Le conteneur n'utilise volontairement ni réflexion ni résolution automatique des dépendances.

Les dépendances restent ainsi visibles et prévisibles.

Input

Fournit un accès immuable aux données d'entrée ainsi que des méthodes de lecture strictement typées.

Les valeurs ne sont jamais converties silencieusement vers des types sans rapport avec leur type d'origine.

Validator

Fournit un système de validation basé sur des règles explicites et composables.

Le composant permet de définir, enregistrer et exécuter les règles de validation tout en conservant les responsabilités clairement séparées.

Routing

Associe les méthodes et chemins HTTP aux gestionnaires de l'application.

Le routage prend notamment en charge :

• les routes statiques ;
• les routes dynamiques ;
• les paramètres de route ;
• la détection des méthodes autorisées ;
• la distribution des requêtes vers les gestionnaires.

HTTP

Fournit le pipeline d'exécution des requêtes HTTP.

Il comprend notamment :

• la création des requêtes ;
• la lecture du corps HTTP ;
• le décodage JSON ;
• le traitement des middlewares ;
• la gestion des exceptions ;
• les réponses HTTP ;
• l'émission finale des réponses.

L'exécution du framework retourne des objets Response plutôt que de produire directement du contenu.

View

Fournit un moteur minimal de rendu de vues PHP avec prise en charge des layouts.

Genesis Foundation n'impose volontairement aucun langage de templates.

Exécution d'une requête

Une requête HTTP suit généralement le flux suivant :

Variables globales PHP
        |
        v
RequestFactory
        |
        v
HttpApplication
        |
        v
HttpKernel
        |
        v
MiddlewarePipeline
        |
        v
Dispatcher
        |
        v
Router
        |
        v
Gestionnaire de l'application
        |
        v
Response
        |
        v
ResponseEmitter

L'application reste responsable de son comportement métier.

Genesis Foundation fournit uniquement les mécanismes nécessaires à son exécution.

Bootstrap

Le Bootstrap est uniquement responsable de l'assemblage de l'application.

Il peut :

• charger la configuration ;
• enregistrer les services ;
• créer l'application ;
• démarrer l'application.

Le Bootstrap ne doit jamais contenir de logique métier.

Genesis et Atlas

Genesis Foundation et Genesis Atlas sont deux projets indépendants.

Genesis Foundation fournit les mécanismes architecturaux backend.

Atlas fournit le langage visuel.

Aucun des deux projets ne dépend de l'autre.

Une application peut utiliser :

• Genesis Foundation uniquement ;
• Atlas uniquement ;
• Genesis Foundation et Atlas ensemble.

Règles de conception

Genesis Foundation suit plusieurs règles architecturales fondamentales.

Dépendances explicites

Les services partagés sont enregistrés explicitement.

Aucun autowiring automatique ni résolution des dépendances basée sur la réflexion n'est utilisé.

Réponses HTTP centralisées

Les classes du framework ne terminent pas directement l'exécution HTTP avec die ou exit et ne produisent pas directement le contenu applicatif.

Le résultat HTTP est représenté par des objets Response puis émis de manière centralisée.

Configuration externalisée

La configuration du framework appartient aux fichiers de configuration et non au Bootstrap ou au code métier.

Responsabilité unique

Chaque composant possède une responsabilité claire.

Lorsque plusieurs responsabilités apparaissent, la composition de plusieurs composants spécialisés est préférée à la création de grandes classes.

Architecture avant fonctionnalités

Les décisions architecturales sont validées avant l'implémentation de fonctionnalités importantes.

Toute modification architecturale nécessite un nouvel ADR.

Cycle de vie des composants

Chaque composant Genesis suit le même cycle de vie :

1. Conception
2. ADR lorsque la décision est architecturale
3. Implémentation
4. Documentation
5. Validation
6. Stable

Un composant n'est considéré comme stable que lorsque sa documentation et sa validation sont terminées.

Tests

Depuis la racine du dépôt, la suite complète de tests peut être exécutée avec :

.\vendor\bin\phpunit tests

Les tests automatisés de Foundation servent à la fois de protection contre les régressions et de contrats garantissant le comportement architectural attendu.

Documentation

La documentation spécifique à Foundation se trouve dans :

Genesis.Foundation/docs/

Elle est organisée ainsi :

docs/
├── FOUNDATION.md
├── ARCHITECTURE.md
└── components/
    ├── configuration.md
    ├── container.md
    ├── input.md
    ├── validator.md
    ├── routing.md
    ├── http.md
    └── view.md

Langue

Le code source de Genesis est écrit en anglais.

Cela concerne notamment :

• les classes ;
• les méthodes ;
• les variables ;
• les commentaires du code.

Les interfaces utilisateur peuvent être traduites dans n'importe quelle langue grâce au système de traduction.

La documentation du projet peut disposer de versions localisées lorsque cela est nécessaire.

Versionnement

Genesis suit le versionnement sémantique :

Major.Minor.Patch

Exemples :

0.1.0-alpha
0.2.0-alpha
0.9.0-beta
1.0.0

Les changements architecturaux incompatibles sont réservés aux versions majeures.

État du projet

Genesis Foundation V1 termine actuellement son cycle de documentation et de stabilisation.

L'implémentation et la validation automatisée sont en place.

La documentation doit être terminée avant que Foundation puisse être officiellement déclarée stable.

Licence

MIT