README

Un framework PHP moderne et léger suivant le pattern MVC avec injection de dépendances, gestion des sessions, validation des données et bien plus.

Fonctionnalités

Architecture MVC : Organisation claire du code avec séparation des responsabilités
Injection de dépendances : Container IoC avec configuration YAML
Routing système : Routage simple et efficace avec support des middlewares
Base de données : Couche d'abstraction PDO avec pattern Singleton
Validation : Système de validation robuste avec règles personnalisables
Gestion d'images : Upload et gestion d'images avec génération d'URLs
Sessions : Wrapper simplifié pour la gestion des sessions PHP
Middlewares : Support des middlewares pour l'authentification et autres traitements
Pattern Repository : Abstraction de la couche de données

Installation

Via Composer

composer install votre-vendor/votre-framework

Installation manuelle

Clonez le repository

git clone https://github.com/votre-username/votre-framework.git

Installez les dépendances

composer install

Configurez votre environnement (voir Configuration)

⚙️ Configuration

1. Configuration de la base de données

Créez vos constantes de base de données dans votre fichier de configuration :

// config/database.php
define('DSN', 'mysql:host=localhost;dbname=votre_db');
define('DB_USER', 'votre_username');
define('DB_PASSWORD', 'votre_password');

2. Configuration des services (services.yml)

Créez un fichier config/services.yml pour définir vos dépendances :

# config/services.yml
core:
  database: App\Core\Database
  session: App\Core\Session
  validator: App\Core\Validator
  imageService: App\Core\ImageService

repositories:
  userRepository: App\Repository\UserRepository
  productRepository: App\Repository\ProductRepository

controllers:
  userController: App\Controller\UserController
  productController: App\Controller\ProductController

3. Configuration des constantes

// config/constants.php
define('APP_URL', 'http://localhost:8000');
define('IMG_DIR', '/public/images/uploads/');

🏗️ Structure du projet

project/
├── app/
│   ├── config/
│   │   ├── services.yml
│   │   ├── middlewares.php
│   │   └── routes.php
│   ├── src/
│   │   ├── Core/
│   │   │   ├── App.php
│   │   │   ├── Database.php
│   │   │   ├── Router.php
│   │   │   ├── Session.php
│   │   │   ├── Validator.php
│   │   │   └── ImageService.php
│   │   ├── Abstract/
│   │   │   ├── AbstractController.php
│   │   │   ├── AbstractEntity.php
│   │   │   └── AbstractRepository.php
│   │   ├── Controller/
│   │   ├── Entity/
│   │   ├── Repository/
│   │   └── Middlewares/
│   └── templates/
├── public/
│   ├── index.php
│   └── images/uploads/
└── composer.json

Utilisation

1. Initialisation de l'application

// public/index.php
<?php
require_once '../vendor/autoload.php';
use App\Core\App;
use App\Core\Router;

// Initialiser l'application
App::init();

// Définir les routes
$routes = [
    '/' => [
        'controller' => 'App\Controller\HomeController',
        'method' => 'index',
        'middlewares' => []
    ],
    '/login' => [
        'controller' => 'App\Controller\AuthController',
        'method' => 'login',
        'middlewares' => []
    ],
    '/dashboard' => [
        'controller' => 'App\Controller\DashboardController',
        'method' => 'index',
        'middlewares' => ['auth']
    ]
];

// Résoudre la route
Router::resolve($routes);

2. Création d'un contrôleur

<?php
namespace App\Controller;

use App\Core\Abstract\AbstractController;
use App\Core\App;

class UserController extends AbstractController
{
    private $userRepository;

    public function __construct()
    {
        parent::__construct();
        $this->userRepository = App::getDependency('userRepository');
    }

    public function index()
    {
        $users = $this->userRepository->selectAll();
        $this->render('users/index.php', ['users' => $users]);
    }

    public function create()
    {
        $this->render('users/create.php');
    }

    public function store()
    {
        $validator = App::getDependency('validator');
        
        $rules = [
            'name' => [['required', 'Le nom est requis']],
            'email' => [['required', 'L\'email est requis'], ['isMail', 'Email invalide']],
            'password' => [['required', 'Le mot de passe est requis'], ['isPassword', 'Mot de passe trop faible']]
        ];

        if ($validator->validate($_POST, $rules)) {
            $this->userRepository->insert($_POST);
            header('Location: /users');
        } else {
            $errors = $validator->getErrors();
            $this->render('users/create.php', ['errors' => $errors]);
        }
    }

    public function show() { /* Implementation */ }
    public function edit() { /* Implementation */ }
}

3. Création d'une entité

<?php
namespace App\Entity;

use App\Core\Abstract\AbstractEntity;

class User extends AbstractEntity
{
    private int $id;
    private string $name;
    private string $email;
    private string $password;

    public function __construct(int $id = 0, string $name = '', string $email = '', string $password = '')
    {
        $this->id = $id;
        $this->name = $name;
        $this->email = $email;
        $this->password = $password;
    }

    public static function toObject(array $data): static
    {
        return new self(
            $data['id'] ?? 0,
            $data['name'] ?? '',
            $data['email'] ?? '',
            $data['password'] ?? ''
        );
    }

    public function toArray(): array
    {
        return [
            'id' => $this->id,
            'name' => $this->name,
            'email' => $this->email,
            'password' => $this->password
        ];
    }

