Ravi Kishan

Posted on Nov 7

Introducing NexaPHP: A Lightweight MVC PHP Framework

#webdev #programming #php #tutorial

Building PHP applications often involves a lot of boilerplate code and organization to maintain a clean structure. Many developers reach for frameworks like Laravel or Symfony to handle this, but what if you just need a light, straightforward MVC (Model-View-Controller) framework? NexaPHP might be exactly what you're looking for. This minimalist framework is designed for developers who want a lean structure without all the weight of larger frameworks, making it an ideal choice for learning or creating small to medium-sized applications.

Why NexaPHP?

NexaPHP is tailored for developers who value simplicity and want more control over the core framework functionality. The design of NexaPHP is straightforward and lets you focus on essential aspects of your application without navigating through heavy framework abstractions. Here’s what NexaPHP offers:

Lightweight and minimal - Core MVC components without excessive dependencies.
Easy setup and configuration - Straightforward configuration for database and routing.
Middleware support - Add custom middleware for enhanced request filtering.
Event-driven - Use custom events to customize application behavior.

Whether you're a beginner or an experienced developer wanting to learn MVC principles, NexaPHP’s small footprint allows you to dive directly into PHP web development.

Getting Started with NexaPHP

1. Installation

Install NexaPHP via Composer, which makes it easy to integrate into any PHP project:

composer require ravikisha/nexaphp

2. Basic Setup

To initialize a NexaPHP application, configure your application root directory and database details:

use ravikisha\nexaphp\Application;

$config = [
    'userClass' => \app\models\User::class,
    'db' => [
        'dsn' => 'mysql:host=localhost;dbname=testdb',
        'user' => 'root',
        'password' => 'password'
    ]
];

$app = new Application(__DIR__, $config);

This setup includes:

userClass: Defines the User model, critical for handling user authentication and management.
db: Provides database connection parameters, including Data Source Name (DSN), user, and password.

Key Components in NexaPHP

NexaPHP provides several foundational classes that power its core MVC structure:

Application: Manages the lifecycle of your app and orchestrates different components.
Router: Maps URLs to specific controllers and actions.
Request and Response: Handle HTTP requests and responses.
Database: Manages database connections and queries.
Session: Offers session management functions.
View: Handles the rendering of HTML templates.

Building Your First Controller

Controllers define how NexaPHP handles requests for different routes. Here’s an example of a SiteController:

namespace app\controllers;

use ravikisha\nexaphp\Controller;

class SiteController extends Controller
{
    public function home()
    {
        return $this->render('home');
    }

    public function contact()
    {
        return $this->render('contact');
    }
}

Using $this->render() renders a view file, while setLayout() can define custom layouts.

Defining Routes

The Router allows you to define GET and POST routes that correspond to specific controller actions:

$app->router->get('/', [SiteController::class, 'home']);
$app->router->post('/contact', [SiteController::class, 'contact']);

NexaPHP supports dynamic routes with parameters, allowing you to handle user-specific pages:

$app->router->get('/profile/{id}', [UserController::class, 'profile']);

Database Integration

NexaPHP uses PDO for database interactions, making it easy to integrate with various databases. Here’s a quick overview:

Defining a Model: Use models to interact with database tables.

namespace app\models;

use ravikisha\nexaphp\db\DBModel;

class User extends DBModel
{
    public string $id;
    public string $name;

    public static function tableName(): string
    {
        return 'users';
    }

    public function attributes(): array
    {
        return ['id', 'name'];
    }
}

Migrations: NexaPHP can run migrations to keep the database schema updated:
```
$app->db->applyMigrations();
```
CRUD Operations: NexaPHP provides methods like save() and findOne() for database operations.

Middleware Support

NexaPHP’s middleware feature allows you to implement request filtering and control. Here’s an example of creating and applying custom middleware:

namespace app\middlewares;

use ravikisha\nexaphp\middlewares\BaseMiddleware;

class AuthMiddleware extends BaseMiddleware
{
    public function execute()
    {
        // Authentication logic
    }
}

To register middleware:

$this->registerMiddleware(new AuthMiddleware(['profile', 'settings']));

Views and Templating

NexaPHP views offer a simple way to manage HTML templates. By default, templates are stored in the views folder, and you can use layout files to maintain a consistent design.

return $this->render('profile', ['name' => 'John Doe']);

Layouts can be defined under views/layouts, and placeholders like {{content}} allow views to be inserted dynamically.

Forms and Fields

NexaPHP offers a convenient form and field builder, making it easy to create dynamic HTML forms:

use ravikisha\nexaphp\form\Form;

$form = Form::begin('/submit', 'post');
echo $form->field($model, 'username');
Form::end();

You can render various field types such as password, email, and date fields for different form requirements.

Session Management

The Session class provides session handling, allowing you to set, get, and manage flash messages:

Application::$app->session->setFlash('success', 'Logged in successfully');

This is particularly useful for displaying temporary notifications.

Exception Handling

NexaPHP has built-in support for handling exceptions, including:

NotFoundException for invalid routes.
ForbiddenException for access control.

User Authentication

User authentication is managed through the abstract UserModel class, which provides foundational methods like login(), logout(), and isGuest().

class User extends UserModel
{
    public static function primaryKey(): string
    {
        return 'id';
    }

    public function getDisplayName(): string
    {
        return $this->username;
    }
}

Sample NexaPHP Application

Below is an example of a basic NexaPHP application setup:

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

use ravikisha\nexaphp\Application;
use app\controllers\SiteController;

$config = [
    'userClass' => \app\models\User::class,
    'db' => [
        'dsn' => 'mysql:host=localhost;dbname=testdb',
        'user' => 'root',
        'password' => 'password'
    ]
];

$app = new Application(__DIR__, $config);

$app->router->get('/', [SiteController::class, 'home']);
$app->router->get('/contact', [SiteController::class, 'contact']);

$app->run();

Conclusion

NexaPHP provides a clean and concise way to build MVC applications with PHP. While it’s intended for learning and small projects, it’s a great choice for those who want to understand how an MVC framework works under the hood. Explore the framework on GitHub or install it via Composer to get started.

GitHub: NexaPHP GitHub

Composer: NexaPHP on Packagist

DEV Community