README

Adja Core est une bibliothèque PHP légère, modulaire et réutilisable conçue pour servir de socle aux applications PHP orientées objet et aux architectures MVC.

Elle fournit plusieurs composants permettant de centraliser les fonctionnalités courantes d'une application : gestion des requêtes HTTP, sessions, base de données, validation, vues, redirections, helpers et débogage.

Sommaire

Prérequis
Installation
Autoload PSR-4
Fonctionnalités
- Request
- Controller
- Database
- Validator
- SessionManager
- Helpers
- Debug
Structure du package
Auteur
Licence

Prérequis

Avant d'utiliser Adja Core, votre environnement doit disposer de :

PHP 8.3 ou supérieur
Composer
PDO
mbstring
pdo_pgsql pour PostgreSQL
pdo_mysql pour MySQL

Les extensions pdo_pgsql et pdo_mysql sont nécessaires uniquement si vous utilisez le pilote correspondant.

Installation

Installez le package avec Composer :

composer require adja/core

Composer installe automatiquement le package ainsi que son autoloader.

Dans votre application PHP, chargez l'autoloader :

<?php

require_once __DIR__ . '/vendor/autoload.php';

Vous pouvez ensuite utiliser les classes du package :

<?php

use Adja\Core\Debug;

Debug::dump('Hello Adja Core');

Autoload PSR-4

Adja Core utilise l'autoloading PSR-4 avec le namespace :

Adja\Core\

La configuration du package est :

{
    "autoload": {
        "psr-4": {
            "Adja\\Core\\": "src/"
        }
    }
}

Ainsi :

src/Validator.php

correspond à :

namespace Adja\Core;

class Validator
{
    // ...
}

Après une modification de l'autoload, régénérez l'autoloader :

composer dump-autoload

Fonctionnalités

1. Request

La classe Adja\Core\Request permet de centraliser la gestion des requêtes HTTP.

<?php

use Adja\Core\Request;

if (Request::isPost()) {
    $email = Request::post('email', '');
}

if (Request::isGet()) {
    $page = Request::get('page', 1);
}

$method = Request::getMethod();

$data = Request::all();

$uri = Request::uri();

Principales fonctionnalités

Détection de la méthode HTTP
Récupération des données GET
Récupération des données POST
Récupération de toutes les données
Récupération de l'URI
Centralisation de l'accès aux données HTTP

2. Controller

La classe Adja\Core\Controller facilite :

le rendu des vues ;
le rendu avec layout ;
les redirections.

Structure des vues

views/
├── layout/
│   └── app.php
└── users/
    └── index.php

Afficher une vue

<?php

use Adja\Core\Controller;

Controller::renderView('users', [
    'title' => 'Liste des utilisateurs',
    'users' => $users
]);

La classe recherchera :

views/users/index.php

Afficher une vue avec un layout

Controller::renderViewLayout('users', 'app', [
    'title' => 'Liste des utilisateurs',
    'users' => $users
]);

Le système recherchera :

views/users/index.php
views/layout/app.php

Le contenu de la vue est disponible dans le layout avec :

<?= $contentView ?>

Redirection

Controller::redirectToRoute('users');

Avec une base URL :

Controller::redirectToRoute('dashboard', '/mon-projet');

3. Database

La classe Adja\Core\Database centralise la connexion PDO et l'exécution des requêtes SQL.

Elle prend en charge :

PostgreSQL ;
MySQL ;
les requêtes préparées ;
les requêtes SELECT ;
INSERT ;
UPDATE ;
DELETE ;
la récupération des résultats ;
la récupération de l'instance PDO.

Configuration PostgreSQL

<?php

use Adja\Core\Database;

Database::init(
    'localhost',
    5432,
    'mon_app_db',
    'postgres',
    'password',
    'pgsql'
);

Configuration MySQL

Database::init(
    '127.0.0.1',
    3306,
    'mon_app_db',
    'root',
    '',
    'mysql'
);

Requête préparée

Pour récupérer un seul résultat :

$user = Database::executeQuery(
    'SELECT * FROM users WHERE email = :email',
    ['email' => 'adja@example.com'],
    true
);

Pour récupérer plusieurs résultats :

$users = Database::executeQuery(
    'SELECT * FROM users WHERE status = :status',
    ['status' => 'actif'],
    false
);

INSERT

$newId = Database::executeUpdate(
    'INSERT INTO users (nom, email) VALUES (:nom, :email)',
    [
        'nom' => 'Adja',
        'email' => 'adja@example.com'
    ]
);

UPDATE

$affectedRows = Database::executeUpdate(
    'UPDATE users SET status = :status WHERE id = :id',
    [
        'status' => 'inactif',
        'id' => 1
    ]
);

DELETE

$affectedRows = Database::executeUpdate(
    'DELETE FROM users WHERE id = :id',
    ['id' => 1]
);

Requête sans paramètres

$users = Database::query(
    'SELECT * FROM users',
    false
);

