⚡ Strife PHP Framework

A fast, lightweight PHP MVC framework designed for developers who prefer clean architecture, file-based routing, and a Vue.js-friendly front-end workflow.

Features

Smart Routing — File-based or explicit route definitions with full HTTP verb support.
Query Builder — Active record database layer with full isolation between models, transactions, seeding, and JSON backups.
Compiled View Engine — A blade-like template compiler that writes to disk cache (no eval()), with Vue-style component slots and layout composition.
Migration System — Generate, run, and rollback schema changes via CLI.
Yamato CLI — Code generation and database management from the command line.
Encryption & Hashing — Built-in tools for encoding strings.

Requirements

PHP 7.0 or higher
A web server (Apache or Nginx)
Composer

Installation

git clone https://github.com/strifejeyz/framework.git
cd framework
composer install

Copy and configure your environment:

# Edit app/config/application.php — set APP_NAME, APP_KEY, BASE_URL, etc.
# Edit app/config/database.php   — set host, database, username, password

Directory Structure

/
├── app/
│   ├── config/          # Application and database configuration
│   ├── controllers/     # Controller classes
│   ├── migrations/      # Database schema migration files
│   ├── models/          # Model classes extending QueryBuilder
│   ├── seeders/         # Database seeders
│   ├── views/           # Template files (.php)
│   └── routes.php       # Explicit route definitions
├── assets/
│   └── css/             # Public stylesheets
├── kernel/              # Framework core — do not modify
│   ├── database/        # QueryBuilder and connection drivers
│   ├── security/        # Encryption utilities
│   └── View.php         # Template engine (compiler + slots)
├── storage/
│   ├── cache/           # Compiled view cache
│   ├── backups/         # JSON database backups
│   └── logs/            # Application logs
├── index.php            # Application entry point
└── yamato               # CLI entry point

Configuration

Key constants in app/config/application.php:

Constant	Default	Purpose
`APP_NAME`	`'Strife App'`	Application name used in views
`DEV_MODE`	`TRUE`	Enables dev-only tools — set `FALSE` in production
`FILE_BASED_ROUTING`	`true`	Toggle between file-based and explicit routing
`CACHED_VIEWS`	`FALSE`	Skip view recompilation on each request
`MAINTENANCE_MODE`	`FALSE`	Serves 503 to all requests when `TRUE`

Routing

File-Based Routing (Recommended)

Enable in app/config/application.php:

const FILE_BASED_ROUTING = true;

With file-based routing, URLs are automatically mapped to controllers and methods:

URL	Resolves to
`/home/index`	`HomeController::index()`
`/book/show`	`BookController::show()`
`/user/profile`	`UserController::profile()`

No manual route registration required. Any HTTP method is accepted.

Explicit Route Definitions

Set FILE_BASED_ROUTING = false and define routes in app/routes.php:

get('/users',          'UsersController@index');
post('/users/store',   'UsersController@store');
put('/users/update',   'UsersController@update');
patch('/users/modify', 'UsersController@modify');
delete('/users/remove','UsersController@destroy');

Tip: To use PUT, PATCH, or DELETE from an HTML form, add a hidden _method input field:
<form method="POST">
  <input type="hidden" name="_method" value="DELETE">
</form>

Named routes:

get('users-list -> /users', 'UsersController@index');

Route Priority

Specific (literal) routes always beat wildcard routes, regardless of the order they are defined in routes.php. The router automatically sorts routes by specificity before matching — so this is always safe:

get('/:any', 'HomeController@index'); // registered first — does NOT hijack /about-us
get('/about-us', 'HomeController@about');

/about-us correctly resolves to HomeController@about every time.

SPA Catch-All (Vue / React)

When pairing Strife with a frontend SPA, define a /:any catch-all to serve your app shell for any unmatched single-segment URL. Vue Router or React Router then handles client-side navigation:

// API routes first
get('/api/books',      'Api\BookController@index');
post('/api/books',     'Api\BookController@store');

