Download the PHP package neuron-php/mvc without Composer

Neuron-PHP MVC

A lightweight MVC (Model-View-Controller) framework component for PHP 8.4+ that provides core MVC functionality including controllers, views, routing integration, request handling, and a powerful view caching system.

Table of Contents

• Installation
• Quick Start
• Core Components
• Configuration
• Usage Examples
• Advanced Features
• CLI Commands
• API Reference
• Testing
• More Information

Installation

Requirements

• PHP 8.4 or higher
• Composer

Install via Composer

Install php composer from https://getcomposer.org/

Install the neuron MVC component:

Quick Start

1. Create the Front Controller

Create a public/index.php file:

2. Configure Apache (.htaccess)

Create a public/.htaccess file to route all requests through the front controller:

For Nginx

If using Nginx, add this to your server configuration:

3. Minimal Configuration

Create a config/neuron.yaml file:

Core Components

Application

The main application class (Neuron\Mvc\Application) handles:

• Route discovery from controller attributes
• Request routing and controller execution
• Event dispatching for HTTP errors
• Output capture for testing
• Cache management

Controllers

Controllers handle incoming requests and return responses. All controllers should extend Neuron\Mvc\Controllers\Base and implement the IController interface.

Available render methods:

• renderHtml() - Render HTML views with layouts
• renderJson() - Return JSON responses
• renderXml() - Return XML responses
• renderMarkdown() - Render Markdown content with CommonMark

Views

Views support multiple formats and are stored in the configured views directory:

HTML Views

Layouts

Routing

Routes are defined using PHP attributes on controller methods:

Request Handling

Create request DTO definitions for validation. You can define DTOs inline or reference external DTO files:

Inline DTO Definition:

Referenced DTO:

Access validated data in controllers:

URL Helpers

The framework provides Rails-style URL helpers for generating URLs from named routes. This makes it easy to generate consistent URLs throughout your application.

Route Naming

Routes are automatically named based on their configuration key in the YAML file:

Using URL Helpers in Controllers

Controllers can use URL helpers directly via magic methods:

Direct URL Helper Methods

Controllers also provide direct helper methods:

Using URL Helpers in Views

URL helpers are automatically available in all views through the injected $urlHelper variable:

Magic Method Conventions

The magic methods follow Rails naming conventions:

URL Helper Methods

Error Handling

URL helpers gracefully handle missing routes:

Advanced Usage

Configuration

All YAML config file parameters can be overridden by environment variables in the form of <CATEGORY>_<KEY>, e.g. SYSTEM_BASE_PATH.

Main Configuration (neuron.yaml)

Routing Configuration (routing.yaml)

Routing configuration is now handled in a dedicated config/routing.yaml file. This separates routing concerns from the main application configuration.

Key Features:

1. URL Rewrites: Transparently rewrite URLs before route matching

   • No HTTP redirects (faster, invisible to client)
   • Override package-provided routes
   • Support legacy URLs without duplicate routes
2. Controller Paths: Specify where to scan for route attributes
   • Order matters: first paths take precedence
   • Allows overriding routes from packages

Backward Compatibility:

For backward compatibility, controller_paths can still be configured in neuron.yaml:

If both files exist, routing.yaml takes precedence.

Cache Configuration Options

Usage Examples

Creating a Controller

Request Validation with DTOs

Define request DTOs in YAML:

Available property types:

• string, integer, float, boolean
• email, url, uuid
• date, date_time, time
• currency, us_phone_number, intl_phone_number
• array, object
• ip_address, ein, upc, name, numeric

Error Handling

The framework automatically handles 404 errors:

Advanced Features

View Caching

The framework includes a sophisticated view caching system with multiple storage backends:

Storage Backends

1. File Storage (Default): Uses the local filesystem for cache storage
2. Redis Storage: High-performance in-memory caching with Redis

Features

1. Automatic Cache Key Generation: Based on controller, view, and data
2. Selective Caching: Enable/disable per view type
3. TTL Support: Configure expiration times
4. Garbage Collection: Automatic cleanup of expired entries
5. Multiple Storage Backends: Choose between file or Redis storage