Récupérer toutes les données d'une table

$users = Database::getAllData('users');

Récupérer l'instance PDO

$pdo = Database::getInstance();

4. Validator

La classe Adja\Core\Validator permet de valider facilement les données provenant des formulaires.

<?php

use Adja\Core\Validator;

$errors = [];

Validator::required(
    $_POST['nom'] ?? null,
    'nom',
    $errors,
    'Le nom est obligatoire'
);

Validator::minLength(
    $_POST['nom'] ?? '',
    3,
    'nom',
    $errors,
    'Le nom doit contenir au moins 3 caractères'
);

Validator::maxLength(
    $_POST['nom'] ?? '',
    50,
    'nom',
    $errors
);

Validator::isEmail(
    $_POST['email'] ?? '',
    'email',
    $errors,
    "Format d'email invalide"
);

Validator::isPositive(
    $_POST['quantite'] ?? null,
    'quantite',
    $errors
);

Validator::isGreaterThanZero(
    $_POST['prix'] ?? null,
    'prix',
    $errors,
    'Le prix doit être supérieur à 0'
);

if (Validator::hasErrors($errors)) {
    // Traitement des erreurs
}

Méthodes disponibles

Méthode	Description
`required()`	Vérifie qu'une valeur est renseignée
`isPositive()`	Vérifie qu'une valeur est positive ou nulle
`isGreaterThanZero()`	Vérifie qu'une valeur est supérieure à zéro
`isEmail()`	Vérifie le format d'un email
`minLength()`	Vérifie la longueur minimale
`maxLength()`	Vérifie la longueur maximale
`unique()`	Vérifie l'unicité d'une valeur
`hasErrors()`	Vérifie la présence d'erreurs

5. SessionManager

Adja\Core\SessionManager simplifie la gestion des sessions PHP.

Stocker une donnée

<?php

use Adja\Core\SessionManager;

SessionManager::setData(
    'user',
    [
        'id' => 1,
        'nom' => 'Adja'
    ]
);

Récupérer une donnée

$user = SessionManager::getData('user');

Avec une valeur par défaut :

$page = SessionManager::getData('page', 1);

Vérifier une clé

if (SessionManager::hasKey('user')) {
    // La clé existe
}

Supprimer une donnée

SessionManager::removeSession('user');

Récupérer toute la session

$sessionData = SessionManager::getAllSession();

Vider les données

SessionManager::clearSession();

Détruire complètement la session

SessionManager::destroySession();

6. Helpers

La classe Adja\Core\Helpers contient plusieurs méthodes utiles pour les vues PHP.

<?php

use Adja\Core\Helpers;

Assets

<link rel="stylesheet" href="<?= Helpers::asset('css/app.css') ?>">

Résultat :

/assets/css/app.css

URL

<a href="<?= Helpers::pathUrl('users/create') ?>">
    Nouveau
</a>

Échapper une valeur HTML

<?= Helpers::e($user->nom) ?>

Cette méthode utilise htmlspecialchars() pour éviter l'injection de HTML dans les sorties.

Ancienne valeur d'un formulaire

<input
    type="text"
    name="nom"
    value="<?= Helpers::old($_POST, 'nom') ?>"
>

Option sélectionnée

<option value="1" <?= Helpers::selected($selectedId, 1) ?>>
    Option 1
</option>

Checkbox

<input
    type="checkbox"
    name="active"
    <?= Helpers::checked($status, 'active') ?>
>

Classe CSS active

<a
    href="/users"
    class="<?= Helpers::active($currentUri, '/users') ?>"
>
    Utilisateurs
</a>

7. Debug

La classe Adja\Core\Debug fournit des outils simples pour le débogage.

Afficher une variable

<?php

use Adja\Core\Debug;

Debug::dump($data);

dump() affiche la valeur sans arrêter l'exécution du programme.

Afficher et arrêter l'exécution

Debug::dd($data);

dd() affiche la valeur puis arrête immédiatement l'exécution du script.

Exemple rapide

require_once __DIR__ . '/vendor/autoload.php';

use Adja\Core\Debug;

Debug::dump('Hello Adja Core');

Structure du package

adja-core/
├── src/
│   ├── Controller.php
│   ├── Database.php
│   ├── Debug.php
│   ├── Helpers.php
│   ├── Request.php
│   ├── SessionManager.php
│   └── Validator.php
├── tests/
├── composer.json
├── README.md
├── LICENSE
└── .gitignore

Le namespace de toutes les classes est :

Adja\Core

Exemple :

use Adja\Core\Validator;
use Adja\Core\Database;
use Adja\Core\Request;
use Adja\Core\Controller;
use Adja\Core\Helpers;
use Adja\Core\SessionManager;
use Adja\Core\Debug;

Utilisation dans un projet MVC

Après installation :

composer require adja/core

Vous pouvez utiliser les composants directement dans vos contrôleurs, services ou vues.