// SPA shell — catch everything else and let the frontend router decide
get('/:any', 'HomeController@index');

Note: /:any only matches URLs with exactly one path segment. Multi-segment API routes like /api/books or /api/books/42 are never affected.

Dev Tools

Route Inspector

When DEV_MODE = TRUE, a route inspector is available at /_routes. It lists every registered endpoint with its HTTP method, URL pattern, handler, and route name. Filter by method or search by URL in real time.

Set DEV_MODE = FALSE before deploying to production — the /_routes endpoint is not registered at all when disabled.

Controllers

Create controllers in app/controllers/. Class names must be PascalCase and suffixed with Controller.

<?php

class BookController
{
    public function index()
    {
        $books = Book::get();
        return render('book', compact('books'));
    }

    public function show()
    {
        $book = Book::find($_GET['id']);
        return render('book/show', compact('book'));
    }
}

Generate a controller with Yamato:

php yamato create:controller Book

Models

Models live in app/models/ and extend Kernel\Database\QueryBuilder. Always specify the target table.

<?php

use Kernel\Database\QueryBuilder as Model;

class Book extends Model
{
    protected static $table = "books";
}

Generate a model with Yamato:

php yamato create:model Book books

Query Builder

Fetching

// Get all rows
$books = Book::get();

// Get the first row
$book = Book::first();

// Find by primary key
$book = Book::find(1);

// Find or throw an error
$book = Book::findOrFail(1);

Filtering

// Single condition
Book::where('author', '=', 'John')->get();

// OR condition
Book::where('author', '=', 'John')->orWhere('author', '=', 'Jane')->get();

// IN list
Book::whereIn('status', ['active', 'pending'])->get();

// Between two values
Book::whereBetween('created', $start, $end)->get();

// Check if any row matches
Book::where('title', '=', 'Dune')->exists(); // true/false

Selecting & Ordering

Book::select(['title', 'author'])
    ->where('author', '=', 'Frank Herbert')
    ->order('title', 'ASC')
    ->limit(10, 0)
    ->get();

Aggregates

Book::count();
Book::min('price');
Book::max('price');
Book::sum('price');
Book::avg('price');
Book::distinct('author')->get();

Insert

Book::insert([
    'title'  => 'Dune',
    'author' => 'Frank Herbert',
]);

// Insert, excluding certain fields
Book::insertExcept($data, ['csrf_token', 'submit']);

Update

// Update by primary key
Book::update(['title' => 'New Title'], $id);

// Increment / Decrement a column value
Book::where('id', '=', 1)->increment('views', 1);
Book::where('id', '=', 1)->decrement('stock', 5);

Delete

// Delete by condition
Book::where('id', '=', 1)->delete();

// Delete all rows
Book::delete();

Pull (Pluck single column)

// Single value
$title = Book::pull('title');

// Multiple columns as array
$info = Book::pull('title', 'author');

Joins

Book::join('authors')
    ->on('books.author_id = authors.id')
    ->get();

Transactions

Book::transact();

try {
    Book::insert(['title' => 'Draft']);
    Book::commit();
} catch (Exception $e) {
    Book::rollback();
}

Backup & Restore

// Exports table data to storage/backups/ as JSON
Book::backup();

// Restores from the most recent backup
Book::restore();

Important: Each model class maintains its own isolated query state. Using User::find(1) followed by Book::find(2) will not cause any result contamination between the two.

Views

Templates live in app/views/. The framework uses a compiled view engine — all custom syntax is converted to standard PHP and written to storage/cache/ as real files. No eval(). No OPCache penalty.

Render a View

// In a controller
return render('book', compact('books'));

// Equivalent full call
return View::render('book', compact('books'));

Template Engine

Layouts & Slots

Define your page shell in a single layout file (app/views/layouts/layout.php):

<!DOCTYPE html>
<html>
<head>
    <title>@show('title', 'Default Title')</title>
</head>
<body>
    <header>
        @show('header')
    </header>

    <main>
        @show
    </main>

    <footer>
        @show('footer', '<p>&copy; 2026</p>')
    </footer>
