feat: métadonnées étendues (author, revisions), migration BDD → fichiers

data/8ed45b6e-d89b-4ae9-94e2-ed8476c00080/index.md

@@ -0,0 +1,104 @@
+Tout commence avec une idée simple : bâtir un système web **léger, modulaire et compréhensible**, sans dépendre d’un framework externe.
+Un **framework maison**, conçu pour gérer efficacement des **posts**, des **commentaires** et des **pièces jointes**, tout en respectant les principes de l’architecture **MVC**.
+
+### L’objectif
+
+Disposer d’une base claire et extensible, où chaque brique du système — du routeur aux modèles — reste transparente et entièrement maîtrisable.
+
+---
+
+## **La structure du projet**
+
+L’application s’organise autour d’une arborescence simple et logique.
+
+Au sommet, le dossier `public/` joue le rôle de **porte d’entrée** du site, avec un fichier `index.php` qui orchestre tout : c’est lui qui intercepte chaque requête et la transmet au **routeur**.
+
+Dans le dossier `app/`, on retrouve le cœur de la logique métier :
+
+* `Core/` contient les **fondations** : le routeur et la classe de base des contrôleurs.
+* `Controllers/` regroupe les différentes logiques d’action (posts, commentaires, pièces jointes).
+* `Models/` gère la **persistance des données** — ici stockées dans des fichiers JSON pour plus de simplicité.
+
+Chaque couche a un rôle précis, et l’ensemble reste clair, modulaire et facile à maintenir.
+
+---
+
+## **Le routeur : le cerveau du système**
+
+Au cœur du projet, le fichier `Router.php` agit comme un **chef d’orchestre**.
+Il écoute les requêtes entrantes, analyse leur méthode (`GET`, `POST`, `PATCH`, etc.) et les fait correspondre à la bonne route.
+
+Grâce à un jeu de **regex**, le routeur reconnaît des chemins dynamiques comme `/posts/:id` et transmet automatiquement les paramètres au contrôleur concerné.
+Une architecture élégante, minimaliste et pourtant très puissante.
+
+---
+
+## **L’entrée principale : `index.php`**
+
+Tout commence dans `public/index.php`.
+Après avoir chargé les classes nécessaires, on y définit les routes — une à une — comme les **règles d’un jeu**.
+
+Chaque route associe une méthode HTTP à une action précise :
+
+* Afficher tous les posts
+* Créer un nouveau post
+* Mettre à jour, publier ou masquer un post
+* Ajouter un commentaire ou une pièce jointe
+
+Une fois toutes les routes enregistrées, le routeur **intercepte la requête HTTP réelle** et la redirige vers le bon contrôleur.
+C’est simple, direct et parfaitement lisible.
+
+---
+
+## **Les contrôleurs : la logique métier**
+
+Prenons `PostController` comme exemple.
+Chaque méthode correspond à une **action concrète** du système : afficher la liste des posts, en créer un, le modifier, le publier ou le masquer.
+
+Les contrôleurs sont **stateless** : ils reçoivent les données, invoquent le modèle correspondant, puis renvoient une réponse JSON propre et explicite.
+Aucune dépendance superflue, aucun artifice — le code parle de lui-même.
+
+---
+
+## **Les modèles : la mémoire du système**
+
+Les modèles (`Post`, `Comment`, `Attachment`) assurent la gestion des données.
+Ici, les informations sont stockées dans des fichiers JSON — un choix volontairement simple, idéal pour le prototypage ou les petits projets.
+
+Mais la structure est pensée pour pouvoir évoluer facilement vers une **base de données réelle** (MySQL, SQLite, etc.) via PDO.
+Chaque modèle sait comment **lire, créer, modifier et sauvegarder** ses propres objets, garantissant ainsi une séparation claire des responsabilités.
+
+---
+
+## **Une API claire et RESTful**
+
+Les routes suivent une logique **RESTful**, simple et cohérente :
+
+```bash
+PATCH /posts/42/publish
+PATCH /posts/42/comments/17/hide
+POST  /posts/42/attachments
+```
+
+L’API est lisible, homogène et prête à être consommée par n’importe quel front-end — qu’il soit en Vue.js, React, ou même une interface HTML minimale.
+
+---
+
+## **Pourquoi cette approche séduit**
+
+Ce mini-framework maison présente plusieurs atouts :
+
+* **Zéro dépendance externe** : tout est sous ton contrôle.
+* **Architecture claire et didactique** : parfaite pour comprendre la mécanique interne d’un framework.
+* **Routing dynamique et élégant** : les paramètres d’URL sont gérés naturellement.
+* **Extensibilité** : tu peux facilement ajouter l’authentification, des middlewares ou la validation des données.
+* **Légèreté** : un cœur minimal, mais robuste et fonctionnel.
+
+---
+
+## **Et après ?**
+
+La prochaine étape : implémenter la **gestion complète des fichiers uploadés**, avec vérification du type MIME, stockage sécurisé dans `/uploads`, et possibilité de masquer les pièces jointes à la demande.
+
+Petit à petit, ton framework prend forme — un système MVC léger, propre et totalement maîtrisé.
+Tu n’utilises plus un framework : tu **en construis un**.

data/8ed45b6e-d89b-4ae9-94e2-ed8476c00080/meta.json

@@ -0,0 +1,11 @@
+{
+    "uuid": "8ed45b6e-d89b-4ae9-94e2-ed8476c00080",
+    "slug": "creer-son-propre-mini-framework-php-from-scratch",
+    "title": "Créer son propre mini-framework PHP from scratch",
+    "author": "",
+    "published": false,
+    "published_at": "2025-11-04 22:07:52",
+    "created_at": "2025-11-04 22:07:52",
+    "updated_at": "2025-11-04 22:07:52",
+    "revisions": []
+}