Natora Core : Un framework PHP moderne

Natora Core : Un framework PHP moderne

Socle applicatif modulaire, sécurisé et évolutif, conçu pour construire des applications web durables.

Ce site repose sur Natora Core, un framework PHP personnel conçu et développé from scratch autour d'une idée simple : conserver la maîtrise de l'architecture tout en bénéficiant des principes qui font la robustesse des frameworks modernes.

Plutôt que de construire chaque projet indépendamment, le framework fournit un socle commun pour le routage, les contrôleurs, les services, la sécurité, l'authentification, les permissions, les vues, l'internationalisation et les modules applicatifs.

Il permet ainsi de développer des applications complexes sans dépendre d'un framework monolithique, tout en conservant une architecture cohérente et réutilisable d'un projet à l'autre.

Une architecture structurée

Le cœur du framework organise le cycle complet d'une requête HTTP, depuis son arrivée dans l'application jusqu'à la génération de la réponse envoyée au navigateur.

• Front Controller

  Un point d'entrée unique initialise l'application et transmet les requêtes au Kernel.

• Kernel applicatif

  Le Kernel orchestre les principaux composants du framework et le traitement de chaque requête.

• Container de services

  Les composants techniques et applicatifs sont enregistrés dans un container afin de centraliser leur création et leurs dépendances.

• Router

  Le système de routage associe les URLs aux contrôleurs et applique les middlewares nécessaires.

• Request / Response

  Les échanges HTTP sont représentés par des objets dédiés, permettant aux contrôleurs de rester indépendants des détails d'implémentation.

• Middlewares

  Authentification, rôles, permissions, CSRF, internationalisation, journalisation et autres traitements transversaux peuvent intervenir dans le pipeline HTTP.

Un véritable système de modules

L'une des caractéristiques centrales de Natora Core est son architecture modulaire. Une fonctionnalité importante n'est pas directement intégrée au cœur du framework : elle peut être encapsulée dans un module indépendant.

Le framework dispose d'un registre de modules et d'un mécanisme de découverte permettant de charger les fonctionnalités disponibles dans le Core ou dans l'application.

Un projet peut ainsi activer uniquement les composants dont il a réellement besoin.

Quelques modules déjà développés

• Utilisateurs et authentification
• Profils membres
• Rôles et permissions
• CMS et gestion des pages
• Menus dynamiques
• Gestion des médias
• Blog
• Boutique
• Forum
• Messagerie privée
• Notifications
• Analytics
• SEO
• Mailing-list
• Administration

Cette approche permet de faire évoluer une application progressivement sans transformer le cœur du framework en un ensemble monolithique difficile à maintenir.

Core et logique applicative séparés

Le framework distingue volontairement les mécanismes génériques de la logique propre à chaque projet.

Cette séparation facilite les mises à jour du framework et limite fortement le couplage entre infrastructure et logique métier.

Un pipeline HTTP basé sur les middlewares

Les contrôleurs ne sont pas responsables de toutes les vérifications. Les préoccupations transversales sont prises en charge en amont par une chaîne de middlewares.

1. Réception de la requête
2. Identification et journalisation de la requête
3. Résolution de la langue
4. Protection CSRF lorsque nécessaire
5. Authentification
6. Contrôle des rôles
7. Contrôle des permissions
8. Exécution du contrôleur
9. Construction de la réponse

Cette organisation permet de conserver des contrôleurs plus simples et d'appliquer les mêmes règles de manière cohérente dans toute l'application.

La sécurité comme composant de l'architecture

La sécurité n'est pas ajoutée après le développement. Elle fait partie de la conception du framework et intervient à différents niveaux de l'application.

• Protection CSRF des formulaires
• Content Security Policy avec nonce généré par requête
• Authentification et gestion des sessions
• Authentification persistante avec remember-me
• Réinitialisation sécurisée des mots de passe
• Contrôle d'accès par rôles
• Permissions applicatives
• Politiques d'interaction entre utilisateurs
• Validation centralisée des entrées
• Accès aux données via PDO
• Journalisation centralisée
• Gestion structurée des erreurs
• Mode maintenance configurable

L'objectif n'est pas seulement d'empêcher les erreurs, mais de rendre les comportements sensibles explicites et prévisibles dans le code.

Rôles, permissions et contrôle d'accès

Le contrôle d'accès ne repose pas uniquement sur la distinction entre utilisateur connecté et administrateur.

Le framework possède plusieurs niveaux de rôles ainsi qu'un système de permissions permettant de contrôler précisément l'accès aux fonctionnalités.