</body>
</html>

In your view file, wrap content with @layout / @endlayout and fill slots with @slot / @endslot:

@layout('layouts/layout')

  @slot('title')
    Books — My App
  @endslot

  @slot('header')
    <h1>Book Library</h1>
  @endslot

  {{-- Default slot: any content outside @slot tags goes into @show --}}
  <div class="content">
    <p>Hello from the main content area!</p>
  </div>

  @slot('footer')
    <p>Custom footer text</p>
  @endslot

@endlayout

Directive reference:

Directive	Purpose
`@layout('path/to/layout')`	Set the parent layout for this view
`@endlayout`	Close the layout and trigger rendering
`@slot('name')`	Start filling a named slot
`@endslot`	End the named slot (resume default slot)
`@show('name')`	Output a named slot in the layout
`@show('name', 'fallback')`	Output slot or a fallback string if empty
`@show`	Output the default (unnamed) slot

Outputting Variables

{{-- HTML-escaped output (safe) --}}
{{ $variable }}

{{-- Raw, unescaped output --}}
{! $variable !}

Conditionals

{if ($user->isAdmin())}
    <p>Welcome, admin.</p>
{elseif ($user->isEditor())}
    <p>Welcome, editor.</p>
{else}
    <p>Welcome, guest.</p>
{endif}

Loops

{foreach ($books as $book)}
    <li>{{ $book->title }}</li>
{endforeach}

{for ($i = 0; $i < 5; $i++)}
    <p>Item {{ $i }}</p>
{endfor}

{while ($condition)}
    <p>Looping...</p>
{endwhile}

Including Sub-Templates

{{-- Include and compile another template --}}
@render('partials/navbar')

{{-- Include a raw PHP file (no compilation) --}}
@get('partials/sidebar')

Escaping the `@` Symbol

Since @ is the directive prefix, use @@ to output a literal @ in HTML:

<p>Contact us at info@@gmail.com</p>

Renders as:

<p>Contact us at info@gmail.com</p>

Legacy Layout System

The older @extend / @stop layout system is still supported for backward compatibility:

@extend('layouts/frontend')

<p>Page content here</p>

@stop()

Database Migrations

Generate a migration:

php yamato create:migration create_books_table books

Edit the generated file in app/migrations/, then run:

php yamato db:migrate   # Apply all pending migrations
php yamato db:rollback  # Undo all migrations

Yamato CLI

php yamato

Generators

Command	Description
`php yamato create:controller Name`	Create a new controller
`php yamato create:model Name table`	Create a new model
`php yamato create:migration Name table`	Create a migration file
`php yamato create:key`	Generate a random application key

Database

Command	Description
`php yamato db:migrate`	Run all migrations
`php yamato db:rollback`	Rollback all migrations
`php yamato db:backup`	Backup table data to JSON
`php yamato db:restore`	Restore from last backup
`php yamato db:seed`	Run database seeders

Utilities

Command	Description
`php yamato clear:logs`	Delete log files
`php yamato clear:cache`	Delete compiled view cache
`php yamato clear:all`	Delete logs, cache, and backups
`php yamato hash:encode string`	Hash a string
`php yamato encryption:encode string`	Encrypt a string
`php yamato encryption:decode string`	Decrypt a string

Contributing

Fork the repository.
Create a new branch for your feature or bugfix.
Submit a pull request with a clear description of your changes.

License

Strife is open-source software licensed under the MIT License.

Support

For questions or issues, open a ticket on GitHub Issues.

Name		Name	Last commit message	Last commit date
Latest commit History 270 Commits
.agents		.agents
app		app
assets/css		assets/css
kernel		kernel
storage		storage
.gitignore		.gitignore
.htaccess		.htaccess
LICENSE		LICENSE
composer.json		composer.json
composer.lock		composer.lock
favicon.ico		favicon.ico
index.php		index.php
readme.md		readme.md
yamato		yamato

Folders and files

Latest commit

History

Repository files navigation