    // Getters et setters...
    public function getId(): int { return $this->id; }
    public function getName(): string { return $this->name; }
    public function getEmail(): string { return $this->email; }
    // ...
}

4. Création d'un repository

<?php
namespace App\Repository;

use App\Core\Abstract\AbstractRepository;
use App\Entity\User;

class UserRepository extends AbstractRepository
{
    public function selectAll(): array
    {
        $stmt = $this->pdo->query("SELECT * FROM users");
        $users = [];
        
        while ($userData = $stmt->fetch()) {
            $users[] = User::toObject($userData);
        }
        
        return $users;
    }

    public function insert(array $data): bool
    {
        $sql = "INSERT INTO users (name, email, password) VALUES (:name, :email, :password)";
        $stmt = $this->pdo->prepare($sql);
        
        return $stmt->execute([
            'name' => $data['name'],
            'email' => $data['email'],
            'password' => $data['password']
        ]);
    }

    public function selectById($id): ?User
    {
        $sql = "SELECT * FROM users WHERE id = :id";
        $stmt = $this->pdo->prepare($sql);
        $stmt->execute(['id' => $id]);
        
        $userData = $stmt->fetch();
        return $userData ? User::toObject($userData) : null;
    }

    public function selectBy(array $filter): array
    {
        // Implementation selon vos besoins
        return [];
    }

    public function update() { /* Implementation */ }
    public function delete() { /* Implementation */ }
}

5. Validation des données

use App\Core\App;

$validator = App::getDependency('validator');

$rules = [
    'name' => [['required', 'Le nom est obligatoire'], ['minLength', 3, 'Minimum 3 caractères']],
    'email' => [['required', 'Email requis'], ['isMail', 'Format email invalide']],
    'password' => [['required', 'Mot de passe requis'], ['isPassword', 'Mot de passe trop faible']],
    'phone' => [['isSenegalPhone', 'Numéro de téléphone sénégalais invalide']],
    'cni' => [['isCNI', 'Numéro CNI invalide']]
];

if ($validator->validate($_POST, $rules)) {
    // Données valides
    echo "Validation réussie !";
} else {
    // Récupérer les erreurs
    $errors = $validator->getErrors();
    foreach ($errors as $field => $error) {
        echo "$field: $error\n";
    }
}

6. Gestion des sessions

use App\Core\Session;

// Démarrer une session (automatique avec le router)
Session::set('user', ['id' => 1, 'name' => 'John Doe']);

// Récupérer une valeur de session
$userId = Session::get('user', 'id');

// Vérifier si une clé existe
if (Session::isset('user')) {
    echo "Utilisateur connecté";
}

// Supprimer une clé
Session::unset('user');

// Détruire la session
Session::destroy();

7. Upload d'images

use App\Core\ImageService;

// Upload d'une seule image
try {
    $result = ImageService::uploadImage(
        $_FILES['image'], 
        '/public/images/uploads/',
        ['jpg', 'jpeg', 'png', 'gif']
    );
    
    echo "Image uploadée : " . $result['url'];
    
} catch (Exception $e) {
    echo "Erreur : " . $e->getMessage();
}

// Upload multiple (dans un contrôleur)
$photoData = $this->uploadPhotos($_FILES);
if ($photoData) {
    $photos = json_decode($photoData, true);
    echo "Recto : " . $photos['recto'];
    echo "Verso : " . $photos['verso'];
}

8. Middlewares

// config/middlewares.php
function runMiddleWare(array $middlewares) {
    $middlewareMap = [
        'auth' => App\Core\Middlewares\Auth::class,
        'cryptPassword' => App\Core\Middlewares\CryptPassword::class
    ];

    foreach ($middlewares as $middleware) {
        if (isset($middlewareMap[$middleware])) {
            $middlewareInstance = new $middlewareMap[$middleware]();
            $middlewareInstance();
        }
    }
}

Créer un middleware personnalisé :

<?php
namespace App\Core\Middlewares;

class CustomMiddleware
{
    public function __invoke()
    {
        // Votre logique de middleware
        if (!condition()) {
            header('Location: /error');
            exit();
        }
    }
}

Règles de validation disponibles

required : Champ obligatoire
minLength : Longueur minimale
isMail : Format email valide
isPassword : Mot de passe fort (8+ caractères, majuscule, minuscule, chiffre, caractère spécial)
isSenegalPhone : Numéro de téléphone sénégalais (70, 75, 76, 77, 78)
isCNI : Numéro de CNI sénégalais

Sécurité

Utilisation de requêtes préparées (PDO)
Hashage automatique des mots de passe
Protection CSRF (à implémenter selon vos besoins)
Validation stricte des données d'entrée
Gestion sécurisée des uploads de fichiers

Contribution

Fork le projet
Créez votre branche feature (git checkout -b feature/AmazingFeature)
Committez vos changements (git commit -m 'Add some AmazingFeature')
Push vers la branche (git push origin feature/AmazingFeature)
Ouvrez une Pull Request

Licence

Ce projet est sous licence MIT. Voir le fichier LICENSE pour plus de détails.

📞 Support

Documentation : [Lien vers votre documentation]
Issues : [Lien vers les issues GitHub]
Email : votre-email@example.com

🔄 Changelog

v1.0.0

Release initiale
Architecture MVC complète
Système d'injection de dépendances
Validation des données
Gestion des sessions et images
Support des middlewares

Développé avec pour la communauté PHPf_

wesh / core

Package info

Security

Statistics