A lightweight, modern PHP framework designed for building web applications with clean architecture and modular design.

To use this package, please create an application from this package bowphp/app

Bow Framework is a lightweight PHP framework created by Franck DAKIA that emphasizes simplicity, performance, and developer experience. It provides a comprehensive set of tools for building modern web applications with clean, maintainable code.

Requirements:

• PHP ^8.1+
• Composer
• Extensions: ext-ftp, ext-openssl, ext-pcntl, ext-readline, ext-pdo

Key Highlights:

• Modern PHP 8.1+ features (union types, attributes, named arguments)
• Modular architecture with 20+ independent components
• Lightweight and fast with minimal dependencies
• Full-stack framework with everything you need
• Well-tested: 1,600+ tests, 3,300+ assertions, zero logical failures
• Active development with regular updates

• Barry ORM: Lightweight ActiveRecord-style ORM
• Query Builder: Fluent, expressive database queries
• Multi-database: MySQL, PostgreSQL, SQLite support
• Migrations: Version control for database schema
• Relationships: HasOne, HasMany, BelongsTo, BelongsToMany
• Soft delete: SoftDelete trait with delete/restore/forceDelete and withTrashed/onlyTrashed query scopes
• Pagination: Built-in pagination support

• Simple, expressive routing syntax ($app->get, $app->post, ...)
• PHP 8 attribute routing: #[Controller], #[Get], #[Post], #[Put], #[Patch], #[Delete], #[Options], #[Route]
• RESTful resource routing with automatic CRUD operations
• Route naming for easy URL generation
• Route parameters with regex constraints
• Middleware support per route or route group, with name:arg parameter syntax
• Route prefix and domain grouping
• Custom HTTP error handlers via code()

• Multiple adapters: SMTP, AWS SES, Native PHP mail
• RFC-compliant SMTP implementation
• Email parsing with "Name name@email.com" format support
• File attachments
• Queue integration for asynchronous sending

• Multiple backends: Beanstalkd, Redis, SQS, Database, Sync
• Object-oriented job definitions
• Event-driven job queuing
• Automatic retry logic with exponential backoff
• Mail queue support

• Multi-driver: Local, FTP, AWS S3
• Dynamic storage adapter selection
• File operations: upload, download, copy, move, delete
• Directory management
• Efficient stream handling for large files

• XSS protection with automatic filtering
• CSRF token-based validation
• Data encryption utilities
• Password hashing (Bcrypt/Argon2)
• Native authentication system with guards

• Cache: Filesystem, Redis, Database caching
• Events: Event management and dispatching
• Session: User session management
• Validation: Comprehensive form and data validation
• Console: CLI commands and generators
• Testing: PHPUnit integration with test utilities
• Translation: Internationalization support
• View Rendering: Tintin template engine integration
• Middleware: HTTP middleware stack
• Container: Dependency injection with auto-resolution

flowchart LR
    Client --> Request
    Request --> Kernel
    Kernel --> Router
    Router --> Middleware
    Middleware --> Controller
    Controller --> Model[Model<br/>Barry ORM]
    Model --> Database
    Database --> View
    Database --> Response
    View --> Response
    Response --> Client

1. Request arrives at entry point
2. Kernel loads configurations from config/
3. Router matches URL to controller/action
4. Middleware processes request (auth, validation, etc.)
5. Controller executes business logic
6. Model interacts with database
7. View renders response (HTML/JSON)
8. Response sent back to client

The framework implements several design patterns:

• Singleton: Application, Configuration loaders
• Factory: Database connections, Mail adapters
• Strategy: Storage drivers, Queue backends
• Observer: Event system
• Middleware Pattern: HTTP request pipeline
• Repository Pattern: Database abstraction
• Service Container: Dependency injection
• Facade Pattern: Helper functions

The project is organized into the following directories, each representing an independent module:

• src/: Source code for the Bow Framework.
  • Application/: Main application logic and configuration.
  • Auth/: Authentication and authorization management.
  • Cache/: Caching mechanisms.
  • Configuration/: Configuration settings management.
  • Console/: Console commands and utilities.
  • Container/: Dependency injection and service container.
  • Contracts/: Interfaces and contracts for various components.
  • Database/: Database connections and ORM.
  • Event/: Event management and dispatching.
  • Http/: HTTP requests and responses management.
  • Mail/: Email sending and configuration.
  • Notifier/: Notifications.
  • Middleware/: Middleware classes for request handling.
  • Queue/: Job queues and background processing.
  • Router/: HTTP request routing.
  • Security/: Security features like encryption and hashing.
  • Session/: User session management.
  • Storage/: File storage and retrieval.
  • Support/: Utility classes and helper functions.
  • Testing/: Unit testing classes and utilities.
  • Translate/: Translation and localization.
  • Validation/: Data validation.
  • View/: View rendering and templating.
• tests/: Unit tests for the project.

# Create a new Bow application
composer create-project bowphp/app my-app

# Navigate to the project
cd my-app

# Start the development server
php bow serve

Define Routes:

// routes/app.php
$app->get('/', function () {
    return 'Hello World!';
});

$app->get('/users/:id', function ($id) {
    return "User ID: $id";
});

// RESTful resource routing
$app->rest('/api/posts', 'PostController');

// Attribute-based controllers (no central route file required)
$app->register(\App\Controllers\PostController::class);

Create a Controller:

namespace App\Controllers;

use Bow\Http\Request;
use App\Models\Post;

class PostController
{
    public function index()
    {
        return Post::all();
    }

    public function store(Request $request)
    {
        $post = Post::create($request->all());
        $post->persist();

        return $post;
    }
}

Work with Database:

use App\Models\User;
use Bow\Database\Database;

// Using Barry ORM
$user = User::retrieve(1);
$users = User::where('active', true)->get();

// Using the Query Builder
$users = Database::table('users')
    ->where('role', 'admin')
    ->orderBy('created_at', 'desc')
    ->paginate(10);

• Test Suite: 1,600+ tests with 3,300+ assertions
• Logical failures: 0 — the only remaining errors require external services (FTP server, S3 endpoint) and are skipped by default
• Code Style: PSR-12 (composer phpcs to check, composer phpcbf to fix)
• Static analysis: PHPStan in require-dev (vendor/bin/phpstan analyse src)
• PHP Version: 8.1+ with modern features

• SMTP Adapter: Complete rewrite (8 → 21 methods, RFC-compliant)
• FTP Service: Enhanced with retry logic and better error handling
• Queue System: Graceful logger fallback
• Attribute routing: PHP 8 #[Controller] / #[Get] / #[Post] / ... wiring via $app->register(...)
• Barry soft delete: trait + query scopes (withTrashed, onlyTrashed, withoutTrashed)
• Router: instance-level route storage (no more cross-test leakage)
• PHP 8.x: Modernized code style (arrow functions, union types)

See CHANGELOG.md for full details.

Ideal For:

• REST APIs and microservices
• Web applications with complex database requirements
• Applications requiring file storage (S3, FTP)
• Projects needing queue/job processing
• Multi-tenant applications
• Internationalized applications

The Bow ecosystem includes several packages:

• bowphp/app: Application skeleton
• bowphp/tintin: Template engine
• bowphp/policier: Authentication & authorization
• bowphp/payment: Payment gateway integration

Thank you for considering contributing to Bow Framework! The contribution guide is in the framework documentation.

• Franck DAKIA
• Thank's collaborators

We welcome contributions from the community! To contribute to the project, please follow these steps:

1. Fork the project and clone it to your local machine.
2. Create a new branch for your changes.
3. Make your changes and commit them.
4. Push your changes to your fork and create a pull request.

For more detailed information, refer to the CONTRIBUTING.md file.

• Official Documentation
• API Reference
• Tutorials & Guides

• Documentation: https://bowphp.com
• Issues: GitHub Issues
• Discussions: GitHub Discussions

• Twitter: @papacdev
• GitHub: bowphp

The Bow Framework is open-source software licensed under the MIT license.

• Email: papac@bowphp.com
• Twitter: @papacdev

For bug reports, please use GitHub Issues.

Made with love by the Bow Framework Team