PHP code example of nexa / framework

    
        
<?php
require_once('vendor/autoload.php');

/* Start to develop here. Best regards https://php-download.com/ */

    

nexa / framework example snippets

// Routes basiques
Route::get('/', function() {
    return view('welcome');
});

Route::post('/users', [UserController::class, 'store']);

// Groupes de routes avec middleware
Route::group(['prefix' => 'api', 'middleware' => 'auth'], function() {
    Route::resource('posts', PostController::class);
    Route::get('/profile', [UserController::class, 'profile']);
});

// Modèle simple
class User extends Model
{
    protected $fillable = ['name', 'email'];
    protected $casts = ['email_verified_at' => 'datetime'];
    
    public function posts()
    {
        return $this->hasMany(Post::class);
    }
}

// Requêtes fluides
$users = User::where('active', true)
    ->whereNotNull('email_verified_at')
    ->with('posts')
    ->orderBy('created_at', 'desc')
    ->limit(10)
    ->get();

// Création et mise à jour
$user = User::create([
    'name' => 'John Doe',
    'email' => '[email protected]'
]);

$user = User::firstOrCreate(
    ['email' => '[email protected]'],
    ['name' => 'Jane Doe']
);

// Dans un contrôleur
public function store(Request $request)
{
    $validated = $request->validate([
        'name' => 'eger|min:18'
    ]);
    
    return User::create($validated);
}