• Visiteur
• Utilisateur
• Staff
• Administrateur
• Super administrateur

Des politiques applicatives peuvent également compléter ces permissions pour gérer des situations métier plus fines, notamment les interactions entre membres.

Une architecture événementielle

Natora Core intègre également un système d'événements permettant aux modules de communiquer sans créer de dépendances directes inutiles entre eux.

Une action peut publier un événement auquel d'autres modules choisissent de réagir.

Par exemple, la création d'un utilisateur peut déclencher indépendamment l'envoi d'un message, la création d'une notification ou d'autres traitements sans que le module d'inscription ait besoin de connaître leur implémentation.

Ce mécanisme contribue à maintenir un faible couplage entre les différentes fonctionnalités.

Internationalisation native

Le multilingue est intégré directement à l'architecture et n'est pas traité comme une fonctionnalité secondaire.

• URLs localisées
• Résolution automatique de la langue
• Catalogues de traductions par page
• Traductions communes réutilisables
• Variables et placeholders dynamiques
• Intégration directe dans les templates

Une même application peut ainsi proposer plusieurs langues tout en conservant des contrôleurs et des templates communs.

Un moteur de vues indépendant de la logique métier

L'affichage repose sur Smarty, utilisé comme moteur de templates afin de maintenir une séparation claire entre logique PHP et présentation.

Un constructeur de contexte centralise les données globales nécessaires aux pages avant leur transmission aux templates. Les contrôleurs peuvent ainsi se concentrer sur leur responsabilité principale plutôt que reconstruire à chaque fois le contexte général de l'application.

Des helpers communs normalisent également les réponses HTML, les redirections, les erreurs de validation et les réponses JSON.

Validation et formulaires cohérents

Les formulaires suivent une architecture commune afin d'éviter que chaque module développe son propre système de validation.

• Validation centralisée des entrées
• Gestion uniforme des erreurs
• Protection CSRF
• Messages internationalisés
• Réponses de validation normalisées
• Comportement cohérent entre HTML et AJAX

Cette uniformisation simplifie le développement des nouveaux modules tout en réduisant les comportements inattendus.

Une couche d'accès aux données maîtrisée

L'accès aux données s'appuie sur PDO et sur des repositories dédiés aux différentes responsabilités métier.

Les requêtes SQL restent ainsi explicites et maîtrisées, tandis que les contrôleurs et les services manipulent des interfaces adaptées à leur domaine.

Cette approche conserve la puissance du SQL lorsque celle-ci est nécessaire sans disperser les accès à la base de données dans toute l'application.

Une administration construite sur le même socle

Le back-office n'est pas une application séparée. Il repose sur les mêmes mécanismes de routage, sécurité, permissions, vues et modules que la partie publique.

L'administration permet notamment de gérer :

• les utilisateurs,
• les rôles et permissions,
• les modules,
• les pages du CMS,
• les menus,
• les médias,
• le référencement,
• les statistiques,
• les contenus communautaires,
• et les fonctionnalités propres à chaque application.

Conçu pour évoluer

L'un des objectifs fondamentaux du projet est de pouvoir ajouter de nouvelles fonctionnalités sans remettre en cause l'architecture existante.

Le framework privilégie pour cela des composants spécialisés, des interfaces, des services, des repositories, des événements et des modules indépendants plutôt qu'une accumulation de logique dans quelques classes centrales.

Une nouvelle application peut réutiliser le Core existant puis développer uniquement les modules correspondant à son propre domaine métier.

Quelques principes directeurs

Garder le cœur générique, les modules indépendants et la logique métier à sa place.

• Responsabilités clairement séparées
• Faible couplage entre les modules
• Comportements explicites plutôt qu'implicites
• Configuration centralisée
• Sécurité intégrée dès la conception
• Code réutilisable entre plusieurs projets
• Compatibilité entre environnements de développement et production
• Évolution progressive sans réécriture complète

Un laboratoire technique en évolution permanente

Natora Core est avant tout un projet personnel. Il s'est construit progressivement au fil des besoins réels rencontrés lors du développement de différentes applications.

Chaque nouveau projet permet d'éprouver l'architecture, d'identifier ses limites et de faire évoluer le Core lorsque cette évolution peut bénéficier à l'ensemble des applications.

Ce travail constitue ainsi à la fois un framework utilisable, un environnement d'expérimentation et un projet d'apprentissage continu autour de PHP, de l'architecture logicielle, de la sécurité et du développement web.