Slim-Skeleton représente la structure de référence pour initier des projets basés sur Slim Framework 4. Conçu comme une fondation solide, ce squelette applicatif intègre nativement les standards PSR, la gestion des dépendances via PHP-DI et un système de journalisation robuste avec Monolog. Il permet aux ingénieurs logiciel de s'affranchir de la configuration initiale complexe pour se concentrer sur la logique métier.

Gestion des services via l'injection de dépendances

Le cœur de Slim-Skeleton repose sur son conteneur d'injection de dépendances (DIC). L'implémentation utilise PHP-DI, offrant une flexibilité totale pour découpler les composants du système. Dans le fichier d'entrée public/index.php, l'initialisation suit une logique modulaire :

use DI\ContainerBuilder;

$builder = new ContainerBuilder();

// Configuration des paramètres globaux
$setupSettings = require __DIR__ . '/../app/settings.php';
$setupSettings($builder);

// Définition des services et ressources
$setupServices = require __DIR__ . '/../app/dependencies.php';
$setupServices($builder);

$container = $builder->build();

Cette approche permet de définir des services (comme des référentiels de données ou des clients API) dans des fichiers séparés, facilitant ainsi la maintenance et l'interchangeabilité des composants lors des phases de test.

Définition de routes et conception d'API RESTful

Le routage dans Slim-Skeleton est conçu pour être à la fois expressif et performant. Les points d'entrée de l'application sont centralisés, permettant une gestion fine des méthodes HTTP et des paramètres d'URL. Voici un exemple de définition de route structurée :

use Psr\Http\Message\ResponseInterface as Response;
use Psr\Http\Message\ServerRequestInterface as Request;
use Slim\App;

return function (App $app) {
    $app->get('/health-check', function (Request $request, Response $response) {
        $payload = json_encode(['status' => 'active', 'timestamp' => time()]);
        $response->getBody()->write($payload);
        return $response->withHeader('Content-Type', 'application/json');
    });

    $app->group('/v1', function ($group) {
        // Définition de sous-groupes pour l'API
    });
};

Pipeline de Middleware : Le moteur d'extensibilité

L'architecture en couches de Slim-Skeleton s'appuie sur les middlewares pour traiter les requêtes entrantes et les réponses sortantes. Chaque middleware agit comme un filtre capable d'intercepter la requête avant qu'elle n'atteigne le contrôleur, ou de modifier la réponse avant son envoi au client. Cette structure est idéale pour gérer l'authentification, la validation CORS ou la compression des données.

// Chargement du pipeline de middlewares
$middlewareStack = require __DIR__ . '/../app/middleware.php';
$middlewareStack($app);

Stratégies de tests automatisés

L'intégration de tests unitaires et d'intégration est simplifiée par la structure du conteneur. Dans le répetroire tests/, Slim-Skeleton fournit des exemples permettant de simuler des requêtes HTTP sans démarrer de serveur Web réel. En manipulant le conteneur DI, il est possible d'injecter des "mocks" (doublures de test) pour isoler les composants.

// Exemple de substitution d'un service pour un test
$container->set(DataServiceInterface::class, function () {
    return $this->createMock(DataServiceInterface::class);
});

Avantages structurels pour les projets d'entreprise

Adopter Slim-Skeleton offre plusieurs bénéfices techniques majeurs :

• Conformité aux standards : Utilisation rigoureuse des interfaces PSR-7 (HTTP messages), PSR-11 (Container) et PSR-15 (Middleware).
• Empreinte mémoire réduite : Contrairement aux frameworks full-stack, le squelette ne charge que le strict nécessaire.
• Évolutivité : La séparation claire entre la configuration (app/) et le code source (src/) favorise la scalabilité du projet.