LavaLust

LavaLust Framework

A lightweight, fast PHP framework built for developers who want clean MVC architecture without unnecessary complexity or performance overhead.

---

Overview

LavaLust is an open-source PHP framework that follows the MVC (Model–View–Controller) architectural pattern. It is designed for developers who need a structured, maintainable, and scalable foundation — without the bloat of heavier modern frameworks.

Whether you are building a simple web application, a REST API, or a teaching project, LavaLust provides the right tools with minimal friction.

---

Features

Feature	Description
MVC Architecture	Clean separation of Models, Views, and Controllers for organized, maintainable code
Built-in Routing	Flexible URL routing that maps requests to controllers with minimal configuration
Libraries & Helpers	Reusable components for sessions, forms, validation, and database access
Modular Design	Scalable structure that supports clean organization as your application grows
REST API Support	First-class support for building RESTful APIs using LavaLust conventions
ORM-like Models	Simplified, readable database interaction without a heavy abstraction layer

---

Requirements

• PHP 7.4 or higher
• A web server with URL rewriting support (Apache .htaccess or Nginx config)
• Composer (optional, for dependency management)

---

Installation

Clone the repository:

git clone https://github.com/ronmarasigan/lavalust.git
cd lavalust

Or download a release directly:

wget https://github.com/ronmarasigan/lavalust/archive/refs/heads/main.zip
unzip main.zip

Configure your web server to point to the project root and ensure mod_rewrite (Apache) or equivalent is enabled.

---

Quick Start

1. Define a Route

File: app/config/routes.php

$router->get('/', 'Welcome::index');
$router->get('/about', 'Welcome::about');
$router->post('/users/store', 'Users::store');

2. Create a Controller

File: app/controllers/Welcome.php

call->view('welcome', $data);
    }

    public function about()
    {
        $this->call->view('about');
    }
}

3. Create a View

File: app/views/welcome.php

    
    

    
Welcome to LavaLust Framework

    
Lightweight. Fast. MVC.

4. Create a Model

File: app/models/User_model.php

db->table($this->table)->get()->getResult();
    }

    public function findById(int $id)
    {
        return $this->db->table($this->table)
                        ->where('id', $id)
                        ->get()
    }
}

---

Project Structure

lavalust/
├── app/
│   ├── config/          # Application configuration (database, routes, etc.)
│   ├── controllers/     # Controller classes
│   ├── models/          # Model classes
│   ├── views/           # View templates
│   └── libraries/       # Custom libraries and helpers
├── scheme/              # Core framework files (do not modify)
├── public/              # Publicly accessible entry point
│   └── index.php
└── runtime/            # Cache, logs, and uploads (must be writable)

---

Configuration

Database

File: app/config/database.php

$database['main'] = array(
    'driver'	=> getenv('DB_DRIVER') ?: '',
    'hostname'	=> getenv('DB_HOST') ?: '',
    'port'		=> getenv('DB_PORT') ?: '',
    'username'	=> getenv('DB_USER') ?: '',
    'password'	=> getenv('DB_PASSWORD') ?: '',
    'database'	=> getenv('DB_NAME') ?: '',
    'charset'	=> getenv('DB_CHARSET') ?: '',
    'dbprefix'	=> getenv('DB_PREFIX') ?: '',
    // Optional for SQLite
    'path'      => ''
);

Base URL

File: app/config/config.php

$config['base_url'] = 'http://localhost:3000/';

---

Building a REST API

LavaLust supports REST API development out of the box. Controllers can return JSON responses for API endpoints.

call->library('api');

    public function users()
    {
        $this->api->require_method('GET');
        $auth = $this->api->require_jwt(); 

        $this->call->model('User_model');
        $users = $this->User_model->getAll();

        $this->api->respond(['data' => $users]);
    }
}

Route definition:

$router->get('/api/users', 'Api::users');

---

Philosophy

LavaLust is built on a single principle: minimal core, maximum control.

Modern frameworks often add layers of abstraction that benefit large enterprise teams but get in the way of developers who want to understand exactly what their code is doing. LavaLust provides structure and utilities without hiding the underlying logic — making it an excellent choice for:

• Rapid prototyping — Get an application running in minutes
• Learning MVC — Understand how each architectural layer works
• Lightweight production apps — Deploy without dragging in unused dependencies
• Teaching PHP development — Clear conventions, readable source code

---

Documentation

Full documentation is available at https://lavalust.netlify.app

Topics covered include:

• Installation and server configuration
• Routing: static, dynamic, and grouped routes
• Controllers and request handling
• Models and query builder
• Views, layouts, and partials
• Built-in libraries (sessions, form validation, file upload)
• Helper functions
• REST API development
• Security best practices

---

Contributing

Contributions are welcome. To contribute:

1. Fork the repository
2. Create a feature branch: git checkout -b feature/your-feature-name
3. Commit your changes: git commit -m "Add your feature description"
4. Push to your branch: git push origin feature/your-feature-name
5. Open a pull request against main

Please ensure your code follows the existing style conventions and includes relevant documentation or comments where appropriate.

---

Roadmap

• CLI tool for generating controllers, models, and migrations
• Middleware support
• Improved query builder with relationship support
• Enhanced error handling and debugging tools

---

License

LavaLust Framework is open-source software licensed under the MIT License.

---

Links

• GitHub Repository: https://github.com/ronmarasigan/lavalust
• Documentation: https://lavalust.netlify.app
• Report an Issue: https://github.com/ronmarasigan/lavalust/issues