Configuration

File Storage Configuration

Redis Storage Configuration

This flat structure ensures compatibility with environment variables:

• CACHE_STORAGE=redis
• CACHE_REDIS_HOST=127.0.0.1
• CACHE_REDIS_PORT=6379
• etc.

Programmatic Usage

Manual Cache Management

Using CacheStorageFactory

You can also manage cache using the CLI commands. See CLI Commands section for details.

Custom View Implementations

Create custom view types by implementing IView:

Event System

Listen for HTTP events:

CLI Commands

The MVC component includes several CLI commands for managing cache and routes. These commands are available when using the Neuron CLI tool.

Cache Management Commands

mvc:cache:clear

Clear view cache entries.

Options:

• --type, -t VALUE - Clear specific cache type (html, json, xml, markdown)
• --expired, -e - Only clear expired entries
• --force, -f - Clear without confirmation
• --config, -c PATH - Path to configuration directory

Examples:

mvc:cache:stats

Display comprehensive cache statistics.

Options:

• --config, -c PATH - Path to configuration directory
• --json, -j - Output statistics in JSON format
• --detailed, -d - Show detailed breakdown by view type

Examples:

Sample Output:

Rate Limiting

The MVC component includes integrated rate limiting support through the routing component. Rate limiting helps protect your application from abuse and ensures fair resource usage.

Configuration

Rate limiting is configured in your neuron.yaml file using two categories:

Standard Rate Limiting

API Rate Limiting (Higher Limits)

Environment Variables

Configuration maps to environment variables using the {category}_{name} pattern:

• RATE_LIMIT_ENABLED=true
• RATE_LIMIT_STORAGE=redis
• RATE_LIMIT_REQUESTS=100
• API_LIMIT_ENABLED=true
• API_LIMIT_REQUESTS=1000

Usage in Routes

Global Application

Set global: true in configuration to apply rate limiting to all routes:

Per-Route Application

Apply rate limiting to specific routes using the filters parameter in route attributes:

Storage Backends

File Storage (Default)

Best for single-server deployments:

Redis Storage (Recommended for Production)

Best for distributed systems and high traffic:

Memory Storage (Testing Only)

For unit tests and development. Data is lost when PHP process ends:

Rate Limit Headers

When rate limiting is active, the following headers are included in responses:

• X-RateLimit-Limit: Maximum requests allowed
• X-RateLimit-Remaining: Requests remaining in current window
• X-RateLimit-Reset: Unix timestamp when limit resets

When limit is exceeded (HTTP 429):

• Retry-After: Seconds until retry is allowed

Example Implementation

1. Enable rate limiting in neuron.yaml:

2. Apply to routes using attributes:

Customization

For advanced use cases, you can extend the rate limiting system by creating custom filters in your application. The rate limiting system automatically detects if the routing component version supports it and gracefully degrades if not available.

Route Management Commands

mvc:routes:list

List all registered routes with filtering options.

Options:

• --config, -c PATH - Path to configuration directory
• --controller VALUE - Filter by controller name
• --method, -m VALUE - Filter by HTTP method (GET, POST, PUT, DELETE, etc.)
• --pattern, -p VALUE - Search routes by pattern
• --json, -j - Output routes in JSON format

Examples:

Sample Output:

API Reference

Bootstrap Functions

Boot(string $ConfigPath): Application

Initialize the application with configuration.

Dispatch(Application $App): void

Process the current HTTP request.

ClearExpiredCache(Application $App): int

Remove expired cache entries.

Key Interfaces

IController

All controllers must implement this interface:

• renderHtml() - Render HTML with layout
• renderJson() - Render JSON response
• renderXml() - Render XML response

IView

Views must implement:

• render(array $Data): string - Render the view

ICacheStorage

Cache storage implementations must provide:

• read(), write(), exists(), delete()
• clear() - Clear all entries
• isExpired() - Check expiration
• gc() - Garbage collection

Testing

Run the test suite:

More Information

You can read more about the Neuron components at neuronphp.com