// Validation avec middleware
Route::post('/users', [UserController::class, 'store'])
    ->middleware(ValidationMiddleware::make([
        'name' => '

// Cache simple
Cache::put('key', 'value', 3600); // 1 heure
$value = Cache::get('key', 'default');

// Remember pattern
$users = Cache::remember('active_users', 3600, function() {
    return User::where('active', true)->get();
});

// Cache permanent
Cache::forever('settings', $settings);

// Déclencher un événement
Event::dispatch('user.created', $user);

// Écouter un événement
Event::listen('user.created', function($user) {
    // Envoyer un email de bienvenue
    Mail::send('welcome', $user);
});

// Wildcards
Event::listen('user.*', function($event, $data) {
    Log::info("Événement utilisateur: {$event}");
});

// workspace/entities/User.php
#[AutoDiscover, Cache('users'), Validate, Secure]
class User extends Entity
{
    #[HasMany(Task::class)]
    public function tasks() { return $this->hasMany(Task::class); }
    
    #[Intelligent]
    public function getPerformanceScore() {
        return $this->ai()->calculateScore();
    }
}

// workspace/handlers/UserHandler.php
#[AutoRoute('/api/users'), Middleware('auth'), Cache, Secure]
class UserHandler extends Handler
{
    #[Get('/'), Paginate, Cache(300)]
    public function index() {
        return User::quantum()->paginate();
    }
    
    #[Post('/'), Validate(UserRequest::class), Audit]
    public function store(UserRequest $request) {
        return User::quantum()->create($request->validated());
    }
}

// Génération d'un token JWT
$token = \Nexa\Auth\JWT::generate([
    'user_id' => 1,
    'role' => 'admin'
]);

// Vérification d'un token
$payload = \Nexa\Auth\JWT::verify($token);

// Utilisation du middleware JWT
Router::group(['middleware' => 'jwt'], function() {
    Router::get('/profile', 'UserController@profile');
});

// Utilisation des événements prédéfinis
use Nexa\Events\UserRegistered;
use Nexa\Events\UserLoggedIn;
use Nexa\Events\ModelCreated;

// Instancier un événement avec des données
$event = new UserRegistered($user);

// Accéder aux données de l'événement
$userId = $event->user->id;
$email = $event->user->email;

// Événement de connexion
$loginEvent = new UserLoggedIn($user, $request->ip());

// Événement de création de modèle
$modelEvent = new ModelCreated($post, 'Post');
$modelName = $modelEvent->modelType; // 'Post'

// Création d'un job
$job = new \Nexa\Queue\Job('App\Jobs\SendEmail', [
    'user_id' => 123,
    'subject' => 'Bienvenue!',
    'content' => 'Merci de votre inscription.'
]);

// Ajout à la queue pour exécution immédiate
\Nexa\Queue\Queue::push($job);

// Ajout à la queue pour exécution différée (60 secondes)
\Nexa\Queue\Queue::later($job, 60);

// config/database.php
return [
    'default' => 'mysql',
    'connections' => [
        'mysql' => [
            'driver' => 'mysql',
            'host' => 'localhost',
            'database' => 'nexa',
            'username' => 'root',
            'password' => '',
            'charset' => 'utf8mb4',
            'collation' => 'utf8mb4_unicode_ci',
            'prefix' => '',
        ],
        'sqlite' => [
            'driver' => 'sqlite',
            'database' => __DIR__ . '/../database/database.sqlite',
        ],
    ],
];

// config/events.php
return [
    'listeners' => [
        'Nexa\Events\UserRegistered' => [
            'App\Listeners\SendWelcomeEmail',
            'App\Listeners\CreateUserProfile',
        ],
        'Nexa\Events\UserLoggedIn' => [
            'App\Listeners\LogUserActivity',
        ],
    ],
];

// config/queue.php
return [
    'default' => 'database',
    'connections' => [
        'sync' => [
            'driver' => 'sync',
        ],
        'database' => [
            'driver' => 'database',
            'table' => 'jobs',
            'retry_after' => 90,
        ],
    ],
];

bash
# Installation via Composer
composer create-project nexa/framework mon-projet
cd mon-projet

# Configuration de base
cp .env.example .env
php nexa key:generate

# Migration de la base de données
php nexa migrate

# Démarrage du serveur de développement
php nexa serve

bash
# Générer un contrôleur
php nexa make:controller UserController

# Générer un modèle
php nexa make:model User

# Créer une migration
php nexa make:migration create_users_table

# Générer un middleware
php nexa make:middleware AuthMiddleware

bash
# Nouveau projet
composer create-project nexa/framework mon-projet
cd mon-projet

# Configuration
cp .env.example .env
php nexa key:generate

# Base de données (optionnel)
php nexa migrate

# Démarrage
php nexa serve

bash
# Créer un contrôleur avec méthodes CRUD
php nexa make:controller ProductController --resource

# Générer un modèle avec migration
php nexa make:model Product --migration

# Créer un middleware personnalisé
php nexa make:middleware AuthMiddleware

# Générer un handler pour API
php nexa make:handler ApiHandler

bash
# Créer une migration
php nexa make:migration create_products_table

# Exécuter les migrations
php nexa migrate

# Rollback des migrations
php nexa migrate:rollback

# Seeder la base de données
php nexa db:seed

bash
# Démarrer le serveur de développement
php nexa serve

# Nettoyer le cache
php nexa cache:clear

# Optimiser l'application
php nexa optimize

# Lancer les tests
php nexa test

bash
php scripts/cleanup.php

html
<!-- interface/UserDashboard.nx -->
@cache('user-dashboard', 300)
@entity(User::class)
@handler(UserHandler::class)

<div class="dashboard" nx:reactive>
    <nx:navigation />
    
    <div class="stats-grid">
        @foreach($stats as $stat)
            <nx:stat-card 
                :title="$stat.title" 
                :value="$stat.value" 
                :trend="$stat.trend" 
                :color="$stat.color" />
        @endforeach
    </div>
    
    <div class="projects">
        @if($projects->count() > 0)
            @foreach($projects as $project)
                <nx:project-card :project="$project" />
            @endforeach
        @else
            <nx:empty-state message="Aucun projet trouvé" />
        @endif
    </div>
    
    @realtime('user-updates')
    <nx:notification-center />
</div>

<script>
export default {
    data: () => ({
        reactive: true,
        realtime: true
    }),
    
    computed: {
        totalProjects() {
            return this.projects.length;
        }
    },
    
    methods: {
        refreshData() {
            this.$quantum.refresh();
        }
    }
}
</script>

├── app/                     # Code de l'application
│   ├── Controllers/         # Contrôleurs
│   ├── Models/              # Modèles
│   ├── Middleware/          # Middlewares personnalisés
│   ├── Events/              # Événements personnalisés
│   └── Jobs/                # Jobs pour les queues
├── config/                  # Configuration
│   ├── app.php
│   ├── database.php
│   ├── auth.php
│   └── queue.php
├── database/                # Migrations et seeds
│   ├── migrations/
│   └── seeds/
├── public/                  # Point d'entrée public
│   └── index.php
├── resources/               # Assets et vues
│   ├── views/
│   ├── css/
│   └── js/
├── routes/                  # Définition des routes
│   ├── web.php
│   └── api.php
├── src/                     # Code source du framework
│   └── Nexa/
│       ├── Core/
│       ├── Database/
│       ├── Routing/
│       ├── Auth/
│       ├── Events/
│       └── Queue/
├── storage/                  # Stockage (logs, cache, uploads)
│   ├── logs/
│   ├── cache/
│   └── uploads/
├── examples/                 # Exemples d'utilisation
│   └── complete_app.php
├── docs/                     # Documentation
│   └── PHASE2.md
├── nexa                      # CLI exécutable
├── NexaCLI.php              # Classe CLI principale
└── README.md                # Ce fichier

bash
# Fork et clone
git clone https://github.com/votre-username/nexa-framework.git
cd nexa-framework

# Installation des dépendances
composer install

# Tests
php vendor/bin/phpunit

# Standards de code
php vendor/bin/php-cs-fixer fix